MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications

“MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications” is a nine-page paper by Andrew G. Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto and Hartwig Adam of Google. It was posted to arXiv on 17 April 2017 and has only that one version; it was not published at a conference or in a journal (we found no such version, and Crossref has no record of one), so it is cited as arXiv:1704.04861. The paper built a family of small convolutional networks almost entirely from depthwise separable convolutions, added two global hyperparameters that shrink a network to fit a latency or size budget, and showed the resulting models on ImageNet and on five other recognition tasks. Google released the models in TensorFlow two months later. The family it started, MobileNet v1 to MobileNetV4, is covered as it is understood today in the MobileNet article; this article is about the 2017 publication.

Problem

The paper opens with the trend since AlexNet: networks had become deeper and more complicated to gain accuracy, which did not necessarily make them smaller or faster, while applications such as robotics, self-driving cars and augmented reality needed recognition done in a timely fashion on a computationally limited platform. Accurate ImageNet classifiers of the time, such as VGG-16 at 15,300 million multiply-adds and 138 million parameters (as the paper’s Table 8 lists it), were far from that.

The authors sort earlier work on small networks into two groups. The first compresses a pretrained network: product quantization, hashing, pruning with vector quantization and Huffman coding, and factorizations that speed up pretrained layers. The second trains a small network directly: Flattened networks of fully factorized convolutions, Factorized Networks (which the authors describe as independent work with a similar factorized convolution), Xception, SqueezeNet’s bottleneck design, structured transform networks and deep fried convnets. They describe distillation, in which a large network teaches a small one, as another way of training small networks and as complementary to theirs, and mention low-bit networks as an emerging approach.

Two aims set the paper apart from the second group, in the authors’ account. Many small-network papers, they write, focus only on size and do not consider speed, while MobileNets primarily optimize for latency and also yield small networks. And rather than a single small model, they wanted a class of networks from which a developer can choose one that matches the latency and size limits of an application.

Contribution

The abstract and conclusion list:

• A streamlined architecture built from depthwise separable convolutions, with an investigation of the design decisions behind it (separable against full convolutions, thinner against shallower networks).
• Two simple global hyperparameters, the width multiplier and the resolution multiplier, that trade latency against accuracy, so that a model builder can pick the right size for a problem’s constraints.
• Experiments on resource and accuracy trade-offs, with comparisons against popular ImageNet models.
• A demonstration across applications: object detection, fine-grained classification, face attributes and large-scale geolocalization in the abstract, plus face embeddings in the experiments.

The conclusion adds a plan to release the models in TensorFlow. The layer itself was not new: the paper credits depthwise separable convolution to Sifre’s 2014 thesis and notes its earlier use in Inception models to cut the computation of the first layers.

Method

Architecture. The network in the paper’s Table 1 is a standard $3 \times 3$ convolution with 32 filters and stride 2, followed by 13 depthwise separable blocks (a $3 \times 3$ depthwise convolution and a $1 \times 1$ pointwise convolution, each followed by batch normalization and ReLU), a $7 \times 7$ average pool and a 1000-way fully connected layer feeding a softmax. Counting depthwise and pointwise layers separately, it has 28 layers. Strided depthwise convolutions, and the first layer, do all the downsampling. The factorization, its cost ratio of $1/C_\text{out} + 1/k^2$ (printed as $1/N + 1/D_K^2$) and the paper’s single-layer example in Table 3 are explained in the depthwise separable convolution article, which also gives the paper’s argument that $1 \times 1$ convolutions map directly onto optimized matrix multiplication.

Two details of the published description differ from the code Google released. Table 1 prints stride 2 for the last depthwise layer, but that layer’s input is already $7 \times 7$ and the next layer is a $7 \times 7$ average pool, which only fit a stride of 1; the official TF-Slim definition uses stride 1 there, and only with stride 1 do the paper’s own multiply-add counts come out (the example below). And the text says every layer is followed by ReLU, while the TF-Slim code applies ReLU6, $\min(\max(x, 0), 6)$. MobileNetV2 later describes ReLU6 as the choice for robustness in low-precision computation and cites MobileNet v1 for it.

