💻 computer science

MobileAgeNet: Lightweight Facial Age Estimation for Mobile Deployment

This paper introduces MobileAgeNet, a lightweight facial age estimation framework based on MobileNetV3-Large that achieves a competitive mean absolute error of 4.65 years with only 3.23M parameters while ensuring efficient, real-time on-device inference with 14.4ms latency.

Original authors: Arun Kumar, Aswathy Baiju, Radu Timofte, Dmitry Ignatov

Published 2026-04-21

📖 5 min read🧠 Deep dive

CC0 1.0

Original authors: Arun Kumar, Aswathy Baiju, Radu Timofte, Dmitry Ignatov

Original paper dedicated to the public domain under CC0 1.0 (http://creativecommons.org/publicdomain/zero/1.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a smartphone app that can look at a photo of a person and guess their age. Sounds cool, right? But here's the catch: most smart computer programs that do this are like giant, heavy trucks. They need massive servers to run, take forever to load, and would drain your phone's battery in minutes.

The researchers behind this paper, MobileAgeNet, wanted to build a sleek, electric scooter instead. They wanted a system that is just as smart but light enough to zip around on your phone instantly without breaking a sweat.

Here is the story of how they did it, broken down into simple parts:

1. The Problem: The "Heavy Truck" vs. The "Scooter"

Usually, to guess someone's age, computers use very complex models (like giant trucks). They are accurate but slow and heavy. If you tried to run one on a phone, it would be like trying to drive a semi-truck through a narrow city street—it just doesn't fit, and it's too slow for real-time use.

The team asked: "Can we build a tiny, efficient model that still knows what it's doing?"

2. The Solution: MobileAgeNet (The Smart Scooter)

They built MobileAgeNet. Think of this model as a highly trained apprentice who has already learned the basics of the job from a master teacher.

The Pre-Trained Backbone (The Master's Knowledge): Instead of teaching the model from scratch (which takes forever), they started with a model called MobileNetV3-Large. Imagine this as a student who has already spent years studying millions of faces in a library (a dataset called ImageNet). They know what eyes, noses, and wrinkles look like. The researchers just took this "graduated student" and gave them a specific new job: guessing age.
The Compact Head (The Specialized Tool): They added a small, lightweight "head" to the model. This is like giving the apprentice a specialized magnifying glass. It's designed specifically to look at the face and output a number (the age) without needing a giant brain to do it.
The Bounded Output (The Safety Net): Sometimes, if you ask a computer to guess an age, it might get confused and say "150 years old" or "-5 years old." To stop this, the researchers put a "safety net" around the model. They told it, "You can only guess between 0 and 116." This keeps the model honest and prevents wild, impossible guesses.

3. The Training: Two-Step Dance

Training this model wasn't a one-shot deal. They used a two-stage strategy, like a dance:

Stage 1 (The Warm-up): They froze the "body" of the model (the part that recognizes faces) and only trained the "head" (the age guesser). This let the new part get comfortable with the job without messing up the face-recognition skills it already had.
Stage 2 (The Fine-Tuning): Once the head was ready, they unlocked the body and let the whole model dance together. They taught it to adjust its face-recognition slightly to get even better at spotting age-specific wrinkles and lines.

4. The Results: Fast, Light, and Accurate

How did the scooter perform compared to the trucks?

Accuracy: On a test set of over 20,000 photos, the model guessed the age with an average error of just 4.65 years. That's pretty good! If the person is 30, the model guesses somewhere between 25 and 35.
Size: The whole model is tiny—only 3.23 million parameters. For comparison, some other models are like skyscrapers; this is a cozy cottage.
Speed: When they tested it on a real phone (a Motorola Edge 40), it took only 14.4 milliseconds to guess an age. That's faster than the blink of an eye! It's so fast you could use it in a live video chat without any lag.

5. The "Reproducible" Promise

One of the most important parts of this paper isn't just the model, but how they built it.

In science, sometimes researchers get lucky with one specific setup and claim it's the best, but no one else can copy it. The authors built their entire process inside a special framework called NN LEMUR. Think of this as a recipe book with exact measurements.

They didn't just guess the settings; they used a robot (Optuna) to test hundreds of different combinations to find the perfect one.
They kept a "test set" hidden away that they never touched until the very end, ensuring they didn't cheat or accidentally memorize the answers.
They proved that the model works exactly the same whether it's running on a powerful computer, a file format called ONNX, or a phone app (TensorFlow Lite).

The Bottom Line

MobileAgeNet is a proof that you don't need a supercomputer to guess someone's age. By using a smart, pre-trained "skeleton" and adding a tiny, efficient "brain," the researchers created a tool that fits in your pocket, runs instantly, and is accurate enough for real-world use.

It's the difference between hiring a team of 100 experts to guess your age (slow and expensive) and hiring one very well-trained, quick-witted expert who can do it while you wait for your coffee to brew. ☕📱

1. Problem Statement

Facial age estimation is a challenging computer vision task due to high inter-individual variability in aging, pose, illumination, expression, and image quality. While deep learning models have achieved high accuracy, most state-of-the-art approaches rely on heavy architectures (e.g., Transformers, large CNNs) that are computationally expensive and memory-intensive.

The Gap: There is a lack of reproducible, lightweight frameworks that balance predictive accuracy with the strict latency and memory constraints required for mobile and edge device deployment.
The Goal: Develop a model that achieves competitive Mean Absolute Error (MAE) on standard datasets (UTKFace) while maintaining real-time inference capabilities (<30ms) on consumer smartphones, all within a transparent and reproducible evaluation pipeline.

2. Methodology

A. Architecture: MobileAgeNet

The proposed model is a lightweight age-regression framework built upon a pretrained MobileNetV3-Large backbone.

Backbone: Utilizes MobileNetV3-Large for efficient feature extraction via depthwise separable convolutions and h-swish activations. It leverages ImageNet pretraining to reduce the need for massive training data.
Regression Head: A compact, end-to-end design consisting of:
- Global Average Pooling to aggregate spatial features.
- Two fully connected layers (960 → 256 → 64) with Hardswish activation and dropout.
- A final linear layer mapping to a single scalar output.
Bounded Output: To ensure realistic predictions, the scalar output is passed through a sigmoid function and scaled to a predefined range of [0, 116] years. This prevents extreme outliers and improves training stability.

B. Training Strategy

The authors employ a two-stage transfer learning strategy to optimize stability and generalization:

Warm-up Stage: The backbone is frozen; only the regression head is trained. Batch normalization layers in the backbone remain in evaluation mode.
Fine-tuning Stage: The backbone is unfrozen. The regression head uses the base learning rate, while the backbone uses a reduced learning rate (scaled by 0.10) to adapt gradually without forgetting pre-trained features.

Loss Function: Smooth L1 Loss ( $\beta=1.0$ ) with target ages clamped to the effective training range [1, 95] years.
Optimization: AdamW optimizer with Cosine Annealing learning rate scheduling and gradient clipping (max norm 2.0).

C. Reproducibility Framework

A key component of the methodology is the integration into the NN LEMUR Dataset framework. This ensures:

Stratified Sampling: Data is split into training (70%), validation (10%), and held-out test (20%) subsets based on 5-year age bins to prevent age distribution bias.
Hyperparameter Optimization: Automated search using Optuna (40 trials) to tune learning rates, dropout, batch size, and augmentation strategies.
Locked Configuration: The best hyperparameters found during the search phase are fixed for a final, single training run to prevent overfitting to the validation set.

3. Key Contributions

MobileAgeNet Model: A lightweight age-estimation model (3.23M parameters) achieving high accuracy on the full-range UTKFace dataset, specifically designed for mobile deployment.
Reproducible Pipeline: A complete, open-source training and evaluation framework integrated with NN LEMUR, featuring structured hyperparameter optimization, stratified data splitting, and held-out testing to ensure fair and repeatable results.
Deployment Validation: Comprehensive analysis of the model's behavior from PyTorch training through ONNX export to TensorFlow Lite (TFLite) conversion, confirming zero measurable degradation in accuracy during conversion.

4. Experimental Results

Performance Metrics

Dataset: UTKFace (20,000+ images, ages 0–116).
Accuracy: Achieved a Mean Absolute Error (MAE) of 4.65 years on the held-out test set.
Efficiency:
- Parameters: 3.23 Million.
- Compute: 0.233 GFLOPs per inference.
Comparison: Outperforms prior MobileNet-based baselines (e.g., Savchenko's MobileNet with 5.44 MAE) and matches the performance of distilled MobileNetV3 models trained on restricted age ranges, despite being trained on the full age spectrum.

Deployment Performance

On-Device Latency: Measured on a Motorola Edge 40 using the AI Benchmark application.
- Average Latency: 14.4 ms (well within the 30ms interactive threshold).
- Standard Deviation: 1.4 ms (indicating stable runtime).
- Initialization Time: 25.6 ms.
Conversion Consistency: The MAE remained identical (4.8387 years) between ONNX and TFLite formats on the validation set, with a conversion delta ( $\Delta_{conv}$ ) of 0.0000.

5. Significance and Conclusion

This work provides a practical, deployment-ready baseline for mobile facial age estimation. It demonstrates that:

Efficiency vs. Accuracy: High accuracy does not require heavy architectures; a carefully tuned lightweight backbone with bounded regression is sufficient.
Reproducibility: Standardizing evaluation protocols (stratified splits, held-out tests, locked hyperparameters) is crucial for fair comparison in age estimation research, addressing issues where protocol differences often skew reported results.
Real-World Viability: The model successfully bridges the gap between academic research and mobile application, offering real-time performance (<15ms) without accuracy loss during format conversion.

The paper concludes that MobileAgeNet is a transparent, efficient, and robust solution for mobile-oriented biometric applications, setting a new standard for reproducible lightweight age estimation.