---
name: MATLAB AI Model Deployment
slug: matlab-ai-model-deployment
category: DevOps
description: MATLAB AI Model Deployment generates MEX, C/C++, or CUDA code from PyTorch ExportedProgram or LiteRT models for use in applications or Simulink. Use it when you need to verify inference in MATLAB and then deploy the model as a library, executable, or GPU-accelerated build.
github: "https://github.com/matlab/matlab-agentic-toolkit/tree/main/skills-catalog/code-generation/matlab-deploy-ai-model"
language: MATLAB
stars: 938
forks: 115
install: "npx degit https://github.com/matlab/matlab-agentic-toolkit/tree/main/skills-catalog/code-generation/matlab-deploy-ai-model ~/.claude/skills/matlab-deploy-ai-model"
installs_to: ~/.claude/skills/matlab-deploy-ai-model
source_path: skills-catalog/code-generation/matlab-deploy-ai-model/SKILL.md
collection_size: 25
category_size: 798
collection_url: "https://dirskills.com/collections/matlab/matlab-agentic-toolkit"
added: 2026-08-21T05:15:39.706Z
last_synced: 2026-08-21T05:15:39.706Z
canonical_url: "https://dirskills.com/skills/matlab-ai-model-deployment"
---

# MATLAB AI Model Deployment

MATLAB AI Model Deployment generates MEX, C/C++, or CUDA code from PyTorch ExportedProgram or LiteRT models for use in applications or Simulink. Use it when you need to verify inference in MATLAB and then deploy the model as a library, executable, or GPU-accelerated build.

**Install:**

```bash
npx degit https://github.com/matlab/matlab-agentic-toolkit/tree/main/skills-catalog/code-generation/matlab-deploy-ai-model ~/.claude/skills/matlab-deploy-ai-model
```

## README

# 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:**
```matlab
cfg = coder.config("mex");
codegen -config cfg -args {coder.Constant("model_file"), input} entryPoint
```

**CUDA MEX (GPU acceleration):**
```matlab
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:

```matlab
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:

```matlab
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").

## See Also

- `matlab-generate-code` — Generic MATLAB Coder tuning (SIMD instruction sets, OpenMP multi-threading, reduction-loop vectorization). Consult for performance options not specific to DNN inference.
- `matlab-deploy-embedded-ai` — `dlnetwork`-based codegen with model compression (quantization, pruning, projection) and `exportNetworkToSimulink` workflows (Pattern 1). Use it when the source is an editable `dlnetwork` in MATLAB rather than a `.pt2` / `.tflite` file.
- `matlab-optimize-gpu-codegen` — CUDA-target codegen tuning (`coder.gpuConfig`, kernel fusion, memory-hierarchy options) when the deployment target is an NVIDIA GPU rather than CPU or embedded hardware.

----

Copyright 2026 The MathWorks, Inc.

----