tf_mobilenetv3_large_minimal_100.in1k

Technical Overview

The tf_mobilenetv3_large_minimal_100.in1k model is a TensorFlow‑originated MobileNet‑V3 Large architecture that has been ported to PyTorch via the timm library. It is an image‑classification backbone trained on the ImageNet‑1k dataset (1 000 classes). The model accepts 224 × 224 RGB images, processes them through a lightweight convolutional pipeline, and produces a 1 000‑dimensional probability distribution over the ImageNet classes.

• Key features and capabilities
  • Only 3.9 M trainable parameters – ideal for edge devices and mobile deployment.
  • Low computational cost: 0.2 GMAC per forward pass, enabling real‑time inference on modest hardware.
  • Five intermediate feature maps (16, 24, 40, 112, 960 channels) are exposed when features_only=True, supporting transfer learning and downstream tasks such as object detection or segmentation.
  • Pre‑trained weights are provided in safetensors format, ensuring fast loading and reduced memory footprint.
• Architecture highlights
  • Based on the MobileNet‑V3 Large design introduced in the 2019 paper “Searching for MobileNetV3”.
  • Uses a combination of inverted residual blocks and hard‑swish activation functions for high efficiency.
  • The “minimal” variant reduces the number of channels in early layers (e.g., 16 → 24) while preserving the overall top‑5 accuracy of the full Large model.
  • Final classifier consists of a 1×1 convolution followed by a global average pooling and a fully‑connected layer with 1 000 outputs.
• Intended use cases
  • On‑device image classification for smartphones, AR glasses, or IoT cameras.
  • Feature extraction for downstream vision tasks (e.g., similarity search, clustering).
  • Rapid prototyping of computer‑vision pipelines where latency and memory are critical.

Benchmark Performance

For image‑classification backbones, the most relevant benchmarks are top‑1 / top‑5 accuracy on ImageNet‑1k, GMACs (giga‑multiply‑adds), and parameter count. The README reports the following statistics:

• Parameters: 3.9 M
• GMACs: 0.2 GMAC
• Activations: 4.4 M
• Image size: 224 × 224

These numbers place the model in the “ultra‑lightweight” tier, competing directly with EfficientNet‑B0 and the original MobileNet‑V2. In practice, the model typically achieves around 71 % top‑1 and 90 % top‑5 accuracy on ImageNet, which is comparable to other 4‑M‑parameter networks while consuming far fewer FLOPs.

Why these benchmarks matter:

• Top‑1/Top‑5 accuracy reflects real‑world classification quality.
• GMACs correlate directly with inference latency on CPUs/GPUs.
• Parameter count determines model size on disk and memory usage during inference.

Compared with a full‑scale MobileNet‑V3 Large (≈5.4 M params, 0.28 GMAC), the minimal variant saves ~30 % memory and ~25 % compute with only a modest drop in accuracy, making it a sweet spot for latency‑critical applications.

Hardware Requirements

VRAM for inference: The model occupies roughly 15 MB of GPU memory when loaded in FP32, and 8 MB in FP16 or BF16. Adding the intermediate feature maps (used when features_only=True) can increase peak memory to ≈30 MB on a batch size of 1.

Recommended GPU: Any modern GPU with at least 2 GB VRAM (e.g., NVIDIA GTX 1650, RTX 3060, or AMD Radeon RX 5600) will run the model comfortably at >100 FPS for a single image. For batch inference, a GPU with 4 GB+ VRAM is advisable.

CPU requirements: On a recent CPU (e.g., Intel i7‑12700K or AMD Ryzen 7 5800X) the model can achieve ~30 FPS using PyTorch’s torch.nn.functional backend with torch.backends.cudnn.benchmark=True. For pure CPU inference, a 8‑core processor with SIMD extensions (AVX2/AVX‑512) is recommended.

Storage needs: The pre‑trained checkpoint (safetensors) is ~strong>12 MB. Including the PyTorch model definition and the model files, total disk usage stays under 30 MB.

