Precision Governor
Adaptive AI for Arm Mobile
Runtime-Adaptive Mixed-Precision Inference for On-Device Vision AI
Arm AI Optimization Challenge 2026 — Mobile AI Track
Download the Android APK · Launch the live demo · Read the technical report
AI that knows when to spend bits—and when to save them.
Project at a glance
Challenge track: Mobile AI
What we built: A working Android vision application that automatically switches between three real TensorFlow Lite model tiers as battery and thermal conditions change.
Headline result: At matched model size, our sensitivity-aware configurations achieve 2.4×–4.1× lower KL-divergence than uniform quantization.
Runtime tiers: Full at 9.8 MB, Balanced at 4.9 MB, and Eco at 2.8 MB.
Validation: Real ImageNet inputs, verified model conversion, live camera inference, and on-device tier transitions.
How judges can test it: Install the APK, grant camera permission, and use the built-in Drain Battery and Overheat controls to trigger model changes immediately.
Why it matters for Arm mobile: Precision Governor helps sustained on-device AI continue operating under real battery and thermal constraints instead of forcing one static model to handle every condition.
Inspiration
Your phone already adapts to its environment.
When the battery is low, it reduces background activity. When the device gets hot, it throttles the CPU. When resources are plentiful, it unlocks maximum performance.
But the AI model running on that phone usually does not adapt at all.
The quantization tools we evaluated—including Qualcomm AIMET, Intel Neural Compressor, AWQ/GPTQ, and Microsoft Olive—optimize models into deployment configurations, but they do not provide a battery- and thermal-aware controller that changes model precision while an application is running.
The same model is therefore used whether the phone is:
- Fully charged or nearly empty
- Cool or thermally constrained
- Processing one image or running a continuous camera stream
The model that is “fast enough” at 90% battery is not necessarily the model you want running at 15%.
We wanted to close that gap by treating model precision as a live, runtime-adjustable system resource, just like CPU frequency.
That idea became Precision Governor.
What it does
Precision Governor combines two working systems:
1. Sensitivity-aware mixed-precision optimization
Instead of compressing every layer equally, we measure which layers tolerate aggressive quantization and which layers need protection.
The search considers both:
- The output error introduced by reducing a layer’s precision
- The model-size cost of preserving that layer at higher precision
This lets us spend the available precision budget where it creates the most value.
At the same file size, our sensitivity-aware configurations achieve 2.4×–4.1× lower output error than naive uniform quantization, measured using KL-divergence against the original model.
The comparison was performed using real ImageNet images—not random or simulated inputs.
2. A live on-device precision governor
Our CameraX-based Android app performs real-time image classification while monitoring:
- Battery percentage
- Device temperature
- Android thermal state
The governor automatically switches among three real TensorFlow Lite model tiers.
Full — 9.8 MB
Prioritizes maximum model quality when battery and thermal conditions are healthy.
Balanced — 4.9 MB
Reduces model cost while maintaining a practical balance between quality and efficiency.
Eco — 2.8 MB
Prioritizes battery life and thermal protection when the device becomes constrained.
The live camera overlay displays:
- Current prediction
- Confidence
- Active model tier
- Battery percentage
- Device temperature
- Per-frame inference latency
The application also includes an accessibility narrator powered by Android’s on-device TextToSpeech engine. Predictions can be spoken aloud without sending camera data to a cloud service.
The result is graceful degradation:
When battery or thermal pressure increases, the AI feature does not disappear. It continues operating with a leaner model.
Why this is different
Traditional model optimization asks:
What is the smallest model we can deploy?
Precision Governor asks:
Which model precision is appropriate for this device right now?
That shift introduces a runtime control layer that static quantization pipelines do not provide.
Precision changes after deployment
The application can move between Full, Balanced, and Eco while it is running.
Sensitivity is measured, not guessed
We evaluate actual quantization error instead of assuming that layer shape or parameter count predicts importance.
Allocation is cost-aware
A sensitive layer may also be extremely large. The search considers both its importance and the storage cost of preserving it.
Exported models are verified
We compare converted model outputs against the source PyTorch model using real images before trusting the deployment artifact.
Adaptation produces a visible user benefit
The accessibility narrator keeps describing the world as the device becomes constrained. The experience survives because the model adapts instead of shutting down.
Why it matters for Arm mobile
Arm-powered devices increasingly run AI experiences that must remain responsive, private, and available without a network connection.
Examples include:
- Assistive vision
- Mobile camera intelligence
- Robotics
- Field inspection
- Smart sensors
- Offline recognition
- Safety applications
- Edge monitoring
In these environments, efficiency is not only about improving a benchmark.
It determines:
- How long the application remains available
- Whether sustained inference remains practical
- Whether the device overheats
- Whether AI features can run on lower-power hardware
- Whether accessibility features continue operating under battery pressure
Precision Governor is designed around these mobile constraints.
The application uses:
- Kotlin for the Android application
- CameraX for continuous camera input
- TensorFlow Lite for on-device inference
- XNNPACK for optimized CPU execution
- Android battery APIs for power-state monitoring
- Android thermal APIs for thermal-pressure detection
- On-device TextToSpeech for accessibility narration
Inference, governance, and narration all operate on the device.
Instead of assuming ideal conditions, Precision Governor adapts to the resources the device actually has.
Try it in three minutes
Download the Precision Governor APK
- Open the APK link on an Android phone and download the file.
- Tap the downloaded APK to install it.
- Android may ask you to allow installation from your browser or file manager because the APK is being sideloaded.
- Open Precision Governor and grant camera permission.
- Point the camera at an object.
- Observe the prediction, confidence, latency, battery level, temperature, and active model tier.
- Select Drain Battery to simulate battery pressure.
- Select Overheat to simulate thermal pressure.
- Confirm that the active model changes while camera inference continues.
- Enable narration to hear stabilized predictions through on-device TextToSpeech.
What judges should observe
Under healthy conditions, the application uses the Full tier.
As resource pressure increases, the governor moves to Balanced or Eco. The overlay updates to show the new tier, and classification continues instead of being disabled.
When conditions recover, the policy can return to a higher-quality tier.
These controls make the system repeatable and judge-friendly. There is no need to wait for a real battery to drain or a phone to overheat.
Judges who cannot install the APK can also explore the browser demonstration:
Launch the live Hugging Face demo
How we built it
Precision Governor is divided into four technical stages:
Sensitivity analysis → Cost-aware search → Verified model export → Runtime governance
1. A zero-forward-pass sensitivity proxy
The expensive way to measure layer sensitivity is to quantize one layer at a time, repeatedly run inference, and compare the result with the original model.
That provides valuable ground truth, but it is too expensive for a practical search process.
We tested several lower-cost alternatives and found that the RMS quantization error of a layer’s own weights was the strongest proxy:
$$ P(W)=\sqrt{\frac{1}{n}\sum_{i=1}^{n}(W_i-Q(W_i))^2} $$
Here, Q represents fake quantization to 4-bit precision.
The proxy operates directly on the model weights and requires zero forward passes.
We validated it against brute-force ground truth and measured:
Spearman ρ = 0.73
p < 10⁻⁹
This gave us a statistically significant and inexpensive signal for identifying layers that need additional precision.
2. Cost-aware mixed-precision search
Sensitivity alone is not enough.
A highly sensitive layer may contain a large portion of the model’s total parameters. Preserving that layer at high precision could consume most of the available model-size budget.
Our search therefore considers both:
- The measured quantization sensitivity of each layer
- The storage cost of assigning that layer a higher precision
The search generates a Pareto frontier rather than forcing one universal answer.
From that frontier, we identify quality-first, balanced, and efficiency-first operating regions.
3. Verified model conversion
Our deployment path is:
PyTorch → ONNX → TensorFlow Lite
We use onnx2tf for conversion and compare the exported output with the source PyTorch model using real images before trusting the artifact.
This verification is essential because successful conversion does not guarantee correct inference.
A converted model may still contain problems involving:
- Quantization scales
- Calibration metadata
- Tensor layouts
- Operator support
- Output interpretation
Our workflow treats output verification as part of deployment rather than an optional final check.
4. Runtime governance on Android
The governor’s decision logic lives in a pure-Kotlin PrecisionPolicy class with no Android framework dependencies.
This separation makes the policy independently testable and keeps runtime decisions separate from the camera interface.
The on-device control path remains lightweight:
- Read battery and thermal state.
- Evaluate the precision policy.
- Select the appropriate prepared model tier.
- Continue inference.
- Update the overlay and narrator.
The expensive analysis and search happen offline. The phone only performs lightweight state evaluation and model selection.
Battery Race
A real battery experiment can take hours, making it difficult to demonstrate during judging.
We created a side-by-side Battery Race that runs the same governor logic using a fast-forwarded simulated clock.
It compares two phones under the same conditions:
- A naive phone that always runs the Full model
- A governed phone that changes tiers as resources become constrained
The same multi-hour battery story plays out in under a minute.
This makes the purpose of runtime precision adaptation immediately visible: the governed phone reduces its inference cost when conditions worsen, while the always-Full strategy continues paying the maximum cost.
Optimization results
2.4×–4.1× lower error at matched size
At equivalent model-size targets, sensitivity-aware quantization achieved 2.4×–4.1× lower KL-divergence than uniform quantization.
The largest gain appeared in the most constrained Eco region, where intelligent bit allocation mattered most.
Three real deployment tiers
The runtime governor operates across three TensorFlow Lite artifacts:
- Full: 9.8 MB
- Balanced: 4.9 MB
- Eco: 2.8 MB
Balanced is approximately half the size of Full, while Eco is less than one-third of the Full model size.
Statistically validated sensitivity signal
Our zero-forward-pass proxy achieved:
- Spearman ρ = 0.73
- p < 10⁻⁹
Our first shape-based heuristic achieved only ρ = 0.06, making it effectively useless for guiding allocation.
On-device inference latency
Initial Pixel 10 spot checks showed approximately 9 ms per inference.
This is an initial real-device observation rather than a complete sustained battery and thermal benchmark suite. Full device profiling remains part of the next evaluation stage.
For this frame-based vision classifier, per-frame inference latency is the relevant responsiveness metric.
Runtime transition validation
We exercised the following transitions through the live camera and inference pipeline:
- Full to Balanced
- Balanced to Eco
- Thermal pressure to a lower-cost tier
- Recovery to a higher-quality tier
The transitions were verified through the working application—not only through isolated policy tests or code inspection.
Challenges we ran into
A broken conversion toolchain
Our original PyTorch-to-TensorFlow Lite route depended on unpublished packages and could not be reproduced reliably.
We replaced it with a PyTorch-to-ONNX-to-TensorFlow Lite path and added explicit output verification.
A silent INT8 calibration failure
One exported model loaded and returned outputs, but every input collapsed to the same predicted class.
The cause was a calibration failure that assigned scale = 0.0 to the quantized tensors.
Because the model still appeared to run, the issue could easily have been mistaken for successful deployment.
We detected it by comparing its output distribution with the source model and tracing the mismatch back to invalid calibration metadata.
Flickering predictions caused narration spam
Live classifiers can alternate rapidly between similar classes from frame to frame.
Sending every raw prediction to TextToSpeech created repeated and distracting narration.
We added prediction stabilization and a narration cooldown so the application only speaks meaningful, stable changes.
Confidence values were displayed incorrectly
We also found a mismatch between the model output and the confidence displayed in the interface.
We traced the complete post-processing path, corrected the interpretation, and documented the failure instead of hiding it.
These challenges reinforced one principle:
A model is not deployed when it exports. It is deployed when its behavior has been verified end to end.
Accomplishments that we’re proud of
We built the complete system
Precision Governor connects the full workflow:
Measure → Search → Export → Verify → Govern → Visualize
The project does not stop at a theoretical quantization result. It turns the optimization into a working mobile experience.
We improved quality without increasing model size
Our sensitivity-aware configurations produced 2.4×–4.1× lower output error than uniform quantization at matched size.
This demonstrates that where precision is spent matters as much as how many bits are used overall.
We created a nearly free sensitivity signal
The final proxy requires zero forward passes while maintaining a statistically significant relationship with brute-force sensitivity measurements.
It also outperformed two more complicated proxy formulations that we tested and rejected based on evidence.
We verified a real three-tier governor
The major transitions were exercised through the same camera and inference path used by the application.
They are not merely represented in a diagram or inferred from policy code.
We connected efficiency with accessibility
The on-device narrator makes graceful degradation tangible.
Under resource pressure, the application can continue describing the user’s surroundings with a leaner model instead of removing the feature entirely.
We documented failures honestly
We documented and root-caused:
- The broken conversion path
- The INT8 calibration failure
- The confidence-display issue
- The TextToSpeech spam bug
Reliable mobile AI requires more than a successful export command. It requires evidence that the complete system behaves correctly.
Current integration status
The Android application already switches among three real TensorFlow Lite model tiers and exercises the runtime governor through battery and thermal transitions.
The research pipeline separately validates the sensitivity-aware mixed-precision allocation strategy.
The next integration milestone is to deploy the exact search-produced mixed-precision allocation as the on-device Eco tier, replacing the separately quantized Eco artifact.
We state this boundary clearly so judges can distinguish what is working today from the next engineering step.
What we learned
Measurement beats intuition
Layer shape was a poor predictor of quantization sensitivity.
Our shape-based heuristic produced a correlation of only 0.06, while directly measured quantization error produced a much stronger signal.
Sensitivity and storage cost must be optimized together
A small number of oversized layers can dominate total model size.
Protecting the most sensitive layers only works when the search also accounts for how expensive each precision decision is.
Conversion success does not guarantee correctness
A model can export, load, and return values while still being fundamentally broken.
Verification against the source model must be part of the deployment pipeline.
Runtime context changes the meaning of “optimal”
There is no single universally optimal precision configuration.
The right model depends on battery level, thermal state, workload, and latency requirements.
Precision can become a systems primitive
Operating systems already govern CPU frequency, display brightness, memory pressure, and background activity.
Precision Governor demonstrates how AI model precision can become another controllable system resource.
Project Media
The Project Media gallery provides visual evidence of the complete system:
Live camera application
Shows real-time classification, battery and temperature information, inference latency, and the active governor tier.
Battery Race
Compares the governed strategy against an always-Full strategy under the same accelerated conditions.
Pareto comparison
Shows sensitivity-aware configurations against uniform quantization at matched model sizes.
Architecture
Shows the complete path from sensitivity analysis and cost-aware allocation to TensorFlow Lite export and runtime profile selection.
What’s next
Complete sustained Arm-device benchmarking
We plan to measure latency, battery consumption, memory usage, and thermal behavior over extended workloads on a Pixel 10.
Deploy the exact search-generated allocation
The next integration step is to use the exact sensitivity-aware allocation from the research pipeline as the real on-device Eco model.
Add scene-aware inference frequency
Precision is only one control axis.
A future governor could reduce inference frequency when the scene is static and increase it when motion is detected.
This would allow the system to control both:
- How expensive each inference is
- How often inference runs
Resolve the remaining INT8 calibration issue
We want Eco to share the same trained weights as Full and Balanced while preserving correct calibration and output behavior.
Expand the runtime policy
Future versions can consider battery level, temperature, latency, memory pressure, scene motion, and user preference together.
The long-term goal is an AI application that continuously optimizes itself instead of relying on one deployment-time compromise.
Judge-accessible project artifacts
Download the Android APK
Install and test the complete Android camera experience, model-tier transitions, overlay, and accessibility narration.
Launch the Hugging Face demo
Explore the project through the browser-based demonstration.
Read the technical report and raw results
Review the methodology, experimental process, measurements, debugging findings, and supporting evidence.
Precision Governor turns model precision into a live system resource—measured offline, optimized intelligently, and governed at runtime.
Built With
- ai
- android-studio
- camerax
- gradle
- keras
- kotlin
- litert
- on-device
- onnx
- onnx2tf
- python
- pytorch
- quantisation
- tensorflow
- tflite
- xnnpack
Log in or sign up for Devpost to join the conversation.