Deploy PyTorch models with ExecuTorch

ExecuTorch is PyTorch’s runtime for on-device inference. It takes a PyTorch model, lowers it to a compact .pte program, and runs it on phones, single-board computers, and microcontrollers with backends such as XNNPACK and CMSIS-NN. In this tutorial, you connect PyTorch to Edge Impulse with two custom blocks: a learning block that trains a model and exports ONNX for Edge Impulse Studio plus an optional ExecuTorch .pte, and a deployment block that packages a trained impulse as a .pte with a small runtime harness.

This tutorial uses the Edge Impulse CLI and Docker. Install the Edge Impulse CLI and Docker before you start.

How the blocks fit together

Edge Impulse works with TensorFlow, TFLite, and ONNX models. ExecuTorch consumes PyTorch programs, so the learning block trains in PyTorch and exports ONNX, and the deployment block converts the trained model back to an ExecuTorch program.

Block	Type	Input	Output
PyTorch image classifier	Learning	Project data (NumPy)	`model.onnx` (+ optional `model.pte`)
ExecuTorch export	Deployment	Trained impulse (ONNX/TFLite)	`deploy.zip` with `model.pte`

The learning block is available to all users. The deployment block is available on the Enterprise plan only.

1. Train a PyTorch model with a custom learning block

The learning block trains a compact CNN on your project’s image data and outputs an ONNX model that Edge Impulse converts to TFLite for deployment.

This walkthrough uses the image classifier block. The audio, time-series, and object detection variants listed in Source code follow the same steps with different input data and parameters.json.

Block structure

The block contains the standard custom learning block files:

executorch-pytorch-classification-block/
├── parameters.json    # Block metadata and training parameters
├── model.py           # SmallCNN, a resolution-independent classifier
├── train.py           # Training entrypoint
├── requirements.txt   # Pinned dependencies (CPU PyTorch, ONNX, ExecuTorch)
├── Dockerfile         # Training container
└── tests/             # Model and data smoke tests

The parameters.json file declares the block as a machine learning block that operates on images and expects pixels scaled to 0..1:

{
    "version": 1,
    "type": "machine-learning",
    "info": {
        "name": "PyTorch image classifier (ExecuTorch)",
        "operatesOn": "image",
        "imageInputScaling": "0..1"
    },
    "parameters": [
        { "name": "Number of training epochs", "type": "int", "param": "epochs", "value": 30 },
        { "name": "Learning rate", "type": "float", "param": "learning-rate", "value": 0.001 }
    ]
}

Handle the data format

Edge Impulse provides image data as pre-scaled float32 arrays in NHWC (batch, height, width, channels) order. PyTorch expects NCHW, so the training script transposes the arrays before training:

def to_nchw(x):
    # NHWC (Edge Impulse) -> NCHW (PyTorch)
    return np.transpose(x, (0, 3, 1, 2))

You only transpose for training. Because the block outputs ONNX, Edge Impulse applies the equivalent transpose on-device.

Export ONNX and ExecuTorch

After training, the block writes model.onnx for Studio and, when the --export-pte flag is set, an ExecuTorch program:

from executorch.backends.xnnpack.partition.xnnpack_partitioner import XnnpackPartitioner
from executorch.exir import to_edge_transform_and_lower

exported = torch.export.export(model, (sample_input,))
program = to_edge_transform_and_lower(
    exported, partitioner=[XnnpackPartitioner()]
).to_executorch()
with open("model.pte", "wb") as f:
    f.write(program.buffer)

executorch==0.4.0 requires torch==2.5.0. Pin the two together and install the CPU wheels from https://download.pytorch.org/whl/cpu to avoid pulling CUDA packages into the build.

Test the block locally

Download processed data from a project that has an image impulse, then run the container:

edge-impulse-blocks runner --download-data input/

docker build -t executorch-pytorch-classification-block .
docker run --rm -v "$PWD":/app executorch-pytorch-classification-block \
    --data-directory /app/input \
    --out-directory /app/out \
    --epochs 30 --learning-rate 0.001 --export-pte

You’ll find out/model.onnx and out/model.pte when the run finishes.

Push to Edge Impulse

edge-impulse-blocks init
edge-impulse-blocks push

The block then appears under Create impulse -> Add learning block in the studio.

ExecuTorch learning block added to an image impulse in Edge Impulse Studio — The ExecuTorch learning block added to an image impulse in Studio

Train and test in Studio

Train the model on the learning block’s page, then check it against your test set on the Model testing page.

Training results for the PyTorch classifier in Edge Impulse Studio — Training the PyTorch classifier (93.3% validation accuracy)

Model testing results on the held-out test set in Edge Impulse Studio — Model testing on the held-out test set

2. Export to ExecuTorch with a custom deployment block

Only available on the Enterprise planThis feature is only available on the Enterprise plan. Review our plans and pricing or sign up for our free expert-led trial today.

The custom deployment block takes a trained impulse and produces an ExecuTorch deliverable. Because ExecuTorch consumes PyTorch, the block converts the exported ONNX model to PyTorch with onnx2torch, then lowers it to a .pte. The full source is in executorch-deploy.

Block structure

executorch-deploy/
├── parameters.json    # Deploy block metadata + backend selector
├── build.py           # Entrypoint: metadata -> deploy.zip
├── app/
│   ├── run_pte.py     # Runtime harness (loads a .pte, runs one pass)
│   └── convert.py     # Offline ONNX -> .pte converter
├── requirements.txt
└── Dockerfile