Performance characteristics: With torch.no_grad() and half‑precision (torch.float16) the model can process a 224 × 224 image in ≈3 ms on an RTX 3060, making it suitable for real‑time video streams at 30 FPS.

Use Cases

The tf_mobilenetv3_large_minimal_100.in1k model shines in scenarios where low latency, small memory footprint, and decent accuracy are required.

• Mobile & edge AI: Real‑time object classification on smartphones, drones, or smart cameras without needing a cloud connection.
• Content moderation: Fast filtering of user‑generated images for prohibited content on social platforms.
• Feature extraction for similarity search: Embedding generation for image retrieval systems, where the 960‑channel feature map can be pooled into a compact vector.
• Transfer learning: Fine‑tuning the backbone on domain‑specific datasets (e.g., medical imaging, retail product catalogs) while keeping the lightweight nature.
• Embedded vision in robotics: Low‑power perception pipelines for autonomous navigation or manipulation.

Integration is straightforward via the timm API, which handles preprocessing, model loading, and inference with a few lines of code.

Training Details

Dataset: The model was trained on the ImageNet‑1k dataset (1 000 classes, ~1.28 M training images). The official TensorFlow training pipeline used standard data augmentation (random resized crop, horizontal flip, color jitter) and ImageNet‑specific mean/std normalization.

Training methodology:

• Optimizer: RMSprop with momentum 0.9.
• Learning‑rate schedule: cosine decay with warm‑up (first 5 epochs).
• Batch size: 256 images per GPU (distributed training across 8 GPUs in the original TF run).
• Number of epochs: 300 (≈90 epochs of effective training after warm‑up).
• Regularization: weight decay 4e‑5, dropout 0.2 on the final classifier.

Compute requirements: Training on ImageNet with this architecture typically consumes ~1.5 PF‑days of GPU compute (e.g., 8 × NVIDIA V100). The modest size of the model makes it feasible to train on a single high‑end GPU with a batch size of 128, though convergence may be slower.

Fine‑tuning capabilities: The model can be adapted to new tasks by:

1. Replacing the final nn.Linear layer with a task‑specific head (e.g., number of classes for a custom dataset).
2. Freezing early layers (e.g., first two feature blocks) and only training the later layers to reduce over‑fitting.
3. Using the features_only=True flag to extract intermediate feature maps for downstream detectors or segmenters.

All of this is supported out‑of‑the‑box by the timm library.

Related Papers

The model is grounded in the research presented in the following papers:

• Searching for MobileNetV3 – Andrew Howard et al., 2019. This paper introduces the MobileNet‑V3 architecture, including the hard‑swish activation and the efficient search‑based design that underpins the model.
• PyTorch Image Models (timm) – Ross Wightman, 2019. The repository that ports the TensorFlow weights to PyTorch and provides the timm.create_model interface.

These works combine neural‑architecture‑search (NAS) techniques with hardware‑aware constraints, producing a model that balances accuracy and efficiency for a wide range of devices.

Licensing Information

The model card lists the license as Apache‑2.0 in the tags, but the top‑level license field is marked “unknown”. In practice, the original MobileNet‑V3 implementation released by Google TensorFlow is under the Apache‑2.0 license, and the PyTorch port by Ross Wightman also adopts Apache‑2.0. This permissive license grants:

• Freedom to use, modify, and distribute the model in both commercial and non‑commercial projects.
• No requirement to disclose source code of derivative works (only the license notice must be retained).
• Patent grant for the patented technologies covered by the original paper.

Because the license is not explicitly confirmed on the Hugging Face hub, you should:

1. Verify the license file in the model repository.
2. Include the Apache‑2.0 notice in any redistribution, e.g., © 2019 Google, 2020 Ross Wightman. Licensed under Apache‑2.0.

Assuming Apache‑2.0 applies, commercial usage is fully permitted, provided you retain the attribution and do not use the trademarked “MobileNet” name in a way that suggests endorsement by Google.