--- library_name: litert pipeline_tag: image-classification tags: - vision - image-classification - google - computer-vision datasets: - imagenet-1k model-index: - name: litert-community/convnext_tiny results: - task: type: image-classification name: Image Classification dataset: name: ImageNet-1k type: imagenet-1k config: default split: validation metrics: - name: Top 1 Accuracy (Full Precision) type: accuracy value: 0.8246 - name: Top 5 Accuracy (Full Precision) type: accuracy value: 0.9613 --- # Convnext Tiny ConvNeXt Tiny model designed as a lightweight, pure convolutional backbone for efficient visual recognition in the "Roaring 20s." Originally introduced by Zhuang Liu, Hanzi Mao, Chao-Yuan Wu, Christoph Feichtenhofer, Trevor Darrell, Saining Xie. in the modernized paper, [A ConvNet for the 2020s](https://arxiv.org/abs/2201.03545), this model "modernizes" the standard ResNet by adopting Transformer-inspired inductive biases, such as depthwise convolutions with \\(7 \times 7 \\) kernels and inverted bottlenecks. With approximately 28M parameters and 4.5 GFLOPs, it achieves accuracy levels comparable to the Swin-T Transformer while maintaining the simplicity and high throughput of a standard ConvNet. ## Model description The model was converted from a checkpoint from PyTorch Vision. The original model has: acc@1 (on ImageNet-1K): 82.52% acc@5 (on ImageNet-1K): 96.146% num_params: 28589128 `convnext_tiny_int8_channelwise.tflite`: Mixed INT8/FP32 with channelwise INT8 weights. LayerNorm remains FP32. ### Source and preprocessing TorchVision `ConvNeXt_Tiny_Weights.IMAGENET1K_V1` ([checkpoint](https://download.pytorch.org/models/convnext_tiny-983f1562.pth)). Convert to RGB, resize the short side to 236 with bilinear interpolation and antialiasing, then center crop to 224 × 224. Divide pixels by 255, subtract `[0.485, 0.456, 0.406]`, and divide by `[0.229, 0.224, 0.225]`. The input layout is NCHW, shape `[1, 3, 224, 224]`; output is ImageNet class scores with shape `[1, 1000]`. ### Quantization `convnext_tiny_int8_channelwise.tflite`: Mixed INT8/FP32 with channelwise INT8 weights and INT8 input/output. LayerNorm remains FP32; this is not a fully integer model. The base recipe is `ai_edge_quantizer.recipe.static_wi8_ai8()`, with local scale/bias safeguards to avoid overflowing INT32 biases. Intermediate calibration ranges use an exponential moving average; the output logits use the global observed range. For INT8 input, apply the preprocessing above, then compute `clip(round(x / input_scale) + input_zero_point, -128, 127)` and cast to INT8, using nearest rounding with ties away from zero, as in this validation. Dequantize output scores with `(q - output_zero_point) * output_scale`. Read scales and zero points from the selected model file; do not assume that they match an earlier revision. The existing FP32 usage example, where present, requires this additional I/O handling before it can be used with the INT8 variant. ## Compatibility | File | CPU | GPU | NPU | |---|---|---|---| | `convnext_tiny.tflite` | YES| YES | N/A | | `convnext_tiny_int8_channelwise.tflite` | YES | NO | QC/MTK/...| ## Intended uses & limitations The model files were converted from pretrained weights from PyTorch Vision. The models may have their own licenses or terms and conditions derived from PyTorch Vision and the dataset used for training. It is your responsibility to determine whether you have permission to use the models for your use case. ## How to Use ​​**1. Install Dependencies** Ensure your Python environment is set up with the required libraries. Run the following command in your terminal ```bash pip install numpy Pillow huggingface_hub ai-edge-litert ``` **2. Prepare Your Image** The script expects an image file to analyze. Make sure you have an image (e.g., cat.jpg or car.png) saved in the same working directory as your script. **3. Save the Script** Create a new file named `classify.py`, paste the script below into it, and save the file ```python #!/usr/bin/env python3 import argparse, json import numpy as np from PIL import Image from huggingface_hub import hf_hub_download from ai_edge_litert.compiled_model import CompiledModel def preprocess(img: Image.Image) -> np.ndarray: img = img.convert("RGB") w, h = img.size s = 236 if w < h: img = img.resize((s, int(h * s / w)), Image.BILINEAR) else: img = img.resize((int(w * s / h), s), Image.BILINEAR) left = int(round((img.size[0] - 224) / 2.0)) top = int(round((img.size[1] - 224) / 2.0)) img = img.crop((left, top, left + 224, top + 224)) x = np.asarray(img, dtype=np.float32) / 255.0 x = (x - np.array([0.485, 0.456, 0.406], dtype=np.float32)) / np.array( [0.229, 0.224, 0.225], dtype=np.float32 ) return np.ascontiguousarray(x.transpose(2, 0, 1)[None]) def main(): ap = argparse.ArgumentParser() ap.add_argument("--image", required=True) args = ap.parse_args() model_path = hf_hub_download("litert-community/convnext_tiny", "convnext_tiny.tflite") labels_path = hf_hub_download( "huggingface/label-files", "imagenet-1k-id2label.json", repo_type="dataset" ) with open(labels_path, "r", encoding="utf-8") as f: id2label = {int(k): v for k, v in json.load(f).items()} img = Image.open(args.image) x = preprocess(img) model = CompiledModel.from_file(model_path) inp = model.create_input_buffers(0) out = model.create_output_buffers(0) inp[0].write(x) model.run_by_index(0, inp, out) req = model.get_output_buffer_requirements(0, 0) y = out[0].read(req["buffer_size"] // np.dtype(np.float32).itemsize, np.float32) pred = int(np.argmax(y)) label = id2label.get(pred, f"class_{pred}") print(f"Top-1 class index: {pred}") print(f"Top-1 label: {label}") if __name__ == "__main__": main() ``` **4. Execute the Python Script** Run the below command ```bash python classify.py --image cat.jpg ``` ### BibTeX entry and citation info ```bibtex @misc{liu2022convnet2020s, title={A ConvNet for the 2020s}, author={Zhuang Liu and Hanzi Mao and Chao-Yuan Wu and Christoph Feichtenhofer and Trevor Darrell and Saining Xie}, year={2022}, eprint={2201.03545}, archivePrefix={arXiv}, primaryClass={cs.CV}, url={https://arxiv.org/abs/2201.03545}, } ```