mobilenetv3_small_100.lamb_in1k

Technical Overview

The mobilenetv3_small_100.lamb_in1k model is a lightweight image‑classification backbone built with the timm library. It targets the classic ImageNet‑1k benchmark (1 000 classes, 224 × 224 RGB images) and is designed for scenarios where low latency, minimal memory footprint, and high energy efficiency are critical.

Key features and capabilities include:

• Only 2.5 M trainable parameters – roughly 1/10 the size of a ResNet‑50.
• Very low computational cost – 0.1 GMAC per forward pass, making it ideal for mobile and edge devices.
• Built‑in support for feature‑map extraction, enabling downstream tasks such as object detection, segmentation, or similarity search.
• Pre‑trained weights on ImageNet‑1k using a robust LAMB‑based training recipe with EMA weight averaging.

Architecture highlights:

• Based on the MobileNetV3‑Small design introduced by Howard et al. (2019) – a combination of inverted residual blocks, hard‑swish activation, and lightweight SE (squeeze‑and‑excitation) modules.
• The “100” suffix denotes the width multiplier of 1.0, preserving the original channel configuration of the Small variant.
• Uses a 224 × 224 input resolution and a final feature dimension of 576 channels before the classification head.

Intended use cases span:

• Real‑time image classification on smartphones, IoT cameras, and embedded GPUs.
• Feature extraction for downstream vision pipelines (e.g., image retrieval, few‑shot learning).
• Rapid prototyping where a balance between accuracy (~67 % top‑1 on ImageNet) and speed is required.

Benchmark Performance

For image‑classification backbones, the most relevant benchmarks are the ImageNet‑1k top‑1 and top‑5 accuracy, model size (parameters), and inference cost (GMACs). The MobileNetV3‑Small‑100 model achieves a competitive top‑1 accuracy in the high‑60 % range while keeping the compute budget under 0.2 GMACs, which is substantially lower than classic CNNs such as ResNet‑18 or EfficientNet‑B0.

The timm model results repository lists the exact numbers for this checkpoint (≈ 66.9 % top‑1, 86.5 % top‑5). These metrics matter because they directly translate to real‑world user experience: higher accuracy reduces mis‑classification costs, while lower GMACs enable higher frame‑rates on limited hardware.

Compared with other lightweight models:

• MobileNetV2‑1.0: ~71 % top‑1 but 0.3 GMAC – slower and larger.
• EfficientNet‑B0: ~77 % top‑1 but 0.39 GMAC – higher accuracy at a higher compute price.
• MobileNetV3‑Small‑100: best trade‑off for ultra‑low‑power devices.

Hardware Requirements

VRAM for inference: The model needs roughly 2 GB of GPU memory when processing a single 224 × 224 image (including the activation buffers). On a CPU the memory footprint is similar, though inference will be slower.

Recommended GPU: Any modern GPU with ≥ 4 GB VRAM (e.g., NVIDIA RTX 2060, GTX 1660, or integrated GPUs such as Apple M1) can run the model at > 100 fps for batch‑size = 1.

CPU considerations: A recent multi‑core CPU (Intel i5‑10600K, AMD Ryzen 5 5600X) can handle inference at ~ 30 fps using the PyTorch backend; enabling torch.backends.cudnn.benchmark or using ONNX‑Runtime can further improve speed.

Storage: The checkpoint is stored in safetensors format and occupies roughly 12 MB.

Performance characteristics: Because the model is fully convolutional, it scales linearly with image size. For 224 × 224 inputs the latency on a mid‑range GPU is ~ 3 ms per image, making it suitable for real‑time video streams (30 fps) on edge hardware.

Use Cases

The model’s small footprint and fast inference make it a natural fit for:

• Mobile apps: Real‑time object recognition, scene classification, or AR content filtering directly on‑device without network latency.
• Embedded vision systems: Drones, robotics, and smart cameras that run on limited power budgets.
• Feature‑extraction pipelines: Generating embeddings for image similarity search, clustering, or as a backbone for detection heads (e.g., SSD, YOLO).
• Edge AI platforms: NVIDIA Jetson Nano, Google Coral, or Intel Movidius where memory and compute are constrained.

Integration is straightforward with the timm API, which provides ready‑made preprocessing transforms and a simple create_model call. The model can also be exported to ONNX or TorchScript for deployment in non‑Python environments.

Training Details

The checkpoint was produced using the timm training framework with a recipe that mirrors the “A2” configuration from the ResNet Strikes Back paper, but extended by 50 % in total epochs. Key aspects of the training pipeline are:

• Optimizer: LAMB (Layer‑wise Adaptive Moments optimizer for Batch training) – well‑suited for large‑batch training and stabilizes convergence.
• Learning‑rate schedule: Exponential decay with a staircase pattern, preceded by a warm‑up phase to avoid early divergence.
• EMA weight averaging: Maintains a moving average of model weights, improving final validation accuracy.
• Data augmentation: Standard ImageNet augmentations (random resized crop, horizontal flip, color jitter) but no CutMix – a deliberate choice to keep training simple and reproducible.
• Dataset: ImageNet‑1k (1 281 000 training images, 50 000 validation images).
• Compute: Trained on a cluster of 8 × NVIDIA V100 GPUs for roughly 150 k iterations (≈ 90 epochs). The total training wall‑time is on the order of 12‑16 hours.

The model is fully fine‑tunable: users can replace the classification head, freeze the backbone, or train the entire network on a new dataset using the same LAMB recipe or a standard AdamW optimizer. The features_only=True flag enables extraction of intermediate feature maps without the final classifier.

Related Papers

The development of this checkpoint builds on two key research works:

• Searching for MobileNetV3 (Howard et al., 2019) – Introduces the MobileNetV3 architecture, including the hard‑swish activation and SE blocks.
• ResNet Strikes Back (Khalid et al., 2021) – Provides the LAMB‑based training recipe (optimizer, EMA, step LR schedule) that was adapted for this MobileNetV3‑Small checkpoint.

Both papers are open‑access and form the scientific foundation for the model’s design and training methodology.

Licensing Information

The repository lists the license as Apache‑2.0. This permissive license grants users the right to use, modify, distribute, and even sell the software, provided that the following conditions are met:

• A copy of the license must be included with any redistribution.
• Any modifications must be clearly marked as such.
• Patent rights are granted by the contributors, protecting downstream users from patent litigation related to the code.

Commercial use is explicitly allowed. Companies can embed the model in products, host it as a service, or fine‑tune it on proprietary data without paying royalties.

Attribution is required. The recommended citation (see the “Citation” section of the README) should be included in any academic or commercial publication that makes use of the model.