Edge Impulse calls the entrypoint with the path to deployment-metadata.json, which points to the input and output folders:

metadata = json.load(open(args.metadata))
input_dir = metadata["folders"]["input"]
output_dir = metadata["folders"]["output"]

The block converts the model, copies in the runtime harness and label map, then writes deploy.zip to the output folder. See deployment-metadata.json for the full input schema.

Test the block locally

edge-impulse-blocks runner --download-data input/

docker build -t executorch-deploy .
docker run --rm -v "$PWD":/home executorch-deploy \
    --metadata /home/input/deployment-metadata.json

The resulting deploy.zip contains model.pte, the source model.onnx, labels.txt, and the app/ harness.

Push to Edge Impulse

edge-impulse-blocks init   # choose "Deployment block"
edge-impulse-blocks push

The block then appears as a Custom block option on the project Deployment page.

Deployment page showing the ExecuTorch .pte export target in Edge Impulse Studio — The trained impulse's Deployment page, with the ExecuTorch .pte export target

Run the ExecuTorch program

On a Linux or ARM target with the ExecuTorch Python runtime installed, load the .pte and run a forward pass:

from executorch.runtime import Runtime

runtime = Runtime.get()
program = runtime.load_program("model.pte")
method = program.load_method("forward")
output = method.execute([sample_input])

Compare the output against the original PyTorch model to confirm the conversion preserved its behavior.

The ONNX to PyTorch to ExecuTorch path works for common CNN graphs. Exotic operators may need a custom partitioner or manual conversion with app/convert.py. Validate on your target model before relying on it in production.

Source code

All blocks are open source. Pick the learning block that matches your data. Each one exports an ONNX model for the studio plus an optional ExecuTorch .pte.

Block	Modality	Repository
PyTorch image classifier	Image classification	executorch-pytorch-classification-block
PyTorch keyword spotting	Audio (MFE / MFCC)	executorch-pytorch-kws-block
PyTorch motion classifier	Time-series (spectral)	executorch-pytorch-timeseries-block
PyTorch FOMO detector	Object detection	executorch-pytorch-object-detection-fomo-block
ExecuTorch export	Deployment	executorch-deploy

Try it on Android

The ExecuTorch Android demo runs a .pte on-device with the XNNPACK CPU backend, without the Edge Impulse C++ SDK or TFLite. Each block’s DSP (image scaling, motion spectral analysis, audio MFE) is rewritten in Kotlin, so the .pte only runs the neural network. Each product flavor bundles a different model under its own app ID, so you can install them side by side.

ExecuTorch static-buffer flavor showing the output scores after one inference — Static-buffer: one forward pass over a fixed input buffer

ExecuTorch image classification flavor running live on a phone — Image classification running live on-device

ExecuTorch FOMO object-detection flavor running live on a phone — FOMO object detection running live on-device

ExecuTorch keyword-spotting flavor running live on a phone — Keyword spotting: live mic through the Kotlin MFE

To skip the build, download a prebuilt APK from the Releases page and sideload it:

APK	Model	Input shape	Classes
`app-staticbuffer-debug.apk`	Static buffer (single forward pass)	`[1, 3, 96, 96]`	lamp, plant, unknown
`app-classification-debug.apk`	Image classifier	`[1, 3, 96, 96]`	lamp, plant, unknown
`app-fomo-debug.apk`	FOMO object detection	`[1, 3, 320, 320]`	coffee, lamp
`app-timeseries-debug.apk`	Motion (spectral)	`[1, 39]`	idle, snake, updown, wave
`app-kws-debug.apk`	Keyword spotting (MFE)	`[1, 1, 99, 40]`	background, hey_edge, unknown

adb install -r app-kws-debug.apk

Because the demo rewrites the DSP in Kotlin, each new modality needs its own port. To run the studio’s DSP unchanged, call the Edge Impulse C++ SDK through JNI instead. example-android-inferencing shows the JNI approach.

OVERVIEW

END-TO-END

TOPICS

TOOLS

INTEGRATIONS

How the blocks fit together

1. Train a PyTorch model with a custom learning block

Block structure

Handle the data format

Export ONNX and ExecuTorch

Test the block locally

Push to Edge Impulse

Train and test in Studio

2. Export to ExecuTorch with a custom deployment block

Block structure

Test the block locally

Push to Edge Impulse

Run the ExecuTorch program

Source code

Try it on Android

Next steps

​How the blocks fit together

​1. Train a PyTorch model with a custom learning block

​Block structure

​Handle the data format

​Export ONNX and ExecuTorch

​Test the block locally

​Push to Edge Impulse

​Train and test in Studio

​2. Export to ExecuTorch with a custom deployment block

​Block structure

​Test the block locally

​Push to Edge Impulse

​Run the ExecuTorch program

​Source code

​Try it on Android

​Next steps

How the blocks fit together

1. Train a PyTorch model with a custom learning block

Block structure

Handle the data format

Export ONNX and ExecuTorch

Test the block locally

Push to Edge Impulse

Train and test in Studio

2. Export to ExecuTorch with a custom deployment block

Block structure

Test the block locally

Push to Edge Impulse

Run the ExecuTorch program

Source code

Try it on Android

Next steps