Generated banner for Matlab Import External AI Model
Generated logo for Matlab Import External AI Model

Matlab Import External AI Model

MathWorksOfficialCreated by MathWorks

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

From the author

Import PyTorch, ONNX, or Keras 3 / TensorFlow 2.16+ deep learning models into MATLAB as dlnetwork objects. Use when importing .pt2 exported programs, traced .pt files, .onnx models, or Keras 3 models via matlabsaver. Covers importNetworkFromPyTorch, importNetworkFromONNX, importNetworkFromKeras, importNetworkFromTensorFlow, torch.export.export, PyTorchInputSizes, InputDataFormats, matlabsaver, tf_keras downgrade, numeric validation against PyTorch or ONNX Runtime, and placeholder/custom layer implementation. Applies when user mentions any of these functions, file formats, or encounters import errors, unsupported operator warnings, 0 learnables, or uninitialized networks.
— the description by MathWorks

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

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/matlab/matlab-import-external-ai-model/download
  2. Unzip 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 .keras files to bring into MATLAB

  • User mentions importNetworkFromPyTorch, importNetworkFromONNX, importNetworkFromKeras, or importNetworkFromTensorFlow

  • User mentions torch.export.export, torch.jit.trace, PyTorchInputSizes, InputDataFormats, or matlabsaver

  • User 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-network

  • Deploying to embedded hardware — use /matlab-deploy-embedded-ai

  • Simulink 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 hasAction
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
ArgumentWhen to use
PyTorchInputSizesRequired for traced models (.pt). Not needed for .pt2
NamespaceControl where auto-generated custom layer files are stored
PreferredNestingTypeChoose "networklayer" (default) or "customlayer"
PyTorch Critical Mistakes
MistakeCorrect Approach
Using InputShape NV argumentDoes not exist — use PyTorchInputSizes for .pt, nothing for .pt2
Using PackageName NV argumentDeprecated — use Namespace
Not calling model.to("cpu") before exportAlways model.to("cpu") before export
Not checking PyTorch version before exportAssert torch.__version__ starts with "2.8"
Passing PyTorchInputSizes for .pt2Unnecessary — .pt2 embeds shape info, omit it
Guessing input size for unknown modelsAlways ask the user for exact input dimensions
Assuming net.InputNames matches forward() orderImporter may reorder — always check net.InputNames
PyTorch Conventions
  • Always model.to("cpu") and model.eval() before export

  • Always verify PyTorch version is 2.8 before exporting as .pt2

  • Never guess input sizes — ask the user or inspect the model

  • Use Namespace not PackageName for custom layer storage

  • Prefer .pt2 over .pt — recommend torch.export.export over torch.jit.trace

PyTorch References
  • references/pytorch-export-guidance.md — Full Python-side export procedure

  • references/pytorch-import-guidance.md — Detailed MATLAB import for both formats

  • references/pytorch-numeric-validation.md — Dimension conversion and tolerance comparison

  • references/pytorch-placeholder-guidance.md — Implementing unsupported ops in custom layers

  • scripts/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);
end
InputDataFormats Reference

Characters: B (batch), C (channel), S (spatial), T (time), U (unspecified).

