Matlab Deploy AI Model

MathWorksOfficialCreated by MathWorks

Skill
Tool integration
Software development
BSD-2-Clause
Low risk

From the author

Generate C/C++ or CUDA code from an AI model (PyTorch, LiteRT) using MATLAB Coder or GPU Coder. Use when the user wants to integrate an AI model into an application with code generation as the end goal — generating MEX, CUDA MEX, static library, dynamic library, or executable — or using the model in Simulink for simulation and code generation. Covers PyTorch ExportedProgram (.pt2) via loadPyTorchExportedProgram and LiteRT (.tflite) via loadLiteRTModel (R2026a+). Keywords: PyTorch, torch, .pt2, ExportedProgram, loadPyTorchExportedProgram, invoke, codegen, MEX, CUDA, GPU, C, C++, deploy, AI model, deep learning model, LiteRT, TFLite, TensorFlow Lite, Simulink, slbuild, PyTorch ExportedProgram block, MATLAB Function block, dlosslib, loadLiteRTModel.

— the description by MathWorks

From the skill’s files

Taken from the skill’s own files (its description, section headings and stated usage). Not an AutoGineer summary, and not written by the author as one.

Generate C/C++ or CUDA code from an AI model (PyTorch, LiteRT) using MATLAB Coder or GPU Coder. Use when the user wants to integrate an AI model into an application with code generation as the end goal — generating MEX, CUDA MEX, static library, dynamic library, or executable — or using the model in Simulink for simulation and code generation. Covers PyTorch ExportedProgram (.pt2) via loadPyTorchExportedProgram and LiteRT (.tflite) via loadLiteRTModel (R2026a+). Keywords: PyTorch, torch, .pt2, ExportedProgram, loadPyTorchExportedProgram, invoke, codegen, MEX, CUDA, GPU, C, C++, deploy, AI model, deep learning model, LiteRT, TFLite, TensorFlow Lite, Simulink, slbuild, PyTorch ExportedProgram block, MATLAB Function block, dlosslib, loadLiteRTModel. Generate deployable C/C++ or CUDA code from an AI model using MATLAB Coder or GPU Coder. The workflow follows a common pattern regardless of…

What it does

When to Use
When NOT to Use
Supported Frameworks
Generic Workflow
Key Functions
Conventions

When to use it

Use when the user wants to integrate an AI model into an application with code generation as the end goal — generating MEX, CUDA MEX, static library, dynamic library, or executable — or using the…
User wants to generate C/C++/CUDA code from an AI model (PyTorch, LiteRT)
User has a model file (.pt2, .tflite) and wants to load it into MATLAB
User wants MEX acceleration for an AI model
User wants to generate CUDA code or GPU-accelerated MEX from an AI model
User wants to deploy an AI model to hardware

Advantages

The skill’s files do not state this.

Usage examples

The skill’s files do not state this.

Install

Download the skill as a ZIP:
https://autogineer.com/agent-skills/matlab/matlab-deploy-ai-model/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip matlab-deploy-ai-model.zip -d .agents/skills

Documentation by MathWorks

Generate C/C++/CUDA Code from an AI Model

Generate deployable C/C++ or CUDA code from an AI model using MATLAB Coder or GPU Coder. The workflow follows a common pattern regardless of model framework: load, inspect, write entry-point, generate MEX, verify, then generate production code.

When to Use

User wants to generate C/C++/CUDA code from an AI model (PyTorch, LiteRT)
User has a model file (.pt2, .tflite) and wants to load it into MATLAB
User wants MEX acceleration for an AI model
User wants to generate CUDA code or GPU-accelerated MEX from an AI model
User wants to deploy an AI model to hardware
User wants to use a PyTorch or LiteRT model in Simulink (simulation or code generation)
User wants to verify AI model numerics between the source framework and MATLAB

When NOT to Use

General MATLAB Coder usage (codegen syntax, config tuning, writing codegen-ready code)
Editable dlnetwork for Deep Learning Toolbox workflows (quantization, compression, transfer learning) — use importNetworkFromPyTorch (PyTorch), importNetworkFromTensorFlow (SavedModel), or importNetworkFromKeras (.keras/.h5) which return a dlnetwork. For deployment of an editable dlnetwork with model compression (INT8 quantization via dlquantizer, pruning, projection) or exportNetworkToSimulink workflows — use matlab-deploy-embedded-ai (Pattern 1).
Training or fine-tuning — this skill is for inference code generation only

Supported Frameworks

Framework	Model format	Load function	Status
PyTorch	`.pt2`	`loadPyTorchExportedProgram`	Supported (R2026a+)
LiteRT / TFLite	`.tflite`	`loadLiteRTModel`	Supported (R2026a+)