Where the cost goes. The paper’s Table 2 splits the multiply-adds and parameters by layer type: 94.86% and 74.59% in the $1 \times 1$ convolutions, 3.06% and 1.06% in the depthwise layers, 1.19% and 0.02% in the standard first layer, and 0.18% and 24.33% in the fully connected layer. The multiply-add column sums to 99.29%. Counting the first layer directly ($3^2 \cdot 3 \cdot 32$ multiply-adds at each of $112 \times 112$ positions, 10.8 million of 568.7 million) gives 1.91%, which brings the sum to 100%, so the printed 1.19% appears to have transposed digits (our count, in the example below; every other entry matches to the printed precision). The text also summarizes the table differently from the table itself: it says MobileNet spends 95% of its computation time in $1 \times 1$ convolutions, while the table counts multiply-adds; the paper reports no timings.

Width and resolution multipliers. The width multiplier $\alpha \in (0, 1]$ scales the channels of every layer, with typical values 1, 0.75, 0.5 and 0.25, and the resolution multiplier $\rho$ scales the input and hence every feature map, set in practice by choosing an input of 224, 192, 160 or 128 pixels. The paper’s Eq. (7) gives a separable layer’s cost under both; the pointwise term scales with $\alpha^2$ and both terms with $\rho^2$ (the formula and its consequences are in the MobileNet article). A model with a smaller $\alpha$ is a new architecture trained from scratch.

Training. The models were trained in TensorFlow with RMSprop and asynchronous gradient descent, as for Inception V3, but with less regularization and data augmentation, on the grounds that small models have less trouble with overfitting: no side heads, no label smoothing, and fewer image distortions, by limiting the size of the small crops used in large Inception training. The authors found it important to put very little or no weight decay on the depthwise filters, which have few parameters; in the released TF-Slim code, the depthwise filters are not regularized by default and the other layers use a weight decay of 0.00004. All ImageNet models in the paper used the same training parameters regardless of size. The paper gives no learning rate, batch size or schedule.

Results

The paper reports every ImageNet result as “ImageNet Accuracy” without naming the split, the evaluation protocol or whether the figure is top-1; costs are counted in Mult-Adds, multiply-adds, as everywhere in the paper.

Model choices (§4.1). Against the same network built with full convolutions, the separable version lost 1.1 points of accuracy (70.6% against 71.7%) for under an eighth of the multiply-adds and a seventh of the parameters (Table 4, given in the depthwise separable convolution article). To compare thinning with shortening, the authors removed the five $14 \times 14 \times 512$ separable blocks: this shallow MobileNet reached 65.3% at 307 million multiply-adds and 2.9 million parameters, against 68.4% at 325 million and 2.6 million for the width multiplier $\alpha = 0.75$ (Table 5), so thinner was about 3 points better than shallower at similar cost.

Shrinking hyperparameters (§4.2). Tables 6 and 7:

Model	ImageNet accuracy	Mult-Adds	Parameters
1.0 MobileNet-224	70.6%	569M	4.2M
0.75 MobileNet-224	68.4%	325M	2.6M
0.5 MobileNet-224	63.7%	149M	1.3M
0.25 MobileNet-224	50.6%	41M	0.5M
1.0 MobileNet-192	69.1%	418M	4.2M
1.0 MobileNet-160	67.2%	290M	4.2M
1.0 MobileNet-128	64.4%	186M	4.2M

Accuracy falls smoothly with width until $\alpha = 0.25$, where the network is, in the authors’ words, made too small, and smoothly with resolution throughout. Over the 16 models of the cross product of the four widths and four resolutions, the authors describe accuracy as log-linear in multiply-adds, with a jump down at $\alpha = 0.25$ (their Figure 4); Figure 5 plots the same models against parameters, which do not depend on resolution.

Comparison with popular models. In Table 8, 1.0 MobileNet-224 (70.6%, 569M, 4.2M) is compared with GoogLeNet (69.8%, 1,550M Mult-Adds, 6.8M parameters) and VGG-16 (71.5%, 15,300M, 138M): nearly as accurate as VGG-16 while 32 times smaller and 27 times cheaper, as the authors summarize it. In Table 9, 0.50 MobileNet-160 reaches 60.2% with 76M Mult-Adds and 1.32M parameters, against 57.5% for SqueezeNet (1,700M, 1.25M) and 57.2% for AlexNet (720M, 60M). The paper does not say where the numbers for the other networks come from or how they were evaluated.

