Diplomado en Inferencia en MCU/NPUs (TFLite/ONNX/TensorRT)

2.1 Eficiencia arquitectónica: MobileNet/EfficientNet/ShuffleNet/TinyML patterns.
2.2 Trade-offs: ancho vs profundidad, resolución vs precisión, multi-task vs single-task.
2.3 Operadores “hardware friendly”: conv2d, dwconv, 1×1, pooling; evitar ops costosas.
2.4 Memoria intermedia (activations): cómo domina el footprint en MCU.
2.5 Reutilización de buffers y planning de tensores: estrategias para SRAM limitada.
2.6 Preprocesado y postprocesado: coste, precisión, y dónde ejecutarlos (CPU vs acelerador).
2.7 Compresión estructural: pruning, low-rank, distillation; cuándo conviene en edge.
2.8 Diseño por caso de uso: wake-word, anomaly detection, clasificación visión, segmentación ligera.
2.9 Criterios de aceptación: precisión mínima, latencia máxima, consumo máximo, temperatura.
2.10 Checklist de “deployability”: validación previa a exportación (ops compatibles, rangos, cuantización).

3.1 TFLite vs TFLM: runtime, limitaciones, kernels y memoria.
3.2 Conversión TF → TFLite: SavedModel, Keras, firmas, entradas y salidas.
3.3 Operadores soportados: built-ins, select TF ops, y estrategias de reemplazo.
3.4 Cuantización TFLite: dynamic range, float16, full-integer INT8, INT16.
3.5 Calibración: representative dataset, rangos, sensibilidad por capa.
3.6 TFLM memory planner: arena, tensor allocation, buffers y profiling de SRAM.
3.7 Aceleración en MCU: CMSIS-NN, Ethos-U (conceptual), kernels optimizados y delegados.
3.8 Integración en firmware: build system, C/C++, loops de inferencia, interrupciones y RTOS.
3.9 Benchmarks en dispositivo: latencia, energía, temperatura; medición y registro.
3.10 Validación en campo: drift, robustez, tolerancias y estrategias de actualización.

4.1 ONNX como formato de intercambio: graph, opsets, tensores, initializers.
4.2 Exportación desde PyTorch/TF: buenas prácticas, control de opset y formas dinámicas.
4.3 Simplificación de gráficos: onnx-simplifier, folding de constantes, eliminación de nodos.
4.4 Validación numérica: parity checks, tolerancias, pruebas por lote y por capa.
4.5 Problemas típicos: ops no soportadas, shapes, broadcast, dynamic axes.
4.6 Cuantización ONNX: QDQ vs QOperator, calibración y compatibilidad con runtimes.
4.7 ONNX Runtime: CPU, NNAPI, CoreML, CUDA; cuándo usar cada backend.
4.8 Perfilado y tracing: identificar cuellos de botella por operador y por memoria.
4.9 Interoperabilidad: ONNX ↔ TFLite, límites reales y estrategias de mantenimiento.
4.10 Versionado del modelo: opset, runtime, hardware target; control de cambios.

5.1 Conceptos TensorRT: engine, builder, network definition, optimization profiles.
5.2 Precision modes: FP16, INT8, calibración y sensibilidad por capa.
5.3 Importación de ONNX a TensorRT: parsing, errores comunes y soluciones.
5.4 Plugins y layers custom: cuándo son necesarios y riesgos de mantenimiento.
5.5 Tácticas de optimización: fusion, tactic selection, workspace, sparse weights.
5.6 Batch, dynamic shapes y perfiles: impacto en latencia y memoria.
5.7 Deployment: serialización de engine, compatibilidad por versión, caching y warmup.
5.8 Integración con pipelines: DeepStream, GStreamer, CUDA streams (visión general).
5.9 Benchmarking: trtexec, Nsight (conceptual), métricas y reproducibilidad.
5.10 Operación en producción: monitoreo, fallback, actualizaciones y rollback.