ONNX Input ShapeInputDataFormats
[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;
end

See references/onnx-validation-workflow.md for the full comparison procedure.

ONNX Critical Mistakes
MistakeCorrect Approach
Use importONNXNetwork or importONNXLayersLegacy — always use importNetworkFromONNX
Re-import after implementing placeholdersImport once, then modify. Never re-import.
Guess InputDataFormats randomlyRead input shape from uninitialized network first
Skip numeric verification when ORT is availableCompare against ONNX Runtime if installed
ONNX Conventions
  • Always use importNetworkFromONNX — never legacy APIs

  • Verify numerically against ONNX Runtime after import (if installed)

  • Never re-import after modifying network or implementing placeholders

  • Use dlarray with 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
MistakeCorrect Approach
importNetworkFromKeras fails with "Brace indexing..."Keras 3.10+ changed config.json — apply the patch (see reference)
model.export("folder") then importNetworkFromTensorFlowNo keras_metadata.pb → 0 learnables. Use matlabsaver instead
TF_USE_LEGACY_KERAS=1 set after import tensorflowMust be set before any TF import
Using deprecated importKerasNetworkUse 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

FunctionFrameworkPurpose
importNetworkFromPyTorchPyTorchImport .pt2 or .pt as dlnetwork
importNetworkFromONNXONNXImport .onnx as dlnetwork
importNetworkFromKerasKerasImport Keras 3 folder as dlnetwork (R2026a+)
importNetworkFromTensorFlowTF/KerasImport TF SavedModel as dlnetwork
torch.export.exportPyTorchExport model as .pt2 (Python)
matlabsaver.save_for_matlabKerasExport Keras 3 for MATLAB (Python)
predictAllRun inference on imported dlnetwork
dlarrayAllLabeled multi-dimensional array for deep learning

Copyright 2026 The MathWorks, Inc.


Files

references/pytorch-placeholder-guidance.md

Filling Placeholder Layers After Import

How Placeholders Work

When importNetworkFromPyTorch encounters an unsupported PyTorch operation, it generates a custom layer .m file in the namespace directory. These files contain a skeleton class with an error(...) call in the predict method that must be replaced with a working implementation.

Identifying Placeholders

  1. Check import warnings for lines like:

    'aten::unbind' operator in 'ModelName_unbind_view_6' layer class
  2. Find the generated file in the namespace folder:

    +<namespace>/+ops/pyAtenUnbind.m
  3. The file contains error('...') at the bottom of predict — this must be removed after you implement the operation.

Implementation Rules

Rule 1: Dynamic batch sizes

Never hardcode dimension sizes from the export. The exported graph may record specific sizes (e.g., batch=4) but your implementation must work for any batch size.

% WRONG — hardcoded batch size from export
output = reshape(input, [4, -1]);

% CORRECT — dynamic batch
batchSize = size(input, ndims(input));  % batch is last dim in MATLAB
output = reshape(input, [], batchSize);
Rule 2: Preserve dlarray format labels

When your custom op manipulates dimensions, ensure the output retains correct format labels. Operations that remove or add dimensions need explicit relabeling.

% If input has format 'SSCB' and you remove spatial dims:
output = dlarray(extractdata(result), 'CB');

Key behaviors of dlarray indexing:

  • Indexing with : preserves that dimension and its label

  • Scalar indexing (e.g., X(:,:,i,:)) removes that dimension from the format

  • Use squeeze carefully — it removes all singleton dims and their labels

Rule 3: Handle arbitrary input ranks

Don't assume 4D input. Build indexing dynamically:

ndX = ndims(X);
idx = repmat({':'}, 1, ndX);
idx{targetDim} = i;
slice = X(idx{:});
Rule 4: Ignore template helper references

The auto-generated placeholder may reference helper functions like permuteToPyTorchDimensionOrder or permutePyTorchToReversePyTorch. These do not exist in the generated package. Implement the operation from scratch based on what the PyTorch op actually computes.

Rule 5: Remove the error call

After implementing, delete the error(...) line at the bottom of predict. The import warning will still appear on re-import (it's a static check for the operator name), but this is cosmetic — the network will execute correctly.

Example: Implementing aten::unbind

aten::unbind(tensor, dim) splits a tensor along dim into individual slices, removing that dimension.

function varargout = predict(~, X, dim)
    % Convert 0-based PyTorch dim to 1-based MATLAB dim
    if isa(dim, 'dlarray')
        dim = extractdata(dim);
    end
    matlabDim = double(dim) + 1;

    % Get number of slices dynamically
    numSlices = size(X, matlabDim);

    % Build dynamic indexing for any rank
    ndX = ndims(X);
    idx = repmat({':'}, 1, ndX);

    % Extract each slice
    varargout = cell(1, nargout);
    for i = 1:nargout
        idx{matlabDim} = i;
        slice = X(idx{:});
        % Squeeze the indexed dimension (now singleton)
        slice = squeeze(slice);
        varargout{i} = slice;
    end
end

Example: Implementing pyView (reshape with dynamic batch)

function Y = predict(~, X, targetShape, ~)
    % targetShape comes from the export graph — may have hardcoded batch
    if isa(targetShape, 'dlarray')
        targetShape = extractdata(targetShape);
    end
    targetShape = double(targetShape);

    % Replace any hardcoded batch dimension with actual batch size
    % In MATLAB dlarray 'SSCB' format, batch is the last dimension
    actualBatch = size(X, ndims(X));

    % Find -1 in target shape (inferred dim) or replace batch
    targetShape(targetShape == -1) = [];
    newShape = [prod(targetShape), actualBatch];

    Y = reshape(X, newShape);
end

Validation After Fixing

After implementing all placeholders:

% Test with a sample input
dlIn = dlarray(randn(32, 32, 3, 1, 'single'), 'SSCB');
dlOut = predict(net, dlIn);

% Verify output shape and no errors
fprintf("Output size: [%s]\n", num2str(size(dlOut)));

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 or MathWorks.

Download ZIP

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