Fine-grained recognition (§4.3). On Stanford Dogs, the authors extended the approach of Krause et al. (2016): they collected a larger, noisy training set from the web, pretrained on it, and fine-tuned on the Stanford Dogs training set. On the test set (Table 10), 1.0 MobileNet-224 reached 83.3% top-1 with 569M Mult-Adds and 3.3M parameters, against 84% for Inception V3 from Krause et al. at 5,000M and 23.2M; the smallest model listed, 0.75 MobileNet-192, reached 80.5% at 239M.

Geolocalization (§4.4). PlaNet (Weyand et al., 2016) treats finding where on Earth a photo was taken as classification over a grid of geographic cells. The authors retrained it with the MobileNet architecture on the same data. The Inception V3 PlaNet has 52 million parameters and 5.74 billion Mult-Adds; the MobileNet version has 13 million parameters, 3 million in the body and 10 million in the final layer over the cells. The text gives its cost as “0.58 Million mult-adds”, which is implausible for a network built on the MobileNet body, itself 569 million at 224 pixels in Table 6; billion was presumably meant (our reading). On the Im2GPS test set (Table 11), the fraction of photos localized within each distance was:

Scale	Im2GPS	PlaNet	PlaNet MobileNet
Continent (2500 km)	51.9%	77.6%	79.3%
Country (750 km)	35.4%	64.0%	60.3%
Region (200 km)	32.1%	51.1%	45.2%
City (25 km)	21.9%	31.7%	31.7%
Street (1 km)	2.5%	11.0%	11.4%

The PlaNet column, a note to the table says, comes from an updated version of PlaNet with an improved architecture and training set.

Face attributes (§4.5). Here MobileNet was used to compress a large in-house face attribute classifier, trained on a multi-attribute dataset the paper describes as similar to YFCC100M, by distillation (Hinton et al., 2015): the small network is trained to reproduce the large one’s outputs rather than the labels, so unlabeled data can be used, and the emulation quality is measured by the per-attribute cross-entropy averaged over attributes. The authors report that the distilled system needed no regularization such as weight decay or early stopping. In Table 12, mean average precision across attributes was 88.7% for 1.0 MobileNet-224 (568M Mult-Adds, 3.2M parameters) and 86.4% for 0.25 MobileNet-128 (15M, 0.2M), against 86.9% for the baseline at 1,600M; that is, the smallest model came within half a point of the baseline at about 1% of its multiply-adds. The table gives the baseline 7.5 million parameters, while the text calls it a classifier with 75 million.

Object detection (§4.6). MobileNet was trained as the backbone of two detectors on COCO, in the framework of the work that won the 2016 COCO challenge (Huang et al., 2017): SSD at $300 \times 300$ input (see one-stage object detectors) and Faster R-CNN at 300 and 600 pixels with 300 proposals per image. Models were trained on COCO train+val minus 8,000 minival images and evaluated on minival, with mAP as COCO’s average precision averaged over IoU thresholds 0.5 to 0.95 (Table 13):

Framework	Backbone	mAP	Mult-Adds	Parameters
SSD 300	deeplab-VGG	21.1%	34.9B	33.1M
SSD 300	Inception V2	22.0%	3.8B	13.7M
SSD 300	MobileNet	19.3%	1.2B	6.8M
Faster R-CNN 300	VGG	22.9%	64.3B	138.5M
Faster R-CNN 300	Inception V2	15.4%	118.2B	13.3M
Faster R-CNN 300	MobileNet	16.4%	25.2B	6.1M
Faster R-CNN 600	VGG	25.7%	149.6B	138.5M
Faster R-CNN 600	Inception V2	21.9%	129.6B	13.3M
Faster R-CNN 600	MobileNet	19.8%	30.5B	6.1M

The authors summarize this as comparable results at a fraction of the computation and model size. In every framework MobileNet is less accurate than VGG, by 1.8 to 6.5 points; under Faster R-CNN at 300 pixels it is more accurate than Inception V2, and under the other two settings less.