For PyTorch-specific details (API routing, entry-point pattern, export workflow, data layout, common mistakes): see references/pytorch-workflow.md.

For LiteRT-specific details (API routing, entry-point pattern, variable-size inputs, Simulink integration, conventions): see references/litert-workflow.md. For converting TensorFlow/Keras/.h5 to .tflite: see references/tensorflow-to-litert-conversion.md.

Generic Workflow

The code generation workflow follows the same steps for any framework:

1. Load and Inspect

Load the model and check its input/output specifications to determine expected shapes and types.

2. Write Entry-Point Function

Create a codegen-compatible entry-point function that:

Loads the model from a file path
Runs inference on an input
Returns the output

The model file path must be wrapped with coder.Constant so it's known at compile time.

3. Verify Numerics

Compare MATLAB inference output against the source framework to confirm correct loading. Use the same input data in both environments and compare with tolerance.

4. Generate MEX (First!)

Always generate MEX before lib/exe to verify on the host machine:

CPU MEX:

cfg = coder.config("mex");
codegen -config cfg -args {coder.Constant("model_file"), input} entryPoint

CUDA MEX (GPU acceleration):

cfg = coder.gpuConfig("mex");
codegen -config cfg -args {coder.Constant("model_file"), input} entryPoint

For CPU MEX SIMD acceleration (SIMDAcceleration = 'Full' for AVX2 on Intel/AMD), see the matlab-generate-code skill. For the DNN- inference-specific MEX AVX2 ceiling, see references/dnn-codegen-options.md.

5. Verify MEX Output

Compare MEX output against MATLAB reference using matlab.unittest with tolerance:

refOut = entryPoint("model_file", input);
mexOut = entryPoint_mex("model_file", input);
testCase = matlab.unittest.TestCase.forInteractiveUse;
testCase.verifyThat(mexOut, matlab.unittest.constraints.IsEqualTo(refOut, ...
    'Within', matlab.unittest.constraints.AbsoluteTolerance(single(1e-5))));

6. Generate Library/Executable

Once MEX is verified, generate production code:

cfgLib = coder.config("lib");
cfgLib.TargetLang = "C++";  % set to "C++" for C++ output; default is "C"
codegen -config cfgLib -args {coder.Constant("model_file"), input} entryPoint

For DLL: coder.config("dll"). For executable: coder.config("exe").

CUDA variants: Replace coder.config with coder.gpuConfig.

Performance tuning:

Generic knobs (SIMD instruction sets, reduction-loop vectorization, multithreaded loops): see the matlab-generate-code skill.
MATLAB Coder ↔ Simulink Coder property naming duality and slbuild set_param patterns: see the matlab-deploy-embedded-code skill.
DNN-inference-specific knobs (DLTargetLibrary / DeepLearningConfig to disable third-party DL libraries, LargeConstantGeneration to serialize weights to data files): see references/dnn-codegen-options.md.

7. Use in Simulink

For Simulink integration, use the dedicated PyTorch ExportedProgram block from dlosslib — set ModelFilePath to the .pt2 file and it auto-detects input/output shapes. No entry-point function or coder.Constant needed.

Pre/post-processing can be done with Simulink blocks around the dedicated block. If you need everything in a single block, use a MATLAB Function block with loadPyTorchExportedProgram + invoke (same pattern as the entry-point, but the model path is a string literal — no coder.Constant).

Both paths support slbuild code generation (requires fixed-step solver + ERT or GRT target). See references/simulink-workflow.md for full details.

8. Deploy to Hardware (Optional — requires Embedded Coder)

For embedded deployment, use the same entry-point function with an Embedded Coder configuration. See the matlab-deploy-embedded-code skill for ERT config, hardware settings, PIL/SIL verification, and target-specific options. Ask the user to install the skill if it is not installed

Key Functions

Function	Purpose	Package	Since
`coder.Constant`	Make argument a compile-time constant	MATLAB Coder	R2011a
`coder.gpuConfig`	Create GPU (CUDA) code generation config	GPU Coder	R2017b
`codegen`	Generate code	MATLAB Coder	R2011a
`loadPyTorchExportedProgram`	Load .pt2 into MATLAB	MATLAB Coder Support Package for PyTorch and LiteRT Models	R2026a
`loadLiteRTModel`	Load .tflite into MATLAB	MATLAB Coder Support Package for PyTorch and LiteRT Models	R2026a

Conventions

