Curso de ONNX

Comprender el modelo ONNX como grafo computacional compuesto por nodos, entradas, salidas e inicializadores.

Diferenciar tensores, tipos de datos, shapes, dimensiones dinámicas, atributos y valores constantes.

Analizar cómo un operador representa una operación estándar dentro del grafo.

Revisar operadores habituales: Conv, MatMul, Add, Relu, Softmax, Gather, Reshape, LayerNormalization y Attention.

Entender cómo se guardan pesos, bias, parámetros y constantes dentro del modelo.

Interpretar inputs y outputs del grafo para preparar código de inferencia correctamente.

Revisar metadata del modelo: producer, domain, version, description, doc_string y propiedades personalizadas.

Diferenciar operadores estándar, dominios personalizados y custom ops.

Identificar problemas de compatibilidad cuando un runtime no soporta un operador concreto.

Realizar ejercicio de inspección manual de un modelo ONNX con herramientas Python.

Comprender qué es el IR de ONNX y cómo define la representación intermedia del modelo.

Entender qué es un opset y por qué afecta directamente a compatibilidad de operadores.

Diferenciar versión del paquete ONNX, versión IR, opset importado y versión del modelo exportado.

Revisar cómo un mismo operador puede cambiar entre opsets.

Definir criterios para elegir opset al exportar desde PyTorch, TensorFlow o scikit-learn.

Detectar errores típicos por usar un opset demasiado nuevo para el runtime de destino.

Revisar compatibilidad entre ONNX, ONNX Runtime, Execution Providers y plataformas de despliegue.

Documentar versión exacta de framework, exporter, opset, runtime y acelerador en cada release.

Evitar exportaciones sin versión controlada que no pueden reproducirse meses después.

Realizar ejercicio de exportación del mismo modelo con varios opsets y comparación de diferencias.

Instalar paquetes esenciales: onnx, onnxruntime, onnxscript, skl2onnx, tf2onnx, torch export tools y utilidades relacionadas.

Usar Netron para visualizar grafos, operadores, tensores, shapes y metadatos.

Usar onnx.checker para validar estructura formal del modelo.

Usar shape inference para completar información de shapes cuando es posible.

Usar onnxsim, onnxoptimizer u otras utilidades para simplificación cuando el proyecto lo requiere.

Revisar ONNX Model Zoo como fuente de modelos y ejemplos de referencia.

Diferenciar herramientas oficiales, herramientas comunitarias y herramientas específicas de proveedor hardware.

Crear entorno reproducible con requirements, lockfiles, Docker y documentación.

Evitar mezclar versiones incompatibles de PyTorch, exporters, protobuf, onnx y onnxruntime.

Realizar ejercicio de entorno ONNX completo con visualización, validación e inferencia.

Preparar modelos PyTorch en modo evaluación antes de exportar.

Definir dummy inputs, dynamic axes, nombres de entrada, nombres de salida y opset objetivo.

Exportar modelos con `torch.onnx.export` o flujos modernos disponibles según versión del stack.

Controlar diferencias entre tracing, scripting, export dinámico y modelos con ramas condicionales.

Validar que el modelo exportado mantiene shapes, tipos y comportamiento esperado.

Resolver errores por operadores no soportados, tensores dinámicos, listas, control flow o funciones personalizadas.

Comparar salida PyTorch frente a salida ONNX Runtime con tolerancias numéricas adecuadas.

Exportar modelos de visión, clasificación, embeddings y pequeños transformers.

Documentar configuración de exportación dentro del repositorio del modelo.

Realizar ejercicio de exportación de varios modelos PyTorch a ONNX con validación automática.

Convertir modelos TensorFlow y Keras a ONNX usando herramientas adecuadas del ecosistema.

Revisar SavedModel, H5, Keras model, concrete functions y firmas de entrada.

Definir inputs, outputs, shapes dinámicas, opset y compatibilidad del modelo exportado.

Resolver problemas de conversión con operaciones TensorFlow no soportadas o transformaciones internas.

Validar equivalencia entre inferencia TensorFlow y ONNX Runtime.

Preparar modelos de clasificación, regresión, visión y procesamiento de secuencias.

