L'IA embarquée avec MATLAB et Simulink

Du concept à la production, déployez l'IA sur n'importe quel hardware embarqué.

Pourquoi choisir l'IA embarquée avec MATLAB et Simulink ?

Déployez des modèles d'IA entraînés sur du hardware aux ressources limitées (microcontrôleurs, GPU, FPGA et NPU) grâce à la simulation au niveau système et à la génération automatisée de code.

Simulation au niveau système : testez le comportement de l'IA aux côtés des contrôleurs, des capteurs et des modèles de systèmes physiques avant même d'interagir avec le hardware.
Génération de code : générez directement du code C/C++, CUDA ou HDL à partir de votre modèle Simulink, y compris le composant d'IA, sans aucun portage manuel.
Flexibilité d'importation : importez des modèles PyTorch, ONNX ou TensorFlow et déployez-les via le même pipeline.
Vérification à chaque étape : vérifiez votre composant d'IA à chaque étape grâce à des méthodes formelles, des tests de robustesse contradictoire et des tests SIL (software-in-the-loop), PIL (processor-in-the-loop) et HIL (hardware-in-the-loop).
Conformité aux normes : générez du code conforme à la norme MISRA C avec traçabilité pour répondre aux exigences des certifications DO-178C, ISO 26262 et CEI 61508.

Workflow de l'IA embarquée de bout en bout

Préparer les
données

→

Entraîner/importer
un modèle d'IA

→

Compresser
le modèle

→

Vérifier
le modèle d'IA

→

Intégrer dans
Simulink

→

Déployer et
vérifier

Itératif par nature :

Ce workflow n'est pas strictement linéaire. Les étapes peuvent être répétées, réorganisées ou complètement ignorées selon les contraintes de mémoire, les exigences de latence, le hardware cible et les besoins de conformité aux normes de votre projet.

Entraîner/importer un modèle d'IA

Entraîner de manière programmatique dans MATLAB

% Train a deep learning network
net = trainnet(data, layers, "crossentropy", options);

% Train a machine learning model
mdl = fitcsvm(features, labels);

Entraîner dans MATLAB de manière interactive

Importer à partir de frameworks externes

% Import from PyTorch (exported program format)
net = importNetworkFromPyTorch("exported_pytorch_model.pt2")

net =
  dlnetwork with properties:

         Layers: [9×1 nnet.cnn.layer.Layer]
    Connections: [11×2 table]
     Learnables: [86×3 table]
          State: [42×3 table]
     InputNames: {'InputLayer1'}
    OutputNames: {'ResidualNetSmall:fc'}
    Initialized: 1

Source	Fonction
PyTorch (.pt2/.pt)	`importNetworkFromPyTorch`
ONNX	`importNetworkFromONNX`
TensorFlow 2	`importNetworkFromTensorFlow`
Keras 3	`importNetworkFromKeras`
XGBoost (.json)	`importModelFromXGBoost`

Compresser le modèle

%% Step 1: Prune (e.g., remove 60% of learnables)
netPruned = compressNetworkUsingTaylorPruning(net, dsTrain, "crossentropy", ...
    options, LearnablesReductionGoal=0.6);

%% Step 2: Project (e.g., retain 80% variance)
npca = neuronPCA(netPruned, dsTrain);
netProjected = compressNetworkUsingProjection(netPruned, npca, ...
    ExplainedVarianceGoal=0.8);
netProjected = trainnet(data, netProjected, "crossentropy", optionsFT);

%% Step 3: Quantifier (INT8)
quantObj = dlquantizer(netProjected, ExecutionEnvironment="CPU");
calibrate(quantObj, dsCal);
netQuantized = quantize(quantObj);

Technique	Réduction potentielle de la taille du modèle	Quand l'utiliser
Élagage	50–70%	CNN surparamétrés avec des filtres redondants
Projection	20–85%	Réseaux récurrents ou à fortes couches FC avec des activations corrélées
La quantification	75% (4×)	Étape finale pour les processeurs à virgule fixe

Conseil :

Ordre recommandé : Élaguer → Projeter → Quantifier (réajuster après chaque étape). Utilisez estimateNetworkMetrics(net) pour mesurer les paramètres d'apprentissage, la mémoire d'activation et les MAC avant et après chaque étape. Consultez également la Deep Learning Toolbox Model Compression Library.

Vérifier le modèle d'IA

Prouvez les propriétés de sécurité ou évaluez la robustesse avant le déploiement grâce à la AI Verification Library et à la Deep Learning Toolbox Interface for alpha-beta-CROWN Verifier. Contrairement aux tests sur des entrées échantillonnées, la vérification formelle offre des garanties mathématiques sur des domaines d'entrée continus.

Technique	Fonctionnalités	Fonction clé
Vérification de la robustesse	Prouve que la classification d'un réseau est invariante au sein d'un domaine d'entrée borné	`verifyNetworkRobustness`
Bornes de sortie formelles	Calcule des bornes supérieures et inférieures garanties sur les sorties du réseau pour un domaine d'entrée borné	`estimateNetworkOutputBounds`
Robustesse contradictoire	Trouve des exemples contradictoires provoquant une mauvaise classification au sein d'un domaine d'entrée borné	`findAdversarialExamples`
Détection des données hors distribution	Signale les entrées différentes des données d’apprentissage pour éviter les défaillances silencieuses lors de l'exécution	`networkDistributionDiscriminator`

