matlab/matlab-agentic-toolkit / skills-catalog/ai-and-statistics/matlab-deploy-embedded-ai
matlab-deploy-embedded-ai
VerifiedDeploy AI models to embedded hardware using MathWorks tools (MATLAB, Simulink, Embedded Coder). Covers two workflow patterns: (1) MathWorks-native or imported models rebuilt as dlnetwork for lean hardware, (2) direct C/C++ code generation from PyTorch and LiteRT models. Both patterns support all targets (Cortex-M/A/R, x86, GPU). Trigger when: user wants to deploy AI to embedded targets; generate C/CUDA from neural networks; compress AI models for MCU; integrate AI in Simulink for system-level simulation; import PyTorch/ONNX/TensorFlow models for embedded deployment; optimize AI for resource-constrained hardware; or use loadPyTorchExportedProgram, loadLiteRTModel, importNetworkFromPyTorch, importNetworkFromONNX, importNetworkFromTensorFlow, importNetworkFromKeras, dlquantizer, exportNetworkToSimulink, or Embedded Coder with AI models.
references/pattern1/codegen-embedded.md
View on GitHub# Code Generation for Embedded Targets
Patterns for generating embedded C/C++ code from trained AI models using MATLAB Coder,
Simulink Coder, and Embedded Coder.
## Toolbox Requirements
| Toolbox | Purpose | Required? |
|------------------|---------------------------------------------|-----------|
| MATLAB Coder | Generate C/C++ from MATLAB code | Yes |
| Simulink Coder | Generate code from Simulink models | Yes (if using Simulink) |
| Embedded Coder | Optimized embedded code + IDE integration | Strongly recommended |
### Embedded Coder Warning
If Embedded Coder is NOT available, always inform the user:
> "**Warning:** Embedded Coder is not installed. Code generated by MATLAB Coder
> or Simulink Coder alone may not be optimized for your embedded target.
> Without Embedded Coder, you may experience:
> - Larger code footprint (ROM/RAM)
> - Suboptimal execution speed
> - Limited target-specific optimizations
> - No direct IDE integration
> - Code may not meet production coding standards (MISRA, CERT)
>
> For production deployment on resource-constrained hardware, installing
> Embedded Coder is strongly recommended."
---
## Network Compatibility for Code Generation
Before creating a predict function, ensure the network is codegen-compatible:
| Network Type | Direct MATLAB Coder (`coder.loadDeepLearningNetwork`) | Simulink Path (`exportNetworkToSimulink` → `slbuild`) |
|-------------|----------------|-----------------|
| Standard `dlnetwork` | Supported (float32 C) | Supported (float32 C) |
| Projected network (`lstmProjectedLayer`, `gruProjectedLayer`, or `ProjectedLayer` over conv/FC/stateful-I/O LSTM/GRU) | **Supported** — generic C/C++ only, no MKL-DNN / ARM Compute acceleration. A `ProjectedLayer` over a stateful LSTM/GRU is not supported; unpack with `unpackProjectedLayers(net)` first | **Supported directly in R2026a** — `exportNetworkToSimulink` accepts projected networks; no unpack required |
| Quantized network from `quantize()` | **NOT supported** — use the pre-quantized network | **SUPPORTED** — generates fixed-point C (int8/int16/int32). This is the recommended path for quantized deployment. See [Export Quantized Network to Simulink](https://www.mathworks.com/help/deeplearning/ug/export-quantized-network-to-simulink.html) |
### Validate Codegen Compatibility
Before generating code, run the analysis function to check for unsupported layers:
```matlab
analyzeNetworkForCodegen(netNative, TargetLibrary='none');
```
Set `TargetLibrary` to match your deployment target if not using library-free codegen
(e.g., `'mkldnn'`, `'arm-compute'`, `'cudnn'`, `'tensorrt'`).
This reports any layers or operations that will fail during code generation.
---
## Code Generation from MATLAB (MATLAB Coder)
### Step 1: Create a Predict Function
Wrap the trained model in a standalone prediction function suitable for code generation.
**For dlnetwork (tabular/image data):**
```matlab
function y = predictDLNet(x)
%#codegen
persistent net;
if isempty(net)
net = coder.loadDeepLearningNetwork('trainedNet.mat');
end
dlX = dlarray(x, 'BC'); % x is [1 x numFeatures] (Batch x Channel)
dlY = predict(net, dlX);
y = extractdata(dlY);
end
```
**For dlnetwork (LSTM/GRU sequence models -- stateful, one step at a time):**
```matlab
function y = predictSeqDLNet(x)
%#codegen
persistent net;
if isempty(net)
net = coder.loadDeepLearningNetwork('trainedSeqNet.mat');
end
dlX = dlarray(x, 'CB'); % x is [numFeatures x 1] (Channel x Batch)
[dlY, state] = predict(net, dlX);
net.State = state;
y = extractdata(dlY);
end
```
**For fitcnet:**
```matlab
function [label, score] = predictClassifier(x)
%#codegen
persistent mdl;
if isempty(mdl)
mdl = loadLearnerForCoder('trainedClassifier.mat');
end
[label, score] = predict(mdl, x);
end
```
**For fitrnet:**
```matlab
function y = predictRegressor(x)
%#codegen
persistent mdl;
if isempty(mdl)
mdl = loadLearnerForCoder('trainedRegressor.mat');
end
y = predict(mdl, x);
end
```
### Step 2: Configure Code Generation
**Standard MATLAB Coder configuration:**
```matlab
% Create configuration for static library
cfg = coder.config("lib");
% Set target language
cfg.TargetLang = "C";
% Configure for ARM Cortex-M target
cfg.HardwareImplementation.ProdHWDeviceType = "ARM Compatible->ARM Cortex-M";
% cfg.PurelyIntegerCode = true; % Uncomment only if target has no FPU and
% % you are generating fixed-point code
% Optimize for speed or size
cfg.BuildConfiguration = "Faster Runs"; % or "Smaller Size"
```
**Embedded Coder configuration with native dlnetwork support:**
```matlab
cfg = coder.config('lib', 'ecoder', true);
cfg.TargetLang = 'C';
% Use 'none' for native dlnetwork (no third-party deep learning library)
cfg.DeepLearningConfig = coder.DeepLearningConfig('none'); % default, stated explicitly
% For MCUs without filesystem, keep all weights in source files
cfg.LargeConstantGeneration = 'KeepInSourceFiles';
% ARM Cortex-M (single-core MCU)
cfg.HardwareImplementation.ProdHWDeviceType = 'ARM Compatible->ARM Cortex-M';
cfg.EnableOpenMP = false;
```
**ARM Cortex-A configuration (multi-core SBC):**
```matlab
% cfg.Hardware = coder.hardware('Raspberry Pi');
% cfg.InstructionSetExtensions = 'Neon v7';
% cfg.EnableOpenMP = true;
cfg.HardwareImplementation.ProdHWDeviceType = 'ARM Compatible->ARM Cortex-A';
```
### Step 3: Define Input Types and Generate
```matlab
% Define input types matching your model
numFeatures = 10; % Match your feature count
inputType = coder.typeof(single(0), [1 numFeatures]);
% Generate code (network is loaded internally via coder.loadDeepLearningNetwork)
codegen -config cfg predictDLNet -args {inputType}
```
### Step 3b: Generate MEX First for Desktop Validation
Before generating a static library for the target, generate a MEX function to
validate the pipeline on the desktop:
```matlab
% Generate MEX for desktop testing
cfgMex = coder.config("mex");
codegen -config cfgMex predictDLNet -args {inputType}
% Compare MEX output to MATLAB output
yMATLAB = predictDLNet(xSample);
yMEX = predictDLNet_mex(xSample);
maxDiff = max(abs(yMATLAB - yMEX));
fprintf("Max MEX vs. MATLAB difference: %e\n", maxDiff);
```
MEX validation catches code generation issues (unsupported operations,
dimension mismatches) without requiring the target cross-compiler toolchain.
### Step 4: Numerical Equivalency -- Generated Code vs. MATLAB/Simulink
After MEX generation, validate that the generated code produces numerically
equivalent results to both the MATLAB compressed model and the Simulink model.
```matlab
%% Numerical Equivalency: Full Pipeline Validation
% Compare: MATLAB compressed model vs MEX vs Simulink
numTests = 100; % As agreed with user
errMex = zeros(numTests, 1);
errSimulink = zeros(numTests, 1);
for i = 1:numTests
xTest = single(testInputs{i});
% MATLAB reference
yMatlab = predictDLNet(xTest);
% MEX output
yMex = predictDLNet_mex(xTest);
% Simulink output (if available from Phase 6)
ySimulink = simulinkOutputs(i, :);
errMex(i) = max(abs(yMatlab(:) - yMex(:)));
errSimulink(i) = max(abs(yMatlab(:) - ySimulink(:)));
end
fprintf('\nFull Pipeline Numerical Equivalency Report\n');
fprintf('============================================\n');
fprintf('Tests run: %d\n', numTests);
fprintf('MATLAB vs MEX -- MAE: %.4e, Max: %.4e\n', mean(errMex), max(errMex));
fprintf('MATLAB vs Simulink MAE: %.4e, Max: %.4e\n', mean(errSimulink), max(errSimulink));
if max(errMex) < 1e-5 && max(errSimulink) < 1e-4
fprintf('Pipeline status: PASS\n');
else
fprintf('Pipeline status: INVESTIGATE\n');
end
```
This validates the complete chain: original model → MATLAB import/rebuild → compression →
Simulink → generated code. All stages must agree within expected tolerances.
### Step 5: Review Generated Code (Optional)
If the user asks to review the generated code, open the code generation report:
```matlab
% For MATLAB Coder:
rtw.report.open('predictDLNet', fullfile(pwd, 'codegen', 'lib', 'predictDLNet'));
% For Simulink/Embedded Coder:
rtw.report.open(modelName, fullfile(pwd, [modelName '_ert_rtw']));
```
### Target Support Packages
Embedded Coder support packages for specific hardware targets (e.g., Qualcomm
Hexagon, Infineon AURIX, STMicroelectronics STM32, NXP S32K) must be installed
separately. Check availability via `matlabshared.supportpkg.getInstalled`. If
the required package is missing, direct the user to the Add-On Explorer.
---
## Hardware-Specific Configurations
### ARM Cortex-M (Most Common for Pattern 1)
```matlab
cfg.HardwareImplementation.ProdHWDeviceType = "ARM Compatible->ARM Cortex-M";
% NOTE: ProdBitPerChar/Short/Int/Long/Float/Double and ProdEndianess are
% auto-configured when ProdHWDeviceType is set to a known device.
% These are read-only in R2026a. Only set ProdHWDeviceType.
```
### ARM Cortex-A/R
```matlab
cfg.HardwareImplementation.ProdHWDeviceType = "ARM Compatible->ARM Cortex-A";
```
### Texas Instruments C2000 (DSP)
```matlab
cfg.HardwareImplementation.ProdHWDeviceType = "Texas Instruments->C2000";
```
### x86 (Desktop/Server with MKL-DNN)
```matlab
cfg = coder.config('lib', 'ecoder', true);
cfg.TargetLang = 'C';
cfg.DeepLearningConfig = coder.DeepLearningConfig('mkldnn');
```
### GPU (NVIDIA — cuDNN or TensorRT)
```matlab
% cuDNN
cfg = coder.config('lib', 'ecoder', true);
cfg.TargetLang = 'C++';
cfg.DeepLearningConfig = coder.DeepLearningConfig('cudnn');
% TensorRT (optimized inference)
cfg = coder.config('lib', 'ecoder', true);
cfg.TargetLang = 'C++';
cfg.DeepLearningConfig = coder.DeepLearningConfig('tensorrt');
```
---
## CMSIS/CMSIS-NN Optimization for ARM Cortex-M
Two paths exist for CMSIS acceleration on Cortex-M:
- **CMSIS-NN (INT8, Conv2D and FC only):** Available via BOTH the Simulink CRL path
(`slbuild` with ARM Cortex-M CRL) AND MATLAB Coder (`coder.DeepLearningConfig('cmsis-nn')`).
- **CMSIS-DSP (float32 matrix-multiply for FC/LSTM/GRU/BiLSTM):** Requires the Simulink
CRL path only — not available through MATLAB Coder alone.
When the deployment target is an ARM Cortex-M processor (M0, M0+, M3, M4, M7, M33),
enable CMSIS optimization for significant performance gains. Requires the **Embedded
Coder Support Package for ARM Cortex-M Processors** (CMSIS library v5.9).
### Supported Layers and Acceleration (R2026a)
Sources:
- [Supported Deep Learning Toolbox Blocks with CMSIS for ARM Cortex-M](https://www.mathworks.com/help/ecoder/armcortexm/ug/supported-deep-learning-blocks-with-cmsis-for-armcortexm.html) — Simulink block replacement (INT8 CMSIS-NN)
- [Code Generation for Matrix Multiplication in DL Layers with CMSIS](https://www.mathworks.com/help/ecoder/armcortexm/ug/code-generation-for-matrix-multiplication-in-dl-layers-with-cmsis-for-armcortexm.html) — float32 mat-mult replacement (CMSIS-DSP)
| Layer | CMSIS-NN (INT8 Simulink block) | CMSIS-DSP (float32 mat-mult) |
|-------|-------------------------------|------------------------------|
| `convolution2dLayer` | `arm_convolve_wrapper_s8` | — |
| `fullyConnectedLayer` | `arm_fully_connected_s8` | `mw_arm_mat_mult_f32` |
| `convolution1dLayer` | — | — |
| `lstmLayer` | — | `mw_arm_mat_mult_f32` |
| `gruLayer` | — | `mw_arm_mat_mult_f32` |
| `bilstmLayer` | — | `mw_arm_mat_mult_f32` |
**Key takeaways:**
- INT8 CMSIS-NN replacement is limited to **Conv2D and FC**. There is no INT8 kernel
for LSTM/GRU/BiLSTM/Conv1D in R2026a. A quantized recurrent layer generates as
plain fixed-point C, not an accelerated CMSIS kernel.
- Float32 CMSIS-DSP replacement (`mw_arm_mat_mult_f32`) covers FC, LSTM, GRU,
BiLSTM. For recurrent-heavy networks where latency matters, the float32 path
with CMSIS-DSP may outperform the quantized path (since no INT8 kernel exists
for recurrent layers).
### Scenario A: Simulink Path with CMSIS CRL (INT8 or float32)
This is the simplest approach — add one configuration line before `slbuild`:
```matlab
% After exportNetworkToSimulink, before building:
set_param(modelName, 'SystemTargetFile', 'ert.tlc');
set_param(modelName, 'ProdHWDeviceType', 'ARM Compatible->ARM Cortex-M');
set_param(modelName, 'CodeReplacementLibrary', 'ARM Cortex-M');
slbuild(modelName);
```
- **With quantized model:** CMSIS-NN INT8 kernels replace **Conv2D and FC blocks only**
(~2.8–3x speedup on those layers). Quantized LSTM/GRU/BiLSTM layers in the model
generate as plain fixed-point C — no CMSIS replacement.
- **With float32 model:** CMSIS-DSP `mw_arm_mat_mult_f32` replaces matrix multiply in
FC, LSTM, GRU, and BiLSTM layers.
### Scenario B: MATLAB Coder Path with CMSIS-NN (no Simulink)
For CNN/FC-only models when Simulink is not available, use `coder.DeepLearningConfig('cmsis-nn')`
with a calibration results file for INT8 code generation:
```matlab
cfg = coder.config('lib');
cfg.TargetLang = 'C';
cfg.Hardware = coder.hardware('ARM Cortex-M');
dlcfg = coder.DeepLearningConfig('cmsis-nn');
dlcfg.CalibrationResultFile = 'calibrationResults.mat';
cfg.DeepLearningConfig = dlcfg;
codegen -config cfg predictFcn -args {inputType}
```
- Covers Conv2D and FC layers with INT8 CMSIS-NN kernels
- Does NOT provide CMSIS-DSP float32 replacement for LSTM/GRU — use the Simulink path (Scenario C) for recurrent models
- Requires the "MATLAB Coder Interface for Deep Learning" support package
### Scenario C: Simulink Path with CMSIS-DSP CRL (float32, LSTM/GRU focus)
For sequence models (LSTM/GRU) where INT8 quantization is not suitable (see
dlquantizer layer support table in compression.md), use the CMSIS-DSP code
replacement for float32 matrix operations:
```matlab
% Export float32 network (unquantized)
exportNetworkToSimulink(net, ModelName="model_lstm", ...
Stateful=true, InputDataType="single", SampleTime="1");
% Enable CMSIS-DSP CRL — optimizes FC/LSTM/GRU matrix multiplications
set_param('model_lstm', 'SystemTargetFile', 'ert.tlc');
set_param('model_lstm', 'ProdHWDeviceType', 'ARM Compatible->ARM Cortex-M');
set_param('model_lstm', 'CodeReplacementLibrary', 'ARM Cortex-M');
slbuild('model_lstm');
```
### When to Use Each Scenario
Use [`compression-decision.md`](compression-decision.md) to pick the path. Quick
reference:
| Model Type | Goal | Has Simulink? | Recommended |
|-----------|------|---------------|-------------|
| CNN or FC-only model | Flash or latency | Yes | **Scenario A** with quantized model (INT8 CMSIS-NN, ~2.8–3x) |
| CNN or FC-only model | Flash or latency | No | **Scenario B** (MATLAB Coder CMSIS-NN, ~1.3x) |
| LSTM/GRU/BiLSTM model | **Latency** | Yes | **Scenario C** — keep float32, get CMSIS-DSP `mw_arm_mat_mult_f32` |
| LSTM/GRU/BiLSTM model | **Flash** (retraining OK) | Yes | Project + quantize → Scenario A pattern. FC layers get CMSIS-NN INT8; recurrent layers generate as plain fixed-point C (no CMSIS speedup). |
| LSTM/GRU/BiLSTM model | **Flash** (no retraining) | Yes | Quantize → Scenario A pattern. Same caveat: only FC accelerated by CMSIS-NN. |
| LSTM/GRU model | Any goal | No | Generic C via MATLAB Coder (`DeepLearningConfig('none')`). CMSIS-DSP `mw_arm_mat_mult_f32` requires the Simulink CRL path; without Simulink there is no CMSIS acceleration for recurrent layers. CMSIS-NN INT8 via `DeepLearningConfig('cmsis-nn')` only accelerates Conv2D/FC, not LSTM/GRU. |
### PIL Verification with CMSIS
After generating CMSIS-optimized code, validate on actual hardware via PIL:
```matlab
% For Simulink path: set simulation mode to PIL
set_param(modelName, 'SimulationMode', 'processor-in-the-loop');
simOut = sim(modelName);
% For MATLAB Coder path: generate PIL MEX
cfg.VerificationMode = 'PIL';
cfg.Hardware = coder.hardware('STM32F7xx Based'); % or your board
codegen -config cfg predict_cmsis -args {inputType}
% Compare PIL output to MATLAB output
yPIL = predict_cmsis_pil(xTest);
yMATLAB = predict(net, dlarray(single(xTest), 'BC')); % xTest is [1 x numFeatures]
maxErr = max(abs(yPIL(:) - extractdata(yMATLAB(:))));
fprintf('PIL vs MATLAB max error: %.4e\n', maxErr);
```
---
## Code Generation from Simulink
### Configure the Model
```matlab
% Open model
open_system("myModel");
% Set solver to fixed-step (required for code generation)
set_param("myModel", "SolverType", "Fixed-step");
set_param("myModel", "FixedStep", "0.001");
% Set system target file
% With Embedded Coder:
set_param("myModel", "SystemTargetFile", "ert.tlc");
% Without Embedded Coder (Simulink Coder only):
set_param("myModel", "SystemTargetFile", "grt.tlc");
% Configure hardware
cs = getActiveConfigSet("myModel");
switchTarget(cs, "ert.tlc", []);
set_param("myModel", "ProdHWDeviceType", "ARM Compatible->ARM Cortex-M");
```
### Build the Model
```matlab
% Build and generate code
slbuild("myModel");
% Or use the Embedded Coder app interactively
% embeddedCoderApp("myModel");
```
### Generated Code Structure
Generated code is placed in:
- `<modelName>_ert_rtw/` (Embedded Coder)
- `<modelName>_grt_rtw/` (Simulink Coder)
Key files:
- `<modelName>.c` -- Main model code and parameters
- `<modelName>.h` -- Model header
- `<modelName>_types.h` -- Type definitions
- `rtwtypes.h` -- Common data types
- `*.bin` -- Weight data (when `LargeConstantThreshold` is exceeded)
---
## Code Size Estimation
### Pre-Codegen Estimate (MATLAB)
Use `analyzeNetwork` to estimate parameter counts and memory before
generating code:
```matlab
na = analyzeNetwork(net, Plots='none');
fprintf('Total learnables: %d\n', na.TotalLearnables);
```
### Post-Codegen Measurement (Compiled Binary)
After compiling with the target toolchain, use `arm-none-eabi-size` for accurate
flash/RAM measurements:
```bash
arm-none-eabi-size model.elf
```
The `.text` + `.rodata` sections give flash usage; `.data` + `.bss` give RAM usage.
Do NOT estimate weight sizes from generated `.c` source file sizes — C source text
overhead inflates the numbers significantly (e.g., `0.0234375F` takes 10+ bytes in
source vs. 4 bytes as float32 binary). When `LargeConstantThreshold = 0` is set,
weights are stored in `.bin` files rather than in `.c` source.
---
## Post-Generation Verification
### Software-in-the-Loop (SIL) Testing
```matlab
% Run SIL test to compare MATLAB and generated code behavior
set_param("myModel", "CodeExecutionProfiling", "on");
set_param("myModel", "CodeProfilingInstrumentation", "on");
% Run SIL simulation
simOut = sim("myModel", "SimulationMode", "software-in-the-loop");
```
### Processor-in-the-Loop (PIL) Testing
```matlab
% Requires target hardware connection
% Run PIL test to verify on actual target processor
simOut = sim("myModel", "SimulationMode", "processor-in-the-loop");
```
---
## Deployment Checklist
Before delivering generated code:
- [ ] Code compiles without errors for target architecture
- [ ] ROM usage within target flash capacity
- [ ] RAM usage within target SRAM capacity
- [ ] Inference time meets latency requirements
- [ ] Numerical results match MATLAB simulation within acceptable tolerance
- [ ] **Full pipeline numerical equivalency validated** (original model → MATLAB → Simulink → C)
- [ ] SIL test passed (simulation vs. generated code agreement)
- [ ] PIL test passed (if target hardware available)
- [ ] No dynamic memory allocation in generated code (for safety-critical)
- [ ] **Code generation report reviewed** (if user requested it)
- [ ] Accuracy loss from compression explicitly documented
Copyright 2026 The MathWorks, Inc.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deployment | Stars: 319k | Updated | Claude CodeCodex | Verified | Install |
| xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved. | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |
| shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy. | Stars: 118k | Updated | Claude CodeCodex | Verified | Install |
| childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release. | Stars: 118k | Updated | Claude CodeCodex | Verified | Install |