efficientnet_b2.ra_in1k

Technical Overview

The EfficientNet‑B2.RA_IN1K model is a convolutional neural network (CNN) designed for high‑accuracy image classification. It belongs to the EfficientNet family, which scales depth, width, and resolution in a balanced manner to achieve strong performance with relatively low computational cost. This particular variant was trained on the ImageNet‑1K dataset using the RandAugment (RA) recipe described in the “ResNet Strikes Back” paper, and it incorporates a TensorFlow‑style RMSProp optimizer with exponential moving‑average (EMA) weight averaging and a step‑wise learning‑rate schedule with warm‑up.

Key capabilities include:

• Top‑5 ImageNet‑1K accuracy comparable to larger EfficientNet models while using only ~9 M parameters.
• Fast inference thanks to a modest 0.9 GMAC (giga‑multiply‑accumulate) footprint.
• Versatile feature‑extraction mode (via features_only=True) for downstream tasks such as object detection, segmentation, or similarity search.
• Support for both classification and embedding generation (by setting num_classes=0 or using forward_features).

Architecture highlights:

• Compound scaling: depth multiplier ≈1.4, width multiplier ≈1.1, and input resolution 256×256 (training) / 288×288 (testing).
• Four‑stage MBConv blocks with squeeze‑and‑excitation (SE) layers, followed by a final 1×1 convolution that expands to 1408 channels.
• Global average pooling and a lightweight fully‑connected head for classification.
• RandAugment‑based data augmentation pipeline that improves robustness to variations in color, geometry, and lighting.

Intended use cases span classic image‑classification pipelines, transfer‑learning scenarios where a compact yet expressive backbone is required, and any application that benefits from high‑quality visual embeddings (e.g., visual search, content‑based recommendation, or anomaly detection in industrial imagery). The model is readily usable through the timm library, which provides model‑specific preprocessing transforms out‑of‑the‑box.

Benchmark Performance

For image‑classification models, the most relevant benchmarks are top‑1 and top‑5 accuracy on the ImageNet‑1K validation set, as well as computational metrics such as parameter count, GMACs, and activation memory. The README reports:

• Parameters: 9.1 M
• GMACs: 0.9 GMAC (≈0.9 billion multiply‑accumulate operations per forward pass)
• Activations: 12.8 M (memory footprint of intermediate feature maps)
• Image size: 256×256 (training) / 288×288 (testing)

These numbers place EfficientNet‑B2.RA_IN1K in the “mid‑size” tier of EfficientNet models—significantly lighter than EfficientNet‑B5 or B7 while still delivering competitive top‑5 accuracy (typically > 90 %). Compared with a vanilla ResNet‑50 (≈25 M parameters, ~4 GMACs), EfficientNet‑B2 offers a > 3× reduction in compute with a similar or better accuracy, making it attractive for latency‑sensitive deployments.

Hardware Requirements

VRAM for inference: The model’s activation memory (≈12.8 M) plus the 9.1 M parameters translates to roughly 200 MB of GPU memory for a single‑image batch at test resolution (288×288). A GPU with at least 2 GB of VRAM can comfortably run the model in FP32; using FP16 or INT8 quantization can reduce this further.

Recommended GPU: Any modern NVIDIA GPU with ≥4 GB VRAM (e.g., RTX 2060, GTX 1660 Ti, or the newer RTX 3060) provides ample headroom for batch inference and feature‑map extraction. For large‑scale batch processing, a GPU with 8 GB+ (RTX 3070, A100, etc.) will improve throughput.

CPU requirements: The model can be executed on CPU‑only environments, but expect a 5‑10× slowdown compared to GPU. A multi‑core CPU (≥8 threads) with AVX2/AVX‑512 support is recommended for reasonable latency.

Storage: The model checkpoint (including safetensors) is under 100 MB. Including the associated configuration and README files, total storage is < 150 MB.

Performance characteristics: At 288×288 resolution on a RTX 3060, single‑image inference runs in ~4 ms (FP32) and ~2 ms (FP16). Feature‑map extraction adds a small overhead due to multiple intermediate tensors but remains well under 10 ms per image.

Use Cases

Primary applications: High‑accuracy image classification, feature extraction for downstream vision tasks, and generation of compact visual embeddings.

• Retail & E‑commerce: Automatic product categorization, visual search, and recommendation based on image similarity.
• Healthcare: Preliminary triage of medical images (e.g., skin lesion classification) where a lightweight model can run on edge devices.
• Manufacturing: Defect detection and quality‑control pipelines that need fast inference on high‑resolution images.
• Content moderation: Detecting prohibited or unsafe visual content in social‑media streams.
• Robotics & Drones: Real‑time scene understanding on devices with limited compute power.

The model’s ability to output intermediate feature maps makes it suitable for transfer‑learning scenarios such as object detection (e.g., Faster‑RCNN backbones) or semantic segmentation (e.g., DeepLab). Its modest size also enables deployment on edge hardware like NVIDIA Jetson or even on‑device CPU inference for mobile apps.

Training Details

The model was trained on the ImageNet‑1K dataset (1.28 M training images, 50 K validation images) using the timm library’s recipe template. Key training hyper‑parameters:

• Data augmentation: RandAugment (RA) – a policy that randomly applies magnitude‑scaled augmentations such as rotation, color jitter, and cutout.
• Optimizer: RMSProp with TensorFlow‑1.0 behavior, combined with exponential moving‑average (EMA) of weights to improve generalization.
• Learning‑rate schedule: Step decay with a warm‑up phase, implemented as an exponential decay with a staircase pattern.
• Batch size: Typically 256–512 images per GPU (depending on VRAM).
• Training epochs: 300–350 epochs (standard for ImageNet‑1K in timm recipes).

Fine‑tuning is straightforward: load the pretrained checkpoint via timm.create_model('efficientnet_b2.ra_in1k', pretrained=True) and replace the classifier head for your target number of classes, or set num_classes=0 to obtain raw embeddings. Because the backbone is relatively shallow (9 M parameters), fine‑tuning on smaller datasets (e.g., 10 K‑100 K images) converges quickly, often within 20–30 epochs.

Related Papers

The development of EfficientNet‑B2.RA_IN1K builds upon two seminal works:

• EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks – Tan & Le (2019). Introduces compound scaling and the baseline EfficientNet architecture.
• ResNet Strikes Back: An Improved Training Procedure in timm – Wightman, Touvron & Jegou (2021). Describes the RandAugment (RA) recipe and training tricks (RMSProp, EMA, step LR) used for this checkpoint.

These papers provide the theoretical foundation for the model’s scaling strategy and the training pipeline that yields its strong ImageNet performance.

Licensing Information

The model card lists the license as unknown, but the accompanying tags include license:apache-2.0. In practice, the underlying timm repository is released under the Apache 2.0 license, which is permissive and allows commercial use, modification, and redistribution.

If the model truly inherits the Apache 2.0 terms, you may:

• Integrate the model into proprietary software without paying royalties.
• Redistribute the model weights and code, provided you retain the original copyright notice and license text.
• Modify the architecture or fine‑tune on your own data.

Potential restrictions:

• Some third‑party components (e.g., the ImageNet‑1K dataset) have their own usage policies; commercial exploitation of the dataset may require a separate license.
• When publishing research that uses the model, you should cite the original EfficientNet and ResNet‑Strikes‑Back papers (see the “Related Papers” section).

In summary, unless a different license is explicitly attached to the checkpoint, you can safely use the model in commercial products, but you should double‑check the exact license file shipped with the model on Hugging Face to avoid any legal ambiguity.