# heliaEDGE

• heliaEDGEPyPI v
Build for the edge.Make it your own.

Build Edge AI models for deployment on Ambiq silicon. Combine reusable Keras architectures, preprocessing, metrics and training components in your own workflow, from preparing data to exporting your model.
[Get started](https://ambiqai.github.io/helia-edge/getting-started/)[Browse the API](https://ambiqai.github.io/helia-edge/reference/)
TensorFlow and PyTorch through Keras. Support varies by component.

A WORKSPACE FOR YOUR NEXT STEP
Find your way into the code.
Start with your task or explore a stage. Each example connects to a practical guide.

### Prepare: Give your model a consistent input.

Normalize signals and compose transforms with explicit training behavior. Keep selected targets and masks aligned with the data.

```python
import keras
from helia_edge.layers.preprocessing import Normalization1D

signals = keras.ops.ones((2, 128, 1))
normalize = Normalization1D(mean=0., variance=4.)
inputs = normalize(signals)
```

A small tensor example. Select your Keras backend before importing.

[Prepare guide](https://ambiqai.github.io/helia-edge/guide/preprocessing/)

### Build: A model family. Your configuration.

Start with a configurable architecture, then make the input shape and output classes your own. Keep the parameters alongside the trained weights.

```python
from helia_edge.models import ModelSpec, build, compact_tcn_params

params = compact_tcn_params(filters=8, num_classes=2)
spec = ModelSpec(params=params, input_shape=(240, 14))
model = build(spec)
```

Constructs a model with fresh weights. Training data comes from your task.

[Build guide](https://ambiqai.github.io/helia-edge/guide/architectures/)

### Train: Keep your Keras training workflow.

Use compile() and fit() with the components your task needs. Add progress reporting or explore a specialized training objective.

```python
from helia_edge.callbacks import TQDMProgressBar

history = model.fit(
    train_x, train_y,
    validation_data=(validation_x, validation_y),
    callbacks=[TQDMProgressBar()],
    epochs=10, verbose=0,
)
```

Uses your compiled model and training/validation arrays.

[Train guide](https://ambiqai.github.io/helia-edge/guide/training/)

### Evaluate: Measure what matters to your task.

Inspect classification errors or signal reconstruction quality. Choose metrics for the meaning of your outputs, not just a single aggregate score.

```python
from helia_edge.metrics import Snr

metric = Snr()
metric.update_state(reference_signals, predicted_signals)
print(metric.result())
metric.reset_state()
```

SNR example for aligned reference and predicted signals.

[Evaluate guide](https://ambiqai.github.io/helia-edge/guide/evaluation/)

### Export: Take a measured step toward inference.

Export a supported TensorFlow-backed model to LiteRT, inspect its predictions and keep the settings with the artifact.

```python
from helia_edge.export import ExportSpec, export_model

spec = ExportSpec(precision="a8w8", io_dtype="int8",
                  mode="concrete")
result = export_model(model, spec,
                      calibration=representative_x.astype("float32"))
print(result.sha256)
```

Requires a trained TensorFlow-backed model and representative inputs.

[Export guide](https://ambiqai.github.io/helia-edge/guide/export/)

BUILT TO WORK TOGETHER
One toolkit. No fixed recipe.
Use a single component or connect a workflow. Your application owns the data and training recipe.

- [Architectures](https://ambiqai.github.io/helia-edge/guide/architectures/): Configurable model families for signals, images, audio and physiology.
- [Data transforms](https://ambiqai.github.io/helia-edge/guide/preprocessing/): Preprocessing and augmentation with explicit training and alignment contracts.
- [Training components](https://ambiqai.github.io/helia-edge/guide/training/): Progress callbacks and specialized objectives alongside Keras training.
- [Task metrics](https://ambiqai.github.io/helia-edge/guide/evaluation/): Classification and signal-quality metrics, with plotting helpers for inspection.
CHOOSE YOUR ENVIRONMENTTensorFlow and PyTorch.Through Keras.
Choose the backend before importing Keras. Portable components and selected training paths span both backends. TensorFlow provides the LiteRT conversion and dataset utilities.[Backend support](https://ambiqai.github.io/helia-edge/getting-started/backends/)[Export a model](https://ambiqai.github.io/helia-edge/guide/export/)

FROM READING TO BUILDING
Make your first connection.

- [A small temporal model](https://ambiqai.github.io/helia-edge/getting-started/first-model/): Configure a TCN and save its architecture.
- [A complete training workflow](https://ambiqai.github.io/helia-edge/examples/train-cifar-model/): Follow the CIFAR-10 notebook from data preparation to training.
- [An architecture of your own](https://ambiqai.github.io/helia-edge/examples/custom-model-architecture/): Compose a model from reusable Keras layers.[Explore all examples](https://ambiqai.github.io/helia-edge/examples/)