Embedded KI mit MATLAB und Simulink

Vom Konzept bis zur Produktion: Stellen Sie KI auf beliebiger Embedded Hardware bereit.

Die Vorteile von Embedded KI mit MATLAB und Simulink

Stellen Sie trainierte KI-Modelle mit Systemsimulation und automatischer Codegenerierung auf ressourcenbeschränkter Hardware wie MCUs, GPUs, FPGAs und NPUs bereit.

Simulation auf Systemebene: Testen Sie das Verhalten der KI zusammen mit Reglern, Sensoren und Modellen der Regelstrecke, bevor Sie die Hardware einsetzen.
Codegenerierung: Generieren Sie optimierten C/C++ Code, CUDA-Code oder HDL-Code direkt aus Ihrem Simulink-Modell einschließlich der KI-Komponente – ganz ohne manuelle Portierung.
Flexible Importmöglichkeiten: Importieren Sie PyTorch-, ONNX- oder TensorFlow-Modelle und stellen Sie sie über dieselbe Pipeline bereit.
Durchgängige Verifikation: Verifizieren Sie Ihre KI-Komponente in jeder Phase mithilfe formaler Methoden, Tests der adversarialen Robustheit sowie Software-in-the-Loop-(SIL)-, Processor-in-the-Loop-(PIL)- und Hardware-in-the-Loop-(HIL)-Tests.
Erfüllung von Standards: Generieren Sie MISRA C-konformen Code mit Rückverfolgbarkeit zur Unterstützung der Zertifizierung gemäß DO-178C, ISO 26262 und IEC 61508.

Durchgängiger Embedded KI-Workflow

Vorbereiten der
Daten

→

Trainieren/Importieren des
KI-Modells

→

Komprimieren des
Modells

→

Verifizieren des
KI-Modells

→

Integrieren in
Simulink

→

Bereitstellen und
verifizieren

Iterativer Ansatz:

Dieser Workflow ist nicht streng linear. Je nach Speichebeschränkungen, Latenzzeitanforderungen, Zielhardware und Anforderungen an die Einhaltung von Standards in Ihrem Projekt können einzelne Schritte wiederholt, in einer anderen Reihenfolge ausgeführt oder vollständig übersprungen werden.

Trainieren/Importieren eines KI-Modells

Programmgesteuert in MATLAB trainieren

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

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

Interaktiv in MATLAB trainieren

Aus externen Frameworks importieren

% 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

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

Komprimieren des Modells

%% 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: Quantize (INT8)
quantObj = dlquantizer(netProjected, ExecutionEnvironment="CPU");
calibrate(quantObj, dsCal);
netQuantized = quantize(quantObj);

Technik	Potenzielle Reduzierung der Modellgröße	Einsatzbereich
Pruning	50–70 %	überparametrisierte CNNs mit redundanten Filtern
Projektion	20–85 %	Netzwerke mit vielen vollständig verbundenen Schichten oder rekurrente Netzwerke mit korrelierten Aktivierungen
Quantisierung	75 % (4×)	letzter Schritt für Festkommaprozessoren

Tipp:

Empfohlene Reihenfolge: Pruning → Projektion → Quantisierung (nach jedem Schritt Feinabstimmung durchführen). Verwenden Sie estimateNetworkMetrics(net), um die Anzahl der lernbaren Parameter, den Speicherbedarf für Aktivierungen und die MACs vor und nach jedem Schritt zu ermitteln. Weitere Informationen finden Sie auch in der Deep Learning Toolbox Model Compression Library.

KI-Modell verifizieren

Weisen Sie vor der Bereitstellung Sicherheitseigenschaften nach oder evaluieren Sie die Robustheit mithilfe der AI Verification Library und des Deep Learning Toolbox Interface for alpha-beta-CROWN Verifier. Im Gegensatz zu Tests mit ausgewählten Eingabewerten bietet die formale Verifikation mathematische Garantien für kontinuierliche Eingabebereiche.

Technik	Funktionsweise	Schlüsselfunktion
Verifikation der Robustheit	Weist nach, dass die Klassifizierung eines Netzwerks innerhalb eines begrenzten Eingabebereichs unverändert bleibt.	`verifyNetworkRobustness`
Formale Ausgabegrenzen	Berechnet garantierte Ober- und Untergrenzen für die Netzwerkausgaben innerhalb eines begrenzten Eingabebereichs.	`estimateNetworkOutputBounds`
Adversarielle Robustheit	Findet adversarielle Beispiele, die innerhalb eines begrenzten Eingabebereichs zu Fehlklassifizierungen führen.	`findAdversarialExamples`
Erkennung von Out-of-Distribution	Kennzeichnet Eingaben, die von den Trainingsdaten abweichen, um unbemerkte Fehler zur Laufzeit zu verhindern.	`networkDistributionDiscriminator`

