litert-community/convnext_tiny

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, this model "modernizes" the standard ResNet by adopting Transformer-inspired inductive biases, such as depthwise convolutions with $7\times 77\; \backslash 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.

2026-09-22 maintenance update

This maintenance update removes ten redundant reshapes from the LayerNorm fallback bodies in the published FP32 graph. The source checkpoint and public FP32 input/output interface are unchanged. The channelwise INT8 file is regenerated from the refreshed FP32 export.

File	Size (bytes)	SHA-256
convnext_tiny.tflite	114422656	17d67ff1731ea2a2f9726fc8a8170cd3168c7be2ce1bf36258db3add06316f18
convnext_tiny_int8_channelwise.tflite	29859024	d22d0fd223a678d8af582cf54ae28377d08807922b548e65068e8d35eddffc53

Source and preprocessing

TorchVision ConvNeXt_Tiny_Weights.IMAGENET1K_V1 (checkpoint). 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.

• Calibration images: 500 (manifest image IDs: 0–499).
• Calibration manifest SHA-256: 6a8d04c842352ef41d7795e3ec6acd30a4cbad520466d69b8b0503a521d5d1e5.
• Base quantization recipe SHA-256: 3db5fac189c1707c9a0c3a18fecaa8fabd8c9ef3681af553d9e0c86fc18ec0fb.

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.

Validation of the refreshed artifacts

CPU evaluation used 1000 images from ImageNet-1k validation (manifest image IDs: 1000–1999). These are subset measurements, not a new full-validation accuracy result.

Variant	CPU backend	Top-1 correct	Top-5 correct
FP32	xnnpack	847	958
FP32	builtin	847	958
Mixed INT8/FP32	xnnpack	837	958
Mixed INT8/FP32	builtin	833	956

For both variants on both CPU backends, all 1,000 output vectors are bit-identical to the preceding published revision. Public input/output metadata, quantization parameters and signatures are unchanged.

The model-index values of 82.46% top-1 and 96.13% top-5 in this card's metadata are historical results retained from the earlier publication. They were not remeasured over the full validation set for this maintenance release.

Validation used LiteRT 2.3.0 on host CPU. The 1,000-image subset is disjoint from the 500 calibration images, but was used during earlier recipe development; it is a regression set, not an untouched test set.

Saved calibration arrays were restored as float32. Replaying the same recipe and INT32-bias safeguards on the previous source exports reproduced both previous quantized files byte for byte.

FP32 GPU validation used 10 images on TECNO LJ9 / MT6897 with both default and explicit FP32 precision. Explicit FP32 relative L2 error versus host CPU was 1.77091e-06, with no top-1 changes. This release makes no new latency claim.

Quantized MT6897 NPU execution used 10 images: 0 top-1 changes versus the quantized host CPU reference, relative L2 error 0.188453. The NPU output scores are bit-identical to the retained checks of the preceding published quantized file; the CPU/NPU numerical difference is unchanged. SM8750 and MT6993 coverage is host AOT compilation only; corresponding devices were unavailable.

The existing convnext_tiny_dynamic_wi8_afp32.tflite and convnext_tiny_Google_Tensor_G5_apply_plugin.tflite files are retained unchanged. The validation results in this update apply only to the two files listed in the artifact table.

Compatibility

File	CPU	GPU	NPU
convnext_tiny.tflite	Validated: builtin and XNNPACK, 1,000 images	Validated on TECNO LJ9 / MT6897: full delegation, 10 images	Not evaluated for this FP32 artifact
convnext_tiny_int8_channelwise.tflite	Validated: builtin and XNNPACK, 1,000 images	Not supported on the tested MLDrift stack; use FP32	Full AOT: MT6897, MT6993, SM8750; MT6897 device smoke passed

Compatibility entries above describe the 2026-09-22 artifacts. Earlier releases had FP32 GPU smoke checks and channelwise INT8 Qualcomm/MediaTek AOT compilation checks; those historical checks do not certify changed files. AOT compilation coverage alone does not establish on-device numerical accuracy. Earlier INT8 runs on the tested LiteRT MLDrift GPU stack produced large numerical errors; use the FP32 variant for GPU when its current validation supports that backend.

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

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

#!/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

python classify.py --image cat.jpg

BibTeX entry and citation info

@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}, 
}