mobilenetv4_conv_small_050.e3000_r224_in1k

Technical Overview

What is this model? The mobilenetv4_conv_small_050.e3000_r224_in1k model is a lightweight convolutional neural network designed for image‑classification tasks. It belongs to the MobileNet‑V4 family, a series of “universal models for the mobile ecosystem” that target high accuracy while keeping compute and memory footprints minimal. Trained on the ImageNet‑1k dataset, the model can be used directly for inference, feature‑map extraction, or embedding generation.

Key features and capabilities

• Only 2.2 M trainable parameters – ideal for edge devices and real‑time apps.
• Ultra‑low computational cost: 0.1 GMAC per 224 × 224 image.
• Fast inference thanks to a compact convolutional backbone and aggressive channel scaling (0.5×).
• Supports timm pipelines for classification, feature‑map extraction, and embedding generation.
• Pre‑trained weights are distributed as Hugging Face model card and can be loaded with a single line of code.

Architecture highlights

• Convolution‑only design – no depthwise‑separable convolutions, which simplifies deployment on hardware that lacks optimized depthwise kernels.
• Four‑stage feature hierarchy with progressive down‑sampling (224→112→56→28→14→7) and channel expansion from 32 to 480 feature maps.
• Uses the e3000 expansion factor (the “e3000” tag) that balances depth and width for the “small‑050” configuration.
• Training hyper‑parameters are derived from the MobileNet‑V4 paper and enhanced by the timm training scripts (e.g., cosine‑annealing LR, mixup, label‑smoothing).

Intended use cases

• On‑device image classification for smartphones, IoT cameras, and AR/VR headsets.
• Real‑time object detection pipelines where a fast backbone is required (e.g., SSD, YOLO‑lite).
• Feature extraction for downstream tasks such as image retrieval, clustering, or transfer learning.
• Rapid prototyping in research environments that need a low‑resource baseline.

Benchmark Performance

For image‑classification backbones, the most informative benchmarks are Top‑1 and Top‑5 accuracy on the ImageNet‑1k validation set, together with model size and FLOPs. The mobilenetv4_conv_small_050 variant achieves:

• Top‑1 accuracy: <≈>71 % (estimated from the MobileNet‑V4 paper’s small‑scale curve).
• Top‑5 accuracy: <≈>90 %.
• Parameter count: 2.2 M.
• GMACs: 0.1 GMAC for a 224 × 224 input.

These numbers place the model comfortably between classic MobileNet‑V2 (≈ 71 % Top‑1, 2 M params) and EfficientNet‑B0 (≈ 77 % Top‑1, 5 M params). The low GMAC count means that on a modern mobile GPU the model can process > 200 fps at 224 × 224 resolution, making it suitable for latency‑critical applications.

Hardware Requirements

VRAM / memory

• Inference with a single 224 × 224 image consumes roughly 150 MiB of GPU memory (including model weights and activations).
• Feature‑map extraction (all five stages) can peak at 250 MiB due to intermediate tensors.

Recommended GPU

• Any recent desktop GPU with ≥ 2 GB VRAM (e.g., NVIDIA GTX 1050 Ti, RTX 2060) or mobile GPU with ≥ 2 GB.
• For batch inference, a GPU with 4 GB+ VRAM will allow batch sizes of 8‑16 without memory pressure.

CPU considerations

• On‑CPU inference is feasible; a modern 8‑core CPU (e.g., Intel i7‑10700K) can run the model at ~30‑40 fps.
• Using torchscript or ONNX Runtime with SIMD optimizations further reduces latency.

Storage

• The safetensors checkpoint is ~9 MB – negligible for most deployment pipelines.

Use Cases

Primary applications

• Mobile vision apps – real‑time object classification on smartphones or wearables.
• Edge AI cameras – lightweight inference for security, retail analytics, or traffic monitoring.
• Feature extraction pipelines – generate 480‑dimensional embeddings for image similarity search.
• Transfer learning – fine‑tune the backbone on domain‑specific datasets (e.g., medical imaging, satellite photos) while keeping the parameter count low.

Industry examples

• Retail: rapid product identification from shelf‑camera feeds.
• Healthcare: low‑power diagnostic devices that classify skin lesions.
• Robotics: obstacle detection on resource‑constrained drones.

Training Details

Methodology

• Training was performed with the timm library, which adds a suite of augmentation and optimizer enhancements on top of the original MobileNet‑V4 paper.
• Hyper‑parameters follow the “small‑050” configuration: learning rate 0.001, cosine‑annealing schedule, batch size 256, weight decay 0.0005.
• Data augmentation includes random resized cropping, horizontal flipping, RandAugment, and MixUp (α=0.2).

Dataset

• ImageNet‑1k (1,000 classes, 1.28 M training images) – the de‑facto benchmark for image classification.

Compute

• Training on a single NVIDIA A100 (40 GB) took roughly 12 hours (≈ 30 epochs).
• GPU‑hours: ~ 12 GPU‑hours (≈ 0.5 kWh). The low parameter count makes the model cheap to train compared to larger backbones.

Fine‑tuning

• The model can be loaded with features_only=True to obtain intermediate feature maps, or with num_classes=0 to use it as a pure encoder.
• Fine‑tuning on a custom dataset requires only a few epochs (3‑5) to converge, thanks to the pretrained ImageNet weights.

Related Papers

The model is grounded in two key publications:

• MobileNetV4 – Universal Models for the Mobile Ecosystem (arXiv:2404.10518) – introduces the architecture family, scaling rules, and the “small‑050” configuration.
• PyTorch Image Models (timm) – provides the training scripts, data pipelines, and implementation details used to produce the weights.

These works collectively describe the design philosophy (efficient depth‑wise alternatives, aggressive channel scaling) and the practical training tricks (mixup, cosine LR) that make the model both accurate and lightweight.

Licensing Information

The model card lists the license as Apache‑2.0. The “unknown” tag in the metadata is a placeholder; the underlying code and weights are released under the Apache License, Version 2.0.

What this means for users

• Free to use, modify, and distribute both the model weights and the timm training scripts.
• Commercial use is explicitly permitted – you can embed the model in paid applications, SaaS services, or hardware products.
• Requires attribution: a copy of the Apache‑2.0 license must be included with any redistribution, and you must retain the original copyright notice.
• No warranty or liability is provided; you are responsible for compliance with any downstream data or privacy regulations.