Face embeddings (§4.7). For a mobile version of FaceNet (Schroff et al., 2015), which learns face embeddings with a triplet loss, the authors distilled FaceNet into MobileNets by minimizing the squared difference between the two networks’ outputs on the training data. Table 14 reports a column headed “1e-4 Accuracy”, which the paper does not define: 83% for FaceNet (1,600M Mult-Adds, 7.5M parameters), 79.4% for 1.0 MobileNet-160 (286M, 4.9M) and 78.3% for 1.0 MobileNet-128 (185M, 5.5M). Its last two rows are both labelled 0.75 MobileNet-128, with 75.2% (166M, 3.4M) and 72.5% (108M, 3.8M); at least one label must be wrong, since one architecture at one resolution has one cost.

Reproducing the cost tables. The example below (PyTorch 2.14.1, one thread) builds the network of Table 1 with PyTorch’s nn.Conv2d and counts multiply-adds with PyTorch’s FLOP counter on a synthetic striped image, at the widths and resolutions of Tables 6, 7 and 9, for the shallow network of Table 5, and for Table 1 with the printed final stride. It then splits the cost by layer type as in Table 2.

import torch
import torch.nn as nn
from torch.utils.flop_counter import FlopCounterMode

torch.manual_seed(0)
torch.set_num_threads(1)

