Matlab Import External AI Model
MathWorksOfficialCreated by MathWorks
- Skill
- Tool integration
- Software development
- BSD-2-Clause
- Low risk
AutoGineer summary
Written by AutoGineer from the skill’s own files, not by the author
This skill provides a comprehensive guide for importing trained deep learning models from PyTorch, ONNX, and Keras 3/TensorFlow 2.16+ into MATLAB. It covers the necessary workflows to convert these models into MATLAB dlnetwork objects, ensuring that layer structures and learnable parameters are preserved. The skill includes specific procedures for handling different file formats, such as .pt2, .pt, .onnx, and .keras, and provides guidance on validating the imported models against their source frameworks to ensure numerical consistency.
What it does
- Imports PyTorch models (.pt2 or .pt) using importNetworkFromPyTorch.
- Imports ONNX models using importNetworkFromONNX with support for InputDataFormats.
- Imports Keras 3 models using matlabsaver or tf_keras downgrade paths.
- Imports TensorFlow SavedModels using importNetworkFromTensorFlow.
- Provides workflows for validating imported networks against source framework outputs.
- Offers troubleshooting steps for common import issues like uninitialized networks or missing learnables.
When to use it
- When you need to bring a trained deep learning model from PyTorch, ONNX, or Keras into the MATLAB environment.
- When you encounter import errors, unsupported operator warnings, or uninitialized networks during model migration.
- When you need to verify that an imported model's inference results match the original framework's output.
- When you have a Keras 3 model and need to determine the correct import path based on your MATLAB version.
Advantages
- Enables seamless integration of external deep learning workflows into MATLAB.
- Supports modern model formats like PyTorch exported programs (.pt2).
- Provides structured paths for handling Keras 3 compatibility across different MATLAB releases.
- Includes built-in validation techniques to ensure numerical accuracy after import.
Usage examples
- “How do I import a PyTorch .pt2 file into MATLAB?”
- Use the importNetworkFromPyTorch function: net = importNetworkFromPyTorch('model.pt2');. No input size argument is required as shape information is embedded.
- “My ONNX model import results in an uninitialized network. What should I do?”
- Check the input layer dimensions and re-import using the InputDataFormats argument, for example: net = importNetworkFromONNX('model.onnx', InputDataFormats='BCSS');.
- “How can I import a Keras 3 model into MATLAB R2026a?”
- Use the matlabsaver utility in Python to save the model, then import it in MATLAB using: net = importNetworkFromKeras('exportedModelFolder');.
Install
Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/matlab/matlab-import-external-ai-model/downloadUnzip it into the cross-client skills folder of your project:
mkdir -p .agents/skills && unzip matlab-import-external-ai-model.zip -d .agents/skills
Documentation by MathWorks
Import Deep Learning Models into MATLAB
Import trained PyTorch, ONNX, or Keras 3 models into MATLAB as dlnetwork
objects and verify numerical correctness.
When to Use
User wants to import a deep learning model from PyTorch, ONNX, or Keras/TensorFlow
User has
.pt2,.pt,.onnx, or.kerasfiles to bring into MATLABUser mentions
importNetworkFromPyTorch,importNetworkFromONNX,importNetworkFromKeras, orimportNetworkFromTensorFlowUser mentions
torch.export.export,torch.jit.trace,PyTorchInputSizes,InputDataFormats, ormatlabsaverUser encounters import errors, unsupported operator warnings, uninitialized networks, or 0 learnables after import
User wants to validate that an imported model matches the source framework's outputs
When NOT to Use
Exporting MATLAB networks to ONNX/PyTorch (use
exportONNXNetwork/exportNetworkToPyTorch)Training or fine-tuning after import — use
/matlab-train-networkDeploying to embedded hardware — use
/matlab-deploy-embedded-aiSimulink integration after import (agent handles this well without guidance)
Router: Which Framework?
Q: What format is the source model?
|
+-- .pt2 (PyTorch exported program) ──────────> PYTORCH IMPORT below
+-- .pt (PyTorch traced model) ───────────────> PYTORCH IMPORT below
+-- .onnx ────────────────────────────────────> ONNX IMPORT below
+-- .keras / TensorFlow 2.16+ / matlabsaver ──> KERAS IMPORT below
+-- Unknown ("import my model") ──────────────> Ask: framework? file extension?PyTorch Import
Full pipeline: export from PyTorch → import into MATLAB → validate numerics.
Determine Starting Point
| User has | Action |
|---|---|
| PyTorch model (code or saved) | Export as .pt2 first → see references/pytorch-export-guidance.md |
.pt2 file (exported program) | Import directly (below) |
.pt file (traced model) | Import with input sizes (below) |
Always prefer .pt2 over .pt. If user has a traced model, recommend re-exporting
with torch.export.export first. Only use traced path if re-export is not feasible.
Import .pt2 (Exported Program)
net = importNetworkFromPyTorch("model.pt2");No input size argument needed — shape info is embedded in the .pt2 file.
Import .pt (Traced Model)
net = importNetworkFromPyTorch("model.pt", ...
PyTorchInputSizes=[1 3 224 224]);PyTorchInputSizes is mandatory for traced models. Specify sizes in PyTorch
dimension ordering. For multiple inputs use a cell array: {[1 3 256 256], [1 10]}.
Name-Value Arguments
| Argument | When to use |
|---|---|
PyTorchInputSizes | Required for traced models (.pt). Not needed for .pt2 |
Namespace | Control where auto-generated custom layer files are stored |
PreferredNestingType | Choose "networklayer" (default) or "customlayer" |
PyTorch Critical Mistakes
| Mistake | Correct Approach |
|---|---|
Using InputShape NV argument | Does not exist — use PyTorchInputSizes for .pt, nothing for .pt2 |
Using PackageName NV argument | Deprecated — use Namespace |
Not calling model.to("cpu") before export | Always model.to("cpu") before export |
| Not checking PyTorch version before export | Assert torch.__version__ starts with "2.8" |
Passing PyTorchInputSizes for .pt2 | Unnecessary — .pt2 embeds shape info, omit it |
| Guessing input size for unknown models | Always ask the user for exact input dimensions |
Assuming net.InputNames matches forward() order | Importer may reorder — always check net.InputNames |
PyTorch Conventions
Always
model.to("cpu")andmodel.eval()before exportAlways verify PyTorch version is 2.8 before exporting as .pt2
Never guess input sizes — ask the user or inspect the model
Use
NamespacenotPackageNamefor custom layer storagePrefer .pt2 over .pt — recommend
torch.export.exportovertorch.jit.trace
PyTorch References
references/pytorch-export-guidance.md— Full Python-side export procedurereferences/pytorch-import-guidance.md— Detailed MATLAB import for both formatsreferences/pytorch-numeric-validation.md— Dimension conversion and tolerance comparisonreferences/pytorch-placeholder-guidance.md— Implementing unsupported ops in custom layersscripts/validateImportedNetwork.m— Helper function for numeric validation against .npy reference data
ONNX Import
Import ONNX models using importNetworkFromONNX, diagnose issues, verify numerics.
Workflow
1. IMPORT → importNetworkFromONNX with appropriate NVPs
2. DIAGNOSE → Check initialization, custom layers, warnings
3. RESOLVE → Fix issues (InputDataFormats, placeholder functions)
4. VERIFY → Compare outputs against ONNX Runtime (if installed)CRITICAL: Do NOT re-import after step 3. Re-importing regenerates +ops/ and overwrites all custom implementations.
Import
net = importNetworkFromONNX("model.onnx");If you know the input format:
net = importNetworkFromONNX("model.onnx", InputDataFormats="BCSS");Diagnose and Resolve
If net.Initialized is false, read the input shape and re-import with InputDataFormats:
net = importNetworkFromONNX("model.onnx");
if ~net.Initialized
inputLayer = net.Layers(1);
fprintf("NumDims: %d\n", inputLayer.NumDims);
endInputDataFormats Reference
Characters: B (batch), C (channel), S (spatial), T (time), U (unspecified).
| ONNX Input Shape | InputDataFormats |
|---|---|
| [N, C, H, W] | "BCSS" |
| [N, C] | "BC" |
| [N, T, C] | "BTC" |
| [N, C, T] | "BCT" |
Verify Against ONNX Runtime
If onnxruntime is installed in the user's Python environment, compare outputs. If not installed, skip — do not ask the user to install it.
try
ort = py.importlib.import_module("onnxruntime");
ortAvailable = true;
catch
ortAvailable = false;
endSee references/onnx-validation-workflow.md for the full comparison procedure.
ONNX Critical Mistakes
| Mistake | Correct Approach |
|---|---|
Use importONNXNetwork or importONNXLayers | Legacy — always use importNetworkFromONNX |
| Re-import after implementing placeholders | Import once, then modify. Never re-import. |
| Guess InputDataFormats randomly | Read input shape from uninitialized network first |
| Skip numeric verification when ORT is available | Compare against ONNX Runtime if installed |
ONNX Conventions
Always use
importNetworkFromONNX— never legacy APIsVerify numerically against ONNX Runtime after import (if installed)
Never re-import after modifying network or implementing placeholders
Use
dlarraywith explicit format strings:dlarray(data, "SSCB")Report max absolute difference and assert tolerance < 1e-4 for float32
ONNX Reference
references/onnx-validation-workflow.md— Full ORT comparison including multi-output models
Keras Import
Import Keras 3 / TensorFlow 2.16+ models with full layer structure and learnables.
Decision Tree
Q1: What MATLAB release is available?
+-- R2026a or newer ──> PATH 1 (matlabsaver + importNetworkFromKeras)
+-- R2025b or older ──> Q2
Q2: Does the model use Keras 3-specific features? (keras.ops, multi-backend)
+-- No (standard layers) ──> PATH 2 (tf_keras downgrade)
+-- Yes ────────────────────> PATH 3 (ONNX export fallback)Path 1: matlabsaver + importNetworkFromKeras (R2026a+)
Python:
import matlabsaver
matlabsaver.save_for_matlab(model, "exportedModelFolder")Apply the config.json patch for Keras 3.10+ compatibility (see references/keras-matlabsaver-workflow.md).
MATLAB:
net = importNetworkFromKeras("exportedModelFolder");
assert(numel(net.Learnables.Value) > 0, "Import failed: 0 learnables")Path 2: tf_keras Downgrade (Pre-R2026a, Standard Layers Only)
Python:
import os
os.environ["TF_USE_LEGACY_KERAS"] = "1" # MUST be before importing TensorFlow
import tf_keras as keras
model.save("savedModelFolder")MATLAB:
net = importNetworkFromTensorFlow("savedModelFolder");Path 3: ONNX Export (Fallback)
Requires tf2onnx in the Python environment: pip install tf2onnx
Python:
model.export("exportedModel.onnx", format="onnx")MATLAB:
net = importNetworkFromONNX("exportedModel.onnx");Keras Critical Mistakes
| Mistake | Correct Approach |
|---|---|
importNetworkFromKeras fails with "Brace indexing..." | Keras 3.10+ changed config.json — apply the patch (see reference) |
model.export("folder") then importNetworkFromTensorFlow | No keras_metadata.pb → 0 learnables. Use matlabsaver instead |
TF_USE_LEGACY_KERAS=1 set after import tensorflow | Must be set before any TF import |
Using deprecated importKerasNetwork | Use importNetworkFromKeras (R2026a+) or Path 2/3 |
Keras Conventions
Always verify imported network has non-zero learnables
Always check MATLAB release before choosing import path
Prefer Path 1 > Path 2 > Path 3 (ordered by fidelity)
Report number of layers and learnables after import
Keras References
references/keras-matlabsaver-workflow.md— Full matlabsaver procedure for R2026a+references/keras-tf-keras-downgrade.md— tf_keras setup for pre-R2026a
Key Functions
| Function | Framework | Purpose |
|---|---|---|
importNetworkFromPyTorch | PyTorch | Import .pt2 or .pt as dlnetwork |
importNetworkFromONNX | ONNX | Import .onnx as dlnetwork |
importNetworkFromKeras | Keras | Import Keras 3 folder as dlnetwork (R2026a+) |
importNetworkFromTensorFlow | TF/Keras | Import TF SavedModel as dlnetwork |
torch.export.export | PyTorch | Export model as .pt2 (Python) |
matlabsaver.save_for_matlab | Keras | Export Keras 3 for MATLAB (Python) |
predict | All | Run inference on imported dlnetwork |
dlarray | All | Labeled multi-dimensional array for deep learning |
Copyright 2026 The MathWorks, Inc.
Files
- ATTRIBUTION.mdAdded by AutoGineer1.1 KiB
- LICENSELicence file added by AutoGineer1.4 KiB
- SKILL.md11.1 KiB
- manifest.yaml626 B
- references/keras-matlabsaver-workflow.md4.0 KiB
- references/keras-tf-keras-downgrade.md3.8 KiB
- references/onnx-validation-workflow.md6.4 KiB
- references/pytorch-export-guidance.md3.6 KiB
- references/pytorch-import-guidance.md3.9 KiB
- references/pytorch-numeric-validation.md4.3 KiB
- references/pytorch-placeholder-guidance.md4.3 KiB
- scripts/validateImportedNetwork.m4.3 KiB
scripts/validateImportedNetwork.m
function results = validateImportedNetwork(net, referenceInputFile, referenceOutputFile, options)
%validateImportedNetwork Compare imported dlnetwork output against PyTorch reference.
%
% results = validateImportedNetwork(net, referenceInputFile, referenceOutputFile)
% results = validateImportedNetwork(..., InputFormat="SSCB")
% results = validateImportedNetwork(..., Tolerance=1e-5)
%
% Inputs:
% net - Imported dlnetwork from importNetworkFromPyTorch
% referenceInputFile - Path to .npy file with PyTorch input (NCHW order)
% referenceOutputFile - Path to .npy file with PyTorch output
%
% Name-Value Arguments:
% InputFormat - dlarray format string for the input (default: "SSCB")
% Tolerance - Maximum absolute difference for pass (default: 1e-5)
%
% Output:
% results - struct with fields: passed, maxAbsDiff, meanAbsDiff
arguments
net dlnetwork
referenceInputFile (1,1) string {mustBeFile}
referenceOutputFile (1,1) string {mustBeFile}
options.InputFormat (1,1) string = "SSCB"
options.Tolerance (1,1) double {mustBePositive} = 1e-5
end
% Load reference data
refInput = readNPY(referenceInputFile);
refOutput = readNPY(referenceOutputFile);
% Convert from PyTorch dimension order to MATLAB
nd = ndims(refInput);
inputMATLAB = permute(refInput, nd:-1:1);
% Create dlarray with specified format
dlIn = dlarray(single(inputMATLAB), options.InputFormat);
% Run inference
dlOut = predict(net, dlIn);
matlabOutput = double(extractdata(dlOut));
% Convert output back to PyTorch order for comparison
ndOut = ndims(matlabOutput);
matlabOutput = permute(matlabOutput, ndOut:-1:1);
% Compare
absDiff = abs(matlabOutput - double(refOutput));
results.maxAbsDiff = max(absDiff(:));
results.meanAbsDiff = mean(absDiff(:));
results.passed = results.maxAbsDiff < options.Tolerance;
% Report
fprintf("Max absolute difference: %.2e\n", results.maxAbsDiff);
fprintf("Mean absolute difference: %.2e\n", results.meanAbsDiff);
fprintf("Tolerance: %.2e\n", options.Tolerance);
if results.passed
fprintf("[PASS] Numeric validation passed.\n");
else
fprintf("[FAIL] Max difference exceeds tolerance.\n");
end
end
function data = readNPY(filename)
%readNPY Read a NumPy .npy file (float32/float64) into a MATLAB array.
fid = fopen(filename, 'r', 'l');
if fid == -1
error('validateImportedNetwork:FileOpenFailed', ...
'Cannot open file: %s', filename);
end
cleanupObj = onCleanup(@() fclose(fid));
% Read and validate magic number
magic = fread(fid, 6, '*uint8')';
assert(isequal(magic, uint8([147 78 85 77 80 89])), ...
'validateImportedNetwork:InvalidNPY', 'Not a valid .npy file.');
% Version and header
majorVer = fread(fid, 1, '*uint8');
fread(fid, 1, '*uint8'); % minor version
if majorVer == 1
headerLen = fread(fid, 1, 'uint16', 0, 'l');
else
headerLen = fread(fid, 1, 'uint32', 0, 'l');
end
header = char(fread(fid, headerLen, '*uint8')');
% Parse dtype
descrMatch = regexp(header, "'descr':\s*'([^']+)'", 'tokens');
dtypeStr = descrMatch{1}{1};
if startsWith(dtypeStr, '>')
fclose(fid);
error('validateImportedNetwork:BigEndian', ...
'Big-endian .npy files not supported. Re-save with little-endian.');
end
switch dtypeStr(end-1:end)
case 'f4', precision = 'single';
case 'f8', precision = 'double';
otherwise
fclose(fid);
error('validateImportedNetwork:UnsupportedDtype', ...
'Unsupported dtype: %s', dtypeStr);
end
% Parse shape
shapeMatch = regexp(header, "'shape':\s*\(([^)]*)\)", 'tokens');
shapeStr = strtrim(shapeMatch{1}{1});
shapeVals = str2double(strsplit(shapeStr, ','));
shapeVals = shapeVals(~isnan(shapeVals));
% Read data
numElements = prod(shapeVals);
data = fread(fid, numElements, ['*' precision]);
% Reshape from C-order to MATLAB column-major
if numel(shapeVals) > 1
data = reshape(data, fliplr(shapeVals));
data = permute(data, numel(shapeVals):-1:1);
end
end
% Copyright 2026 The MathWorks, Inc.
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.
Needs: Needs Python
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/ai-and-statistics/matlab-import-external-ai-model · commit 2a7f215
- Licence
- BSD 2-Clause License (redistribution allowed)
- LICENSE (added by AutoGineer from LICENSE.md)
- ATTRIBUTION.md (written by AutoGineer)
- Synced
AutoGineer is not affiliated with or endorsed by MathWorks.
Download ZIP
The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download matlab-import-external-ai-model.zip