Revisar diferencias de formato de datos como NHWC y NCHW cuando afectan a visión.

Gestionar preprocessing y postprocessing que a veces quedan fuera del grafo ONNX.

Documentar limitaciones del exportador y pasos manuales necesarios.

Realizar ejercicio de conversión TensorFlow/Keras y comparación de resultados.

Convertir pipelines de scikit-learn con transformadores, escaladores, encoders y modelos finales.

Exportar clasificadores, regresores, pipelines de preprocessing y modelos tabulares.

Revisar compatibilidad de operadores clásicos de machine learning dentro de ONNX.

Convertir modelos XGBoost, LightGBM o CatBoost cuando el entorno y herramientas lo permiten.

Validar tipos de entrada: float32, int64, string tensors y estructuras tabulares.

Comparar predicciones entre modelo original y modelo ONNX con tolerancias y métricas adecuadas.

Gestionar variables categóricas, columnas, orden de features y metadatos del pipeline.

Evitar perder preprocessing al exportar solo el estimador final.

Crear contratos de inferencia para APIs tabulares.

Realizar ejercicio de exportación de pipeline tabular completo con validación de columnas.

Validar modelos con checker antes de probar rendimiento o despliegue.

Inspeccionar inputs, outputs, shapes, tipos, opsets, nodos e inicializadores.

Ejecutar shape inference para mejorar comprensión y detectar inconsistencias.

Comparar outputs del framework original y ONNX Runtime con tolerancias numéricas.

Crear tests automáticos de equivalencia con datasets de referencia.

Detectar errores por dimensiones dinámicas, batch variable, tipos incorrectos o nombres de entrada mal definidos.

Depurar fallos de ejecución localizando nodo, operador, input y provider afectado.

Usar visualización de grafos para encontrar operaciones redundantes o subgrafos inesperados.

Documentar diferencias aceptables de precisión por plataforma, cuantización o acelerador.

Realizar ejercicio de diagnóstico de modelos ONNX con errores intencionados.

Decidir qué parte del preprocessing debe quedar dentro del grafo y qué parte en código externo.

Incluir normalización, resize, tokenización simple, escalado o transformaciones cuando sea apropiado.

Separar preprocessing complejo que cambia con producto, idioma, tokenizer o configuración externa.

Diseñar postprocessing para clasificación, detección, NMS, decoding, thresholding, labels y formateo de salida.

Evitar inconsistencias entre preprocessing de entrenamiento y preprocessing de producción.

Documentar mean, std, vocabularios, labels, input size, channel order y formatos esperados.

Crear wrappers de inferencia que aplican preprocessing y postprocessing de forma reproducible.

Validar pipeline completo, no solo el grafo aislado.

Preparar tests end-to-end con inputs reales de imagen, texto, tabular o audio.

Realizar ejercicio de empaquetado de modelo ONNX con preprocessing y postprocessing controlado.

Instalar ONNX Runtime CPU y GPU según sistema operativo y acelerador disponible.

Crear InferenceSession y configurar SessionOptions.

Obtener nombres, tipos y shapes de entradas y salidas desde la sesión.

Preparar tensores NumPy con dtype, shape y layout correctos.

Ejecutar inferencia síncrona y medir latencia básica.

Configurar threads, optimization level, logging, memoria y opciones de sesión.

Gestionar modelos con batch, shapes dinámicas y múltiples salidas.

Evitar errores por dtype incorrecto, batch mal formado o dimensiones transpuestas.

Crear capa de servicio reutilizable para ejecutar modelos ONNX desde una API.

Realizar ejercicio de inferencia ONNX Runtime en Python con varios modelos.

Ejecutar modelos ONNX desde C# con paquetes Microsoft.ML.OnnxRuntime.

Diseñar integración en aplicaciones .NET, servicios Windows, APIs y aplicaciones empresariales.

Usar C++ para inferencia de baja latencia, edge, escritorio, sistemas embebidos o integración nativa.

Revisar Java como opción para servicios empresariales y backends JVM.

Usar ONNX Runtime Web para inferencia en navegador o entornos JavaScript.

