IA embebida con MATLAB y Simulink

Del concepto a la producción, despliegue IA en cualquier hardware embebido.

Por qué utilizar IA embebida con MATLAB y Simulink

Despliegue modelos de IA entrenados en hardware con recursos limitados, como MCU, GPU, FPGA y NPU, con simulación en nivel de sistema y generación de código automatizada.

Simulación en nivel de sistema: Pruebe el comportamiento de la IA junto con controladores, sensores y modelos de planta antes de utilizar hardware.
Generación de código: Genere código C/C++, CUDA o HDL optimizado directamente a partir de un modelo de Simulink, incluido el componente de IA, sin necesidad de portar código manualmente.
Flexibilidad de importación: Importe modelos de PyTorch, ONNX o TensorFlow, y despliéguelos mediante la misma cadena de tareas.
Verificación durante todo el proceso: Verifique el componente de IA en cada etapa con métodos formales, pruebas de robustez adversarial y pruebas de software-in-the-loop (SIL), processor-in-the-loop (PIL) y hardware-in-the-loop (HIL).
Conformidad con estándares: Genere código conforme con MISRA C y con trazabilidad para facilitar la certificación según DO-178C, ISO 26262 e IEC 61508.

Flujo de trabajo integral de IA embebida

Prepare
los datos

 →

Entrene/importe
el modelo de IA

 →

Comprima
el modelo

 →

Verifique
el modelo de IA

 →

Integre en
Simulink

 →

Despliegue y
verifique

Proceso iterativo:

Este flujo de trabajo no es estrictamente lineal. Los pasos se pueden repetir, reordenar u omitir por completo en función de las restricciones de memoria del proyecto, requisitos de latencia, hardware objetivo y necesidades de conformidad con estándares.

Entrene/importe el modelo de IA

Entrene en MATLAB de forma programática

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

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

Entrene en MATLAB de manera interactiva

Importe desde marcos externos

% 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

Fuente	Función
PyTorch (.pt2/.pt)	`importNetworkFromPyTorch`
ONNX	`importNetworkFromONNX`
TensorFlow 2	`importNetworkFromTensorFlow`
Keras 3	`importNetworkFromKeras`
XGBoost (.json)	`importModelFromXGBoost`

Comprima el modelo

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

Técnica	Reducción del tamaño del modelo	Cuándo utilizarla
Poda	50-70%	CNN sobreparametrizadas con filtros redundantes
Proyección	20-85%	Redes recurrentes o con muchas capas FC y activaciones correlacionadas
Cuantización	75% (4×)	Paso final para procesadores de punto fijo

Sugerencia:

Orden recomendado: Poda → Proyección → Cuantización (ajuste después de cada paso). Utilice estimateNetworkMetrics(net) para medir parámetros que se pueden aprender, memoria de activación, y MAC antes y después de cada paso. Consulte también Deep Learning Toolbox Model Compression Library.

Verifique el modelo de IA

Demuestre las propiedades de seguridad o evalúe la robustez antes del despliegue con AI Verification Library y Deep Learning Toolbox Interface for alpha-beta-CROWN Verifier. A diferencia de las pruebas con entradas muestreadas, la verificación formal ofrece garantías matemáticas en regiones de entrada continuas.

Técnica	Descripción	Función principal
Verificación de robustez	Demuestra que la clasificación de una red no cambia dentro de una región de entrada acotada	`verifyNetworkRobustness`
Límites de salida formales	Calcula los límites superior e inferior garantizados de salidas de red para una región de entrada acotada	`estimateNetworkOutputBounds`
Robustez adversarial	Busca ejemplos adversariales que provocan una clasificación incorrecta dentro de una región de entrada acotada	`findAdversarialExamples`
Detección de datos fuera de distribución	Marca entradas diferentes de los datos de entrenamiento para evitar fallos silenciosos en tiempo de ejecución	`networkDistributionDiscriminator`

El primer argumento es un objeto dlnetwork, entrenado en MATLAB o importado, o bien la ruta de un archivo de modelo, como un archivo ONNX (.onnx) o un modelo de PyTorch completo guardado con torch.save(). Mismas funciones, misma sintaxis.

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

Integre en Simulink

Incorpore modelos de IA en simulaciones de sistemas para verificar su comportamiento junto con controladores, sensores y modelos de planta antes de generar código.

Bloque	Código	Caso práctico
Bloque Co-Execution		Simule modelos de PyTorch, TensorFlow, ONNX o modelos de Python personalizados directamente en Simulink sin conversión; evalúe cómo funciona la IA de terceros en sistemas más grandes antes de la integración completa
Bloque Predict		Ejecute `dlnetwork` como un único bloque de inferencia, para clasificación o regresión
PyTorch Exported Program		Ejecute un modelo `.pt2` de PyTorch directamente en Simulink con generación de código C/C++ y CUDA
Bloques por capas	`exportNetworkToSimulink`	Exporte redes como bloques de Simulink individuales para realizar control e inspección de punto fijo por capa

Despliegue y verifique

Genere código fuente independiente que se ejecute sin MATLAB, y luego verifíquelo progresivamente en hardware objetivo.

Generación de código

Producto	Salida	Principales plataformas objetivo	Librería objetivo
MATLAB Coder	C/C++	ARM Cortex-A, x86, cualquier POSIX/RTOS	Independiente^*, Intel oneDNN
Embedded Coder	C/C++ para producción	MCU de NXP, Infineon, STMicro, Renesas y otros fabricantes	Independiente^*, CMSIS, CMSIS-NN
GPU Coder	CUDA C++	NVIDIA Jetson Thor, Orin, Xavier, TX2	Independiente^*, TensorRT
Embedded Coder + HSP	C/C++ optimizado para NPU	Qualcomm Hexagon, Infineon PPU (AURIX TC4x)	Entorno de ejecución de NPU del proveedor
HDL Coder	VHDL/Verilog	FPGA de AMD (Xilinx), FPGA de Intel	IP de Deep Learning HDL Toolbox

* Establezca la librería objetivo de Deep Learning en 'none' para generar código ANSI/ISO C/C++ independiente para cualquier procesador, sin dependencias de librerías de terceros.

Patrón de función de punto de entrada

% 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

Configure y genere

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

Librería objetivo	Hardware
`'none'`	Cualquiera (sin librerías)
`'mkldnn'`	x86-64 (Intel oneDNN)
`'cudnn'`	GPU de NVIDIA
`'tensorrt'`	GPU de NVIDIA/Jetson

Verificación en nivel de sistema (MIL/SIL/PIL/HIL)

Verifique progresivamente: modelo (MIL) → código generado en host (SIL) → procesador objetivo (PIL) → sistema completo con E/S real (HIL).

Etapa	Qué se ejecuta	Dónde	Qué verifica
MIL (model-in-the-loop)	Modelo de Simulink (interpretado)	PC host	Corrección del algoritmo: establece la referencia de alto nivel
SIL (software-in-the-loop)	Código C/C++/CUDA generado	PC host (compilado)	Corrección del comportamiento: equivalencia numérica del código generado ejecutado en el procesador host
PIL (processor-in-the-loop)	Código C/C++/CUDA generado	Hardware objetivo	Efectos específicos de la plataforma objetivo: compilador, FPU y equivalencia numérica del código generado ejecutado en el procesador objetivo
HIL (hardware-in-the-loop)	Sistema completo con E/S real	Plataforma objetivo en tiempo real	Efectos en tiempo real: integración, temporización y comportamiento de 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