CtrlK
MobileNet is a family of efficient convolutional neural network (CNN) architectures developed by Google for mobile and edge AI applications. First introduced in 2017 by Andrew G. Howard and colleagues, MobileNet was designed to deliver competitive accuracy on computer vision tasks while operating within the strict computational, memory, and power constraints of smartphones, embedded systems, and IoT devices. The architecture's core innovation, depthwise separable convolutions, dramatically reduces the number of parameters and floating-point operations compared to standard convolutions. Over the years, the MobileNet family has grown through four major versions, each introducing new architectural ideas and improving the accuracy-efficiency tradeoff.
As of 2025, the MobileNet family spans four generations: MobileNetV1 (2017), MobileNetV2 (2018), MobileNetV3 (2019), and MobileNetV4 (2024). These models have become foundational building blocks for on-device machine learning, powering applications from image classification and object detection to semantic segmentation and pose estimation on billions of devices worldwide.
The rise of deep learning in computer vision brought models that achieved remarkable accuracy on benchmarks such as ImageNet, but these models often required billions of floating-point operations and hundreds of millions of parameters. Networks like VGG, ResNet, and Inception were designed primarily for server-side inference with powerful GPUs. Deploying such models on mobile phones, drones, autonomous vehicles, or wearable devices posed serious challenges due to limited compute power, memory, battery life, and thermal constraints.
Before MobileNet, several approaches attempted to address model efficiency, including network pruning, quantization, and knowledge distillation. However, these methods were typically applied as post-processing steps to already-large models. MobileNet took a fundamentally different approach: designing an architecture from the ground up to be efficient, using depthwise separable convolutions as the primary building block.
The original idea behind depthwise separable convolutions can be traced back to Laurent Sifre's work during an internship at Google Brain in 2013, where he explored factorized convolutions as an architectural variation to improve convergence speed and reduce model size. This concept was later refined and formalized in the Xception architecture by Francois Chollet and ultimately in the MobileNet paper series.
MobileNetV1 was introduced in the paper "MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications" by Andrew G. Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam, all affiliated with Google. The paper was published on arXiv in April 2017.
The central contribution of MobileNetV1 is the systematic use of depthwise separable convolutions to replace standard convolutions throughout the network. This single design choice reduces the computational cost by a factor of 8 to 9 while incurring only a small loss in accuracy (roughly 1% on ImageNet).
A standard convolution simultaneously filters and combines input features into new output features in a single step. For a standard convolutional layer with a kernel size of D_K x D_K, M input channels, N output channels, and a spatial feature map of size D_F x D_F, the computational cost is:
Standard convolution cost: D_K x D_K x M x N x D_F x D_F multiply-adds
Depthwise separable convolutions factorize this operation into two distinct steps:
The total cost of a depthwise separable convolution is:
Depthwise separable cost: D_K x D_K x M x D_F x D_F + M x N x D_F x D_F
The reduction ratio compared to standard convolution is 1/N + 1/D_K^2. For MobileNet's 3x3 kernels, this yields roughly an 8 to 9 times reduction in computation. Each depthwise separable convolution block in MobileNetV1 includes batch normalization and ReLU activation after both the depthwise and pointwise layers.
The MobileNetV1 architecture consists of 28 layers. The first layer is a standard 3x3 convolution with 32 filters and stride 2, followed by 13 depthwise separable convolution blocks (each counting as two layers: one depthwise and one pointwise). The network concludes with a global average pooling layer (7x7) and a fully connected layer with 1,000 outputs for ImageNet classification.
Spatial downsampling is handled by depthwise convolutions with a stride of 2 at selected layers. Each time the spatial dimension is halved, the number of channels doubles to compensate for the loss of spatial information. The channel progression goes from 32 to 64, 128, 256, 512, and finally 1,024.
MobileNetV1 introduces two hyperparameters that allow practitioners to trade off latency and accuracy according to their deployment requirements:
These multipliers allow MobileNetV1 to cover a wide range of deployment scenarios, from high-accuracy server-class models to extremely compact models for the most resource-constrained devices.
| Configuration | Top-1 Accuracy (%) | Multiply-Adds (M) | Parameters (M) |
|---|---|---|---|
| MobileNetV1 1.0, 224 | 70.6 | 569 | 4.2 |
| MobileNetV1 0.75, 224 | 68.4 | 325 | 2.6 |
| MobileNetV1 0.50, 224 | 63.7 | 149 | 1.3 |
| MobileNetV1 0.25, 224 | 50.6 | 41 | 0.5 |
At full width and 224x224 resolution, MobileNetV1 achieved 70.6% top-1 accuracy on ImageNet with only 569 million multiply-add operations and 4.2 million parameters. For comparison, VGGNet-16 requires roughly 15.3 billion multiply-adds and 138 million parameters to achieve 71.5% top-1 accuracy, making MobileNetV1 roughly 26 times smaller and 27 times less computationally expensive.
MobileNetV2 was introduced in "MobileNetV2: Inverted Residuals and Linear Bottlenecks" by Mark Sandler, Andrew Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. The paper was published at CVPR 2018 in Salt Lake City.
MobileNetV2 builds on the foundation of depthwise separable convolutions from V1 but introduces two key architectural innovations: inverted residual blocks and linear bottlenecks. These changes improve both accuracy and efficiency.
Traditional residual networks use a "wide-narrow-wide" bottleneck structure: the input is first projected to a lower-dimensional space, processed with a spatial convolution, and then projected back to a higher-dimensional space. The skip connection bridges the wide layers. MobileNetV2 inverts this pattern with a "narrow-wide-narrow" structure:
Shortcut connections are placed between the thin bottleneck layers (the inputs and outputs of the block), not between the expanded layers. This is the opposite of traditional residual networks, hence the name "inverted residual." The inverted design is more memory-efficient because the skip connections carry low-dimensional tensors, reducing peak memory usage during inference.
A critical insight in MobileNetV2 is that applying a nonlinear activation (such as ReLU) in the narrow bottleneck layers destroys information. When the feature space is low-dimensional, ReLU can zero out a significant portion of the information, collapsing the learned manifold. To address this, MobileNetV2 removes the nonlinearity from the output of the bottleneck projection layer, using a linear activation instead. This preserves the representational power of the low-dimensional features. ReLU6 activation is used only after the expansion and depthwise convolution layers, where the feature space is high-dimensional enough to tolerate the information loss.
The MobileNetV2 architecture begins with a standard 32-filter convolution layer and is followed by 19 inverted residual bottleneck layers. The architecture table uses the notation t for expansion factor, c for output channels, n for number of repeated blocks, and s for stride of the first block in each stage.
| Input Resolution | Operator | t | c | n | s |
|---|---|---|---|---|---|
| 224 x 224 x 3 | conv2d | - | 32 | 1 | 2 |
| 112 x 112 x 32 | bottleneck | 1 | 16 | 1 | 1 |
| 112 x 112 x 16 | bottleneck | 6 | 24 | 2 | 2 |
| 56 x 56 x 24 | bottleneck | 6 | 32 | 3 | 2 |
| 28 x 28 x 32 | bottleneck | 6 | 64 | 4 | 2 |
| 14 x 14 x 64 | bottleneck | 6 | 96 | 3 | 1 |
| 14 x 14 x 96 | bottleneck | 6 | 160 | 3 | 2 |
| 7 x 7 x 160 | bottleneck | 6 | 320 | 1 | 1 |
| 7 x 7 x 320 | conv2d 1x1 | - | 1280 | 1 | 1 |
The network concludes with a 1x1 convolution expanding to 1,280 channels, followed by global average pooling and a classification layer.
| Configuration | Top-1 Accuracy (%) | Multiply-Adds (M) | Parameters (M) |
|---|---|---|---|
| MobileNetV2 1.4, 224 | 75.0 | 582 | 6.06 |
| MobileNetV2 1.0, 224 | 71.8 | 300 | 3.47 |
| MobileNetV2 0.75, 224 | 69.8 | 209 | 2.61 |
| MobileNetV2 0.50, 224 | 65.4 | 97 | 1.95 |
| MobileNetV2 0.35, 224 | 60.3 | 59 | 1.66 |
At 1.0 width multiplier and 224x224 resolution, MobileNetV2 achieves 71.8% top-1 accuracy on ImageNet with only 300 million multiply-adds and 3.47 million parameters. Compared to MobileNetV1 (70.6% accuracy, 569M MAdds, 4.2M parameters), V2 is both more accurate and roughly 47% more computationally efficient. On a Google Pixel phone, MobileNetV2 runs 30 to 40% faster than MobileNetV1.
The paper also introduced SSDLite (a lightweight version of SSD for object detection that replaces standard convolutions in the detection head with depthwise separable convolutions) and Mobile DeepLabv3 (a lightweight version of DeepLabv3 for semantic segmentation), demonstrating MobileNetV2's versatility as a feature extraction backbone for multiple tasks.
MobileNetV3 was introduced in "Searching for MobileNetV3" by Andrew Howard, Mark Sandler, Grace Chu, Liang-Chieh Chen, Bo Chen, Mingxing Tan, Weijun Wang, Yukun Zhu, Ruoming Pang, Vijay Vasudevan, Quoc V. Le, and Hartwig Adam. The paper was published at ICCV 2019.
MobileNetV3 represents a shift in methodology: instead of relying purely on manual architectural design, it combines hardware-aware neural architecture search (NAS) with hand-crafted refinements. The result is two model variants, MobileNetV3-Large and MobileNetV3-Small, targeting high and low resource use cases respectively.
MobileNetV3's architecture was discovered through a two-stage process:
This combination of global automated search and local layer-by-layer refinement produces architectures that are well-tuned to specific hardware targets.
MobileNetV3 replaces the standard ReLU and swish activation functions with hard versions that are more computationally efficient:
The swish activation function (x * sigmoid(x)) improves accuracy compared to ReLU but is computationally expensive because of the sigmoid operation, which requires computing an exponential. The hard swish approximation replaces the sigmoid with a piecewise linear function (hard sigmoid), maintaining the accuracy benefits while being much cheaper to compute on mobile hardware. Hard swish is applied in the deeper layers of the network (those with 80 or more channels) where it has the greatest impact on accuracy, while ReLU is retained in the earlier layers where it is sufficient and less costly.
MobileNetV3 incorporates squeeze-and-excitation (SE) modules into its building blocks. Originally proposed by Hu et al. (2018), SE modules enable the network to adaptively recalibrate channel-wise feature responses by modeling interdependencies between channels:
In MobileNetV3, the SE bottleneck size is fixed at 1/4 of the number of channels in the expansion layer. This provides a meaningful accuracy improvement with a modest increase in parameter count and no discernible latency cost on most hardware.
Beyond NAS and NetAdapt, the MobileNetV3 paper introduces several manual architectural refinements:
| Model | Top-1 Accuracy (%) | Multiply-Adds (M) | Parameters (M) |
|---|---|---|---|
| MobileNetV3-Large 1.0 | 75.2 | 217 | 5.4 |
| MobileNetV3-Large 0.75 | 73.3 | 155 | 4.0 |
| MobileNetV3-Small 1.0 | 67.5 | 66 | 2.9 |
| MobileNetV3-Small 0.75 | 65.4 | 44 | 2.4 |
| MobileNetV2 1.0 (baseline) | 71.8 | 300 | 3.47 |
MobileNetV3-Large achieves 75.2% top-1 accuracy with only 217 million multiply-adds, a significant improvement over MobileNetV2's 71.8% at 300M MAdds. MobileNetV3-Large is 3.2% more accurate while reducing latency by about 15% compared to MobileNetV2. MobileNetV3-Small is 4.6% more accurate than the comparable MobileNetV2 variant while reducing latency by about 5%.
Google also released "minimalistic" variants of MobileNetV3 that remove SE modules and h-swish for deployment on hardware where these operations are not well supported. MobileNetV3-Large minimalistic achieves 72.3% top-1 accuracy with 209M multiply-adds and 3.9M parameters.
For 8-bit quantized inference, MobileNetV3-Large retains 73.9% top-1 accuracy (a drop of 1.3 percentage points from floating-point), demonstrating good quantization friendliness.
MobileNetV4 was introduced in "MobileNetV4: Universal Models for the Mobile Ecosystem" by Danfeng Qin, Chas Leichner, Manolis Delakis, Marco Fornoni, Shixin Luo, Fan Yang, Weijun Wang, Colby Banbury, Chengxi Ye, Berkin Akin, Vaibhav Aggarwal, Tenghui Zhu, Daniele Moro, and Andrew Howard at Google. The paper was published at ECCV 2024.
MobileNetV4 was designed with a focus on universal efficiency: performing well not just on a single hardware platform but across a wide range of mobile accelerators, including mobile CPUs, GPUs, DSPs, Apple Neural Engine, and Google Pixel EdgeTPU. Prior MobileNet generations were typically optimized for specific hardware targets, but V4 aims for Pareto optimality across the entire mobile hardware ecosystem.
The core building block of MobileNetV4 is the Universal Inverted Bottleneck (UIB), a flexible and unified structure that generalizes several existing block designs:
The UIB extends the inverted bottleneck by introducing two optional depthwise convolutions: one before the expansion layer and one between the expansion and projection layers. Whether these depthwise convolutions are present is determined through NAS optimization, allowing the search to select the most efficient block type for each position in the network.
MobileNetV4 introduces a hybrid architecture that combines convolutions with attention mechanisms. The Mobile MQA block is an attention mechanism tailored for mobile accelerators. It uses shared keys and values across attention heads (multi-query attention), which reduces memory bandwidth requirements and improves operational intensity. Mobile MQA delivers a 39% inference speedup compared to standard multi-head self-attention while preserving accuracy.
MobileNetV4 also introduces an improved NAS recipe that enhances search effectiveness. The refined search process, combined with UIB and Mobile MQA, produces models that are Pareto optimal across a wide range of hardware platforms.
The paper introduces a novel knowledge distillation recipe that mixes datasets with different augmentations and adds balanced in-class data. Using this technique, the MobileNetV4-Hybrid-Large model achieves 87.0% top-1 accuracy on ImageNet-1K with just 3.8ms latency on the Pixel 8 EdgeTPU. The distilled model is 39 times smaller in MACs than its teacher while being only 0.5% less accurate.
| Model | Top-1 Accuracy (%) | MACs (G) | Parameters (M) | Pixel 6 CPU (ms) | Pixel 8 EdgeTPU (ms) | Samsung S23 GPU (ms) |
|---|---|---|---|---|---|---|
| MNv4-Conv-S | 73.8 | 0.2 | 3.8 | 2.4 | 0.7 | 2.0 |
| MNv4-Conv-M | 79.9 | 1.0 | 9.2 | 11.4 | 1.1 | 4.1 |
| MNv4-Conv-L | 82.9 | 5.9 | 31.0 | 59.9 | 2.4 | 13.2 |
| MNv4-Hybrid-M | 80.7 | 1.2 | 10.5 | 14.3 | 1.5 | 5.9 |
| MNv4-Hybrid-L | 83.4 | 7.2 | 35.9 | 87.6 | 3.8 | 18.1 |
| MNv4-Hybrid-L (distilled) | 87.0 | 7.2 | 35.9 | 87.6 | 3.8 | 18.1 |
The following table summarizes the key specifications across all MobileNet versions at their default configurations on ImageNet-1K classification.
| Model | Year | Top-1 Accuracy (%) | Multiply-Adds / MACs | Parameters (M) | Key Innovation |
|---|---|---|---|---|---|
| MobileNetV1 1.0 | 2017 | 70.6 | 569M | 4.2 | Depthwise separable convolutions |
| MobileNetV2 1.0 | 2018 | 71.8 | 300M | 3.47 | Inverted residuals, linear bottlenecks |
| MobileNetV3-Large 1.0 | 2019 | 75.2 | 217M | 5.4 | NAS + NetAdapt, h-swish, SE modules |
| MobileNetV3-Small 1.0 | 2019 | 67.5 | 66M | 2.9 | Compact NAS-optimized variant |
| MNv4-Conv-S | 2024 | 73.8 | 200M | 3.8 | Universal Inverted Bottleneck |
| MNv4-Conv-M | 2024 | 79.9 | 1.0G | 9.2 | UIB + optimized NAS |
| MNv4-Hybrid-L | 2024 | 83.4 | 7.2G | 35.9 | UIB + Mobile MQA attention |
| MNv4-Hybrid-L (distilled) | 2024 | 87.0 | 7.2G | 35.9 | Enhanced distillation recipe |
From V1 to V4, the MobileNet family has evolved from a purely convolutional architecture to a hybrid convolutional-attention design. The accuracy on ImageNet has climbed from 70.6% (V1) to 87.0% (V4 with distillation), while the architectural innovations have progressively expanded from depthwise separable convolutions to inverted residuals, NAS-designed structures, and attention mechanisms.
EfficientNet, introduced by Mingxing Tan and Quoc V. Le in 2019, takes a different approach to model efficiency. Rather than designing novel convolution types, EfficientNet uses a compound scaling method that simultaneously scales network width (number of channels), depth (number of layers), and input resolution using a fixed set of scaling coefficients derived from a grid search. The scaling follows the relationship alpha^phi * beta^phi * gamma^phi approximately equals 2, where phi is the compound coefficient. The baseline EfficientNet-B0 model was discovered through NAS and uses mobile inverted bottleneck convolution (MBConv) blocks, which are the same building blocks as MobileNetV2.
| Model | Top-1 Accuracy (%) | FLOPs (M) | Parameters (M) |
|---|---|---|---|
| MobileNetV2 1.0 | 71.8 | 300 | 3.47 |
| MobileNetV3-Large 1.0 | 75.2 | 217 | 5.4 |
| EfficientNet-B0 | 77.1 | 390 | 5.3 |
| EfficientNet-B1 | 79.8 | 700 | 7.8 |
| MNv4-Conv-M | 79.9 | 1,000 | 9.2 |
EfficientNet-B0 achieves higher accuracy than MobileNetV3-Large (77.1% vs. 75.2%) with a similar parameter count but at a higher computational cost (390M vs. 217M FLOPs). However, MobileNet models are generally faster in actual inference on mobile hardware because they are explicitly optimized for hardware-specific latency, whereas EfficientNet's compound scaling optimizes primarily for FLOPs. FLOPs alone do not perfectly predict on-device speed, because factors such as memory access patterns, operator support, and hardware-specific optimizations affect actual inference latency. MobileNetV4 closes and surpasses the accuracy gap through its UIB blocks and hybrid attention mechanisms.
ShuffleNet, developed by Xiangyu Zhang and colleagues at Megvii (Face++), uses two key operations to achieve efficiency: pointwise group convolutions and channel shuffling. ShuffleNet V1 (Zhang et al., CVPR 2018) demonstrated that group convolutions combined with channel shuffling could significantly reduce computational cost. In pointwise group convolution, the input channels are partitioned into groups, and convolutions are applied independently within each group. The channel shuffle operation then rearranges the output channels across groups, ensuring that downstream layers can access features from all groups.
ShuffleNet V2 (Ma et al., ECCV 2018) refined this approach based on four practical guidelines for efficient architecture design. The authors argued that FLOPs alone are an insufficient proxy for actual inference speed and proposed: (1) equal channel width minimizes memory access cost, (2) excessive group convolution increases memory access cost, (3) network fragmentation reduces parallelism, and (4) element-wise operations are not negligible. ShuffleNet V2 replaced group convolutions with channel split operations for better hardware efficiency.
| Model | Top-1 Accuracy (%) | FLOPs (M) | Parameters (M) |
|---|---|---|---|
| MobileNetV2 1.0 | 71.8 | 300 | 3.47 |
| ShuffleNetV2 1.5x | 72.6 | 299 | 3.5 |
| MobileNetV3-Large 1.0 | 75.2 | 217 | 5.4 |
| ShuffleNetV2 1.0x | 69.4 | 146 | 2.3 |
| MobileNetV1 0.50 | 63.7 | 149 | 1.3 |
At comparable FLOPs budgets (roughly 300M), ShuffleNetV2 1.5x achieves 72.6% top-1 accuracy, which is slightly better than MobileNetV2 1.0 (71.8%). ShuffleNet V2 tends to be faster than MobileNetV2 in actual inference on both GPU and ARM platforms because it follows hardware-friendly design principles. However, the differences are often small, and MobileNet models benefit from broader software ecosystem support in TensorFlow Lite and other deployment frameworks, plus more extensive hardware-specific optimizations.
The success of vision transformers (ViTs) in computer vision prompted researchers to explore hybrid architectures that combine the efficiency of MobileNet-style convolutions with the global context modeling of transformer self-attention.
MobileViT was introduced by Sachin Mehta and Mohammad Rastegari at Apple, published at ICLR 2022. MobileViT is a lightweight hybrid backbone that alternates MobileNetV2-style inverted residual blocks with transformer-based "MobileViT blocks." Each MobileViT block unfolds spatial features into a sequence of patches, applies multi-head self-attention to capture global relationships across the entire feature map, and then folds the features back into their spatial arrangement. This approach treats transformers as convolutions, combining local spatial processing (from convolutions) with global receptive fields (from self-attention).
| Model | Year | Top-1 Accuracy (%) | FLOPs (G) | Parameters (M) | Key Feature |
|---|---|---|---|---|---|
| MobileViT-XXS | 2022 | 69.0 | 0.4 | 1.3 | Smallest variant |
| MobileViT-XS | 2022 | 74.8 | 0.7 | 2.3 | Mid-range variant |
| MobileViT-S | 2022 | 78.4 | 2.0 | 5.6 | CNN + transformer hybrid |
| MobileViT v2 (1.0) | 2022 | 75.6 | - | ~3.0 | Separable self-attention, O(k) complexity |
| MobileViT v3-S | 2023 | ~79.3 | ~2.0 | ~6.0 | Improved fusion block |
MobileViT-S achieves 78.4% top-1 accuracy with about 5.6 million parameters, which is 3.2% more accurate than MobileNetV3-Large and 6.2% more accurate than DeiT for a similar parameter count. On the MS-COCO object detection benchmark, MobileViT is 5.7% more accurate than MobileNetV3 at a similar parameter budget.
MobileViT V2 (Mehta and Rastegari, 2022) replaces standard multi-head self-attention (which has O(k^2) complexity with respect to the number of tokens k) with separable self-attention, reducing the complexity to O(k). Each token attends to a single learnable latent token via element-wise operations rather than attending to every other token directly. MobileViT v2 achieves 75.6% top-1 accuracy with approximately 3 million parameters, outperforming MobileViT v1 by about 1 percentage point while running 3.2 times faster on a mobile device.
MobileViT v3 (Wadekar and Roop, 2023) introduces improved fusion strategies for combining local, global, and input features. It replaces 3x3 convolutional layers with 1x1 convolutional layers in the fusion block and adds residual connections from the local representation block. The MobileViT v3 variants (XXS, XS, and S) achieve top-1 accuracies ranging from approximately 71% to 79% on ImageNet, boosting accuracy by roughly 2 percentage points over MobileViT v2 at comparable model sizes.
MobileNet models are among the most widely deployed neural networks in the world, running on over 4 billion devices through TensorFlow Lite (now LiteRT) and other on-device inference frameworks. Their compact size and low latency make them suitable for applications that require real-time inference without network connectivity.
Common on-device applications include:
TensorFlow Lite (TFLite) is Google's open-source framework for running machine learning models on mobile, embedded, and IoT devices. MobileNet models have been first-class citizens in the TFLite ecosystem since its inception. TFLite provides optimized kernels for depthwise separable convolutions and supports various optimization techniques:
In September 2024, Google rebranded TensorFlow Lite as LiteRT (Lite Runtime), reflecting the framework's expanded support for models authored in PyTorch, JAX, and Keras. The change is purely a rebrand; existing .tflite model files and conversion tools remain fully compatible with LiteRT.
Core ML is Apple's machine learning framework for iOS, iPadOS, macOS, watchOS, and tvOS. MobileNet models can be converted to the Core ML format (.mlmodel) using Apple's coremltools Python library. Core ML leverages the Apple Neural Engine (ANE) for hardware-accelerated inference, providing fast and energy-efficient execution. MobileViT, developed by Apple researchers, is natively supported in Core ML and optimized for Apple silicon.
Google's Edge TPU, available through the Coral hardware platform, is specifically designed to run quantized TFLite models such as MobileNet. In internal benchmarks, inference with the Edge TPU is 70 to 100 times faster than on a CPU for MobileNet-based models. Coral devices include the Dev Board (a single-board Linux computer with an Edge TPU), the USB Accelerator (which adds an Edge TPU to any Linux system, including Raspberry Pi), and the Coral SoM (System-on-Module) for production deployments.
Google has released MobileNet-EdgeTPU variants that are specifically optimized for Edge TPU hardware. For example, MobilenetEdgeTPU at 1.0 width achieves 75.6% top-1 accuracy on ImageNet in 8-bit quantized mode with 990 million multiply-adds.
Beyond smartphones and dedicated accelerators, MobileNet models are deployed across a wide range of edge devices:
MobileNet models are available in the ONNX (Open Neural Network Exchange) format, enabling deployment across frameworks and hardware platforms. ONNX Runtime provides optimized inference for MobileNet on a variety of hardware backends including CPUs, GPUs, and specialized accelerators from Intel, Qualcomm, and others. PyTorch Mobile provides another deployment path, with official MobileNetV3 implementations available in torchvision.
Deploying MobileNet on real hardware often involves additional optimization steps beyond the architecture itself.
Post-training quantization converts the 32-bit floating-point weights of a trained MobileNet model to 8-bit integers (INT8). This reduces the model size by roughly 4 times and speeds up inference on hardware that supports integer arithmetic. For MobileNetV3-Large, 8-bit quantization reduces the top-1 accuracy from 75.2% to 73.9%, a modest trade-off given the significant gains in size and speed. For MobileNetV3-Small, the drop is from 67.5% to 64.9%.
Quantization-aware training (QAT) simulates quantization effects during the training process, allowing the network to learn to compensate for the reduced precision. QAT typically recovers most of the accuracy lost through post-training quantization and is recommended for deployment scenarios where every fraction of a percentage point of accuracy matters.
Structured and unstructured pruning can further reduce MobileNet's parameter count by removing weights or entire channels that contribute least to the model's output. When combined with quantization, pruning can yield extremely compact models suitable for microcontroller-class devices.
The following table compares MobileNet models with other popular lightweight architectures on the ImageNet classification benchmark.
| Model | Top-1 (%) | FLOPs | Params (M) | Architecture Family |
|---|---|---|---|---|
| MobileNetV1 1.0 | 70.6 | 569M | 4.2 | MobileNet |
| MobileNetV2 1.0 | 71.8 | 300M | 3.47 | MobileNet |
| MobileNetV3-Large 1.0 | 75.2 | 217M | 5.4 | MobileNet |
| MNv4-Conv-M | 79.9 | 1.0G | 9.2 | MobileNet |
| MNv4-Hybrid-L (distilled) | 87.0 | 7.2G | 35.9 | MobileNet |
| ShuffleNetV2 1.0x | 69.4 | 146M | 2.3 | ShuffleNet |
| ShuffleNetV2 1.5x | 72.6 | 299M | 3.5 | ShuffleNet |
| EfficientNet-B0 | 77.1 | 390M | 5.3 | EfficientNet |
| EfficientNet-B1 | 79.8 | 700M | 7.8 | EfficientNet |
| MobileViT-S | 78.4 | 2.0G | 5.6 | MobileViT |
| NASNet-A Mobile | 74.0 | 564M | 5.3 | NASNet |
These numbers show that within the lightweight model space, accuracy and efficiency have improved dramatically over the span of seven years. MobileNetV4 with distillation achieves accuracy that was previously only possible with models orders of magnitude larger.
| Feature | MobileNetV1 | MobileNetV2 | MobileNetV3 | MobileNetV4 |
|---|---|---|---|---|
| Year | 2017 | 2018 | 2019 | 2024 |
| Core Block | Depthwise separable conv | Inverted residual with linear bottleneck | Inverted residual + SE + h-swish | Universal Inverted Bottleneck (UIB) |
| Residual Connections | No | Yes (narrow-to-narrow) | Yes (narrow-to-narrow) | Yes |
| Activation Function | ReLU | ReLU6 | h-swish (deep layers), ReLU (early layers) | Varies by block type |
| Attention Mechanism | None | None | Squeeze-and-Excitation | SE + Mobile MQA (hybrid variants) |
| Architecture Design | Manual | Manual | NAS + NetAdapt + manual | NAS with UIB + optimized recipe |
| Scaling Strategy | Width and resolution multipliers | Width multiplier | NAS-driven (Large and Small) | Conv and Hybrid model families |
| Hardware Target | General mobile | General mobile | Pixel phone-optimized | Universal (CPU, GPU, DSP, ANE, EdgeTPU) |
The MobileNet architecture has had a profound influence on the field of efficient deep learning:
MobileNet's open-source availability through TensorFlow and its integration into popular frameworks like PyTorch, Keras, and Hugging Face Transformers have made it one of the most widely used model families in production machine learning systems.