Gestionar tensores, memoria, tipos y errores de runtime en cada lenguaje.

Comparar ergonomía, rendimiento, empaquetado y despliegue entre APIs.

Evitar duplicar lógica de preprocessing de forma inconsistente entre lenguajes.

Crear contratos de entrada y salida compartidos para integraciones multilenguaje.

Realizar ejercicio de consumo del mismo modelo desde Python, C# y JavaScript.

Comprender cómo ONNX Runtime delega subgrafos a Execution Providers específicos de hardware.

Configurar CPUExecutionProvider como baseline de compatibilidad y comparación.

Usar CUDAExecutionProvider para aceleración en GPUs NVIDIA.

Usar TensorRTExecutionProvider para optimización de inferencia en hardware NVIDIA cuando el modelo es compatible.

Usar OpenVINOExecutionProvider para acelerar en CPUs, GPUs y NPUs Intel compatibles.

Usar DirectMLExecutionProvider para aceleración en Windows con hardware DirectX 12 compatible.

Usar QNNExecutionProvider para escenarios Qualcomm, Android, Windows y NPUs compatibles.

Usar CoreMLExecutionProvider para escenarios Apple con CPU, GPU y Neural Engine.

Diseñar fallback controlado cuando parte del grafo no puede ejecutarse en el provider principal.

Realizar ejercicio de comparación de latencia y compatibilidad entre varios Execution Providers.

Comprender las optimizaciones de grafo aplicadas por ONNX Runtime al cargar un modelo.

Diferenciar niveles de optimización básicos, extendidos y de layout.

Ejecutar optimizaciones online durante la carga del modelo.

Guardar grafos optimizados offline para reducir tiempo de arranque y mejorar despliegue.

Analizar fusiones de nodos, eliminación de redundancias, constant folding y optimizaciones de layout.

Usar ORT format cuando conviene reducir tamaño, acelerar carga o limitar operadores necesarios.

Comparar rendimiento de modelo original, modelo optimizado y modelo en formato ORT.

Evitar optimizar sin validar precisión y compatibilidad del resultado.

Documentar opciones de optimización aplicadas en cada release.

Realizar ejercicio de optimización offline y comparación de rendimiento.

Comprender qué es cuantización y por qué reduce tamaño, memoria y coste de inferencia.

Diferenciar post-training quantization, dynamic quantization, static quantization y quantization aware training.

Preparar modelos FP32 para cuantización mediante shape inference y optimización previa.

Aplicar cuantización dinámica en modelos compatibles, especialmente escenarios CPU.

Aplicar cuantización estática con dataset de calibración cuando el modelo lo requiere.

Evaluar reducción de tamaño frente a pérdida de precisión.

Convertir modelos a FP16 o mixed precision cuando el acelerador lo soporta.

Detectar operadores que no cuantizan correctamente o degradan demasiado la calidad.

Crear informe comparativo de precisión, latencia, tamaño y memoria.

Realizar ejercicio de cuantización de modelo de visión o NLP con validación de calidad.

Comprender Olive como herramienta de optimización de modelos para ONNX Runtime.

Definir hardware objetivo, restricciones de precisión, latencia, tamaño y throughput.

Aplicar passes de optimización, cuantización, conversión y tuning de configuración.

Comparar varias estrategias de optimización de forma reproducible.

Usar Olive para generar modelos y configuraciones eficientes según plataforma.

Integrar Olive en pipelines de experimentación y validación.

Evaluar resultados con datasets y métricas de negocio, no solo benchmarks técnicos.

Documentar configuración, artefactos generados y decisión final.

Evitar optimizaciones automáticas sin revisión de accuracy y compatibilidad.

Realizar ejercicio de optimización end-to-end de un modelo para CPU o GPU.

Exportar modelos transformer pequeños y medianos a ONNX.

Comprender inputs típicos: input_ids, attention_mask, token_type_ids y position_ids.

Gestionar tokenización fuera del grafo cuando el tokenizer no está embebido.

Optimizar modelos BERT-like, embeddings, clasificación de texto y rerankers.

Configurar batch dinámico y longitud de secuencia variable.

