IA embedded con MATLAB e Simulink

Dal concetto alla produzione, implementa l’IA su qualsiasi hardware embedded.

Perché utilizzare l’IA embedded con MATLAB e Simulink?

Distribuisci modelli di IA addestrati su hardware con risorse limitate, come MCU, GPU, FPGA e NPU, utilizzando la simulazione a livello di sistema e la generazione di codice automatica.

Simulazione a livello di sistema: testa il comportamento dell’IA insieme a controller, sensori e modelli d’impianto prima di passare all’hardware.
Generazione di codice: genera codice C/C++, CUDA o HDL ottimizzato direttamente dal tuo modello Simulink, inclusa la componente di IA, senza dover ricorrere al porting manuale.
Flessibilità di importazione: importa modelli PyTorch, ONNX o TensorFlow e distribuiscili tramite la stessa pipeline.
Verifica lungo l’intero processo: verifica la tua componente di IA in ogni fase utilizzando metodi formali, test di robustezza contro attacchi avversari e test Software-In-the-Loop (SIL), Processor-In-the-Loop (PIL) e Hardware-In-the-Loop (HIL).
Conformità agli standard: genera codice conforme a MISRA C con tracciabilità a supporto della certificazione DO-178C, ISO 26262 e IEC 61508.

Workflow end-to-end dell’IA embedded

Preparazione
dei dati

→

Addestramento/importazione
del modello di IA

→

Compressione
del modello

→

Verifica
del modello di IA

→

Integrazione in
Simulink

→

Distribuzione e
verifica

Iterativo per natura:

Questo workflow non è strettamente lineare. I passaggi possono essere ripetuti, riordinati o completamente omessi, a seconda dei vincoli di memoria del progetto, dei requisiti di latenza, dell’hardware di destinazione e delle esigenze di conformità agli standard.

Addestramento/importazione del modello di IA

Addestramento in MATLAB in modo programmatico

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

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

Addestramento interattivo in MATLAB

Importazione da framework esterni

% 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

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

Compressione del modello

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

Tecnica	Potenziale riduzione delle dimensioni del modello	Quando utilizzarla
Pruning	50–70%	CNN sovraparametrizzate con filtri ridondanti
Proiezione	20–85%	Reti con molti strati FC o reti ricorrenti con attivazioni correlate
Quantizzazione	75% (4×)	Passaggio finale per i processori a virgola fissa

Suggerimento:

Ordine consigliato: Pruning → Proiezione → Quantizzazione (ottimizzazione dopo ogni passaggio). Utilizza estimateNetworkMetrics(net) per misurare il numero di parametri addestrabili, la memoria delle attivazioni e le operazioni MAC prima e dopo ogni passaggio. Vedi anche Deep Learning Toolbox Model Compression Library.

Verifica del modello di IA

Verifica le proprietà di sicurezza o valuta la robustezza prima della distribuzione utilizzando AI Verification Library e Deep Learning Toolbox Interface for alpha-beta-CROWN Verifier. A differenza dei test eseguiti su input campionati, la verifica formale fornisce garanzie matematiche su regioni di input continue.

Tecnica	Cosa fa	Funzione chiave
Verifica della robustezza	Dimostra che la classificazione di una rete è invariante all’interno di una regione di input limitata	`verifyNetworkRobustness`
Limiti formali di output	Calcola i limiti superiori/inferiori garantiti delle uscite di rete per una regione di input limitata	`estimateNetworkOutputBounds`
Robustezza contro attacchi avversari	Individua esempi avversari che causano una classificazione errata all’interno di una regione di input limitata	`findAdversarialExamples`
Rilevamento Out-of-Distribution	Segnala gli input che differiscono dai dati di addestramento per prevenire errori silenziosi in fase di runtime	`networkDistributionDiscriminator`

Il primo argomento è un oggetto dlnetwork (addestrato in MATLAB o importato) oppure il percorso a un file di modello, ovvero un file ONNX (.onnx) o un modello PyTorch completo (salvato con torch.save()). Stesse funzioni, stessa sintassi.

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

Integrazione in Simulink

Integra i modelli di IA nelle simulazioni di sistema per verificarne il comportamento insieme ai controller, ai sensori e ai modelli d’impianto prima di generare il codice.

Blocco	Codice	Caso d’uso
Co-Execution		Simulazione di modelli PyTorch, TensorFlow, ONNX o modelli Python personalizzati direttamente in Simulink senza conversione; valutazione delle prestazioni dei modelli di IA di terze parti all’interno di sistemi più complessi prima della loro completa integrazione
Predict		Esecuzione di una `dlnetwork` come singolo blocco di inferenza (classificazione o regressione)
PyTorch Exported Program		Esecuzione di un modello PyTorch `.pt2` direttamente in Simulink con generazione di codice C/C++ e CUDA
Blocchi Layer	`exportNetworkToSimulink`	Esportazione delle reti come singoli blocchi Simulink per il controllo e la verifica a virgola fissa per ogni singolo layer

Distribuzione e verifica

Genera codice sorgente standalone che possa essere eseguito senza MATLAB, quindi verifica progressivamente il codice sull’hardware target.

Generazione di codice

Prodotto	Output	Target principali	Libreria target
MATLAB Coder	C/C++	ARM Cortex-A, x86, qualsiasi POSIX/RTOS	Standalone^*, Intel oneDNN
Embedded Coder	C/C++ di produzione	NXP, Infineon, STMicro, MCU Renesas e altri ancora	Standalone^*, CMSIS, CMSIS-NN
GPU Coder	CUDA C++	NVIDIA Jetson Thor, Orin, Xavier, TX2	Standalone^*, TensorRT
Embedded Coder + HSP	C/C++ ottimizzato per NPU	Qualcomm Hexagon, PPU Infineon (AURIX TC4x)	Runtime NPU del produttore
HDL Coder	VHDL/Verilog	FPGA AMD (Xilinx), FPGA Intel	IP Deep Learning HDL Toolbox

*Imposta la libreria di Deep Learning target su 'none' per generare codice ANSI/ISO C/C++ standalone per qualsiasi processore, senza dipendenze da librerie di terze parti.

Schema della funzione di ingresso

% 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

Configurazione e generazione

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

Libreria target	Hardware
`'none'`	Qualsiasi (senza libreria)
`'mkldnn'`	x86-64 (Intel oneDNN)
`'cudnn'`	GPU NVIDIA
`'tensorrt'`	GPU NVIDIA/Jetson

Verifica a livello di sistema (MIL/SIL/PIL/HIL)

Verifica progressivamente: modello (MIL) → codice generato sull’host (SIL) → processore target (PIL) → sistema completo con I/O reale (HIL).

Fase	Cosa esegue	Dove	Cosa verifica
MIL (Model-In-the-Loop)	Modello Simulink (interpretato)	PC host	Correttezza dell’algoritmo: definisce il modello di riferimento
SIL (Software-In-the-Loop)	Codice C/C++/CUDA generato	PC host (compilato)	Correttezza comportamentale: equivalenza numerica del codice generato in esecuzione sul processore host
PIL (Processor-In-the-Loop)	Codice C/C++/CUDA generato	Hardware target	Effetti specifici del target: compilatore, FPU, equivalenza numerica del codice generato in esecuzione sul processore target
HIL (Hardware-In-the-Loop)	Sistema completo con I/O reale	Target in tempo reale	Effetti in tempo reale: integrazione, temporizzazione e comportamento dell’I/O

% 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