6.1 Fundamentos cuantización: escala, zero-point, simétrica/asimétrica, per-tensor/per-channel.
6.2 INT8 end-to-end: requisitos y trampas en TFLite/ONNX/TensorRT.
6.3 Calibración de datos: representatividad, sesgos, selección de muestras.
6.4 Post-training quantization vs QAT: cuándo usar cada una.
6.5 Sensibilidad por capa: detección, mitigación, “keep FP16/FP32” selectivo.
6.6 Range clipping, bias correction y smooth quant: estrategias prácticas.
6.7 Cuantización de activaciones vs pesos: impacto en precisión y latencia.
6.8 Evaluación de precisión: top-k, mAP, IoU, métricas por clase y robustez.
6.9 Validación en dominio: datasets reales, ruido, condiciones ambientales y drift.
6.10 Criterios de aceptación: definir umbrales de precisión por caso de uso y riesgo.

7.1 Perfilado sistemático: hipótesis, medición, control de variables.
7.2 Análisis de latencia: kernels, pre/post, I/O, copias de memoria y sincronizaciones.
7.3 Memoria: activations, weights, buffers; técnicas para reducir footprint.
7.4 Scheduling y pipelines: batching, pipelining, doble buffer, concurrencia.
7.5 Energía: medición, métricas (mJ/inferencia), estrategias de reducción.
7.6 Thermal throttling: causas, detección y mitigación.
7.7 Optimización del preprocesado: SIMD, lookup tables, fixed-point.
7.8 Compilación y flags: -O2/-O3, LTO, CMSIS-DSP/NN, NEON (visión general).
7.9 Robustez y fallbacks: degradación controlada (resolución, FPS, precisión).
7.10 Reporte de optimización: documentación para repetibilidad y auditoría.

8.1 Arquitectura de software: módulos, drivers, RTOS, colas, prioridades y watchdogs.
8.2 Ciclo de inferencia: adquisición → preprocesado → inferencia → postprocesado → acción.
8.3 Gestión de modelos: almacenamiento, integridad, firma, cifrado, control de versión.
8.4 OTA para modelos: estrategias, delta updates, rollback y compatibilidad.
8.5 Telemetría: latencia, errores, drift, métricas de confianza; privacidad.
8.6 Testing: unit tests de pre/post, regression de precisión, pruebas en hardware-in-the-loop.
8.7 Observabilidad: logs, métricas y trazas; diagnóstico de fallos en campo.
8.8 Gestión de datasets: recolección, etiquetado, y realimentación desde producción.
8.9 Cumplimiento: seguridad, privacidad, documentación y trazabilidad.
8.10 Entrega continua: pipeline CI/CD para artefactos (TFLite/ONNX/engine) y firmware.

9.1 Visión: clasificación ligera con restricciones de FPS y memoria.
9.2 Detección: modelos compactos, NMS, postprocesado eficiente.
9.3 Audio: wake-word y clasificación acústica; MFCC y fixed-point.
9.4 Sensores: series temporales para anomalías en vibración/temperatura.
9.5 Optimización por plataforma: MCU vs NPU vs GPU edge; criterios de elección.
9.6 Comparación TFLite vs ONNX Runtime vs TensorRT: tiempos, precisión y mantenimiento.
9.7 Robustez: ruido, iluminación, variaciones; pruebas de estrés.
9.8 Seguridad funcional: umbrales, incertidumbre, y acciones seguras.
9.9 Evaluación final: benchmark integral (latencia, energía, memoria, precisión).
9.10 Documentación del laboratorio: reporte técnico reproducible y checklist de despliegue.

10.1 Definición del caso: requisitos de precisión, latencia, energía y memoria.
10.2 Selección de modelo base y estrategia de eficiencia.
10.3 Exportación a TFLite/ONNX según objetivo; control de compatibilidad de ops.
10.4 Cuantización (PTQ/QAT) y calibración con dataset representativo.
10.5 Compilación/engine: TensorRT (si aplica) y verificación de parity.
10.6 Integración: loop de inferencia, pre/post, optimización de I/O.
10.7 Benchmark en objetivo: medición de latencia, memoria y energía.
10.8 Validación en condiciones reales: robustez, drift y tolerancias.
10.9 Plan de despliegue: versionado, OTA, monitoreo y rollback.
10.10 Entrega final: informe completo, artefactos, checklist y plan de mantenimiento.