Optimize ahead of time
Transform the graph and select kernels before deployment. Generate a model-specific execution schedule without an on-device interpreter.
Explore graph optimizationheliaAOT
Optimize ahead of time.
Built for Ambiq silicon.
heliaAOT is an ahead-of-time neural network compiler for Ambiq silicon. It turns trained LiteRT models into optimized C modules, transforming the graph, selecting kernels and planning memory before deployment. Build the generated module into your firmware without an on-device interpreter.
GRAPH OPTIMIZATION
Key features
From optimized kernels to explicit memory placement, keep control of how your model runs.
Powered by heliaCORE
Match supported operations to optimized heliaCORE kernels, selected for your Ambiq target, model shapes and precision.
How kernels are selected
Make memory go further
Reuse scratch buffers and share identical constants. Plan separate arenas for weights, temporary data and persistent state.
Understand memory planning
Control the tradeoffs
Tune for size and speed. Set memory budgets, pin tensors to banks and control where model weights live.
Control tensor placement
See what inference costs
Pair with heliaPROFILER for model and layer timing. Measure power and energy with a supported hardware measurement setup.
Profile your model
Integrate with your build
Generate C modules for CMake, Zephyr, neuralSPOT or CMSIS-Pack. Build with your application, selected kernels and platform support.
Integrate a generated moduleHow it works
Inside the compilerStart with a trained LiteRT model and a configuration for your target. heliaAOT optimizes the model on your development machine and generates a C module that you build into your firmware.
Your inputs
model.tfliteModel + configuration
Choose an Ambiq target, an output format and any application-specific constraints.
On your development machine
heliaAOT compiler
- 01Analyze and transform the graph
- 02Select target-aware kernels
- 03Plan memory and generate C
Generated module
C + headers + build filesReady to integrate
Build and link the module into your firmware. Initialize it, supply inputs, run inference and validate outputs on your target.
Conversion produces a C module. Your firmware build produces the device executable.Explore supported targets
Start simple.
Tune what matters.
Convert with the CLI, then add memory controls, profiling or Python automation as your application needs them.
IN PRACTICECLI
helia-aot convert --path kws.yamlOne configuration for your model, target and generated module.
memory:
tensors:
- type: constant
attributes: { memory: MRAM }Example placement rule: keep weights in MRAM on a target that provides it.
Whole-model timing
Per-layer measurements
Firmware footprint
Power & energy**Power and energy need a supported monitor and setup.
Model + configuration
Python API → C moduleRepeatable builds and custom operators.
Convert your first model
Follow the example configuration to select your model, target and module format. One command produces the C module and its build assets.
helia-aot convert --path kws.yamlFine-tune size, speed and memory
Set arena budgets, pin tensors to specific memory banks and choose whether constants are read in place or staged. Use residency reports to inspect the layout, then measure the tradeoffs on your target.
Control memory placementProfile, compare and improve
Use heliaPROFILER to inspect inference timing and per-layer behavior. Compare the same model and target across configurations or engines to see what your changes deliver.
Measure a conversionAutomate and extend
Use the Python API for repeatable conversions and configuration sweeps. Register custom operators or kernel implementations to support your application.
Use the Python API