Technical Overview
Model ID: timm/mobilenetv3_large_100.ra_in1k – a MobileNet‑V3‑Large backbone trained on the ImageNet‑1k dataset using the RandAugment (RA) recipe. The model is part of the timm (PyTorch Image Models) library and is exposed through the Hugging Face Hub for easy download and inference.
What it does: It maps a 224 × 224 RGB image to a 1000‑class probability distribution, enabling state‑of‑the‑art image classification on mobile‑friendly hardware. In addition to the classifier head, the model can be used as a feature extractor (outputting intermediate feature maps) or as an embedding generator (producing a 960‑dimensional vector after global pooling).
Key features & capabilities:
- Lightweight architecture – only 5.5 M trainable parameters.
- Very low compute – 0.2 GMACs per forward pass, making it suitable for real‑time inference on edge devices.
- Rich feature hierarchy – five stages of feature maps ranging from 112 × 112 down to 7 × 7, useful for downstream tasks such as object detection or segmentation.
- Trained with the ResNet‑Strikes‑Back (B) recipe, which combines RandAugment, RMSProp with EMA, and a step‑wise learning‑rate schedule with warm‑up.
Architecture highlights: MobileNet‑V3‑Large builds on the inverted residual block with squeeze‑and‑excitation (SE) modules and hard‑swish activations. The “100” suffix denotes a width multiplier of 1.0, preserving the full channel count of the original design. The model processes the input through a stem (3 × 3 conv, stride 2), followed by a series of bottleneck blocks with varying kernel sizes (3 × 3, 5 × 5, 7 × 7) and expansion ratios, concluding with a 1 × 1 conv that expands to 960 channels before the classifier.
Intended use cases: Mobile‑first image classification, on‑device inference, rapid prototyping of vision pipelines, and as a backbone for transfer‑learning in tasks like fine‑grained classification, feature‑based retrieval, or as a plug‑in for vision‑transformer hybrids.
Benchmark Performance
The most relevant benchmarks for a model of this class are top‑1 and top‑5 accuracy on ImageNet‑1k, as well as computational efficiency (GMACs) and memory footprint. According to the README, the MobileNet‑V3‑Large‑100.ra_in1k achieves the standard ImageNet‑1k performance for its size, typically around 73 % top‑1 and 91 % top‑5 accuracy (the exact numbers are reported in the timm results repository). With only 0.2 GMACs, it outperforms many older MobileNet‑V2 variants while using fewer FLOPs than EfficientNet‑B0.
These benchmarks matter because they directly translate to latency and power consumption on mobile GPUs and CPUs. A model that stays under 0.3 GMACs can run at >30 fps on a mid‑range smartphone while keeping battery impact minimal. Compared to similarly sized architectures (e.g., ShuffleNet‑V2 1.5×, EfficientNet‑B0), MobileNet‑V3‑Large‑100 offers a better accuracy‑to‑compute ratio, making it a top choice for latency‑critical deployments.
Hardware Requirements
VRAM for inference: The model’s parameters occupy roughly 22 MB (5.5 M × 4 bytes). Including activation buffers for a 224 × 224 image, a typical forward pass needs ≈200 MB of GPU memory, comfortably fitting on most consumer GPUs (e.g., RTX 3060, GTX 1660) and even on many integrated GPUs.
Recommended GPU: Any CUDA‑compatible GPU with ≥4 GB VRAM. For batch sizes >1, allocate additional memory proportionally (≈200 MB per image). The model runs efficiently on Apple Silicon (M1/M2) and on ARM‑based NPUs that support PyTorch’s torch.nn operators.
CPU requirements: On a modern multi‑core CPU (e.g., Intel i7‑12700K or AMD Ryzen 7 5800X), inference at batch‑size 1 takes ≈15‑20 ms using the torchvision transforms. Enabling torch.backends.cudnn.benchmark = True can shave a few milliseconds.
Storage needs: The model file (safetensors) is ≈30 MB. Including the associated config and tokenizer files, the total download size is under 50 MB, making it ideal for edge deployment where storage is limited.
Use Cases
Primary applications: Real‑time image classification on mobile devices, low‑power edge AI (drones, IoT cameras), and as a backbone for transfer learning in domain‑specific visual tasks.
Real‑world examples:
- Smartphone apps that identify food items, plants, or products on‑the‑fly.
- Embedded vision systems in retail kiosks for rapid barcode‑free product recognition.
- Robotic perception modules that need quick scene categorization without draining the battery.
Industry domains: Consumer electronics, retail, automotive (driver‑assistance visual cues), healthcare (triage of skin images), and security (quick threat‑object detection).
Integration possibilities: The model can be loaded directly via timm.create_model in Python, wrapped in TorchServe for scalable inference, or exported to ONNX/TensorRT for deployment on hardware accelerators. Its feature‑map output also enables seamless connection to downstream heads such as SSD or Mask‑RCNN.
Training Details
The checkpoint was produced with the timm training template. Key aspects include:
- Dataset: ImageNet‑1k (1 000 classes, ~1.28 M training images).
- Data augmentation: RandAugment (RA) – a set of random magnitude‑controlled transformations that improve robustness.
- Optimizer: RMSProp with TensorFlow‑1.0 behaviour, combined with Exponential Moving Average (EMA) weight averaging.
- Learning‑rate schedule: Step decay with warm‑up (exponential decay on a staircase).
- Training compute: Typically 300 epochs on 8 × NVIDIA V100 GPUs (≈2 days of wall‑clock time).
The model is released with pretrained=True weights, but it can be fine‑tuned on custom datasets by replacing the final linear layer (or setting num_classes=0 for embedding extraction). The features_only=True flag exposes intermediate feature maps, facilitating transfer learning for detection or segmentation pipelines.
Licensing Information
The repository tags the model with license: apache-2.0, yet the public-facing card lists the license as “unknown”. In practice, the underlying timm codebase is released under the Apache 2.0 license, which is permissive and allows commercial use, modification, and distribution provided that a copy of the license is included and that any modifications are clearly marked.
If you redistribute the model (e.g., embed it in a product or share a fine‑tuned checkpoint), you should:
- Retain the original Apache 2.0 notice in the code or documentation.
- Provide attribution to the original authors (Ross Wightman and the MobileNet‑V3 authors).
- Clearly state any changes you made to the model or training pipeline.
Because the license is not explicitly displayed on the Hugging Face page, it is prudent to verify the license file in the model repository before commercial deployment. In most cases, the Apache 2.0 terms will be sufficient for both open‑source and proprietary projects.