Always check the model's input specifications for correct input shape and type
Always generate MEX first, verify, then proceed to lib/exe
Always use coder.Constant for the model file path argument
Input data is typically single-precision (check model input specs to confirm)
Do NOT use importNetworkFromPyTorch, importNetworkFromTensorFlow, or importNetworkFromKeras in this skill — they return a dlnetwork on a different path. If the user needs a dlnetwork for quantization, projection, pruning, or exportNetworkToSimulink before code generation, route to matlab-deploy-embedded-ai instead

References

references/pytorch-workflow.md — Full PyTorch-specific workflow: API routing, entry-point pattern, export guidance, common mistakes, and conventions. Consult for any PyTorch/.pt2 model code generation task. Links to deeper PyTorch references (API signatures, data layout, numeric verification, supported models).
references/export-pytorch-models.md — Exporting an eager-mode PyTorch model to .pt2 with torch.export (upstream of loading). Consult when the user has a PyTorch model but no .pt2 file yet, or hits torch.export SerializeError / kwarg-mismatch errors. Links to pytorch-export-patterns.md (per-source templates) and pytorch-export-gotchas.md (torch 2.11 serialization fixes).
references/simulink-workflow.md — Simulink integration: dedicated PyTorch ExportedProgram block (Path A) vs MATLAB Function block (Path B), block mask parameters, code generation config, and key differences from command-line codegen.
references/litert-workflow.md — Full LiteRT-specific workflow: API routing (loadLiteRTModel → inputSpecifications → invoke), entry-point pattern, variable-size input handling, Simulink integration, and conventions. Consult for any LiteRT/.tflite model code generation task.
references/tensorflow-to-litert-conversion.md — Converting TensorFlow SavedModel/Keras/.h5 to .tflite via the Python tf.lite.TFLiteConverter API. Consult when the user has a TensorFlow model but no .tflite file yet.
references/litert-numeric-verification.md — Verifying MEX numerics against MATLAB reference for LiteRT models (tolerance guidance, common mismatches).
references/codegen-workflow.md — Shared code generation steps for both PyTorch and LiteRT: MEX generation, MEX verification, library/executable targets, coder.Constant usage, and coder.DeepLearningConfig notes.
references/dnn-codegen-options.md — DNN-INFERENCE-SPECIFIC codegen options: DLTargetLibrary / DeepLearningConfig('none') for the plain-C DL path, LargeConstantGeneration for serializing large DNN weights to data files, and MEX SIMD ceiling in a DNN-inference context. Read this when the generic file's knobs need DNN-specific framing (e.g., "the MEX SIMD cap matters because inference is the target").

Files

ATTRIBUTION.mdAdded by AutoGineer1.0 KiB
LICENSELicence file added by AutoGineer1.4 KiB
SKILL.md10.8 KiB
manifest.yaml617 B
references/codegen-workflow.md4.0 KiB
references/dnn-codegen-options.md6.9 KiB
references/export-pytorch-models.md4.6 KiB
references/litert-numeric-verification.md3.8 KiB
references/litert-workflow.md14.7 KiB
references/pytorch-api-reference.md2.6 KiB
references/pytorch-data-layout.md4.1 KiB
references/pytorch-export-gotchas.md4.7 KiB
references/pytorch-export-patterns.md5.2 KiB
references/pytorch-numeric-verification.md2.6 KiB
references/pytorch-supported-models.md3.4 KiB
references/pytorch-workflow.md5.7 KiB
references/simulink-workflow.md12.7 KiB
references/tensorflow-to-litert-conversion.md5.8 KiB

references/tensorflow-to-litert-conversion.md

Converting TensorFlow/Keras Models to LiteRT (.tflite)

How to convert TensorFlow models to LiteRT format for use with loadLiteRTModel and MATLAB Coder code generation.

Steps

Convert to .tflite in Python (this reference)
Load in MATLAB with loadLiteRTModel
Generate code with codegen

Prerequisites

Python environment with TensorFlow installed:

pip install tensorflow

TensorFlow 2.x is required. The tf.lite.TFLiteConverter API is the standard conversion tool.

From SavedModel

A SavedModel is a directory containing saved_model.pb and a variables/ subdirectory. This is TensorFlow's standard serialization format.

import tensorflow as tf

converter = tf.lite.TFLiteConverter.from_saved_model("saved_model_dir")
tflite_model = converter.convert()

with open("model.tflite", "wb") as f:
    f.write(tflite_model)

Common sources of SavedModels:

TensorFlow Hub downloads
model.export("path") (TF 2.16+)
tf.saved_model.save(model, "path")
Training pipelines that checkpoint as SavedModel

From .keras Format

The .keras format is the recommended Keras serialization format (TF 2.12+).

