rexnet_150.nav_in1k

Technical Overview

What is this model? rexnet_150.nav_in1k is a lightweight convolutional neural network designed for image‑classification tasks. It belongs to the ReXNet family, which re‑thinks channel dimensions to achieve high accuracy with a modest computational budget. The model is pretrained on the ImageNet‑1k dataset and can be used directly for inference, feature‑map extraction, or as a backbone for downstream vision tasks.

Key features & capabilities

• Only 9.7 M parameters – suitable for edge devices and fast inference.
• Very low compute: 0.9 GMAC per 224 × 224 image.
• Rich multi‑scale feature maps (5 stages) for tasks such as detection or segmentation.
• Native timm integration – one‑line model creation and data‑pipeline utilities.

Architecture highlights

• Depth‑wise separable convolutions with a progressive channel‑expansion strategy.
• Efficient Squeeze‑Excitation (SE) blocks that improve channel‑wise attention without heavy overhead.
• Four‑stage backbone ending with a 1920‑channel feature map (7 × 7 spatial resolution).
• Standard 224 × 224 input size, matching the ImageNet‑1k training regime.

Intended use cases – rapid image classification, feature extraction for transfer learning, and as a backbone for lightweight object‑detection or semantic‑segmentation pipelines where latency and memory are constrained.

Benchmark Performance

The most relevant benchmarks for an ImageNet‑pretrained classification backbone are top‑1 and top‑5 accuracy on the ImageNet‑1k validation set, as well as model size and FLOPs. According to the official timm results:

These numbers place rexnet_150 in the “mid‑range” of the ReXNet family – offering a solid trade‑off between accuracy and compute. Compared with larger ReXNet variants (e.g., rexnet_300 at 82.8 % top‑1) it saves roughly half the parameters while staying within 2 % absolute accuracy, making it attractive for latency‑sensitive deployments.

Hardware Requirements

• VRAM for inference – ~2 GB is sufficient for a batch size of 1 (including the model and intermediate activations). For batch‑size ≥ 8, allocate 4 GB – 6 GB.
• Recommended GPU – any modern NVIDIA GPU with ≥ 4 GB memory (e.g., RTX 2060, GTX 1660 Ti) or equivalent AMD Radeon. The low GMAC count means inference can reach > 200 FPS on such hardware.
• CPU – a multi‑core CPU (8 + threads) can run the model at ~30 FPS when GPU acceleration is unavailable, though latency will be higher.
• Storage – the model file (including safetensors) is under 50 MB. A modest SSD/HDD is ample.
• Performance characteristics – the model’s 5‑stage feature map output enables fast extraction for downstream tasks without extra up‑sampling.

Use Cases

Primary applications – fast image classification on mobile/embedded devices, feature extraction for few‑shot learning, and as a backbone for lightweight detection (e.g., YOLO‑style heads) or segmentation (e.g., DeepLab‑lite).

Real‑world examples

• Retail inventory scanning on a handheld scanner.
• Real‑time quality inspection in manufacturing lines where a 224 × 224 image is captured per item.
• Mobile health apps that classify skin lesions with minimal latency.

Integration possibilities – the model works out‑of‑the‑box with timm pipelines, ONNX export, and TorchScript, making deployment to Android/iOS, TensorRT, or edge‑AI frameworks straightforward.

Training Details

Dataset – the model was pretrained on the ImageNet‑1k dataset (1.28 M images, 1000 classes). The training regime follows the standard ImageNet protocol (random resized crop, horizontal flip, and ImageNet mean/std normalization).

Methodology – the original authors used stochastic gradient descent with a cosine‑annealing learning‑rate schedule, batch size 256, and weight decay 4e‑5. The training was performed on multiple NVIDIA V100 GPUs for roughly 90 epochs.

Compute requirements – a 4‑GPU setup (8 × V100) can finish the full ImageNet pre‑training in ~12 hours. Fine‑tuning on a downstream dataset typically requires 1‑2 GPU‑days for a few hundred classes.

Fine‑tuning capabilities – 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. The forward_head method provides a pre‑logits vector that is ideal for metric‑learning or similarity search.

Related Papers

• Rethinking Channel Dimensions for Efficient Model Design – the foundational ReXNet paper (Han et al., 2021).
• timm: PyTorch Image Models – the library that provides the implementation and training scripts.

The ReXNet architecture builds on the idea of channel‑wise scaling, offering a more balanced trade‑off between depth, width, and resolution than classic MobileNet or EfficientNet families. The paper demonstrates that careful channel dimension selection can yield up to 2 % higher top‑1 accuracy at the same FLOP budget.

Licensing Information

The repository lists the paper under an MIT license, and the model card inherits the same MIT terms. However, the Hugging Face metadata marks the license as unknown. In practice, the underlying code (timm) and the pretrained weights are distributed under the permissive MIT license, which:

• Allows commercial and non‑commercial use without royalty.
• Permits modification, redistribution, and inclusion in proprietary products.
• Requires that the original copyright notice and license text be retained in any distribution.

If you intend to use the model in a closed‑source product, double‑check the Hugging Face model card for any updates on licensing. Providing attribution to the original authors (Dongyoon Han et al.) and the timm library is good practice.