Evaluar rendimiento con diferentes longitudes de texto y tamaño de batch.

Aplicar optimizaciones específicas para transformers cuando el flujo lo requiere.

Medir impacto de cuantización en embeddings, clasificación y similitud semántica.

Integrar modelos ONNX en pipelines RAG, búsqueda semántica o clasificación documental.

Realizar ejercicio de exportación, optimización e inferencia de modelo NLP ONNX.

Exportar modelos de clasificación, detección, segmentación o keypoints a ONNX.

Gestionar formatos de imagen, resize, normalización, channel order y batch.

Ejecutar inferencia con modelos tipo CNN, YOLO, DETR, U-Net o arquitecturas equivalentes.

Implementar postprocessing de detección: thresholds, boxes, labels y NMS cuando procede.

Validar equivalencia visual y métrica entre framework original y ONNX.

Optimizar modelos de visión para GPU, CPU, edge y dispositivos móviles.

Medir FPS, latencia por imagen, batch throughput y consumo de memoria.

Preparar inferencia en cámaras, inspección industrial, OCR, clasificación o control de calidad.

Evitar errores comunes por cambiar RGB/BGR, normalización o layout NCHW/NHWC.

Realizar ejercicio de despliegue ONNX para clasificación o detección en imagen.

Diseñar inferencia local en dispositivos edge con CPU limitada, GPU integrada o NPU.

Evaluar tamaño del modelo, latencia, consumo, temperatura, memoria y conectividad.

Preparar modelos cuantizados para gateways, cámaras, estaciones industriales o equipos embebidos.

Usar Execution Providers adecuados para Intel, Qualcomm, NVIDIA Jetson, Windows industrial o dispositivos Apple.

Diseñar actualización segura de modelos en entornos distribuidos.

Gestionar inferencia offline cuando no hay conexión a cloud.

Crear logs mínimos, métricas y mecanismos de diagnóstico remoto.

Evitar modelos demasiado grandes para hardware de campo o condiciones reales.

Diseñar fallback cuando el acelerador no está disponible.

Realizar ejercicio de arquitectura edge con modelo ONNX optimizado y control de versiones.

Comprender escenarios donde la inferencia en navegador aporta privacidad, latencia o reducción de backend.

Ejecutar modelos con ONNX Runtime Web mediante JavaScript o TypeScript.

Configurar WebAssembly, WebGL o WebGPU según disponibilidad y compatibilidad.

Gestionar carga de modelo, caché, workers, memoria y experiencia de usuario.

Preparar modelos pequeños o cuantizados para ejecución en cliente.

Diseñar preprocessing y postprocessing en navegador sin bloquear la interfaz.

Evaluar latencia, consumo, tamaño de descarga y compatibilidad entre navegadores.

Proteger modelos cuando se distribuyen al cliente y asumir que pueden extraerse.

Evitar enviar modelos sensibles al navegador si contienen propiedad intelectual crítica.

Realizar ejercicio de aplicación web que ejecuta inferencia ONNX localmente.

Preparar modelos ONNX para aplicaciones móviles con límites de tamaño, memoria y consumo.

Ejecutar ONNX Runtime en Android con CPU, NNAPI, QNN u opciones compatibles.

Ejecutar ONNX Runtime en iOS con CPU, CoreML Execution Provider o aceleración disponible.

Crear builds reducidos cuando la aplicación solo necesita un subconjunto de operadores.

Gestionar empaquetado del modelo, actualizaciones, compatibilidad y fallback.

Optimizar preprocessing para cámara, imágenes, audio o datos de sensores.

Medir latencia, calentamiento, batería, tamaño de app y estabilidad.

Validar resultados en dispositivos reales y no solo en simuladores.

Diseñar estrategia de actualización de modelos sin romper versiones antiguas de la app.

Realizar ejercicio de diseño de despliegue móvil con ONNX Runtime.

Crear API de inferencia con FastAPI, Flask, ASP.NET, Node.js o servicio equivalente.

Cargar modelos ONNX en memoria de forma segura y eficiente.

Gestionar warm-up, pooling de sesiones, threads, batch y concurrencia.