Le premier argument est soit un objet dlnetwork (entraîné dans MATLAB ou importé), soit le chemin d'accès à un fichier modèle : un fichier ONNX (.onnx) ou un modèle PyTorch complet (enregistré avec torch.save()). Mêmes fonctions, même syntaxe.

% Prove classification is robust to sensor noise around input X0
XLower = X0 - epsilon;
XUpper = X0 + epsilon;
[result, cex] = verifyNetworkRobustness(net, XLower, XUpper, trueLabel);

% Compute guaranteed output bounds over the input region
[YLower, YUpper] = estimateNetworkOutputBounds(net, XLower, XUpper);

% Find adversarial examples within bounded region
[adversarials, success] = findAdversarialExamples(net, XLower, XUpper, trueLabel);

Intégrer dans Simulink

Intégrez les modèles d'IA dans les simulations de systèmes pour vérifier leur comportement aux côtés des contrôleurs, des capteurs et des modèles de systèmes physiques avant de générer le code.

Bloc	Code	Cas d'utilisation
Co-exécution		Simuler des modèles PyTorch, TensorFlow, ONNX ou Python personnalisés directement dans Simulink sans conversion ; évaluer les performances des IA tierces au sein de systèmes plus larges avant leur intégration complète.
Predict		Exécuter un `dlnetwork` sous forme de bloc d'inférence unique (classification ou régression)
PyTorch Exported Program		Exécuter un modèle PyTorch `.pt2` directement dans Simulink avec génération de code C/C++ et CUDA
Blocs de couches	`exportNetworkToSimulink`	Exporter des réseaux sous forme de blocs Simulink individuels pour un contrôle et une inspection en virgule fixe par couche

Déployer et vérifier

Générez du code source autonome s'exécutant sans MATLAB, puis le vérifier de manière progressive sur le hardware cible.

Génération de code

Produit	Sortie	Cibles principales	Bibliothèque cible
MATLAB Coder	C/C++	ARM Cortex-A, x86, tout système POSIX/RTOS	Autonome^*, Intel oneDNN
Embedded Coder	C/C++ de production	Microcontrôleurs NXP, Infineon, STMicro, Renesas, etc.	Autonome^*, CMSIS, CMSIS-NN
GPU Coder	CUDA C++	NVIDIA Jetson Thor, Orin, Xavier, TX2	Autonome^*, TensorRT
Embedded Coder + HSP	C/C++ optimisé pour NPU	Qualcomm Hexagon, PPU d'Infineon (AURIX TC4x)	Environnement d'exécution NPU du fournisseur
HDL Coder	VHDL/Verilog	FPGA AMD (Xilinx), FPGA Intel	IP Deep Learning HDL Toolbox

*Définissez la bibliothèque de Deep Learning cible sur « none » pour générer du code C/C++ ANSI/ISO autonome pour n'importe quel processeur, sans dépendance envers des bibliothèques tierces.

Modèle de fonction d'entrée

% Use MATLAB dlnetwork
function out = myPredict(in) %#codegen
    persistent net
    if isempty(net)
        net = coder.loadDeepLearningNetwork('myNet.mat');
   end
    out = predict(net, in);
end

% Use PyTorch model
function out = myPredict(in) %#codegen
    persistent pytorchNet
    if isempty(pytorchNet)
        pytorchNet = loadPyTorchExportedProgram('myPyTorchNet.pt2');
    end
    out = invoke(pytorchNet, in);
end

Configurer et générer

% Generate C++ for any processor
cfg = coder.config('lib');
cfg.TargetLang = 'C++';
cfg.DeepLearningConfig = coder.DeepLearningConfig('none');
codegen -config cfg myPredict -args {ones(224,224,3,'single')}

% Generate CUDA for NVIDIA Jetson
gpuCfg = coder.gpuConfig('lib');
gpuCfg.DeepLearningConfig = coder.DeepLearningConfig('tensorrt');
codegen -config gpuCfg myPredict -args {ones(224,224,3,'single')}

Bibliothèque cible	Hardware
`'none'`	Quel qu'il soit (sans bibliothèque)
`'mkldnn'`	x86-64 (Intel oneDNN)
`'cudnn'`	GPU NVIDIA
`'tensorrt'`	GPU NVIDIA/Jetson

Vérification au niveau système (MIL/SIL/PIL/HIL)

Vérifiez de manière progressive : modèle (MIL) → code généré sur l'hôte (SIL) → processeur cible (PIL) → système complet avec E/S réelles (HIL).

Étape	Ce qui est exécuté	Où	Ce qui est vérifié
MIL (model-in-the-loop)	Modèle Simulink (interprété)	PC hôte	Exactitude de l'algorithme : établit un modèle de référence
SIL (software-in-the-loop)	Code C/C++/CUDA généré	PC hôte (compilé)	Exactitude comportementale : équivalence numérique du code généré s'exécutant sur le processeur hôte
PIL (processor-in-the-loop)	Code C/C++/CUDA généré	Hardware cible	Effets spécifiques à la cible : compilateur, FPU, équivalence numérique du code généré s'exécutant sur le processeur cible
HIL (hardware-in-the-loop)	Système complet avec E/S réelles	Cible en temps réel	Effets en temps réel : intégration, synchronisation et comportement des E/S

% Processor-in-the-Loop verification
set_param("myModel/AI_Subsystem", "SimulationMode", "Processor-in-the-loop");
out = sim("myModel");
% Compare PIL output against MIL baseline to detect numerical drift