Das erste Argument ist entweder ein dlnetwork-Objekt (in MATLAB trainiert oder importiert) oder der Pfad zu einer Modelldatei – einer ONNX-Datei (.onnx) oder einem vollständigen PyTorch-Modell (gespeichert mit torch.save()). Gleiche Funktionen, gleiche Syntax.

% 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);

In Simulink integrieren

Betten Sie KI-Modelle in Systemsimulationen ein, um ihr Verhalten zusammen mit Reglern, Sensoren und Modellen der Regelstrecke zu verifizieren, bevor Sie Code generieren.

Block	Code	Anwendungsfall
Co-Ausführung		Simulieren Sie PyTorch-, TensorFlow-, ONNX- oder benutzerdefinierte Python-Modelle ohne Konvertierung direkt in Simulink und evaluieren Sie, wie sich KI von Drittanbietern in größeren Systemen verhält, bevor Sie sie vollständig integrieren.
Predict		Führen Sie ein `dlnetwork` als einzelnen Inferenzblock aus (Klassifizierung oder Regression).
Aus PyTorch exportiertes Programm		Führen Sie ein PyTorch-`.pt2`-Modell direkt in Simulink aus – mit Codegenerierung für C/C++ und CUDA.
Schichtenblöcke	`exportNetworkToSimulink`	Exportieren Sie Netzwerke als einzelne Simulink-Blöcke, um die Festkommaausführung schichtweise zu steuern und zu überprüfen.

Bereitstellen und verifizieren

Generieren Sie eigenständig ausführbaren Quellcode, der ohne MATLAB ausgeführt werden kann, und verifizieren Sie ihn anschließend schrittweise auf der Zielhardware.

Codegenerierung

Produkt	Ausgabe	Primäre Zielplattformen	Zielbibliothek
MATLAB Coder	C/C++	ARM Cortex-A, x86, beliebige POSIX-/RTOS-Plattformen	Standalone^*, Intel oneDNN
Embedded Coder	Produktionsreifer C/C++ Code	NXP-, Infineon-, STMicroelectronics- und Renesas-MCUs und weitere	Standalone^*, CMSIS, CMSIS-NN
GPU Coder	CUDA C++	NVIDIA Jetson Thor, Orin, Xavier, TX2	Standalone^*, TensorRT
Embedded Coder + HSP	Optimierter C/C++ Code für NPUs	Qualcomm Hexagon, Infineon PPU (AURIX TC4x)	NPU-Laufzeitumgebung des Anbieters
HDL Coder	VHDL/Verilog	AMD (Xilinx) FPGAs, Intel FPGAs	Deep Learning HDL Toolbox IP

*Setzen Sie die Zielbibliothek für Deep Learning auf 'none', um eigenständigen ANSI/ISO-konformen C/C++ Code für beliebige Prozessoren ohne Abhängigkeiten von Drittanbieterbibliotheken zu generieren.

Muster für die Einstiegspunktfunktion

% 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

Konfigurieren und generieren

% 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')}

Zielbibliothek	Hardware
`'none'`	Beliebig (bibliotheksunabhängig)
`'mkldnn'`	x86-64 (Intel oneDNN)
`'cudnn'`	NVIDIA-GPUs
`'tensorrt'`	NVIDIA-GPUs/Jetson

Verifikation auf Systemebene (MIL/SIL/PIL/HIL)

Führen Sie die Verifikation schrittweise durch: Modell (MIL) → generierter Code auf dem Host (SIL) → Zielprozessor (PIL) → Gesamtsystem mit realen Ein-/Ausgängen (HIL).

Phase	Ausgeführte Komponente	Ausführungsumgebung	Gegenstand der Verifikation
MIL (model-in-the-loop)	Simulink-Modell (interpretiert)	Host-PC	Korrektheit des Algorithmus: Dient als Referenzergebnis
SIL (software-in-the-loop)	Generierter C/C++/CUDA-Code	Host-PC (kompiliert)	Korrektheit des Verhaltens: numerische Äquivalenz des auf dem Host-Prozessor ausgeführten generierten Codes
PIL (processor-in-the-Loop)	Generierter C/C++/CUDA-Code	Zielhardware	Zielsystemspezifische Effekte: Compiler, FPU, numerische Äquivalenz des auf dem Zielprozessor ausgeführten generierten Codes
HIL (hardware-in-the-loop)	Gesamtsystem mit realen Ein-/Ausgängen	Echtzeit-Zielsystem	Echtzeiteffekte: Integration, Zeitverhalten und Ein-/Ausgabeverhalten

% 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