Diseñar endpoints de predicción, healthcheck, metadata, versión y métricas.

Contenerizar servicio ONNX con Docker y dependencias mínimas.

Configurar imágenes CPU y GPU según entorno de despliegue.

Preparar Kubernetes, autoscaling, readiness, liveness y límites de recursos.

Evitar recargar modelo en cada request o bloquear workers innecesariamente.

Añadir trazabilidad, logs, correlation IDs y control de errores.

Realizar ejercicio de microservicio de inferencia ONNX desplegable en Docker.

Comprender ONNX Runtime GenAI como capa orientada a bucle generativo sobre modelos ONNX.

Revisar tokenización, preprocesado, inferencia, logits processing, sampling y KV cache.

Evaluar cuándo tiene sentido usar ONNX para modelos generativos frente a otros runtimes LLM.

Preparar modelos compatibles y configuraciones necesarias para generación.

Gestionar parámetros de generación: max length, temperature, top_p, top_k y stopping.

Medir latencia, memoria, tokens por segundo y coste de serving.

Revisar soporte de adapters, modelos, plataformas y APIs disponibles.

Diseñar casos de uso GenAI controlados con requisitos de hardware realistas.

Evitar prometer compatibilidad universal con cualquier LLM convertido a ONNX.

Realizar ejercicio conceptual y práctico de inferencia generativa cuando el entorno lo permita.

Revisar origen del modelo, licencia, pesos, datasets, restricciones comerciales y metadatos.

Evitar ejecutar modelos descargados sin validar procedencia, integridad y permisos de uso.

Aplicar scanning de artefactos, hashes, firmas o controles internos cuando el entorno lo exige.

Gestionar riesgos de modelos maliciosos, operadores personalizados y dependencias externas.

Separar modelos de prueba, modelos aprobados y modelos productivos.

Controlar acceso a modelos que contienen propiedad intelectual, datos sensibles o conocimiento estratégico.

Evitar logs con datos personales, imágenes sensibles, textos internos o inputs de clientes.

Documentar decisiones de seguridad, proveedor, licencia y uso permitido.

Crear proceso de aprobación para incorporar modelos ONNX externos.

Realizar ejercicio de revisión de seguridad y licencia de un modelo antes de desplegarlo.

Crear tests de carga, inferencia, equivalencia, precisión, latencia y regresión.

Validar el modelo ONNX contra golden datasets o muestras representativas.

Comparar outputs entre framework original, ONNX Runtime CPU y provider acelerado.

Definir tolerancias numéricas por tipo de modelo, dtype y optimización aplicada.

Automatizar checker, shape inference, tests de inferencia y benchmark en CI/CD.

Guardar artefactos: modelo original, modelo ONNX, modelo optimizado, métricas y reportes.

Bloquear releases si cae accuracy, sube latencia o falla compatibilidad.

Crear versionado semántico de modelos, opset, runtime y configuración de despliegue.

Evitar subir modelos grandes al repositorio sin estrategia de artefactos o model registry.

Realizar ejercicio de pipeline CI/CD para conversión y validación ONNX.

Medir latencia p50, p95, p99, throughput, uso de CPU/GPU, memoria y errores.

Separar tiempo de preprocessing, inferencia, postprocessing, serialización y transporte.

Crear benchmarks reproducibles con batch size, input shape, provider y configuración controlada.

Monitorizar drift de inputs cuando el servicio recibe datos diferentes a los esperados.

Registrar versiones de modelo, runtime, provider y configuración en cada predicción.

Crear dashboards técnicos para operación de inferencia.

Comparar rendimiento entre CPU, CUDA, TensorRT, OpenVINO, DirectML y otros providers.

Evitar benchmarks engañosos sin warm-up, sin carga concurrente o con inputs irreales.

Preparar alertas por degradación de latencia, errores, caída de provider o fallback a CPU.

Realizar ejercicio de benchmark y diagnóstico de rendimiento de un servicio ONNX.

Integrar ONNX en un flujo MLOps con model registry, artefactos, metadatos y aprobaciones.

Registrar modelo original, exporter, opset, runtime, metrics, dataset y configuración de optimización.