import tensorflow as tf

model = tf.keras.models.load_model("model.keras")
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()

with open("model.tflite", "wb") as f:
    f.write(tflite_model)

From Legacy .h5 Format

The HDF5 (.h5) format is the legacy Keras format. Same conversion pattern — load first, then convert:

import tensorflow as tf

model = tf.keras.models.load_model("model.h5")
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()

with open("model.tflite", "wb") as f:
    f.write(tflite_model)

From SavedModel with Multiple Signatures

A TensorFlow SavedModel can contain multiple serving signatures (functions). To preserve them in the .tflite file, pass signature_keys to the converter:

import tensorflow as tf

converter = tf.lite.TFLiteConverter.from_saved_model(
    "saved_model_dir",
    signature_keys=["adder", "multiplier"]
)
tflite_model = converter.convert()

with open("multi_sig.tflite", "wb") as f:
    f.write(tflite_model)

To discover available signature keys before conversion:

loaded = tf.saved_model.load("saved_model_dir")
print(list(loaded.signatures.keys()))  # e.g. ['adder', 'multiplier']

The resulting .tflite file contains both functions. In MATLAB, these map to FcnNames on the LiteRTModel object:

model = loadLiteRTModel("multi_sig.tflite");
model.FcnNames  % ["adder", "multiplier"]
out = invoke(model, input, FcnName="adder");

Note: If signature_keys is omitted, only the default serving signature is exported. To include all signatures, list them explicitly.

Verifying the Converted Model

After conversion, verify the .tflite model produces correct outputs:

import tensorflow as tf
import numpy as np

interpreter = tf.lite.Interpreter(model_path="model.tflite")
interpreter.allocate_tensors()

input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

print(f"Input shape: {input_details[0]['shape']}")
print(f"Input dtype: {input_details[0]['dtype']}")
print(f"Output shape: {output_details[0]['shape']}")

# Run test inference
test_input = np.random.randn(*input_details[0]['shape']).astype(np.float32)
interpreter.set_tensor(input_details[0]['index'], test_input)
interpreter.invoke()
output = interpreter.get_tensor(output_details[0]['index'])
print(f"Output shape: {output.shape}")

Complete Example: Train, Save, Convert, Load in MATLAB

Python — train and convert:

import tensorflow as tf
import numpy as np

# Build and train a model
model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(28, 28, 1)),
    tf.keras.layers.Conv2D(16, 3, activation='relu'),
    tf.keras.layers.GlobalAveragePooling2D(),
    tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
# model.fit(...)  # train on your data

# Convert directly from the in-memory model
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()
with open("classifier.tflite", "wb") as f:
    f.write(tflite_model)

MATLAB — load and generate code:

model = loadLiteRTModel("classifier.tflite");
specs = inputSpecifications(model);
disp(specs)  % Verify: should show [1, 28, 28, 1] single

% Write entry-point
% function out = mInvoke(modelPath, input) %#codegen
%     net = loadLiteRTModel(modelPath);
%     out = invoke(net, input);
% end

input = ones(specs.Size{1}, specs.Type{1});
cfg = coder.config("mex");
codegen -config cfg -args {coder.Constant("classifier.tflite"), input} mInvoke

Common Mistakes

Mistake	Correct Approach
Using `importNetworkFromTensorFlow` for code generation	Convert to `.tflite` first, then `loadLiteRTModel`
Using `importNetworkFromKeras` for code generation	Convert to `.tflite` first, then `loadLiteRTModel`
Passing a SavedModel directory to `loadLiteRTModel`	Convert to `.tflite` first — `loadLiteRTModel` only accepts `.tflite` files
Passing a `.keras` or `.h5` file to `loadLiteRTModel`	Convert to `.tflite` first
Using `tflite_runtime` package for verification	Use `tf.lite.Interpreter` (built into TensorFlow) or `ai_edge_litert`

Notes

The converted .tflite model preserves the original model's float32 weights by default (no quantization).
Input/output shapes and types are preserved from the source model.
LiteRT uses NHWC layout — same as TensorFlow's default, so no layout conversion is needed during the .tflite export step.
For multi-output models, all outputs are preserved in the .tflite file.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

What our scanner noticed· Low risk

Instructions that use the network

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by

MathWorks

Publisher

MathWorks (Official)

Source

matlab/matlab-agentic-toolkit · skills-catalog/code-generation/matlab-deploy-ai-model · commit 2a7f215

Licence

BSD 2-Clause License (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE.md)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-09

AutoGineer is not affiliated with or endorsed by MathWorks or MathWorks.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download matlab-deploy-ai-model.zip