def conv_bn(c_in, c_out, k, stride=1, groups=1):
    return nn.Sequential(nn.Conv2d(c_in, c_out, k, stride, k // 2, groups=groups, bias=False),
                         nn.BatchNorm2d(c_out), nn.ReLU())

# Table 1: output channels and depthwise stride of the 13 separable blocks
# (the last stride as printed is 2; the TF-Slim code uses 1).
BLOCKS = [(64, 1), (128, 2), (128, 1), (256, 2), (256, 1), (512, 2), (512, 1),
          (512, 1), (512, 1), (512, 1), (512, 1), (1024, 2), (1024, 2)]

def mobilenet_v1(alpha=1.0, last_stride=1, shallow=False):
    blocks = BLOCKS[:-1] + [(1024, last_stride)]
    if shallow:                                   # Table 5: drop the five 14x14x512 blocks
        blocks = blocks[:6] + blocks[11:]
    w = lambda c: int(c * alpha)
    layers, c = [conv_bn(3, w(32), 3, 2)], w(32)
    for c_out, s in blocks:
        layers += [conv_bn(c, c, 3, s, groups=c), conv_bn(c, w(c_out), 1)]   # depthwise, pointwise
        c = w(c_out)
    return nn.Sequential(*layers, nn.AdaptiveAvgPool2d(1), nn.Flatten(), nn.Linear(c, 1000))

def image(size):                    # synthetic RGB image: vertical stripes, period 8 pixels
    x = torch.zeros(1, 3, size, size)
    x[..., (torch.arange(size) // 4) % 2 == 0] = 1.0
    return x

def measure(model, size):
    """Mult-adds (PyTorch counts one multiply-add as 2 FLOPs) and weights (no biases, no BN)."""
    with FlopCounterMode(display=False) as fc, torch.no_grad():
        model.eval()(image(size))
    params = sum(m.weight.numel() for m in model.modules() if isinstance(m, (nn.Conv2d, nn.Linear)))
    return fc.get_total_flops() / 2e6, params / 1e6

print("Tables 6, 7, 9 (paper: Mult-Adds M / params M)")
for a, r, paper in [(1.0, 224, "569 / 4.2"), (0.75, 224, "325 / 2.6"), (0.5, 224, "149 / 1.3"),
                    (0.25, 224, "41 / 0.5"), (1.0, 192, "418 / 4.2"), (1.0, 160, "290 / 4.2"),
                    (1.0, 128, "186 / 4.2"), (0.5, 160, "76 / 1.32")]:
    ma, p = measure(mobilenet_v1(a), r)
    print(f"  {a:<4} MobileNet-{r}: {ma:6.1f} M mult-adds, {p:4.2f} M params   (paper {paper})")

ma, p = measure(mobilenet_v1(1.0, shallow=True), 224)
print(f"Table 5, shallow MobileNet: {ma:6.1f} M mult-adds, {p:4.2f} M params   (paper 307 / 2.9)")
ma, p = measure(mobilenet_v1(1.0, last_stride=2), 224)
print(f"Table 1 as printed (last depthwise stride 2): {ma:6.1f} M mult-adds   (paper 569)")

# Table 2: share of mult-adds and parameters by layer type, 1.0 MobileNet-224
model, ops, prm = mobilenet_v1(1.0), {}, {}
def hook(m, inp, out):
    key = ("FC" if isinstance(m, nn.Linear) else "Conv 1x1" if m.kernel_size == (1, 1)
           else "Conv DW 3x3" if m.groups > 1 else "Conv 3x3")
    per_output = m.weight.numel() if key == "FC" else m.weight[0].numel()
    ops[key] = ops.get(key, 0) + per_output * (out.numel() if key != "FC" else 1)
    prm[key] = prm.get(key, 0) + m.weight.numel()
for m in model.modules():
    if isinstance(m, (nn.Conv2d, nn.Linear)):
        m.register_forward_hook(hook)
with torch.no_grad():
    model.eval()(image(224))
print("Table 2 (paper: 94.86/74.59, 3.06/1.06, 1.19/0.02, 0.18/24.33)")
for k in ops:
    print(f"  {k:12s} {100 * ops[k] / sum(ops.values()):5.2f}% mult-adds"
          f"  {100 * prm[k] / sum(prm.values()):5.2f}% params")

Output:

Tables 6, 7, 9 (paper: Mult-Adds M / params M)
  1.0  MobileNet-224:  568.7 M mult-adds, 4.21 M params   (paper 569 / 4.2)
  0.75 MobileNet-224:  325.4 M mult-adds, 2.57 M params   (paper 325 / 2.6)
  0.5  MobileNet-224:  149.5 M mult-adds, 1.32 M params   (paper 149 / 1.3)
  0.25 MobileNet-224:   41.0 M mult-adds, 0.46 M params   (paper 41 / 0.5)
  1.0  MobileNet-192:  418.1 M mult-adds, 4.21 M params   (paper 418 / 4.2)
  1.0  MobileNet-160:  290.7 M mult-adds, 4.21 M params   (paper 290 / 4.2)
  1.0  MobileNet-128:  186.4 M mult-adds, 4.21 M params   (paper 186 / 4.2)
  0.5  MobileNet-160:   76.5 M mult-adds, 1.32 M params   (paper 76 / 1.32)
Table 5, shallow MobileNet:  307.3 M mult-adds, 2.88 M params   (paper 307 / 2.9)
Table 1 as printed (last depthwise stride 2):  533.8 M mult-adds   (paper 569)
Table 2 (paper: 94.86/74.59, 3.06/1.06, 1.19/0.02, 0.18/24.33)
  Conv 3x3      1.91% mult-adds   0.02% params
  Conv DW 3x3   3.06% mult-adds   1.06% params
  Conv 1x1     94.86% mult-adds  74.59% params
  FC            0.18% mult-adds  24.33% params

The counts match the printed Mult-Adds and parameters, truncated rather than rounded at 160 pixels (290.7M printed as 290M, 76.5M as 76M), so the paper’s tables describe Table 1 with a final depthwise stride of 1; with the printed stride of 2 the full model would cost 533.8 million. Every share in Table 2 matches except the first layer’s, 1.91% against the printed 1.19%.

Impact

On 14 June 2017, Howard and Zhu announced the release of MobileNets on the Google Research Blog: the model definition in TensorFlow using TF-Slim and 16 ImageNet checkpoints, the four widths at the four resolutions, runnable on phones with TensorFlow Mobile. The release table listed 1.0 MobileNet-224 at 70.7% top-1 and 89.5% top-5 on the ILSVRC data, slightly different from the paper’s 70.6%, and gave some costs that differ from the paper’s (317 million MACs for 0.75 MobileNet-224, against 325 million in Table 6). As of October 2026, the TF-Slim page for MobileNet v1, unchanged since June 2020, lists 16 floating-point checkpoints dated August 2018, with 70.9% top-1 and 89.9% top-5 for 1.0 MobileNet-224 from a single crop on ILSVRC-2012, and 16 quantized checkpoints for TensorFlow Lite (70.1% top-1 for the same model). TorchVision 0.29.0 provides MobileNetV2 and V3 but no MobileNet v1.

The models became a standard subject of on-device work. Jacob et al. (2018), whose authors include five of the MobileNets authors, developed integer-only 8-bit inference and quantization-aware training around them, describing MobileNets as a model family known for run-time efficiency, and reported that 8-bit MobileNets were more accurate than floating-point ones at the same latency on Qualcomm phone cores, by about 10 points at 33 ms on a Snapdragon 835 LITTLE core. The detection experiments had a direct successor: MobileNetV2 (Sandler et al., 2018) introduced SSDLite, an SSD head built from separable convolutions, and reported MobileNet v1 with it at 22.2 mAP on COCO test-dev with 1.3 billion multiply-adds and 270 ms on a Pixel 1, alongside MobileNetV2’s 22.1 mAP at 0.8 billion and 200 ms (its Table 6); it also built a mobile DeepLabv3 for segmentation on both backbones.

Within the family, MobileNetV2 (2018) states that its design is based on MobileNet v1 and keeps its simplicity without special operators; it and MobileNetV3 (2019) kept both multipliers, and MobileNetV4 (2024) followed, all with Howard among the authors (MobileNet). EfficientNet scales a network of MobileNetV2-style blocks in width, depth and resolution together with a compound rule.

Limitations

Later papers, and the paper’s own tables, point to several:

• Multiply-adds are not latency. The paper’s stated aim is low latency, but it reports no timing measurements (our observation); its costs are multiply-add counts, and its text describes a multiply-add share as computation time. Later work measured the gap. MobileNetV2’s Table 4 gives v1 113 ms on a single large core of a Pixel 1 phone (TF-Lite) at 575 million multiply-adds, as that paper counts them, against 183 ms for NASNet-A at 564 million. ShuffleNet V2 (Ma et al., 2018) argues that design should target direct metrics such as speed rather than FLOPs; in its measurements MobileNet v1 is less accurate than its counterparts but faster on a GPU than all of them, which the authors attribute to its structure satisfying most of their guidelines, with few fragmented branches. MobileNetV4’s roofline analysis makes a related point: on hardware where data movement rather than arithmetic is the bottleneck, such as accelerators, extra multiply-adds barely slow a model down, and the authors give a 1.5× wide MobileNet v1 as a model that gains capacity there (Qin et al., 2024).
• Quantization. Sheng et al. (2018) found that converting a floating-point TensorFlow MobileNet v1 directly to 8 bits, without retraining, dropped ImageNet validation top-1 from 70.50% to 1.80%, while Inception V3 dropped only from 78.00% to 76.92%. They traced the loss mainly to batch normalization and ReLU6 between the depthwise and pointwise layers: depthwise channels that are all zero get extreme batch-normalization scale factors, which inflate the quantization range for every channel. Their modified separable layer, without those operations between the stages, reached 68.03% in 8 bits; the alternative they discuss is quantization-aware training of the kind Jacob et al. (2018) proposed, at the cost of a separate training run.
• Width reduction and ReLU. MobileNetV2 accepts v1’s intuition that a layer’s activations occupy a low-dimensional manifold, which the width multiplier exploits by narrowing the layers, but argues that the intuition breaks down with ReLU, which destroys information when applied in a low-dimensional space; its linear bottleneck is the response.
• Underspecified protocol. The paper gives no ImageNet split, evaluation crop or learning-rate schedule (see Results), so its numbers cannot be reproduced from the text alone; the released checkpoints and their single-crop numbers fill part of the gap.
• Recipe-bound numbers. Qin et al. (2024) retrained MobileNet v1 with a modern recipe and obtained 74.0% ImageNet-1k top-1, 3.4 points above the original, so the 2017 numbers understate the architecture.
• Misprints. The final stride in Table 1, the first-layer share in Table 2, the PlaNet cost in §4.4, the face attribute baseline’s parameter count in §4.5 and the duplicated row label in Table 14 all need correction or care, as described above.

What Came After

Three versions followed under the same name, each from Google: MobileNetV2’s inverted residual blocks with linear bottlenecks (Sandler et al., 2018), MobileNetV3’s search for measured phone latency with squeeze-and-excitation and hard swish (Howard et al., 2019), and MobileNetV4’s universal inverted bottleneck and mobile attention for a wide range of hardware (Qin et al., 2024), all covered in the MobileNet article. Outside the family, ShuffleNet and ShuffleNet V2 built mobile networks around depthwise convolutions with channel shuffles, and EfficientNet scaled width and resolution, as the paper’s multipliers do, together with depth under one compound rule. By 2024, Qin et al. could describe the inverted bottleneck, a block built around a depthwise convolution, as the standard building block of efficient networks (depthwise separable convolution).