Gestionar versiones de modelos por entorno: development, staging, production y rollback.

Crear lineage desde entrenamiento hasta despliegue ONNX.

Definir owners de modelo, responsables de validación, plataforma, seguridad y producto.

Establecer criterios de promoción entre entornos.

Gestionar retirada de modelos obsoletos, incompatibles o con bajo rendimiento.

Integrar ONNX con MLflow, Azure ML, Kubernetes, pipelines internos o herramientas corporativas.

Evitar modelos productivos sin trazabilidad de datos, código, métricas y decisiones.

Realizar ejercicio de diseño de gobierno MLOps para modelos ONNX.

Diagnosticar errores de exportación por operadores no soportados o control flow complejo.

Resolver problemas de shapes dinámicas, batch variable y dimensiones desconocidas.

Corregir errores de dtype, layout, nombres de entrada y transposición de tensores.

Detectar divergencias numéricas entre framework original y ONNX Runtime.

Analizar fallos de Execution Provider y fallback parcial a CPU.

Resolver incompatibilidades entre opset, runtime y acelerador hardware.

Depurar modelos demasiado lentos por graph optimizations ausentes o provider mal configurado.

Gestionar modelos demasiado grandes, consumo de memoria y problemas de carga.

Crear checklist de diagnóstico antes de rehacer el modelo desde cero.

Realizar ejercicio de reparación de varios modelos ONNX con fallos provocados.

Diseñar arquitectura cloud para serving de modelos ONNX con APIs, GPU, autoscaling y observabilidad.

Diseñar arquitectura edge para inferencia local con sincronización de modelos y métricas.

Diseñar arquitectura móvil/web para inferencia en dispositivo con actualizaciones controladas.

Separar responsabilidades entre entrenamiento, conversión, validación, optimización, serving y operación.

Seleccionar providers por plataforma: NVIDIA, Intel, Qualcomm, Apple, Windows, navegador o CPU genérica.

Integrar ONNX con pipelines de datos, APIs, colas, eventos y aplicaciones de negocio.

Diseñar resiliencia: fallback, rollback, canary, blue/green y control de versiones.

Preparar documentación para seguridad, sistemas, desarrollo y equipos de negocio.

Evitar arquitecturas dependientes de un único hardware sin plan de compatibilidad.

Realizar ejercicio de diseño de arquitectura ONNX para tres escenarios: cloud, edge y móvil.

Seleccionar un caso de uso ML realista: visión, NLP, tabular, embeddings, detección o clasificación.

Entrenar o recibir un modelo base en PyTorch, TensorFlow, Keras o scikit-learn.

Exportar el modelo a ONNX definiendo opset, nombres de entrada, salidas, shapes y dynamic axes.

Validar el modelo con onnx.checker, shape inference, inspección de grafo y visualización en Netron.

Comparar inferencia del framework original frente a ONNX Runtime con dataset de referencia.

Crear tests de equivalencia con tolerancias numéricas documentadas.

Optimizar el modelo con graph optimizations y guardar versión optimizada.

Aplicar cuantización o FP16 cuando el modelo y el hardware lo permitan.

Comparar precisión, latencia, tamaño, memoria y throughput entre versiones.

Ejecutar inferencia con al menos dos Execution Providers o configuraciones de runtime.

Crear API de inferencia con preprocessing, postprocessing, versionado y healthcheck.

Contenerizar el servicio con Docker y configuración reproducible.

Preparar pipeline CI/CD que valide exportación, checker, tests, benchmark y artefactos.

Añadir logging, métricas, correlation ID, versión de modelo y trazabilidad básica.

Diseñar estrategia de seguridad: licencias, origen del modelo, acceso, logs, secrets y datos sensibles.

Documentar compatibilidad de opset, runtime, providers, hardware y dependencias.

Crear informe técnico con decisiones de conversión, optimización, cuantización y despliegue.

Diseñar plan de despliegue en cloud, edge, móvil o web según el caso elegido.

Preparar runbook de troubleshooting con errores frecuentes y acciones de recuperación.

Presentar la solución final defendiendo portabilidad, rendimiento, precisión, seguridad, operación y valor empresarial.