Curso de Pytorch

Revisar vectores, matrices, tensores, dimensiones, broadcasting, productos, normas y operaciones básicas.

Entender gradientes, derivadas parciales, regla de la cadena y descenso por gradiente desde una perspectiva aplicada.

Relacionar funciones de pérdida con el aprendizaje del modelo.

Interpretar activaciones, pesos, sesgos, logits, probabilidades y umbrales.

Entender regularización, penalización, normalización y estabilidad numérica.

Diferenciar clasificación, regresión, ranking, embeddings, generación y representación latente.

Revisar métricas como accuracy, precision, recall, F1, AUC, MAE, RMSE, perplexity o IoU según problema.

Evitar entrenar redes neuronales sin comprender qué optimiza realmente el modelo.

Traducir conceptos matemáticos a operaciones PyTorch.

Taller: implementar una regresión simple con tensores y gradientes manuales.

Crear tensores desde listas, NumPy, valores aleatorios, ceros, unos y distribuciones.

Entender shape, dtype, device, stride, layout y memoria.

Manipular tensores con reshape, view, permute, transpose, squeeze, unsqueeze, stack y cat.

Aplicar indexing, slicing, masking, gather y operaciones vectorizadas.

Evitar bucles Python innecesarios cuando puede usarse álgebra tensorial.

Controlar conversiones entre CPU, GPU, NumPy y tensores.

Usar operaciones inplace con prudencia para no romper autograd.

Detectar errores de broadcasting y dimensiones incompatibles.

Medir impacto de dtype y device en rendimiento y memoria.

Taller: resolver transformaciones tensoriales típicas de datos reales.

Entender diferencias entre CPU, CUDA, MPS y otros backends disponibles.

Mover modelos y tensores correctamente entre dispositivos.

Detectar errores clásicos por mezclar tensores en CPU y GPU.

Monitorizar memoria GPU, asignación, liberación y picos de uso.

Reducir consumo con batch size, mixed precision, gradient accumulation y liberación de referencias.

Evitar copiar tensores innecesariamente entre CPU y GPU.

Diseñar código agnóstico al dispositivo.

Controlar seeds y reproducibilidad en GPU cuando sea viable.

Revisar límites prácticos de memoria según arquitectura y datos.

Taller: optimizar un entrenamiento que agota memoria GPU.

Entender cómo PyTorch construye grafos dinámicos de computación.

Usar `requires_grad`, `backward`, `grad`, `detach` y contextos `no_grad`.

Revisar gradientes acumulados y necesidad de `zero_grad`.

Detectar operaciones que rompen el grafo o eliminan gradientes.

Diferenciar entrenamiento, inferencia y cálculo de gradientes personalizados.

Inspeccionar gradientes para diagnosticar exploding, vanishing o gradientes nulos.

Usar `detach` correctamente en métricas, logging y estados intermedios.

Evitar operaciones inplace peligrosas sobre tensores usados por autograd.

Crear funciones simples y validar gradientes.

Taller: depurar un modelo que no aprende por fallo en el grafo de autograd.

Crear modelos heredando de `nn.Module`.

Definir capas, submódulos, forward, parámetros y buffers.

Usar capas lineales, convolucionales, normalización, dropout, embeddings y activaciones.

Separar arquitectura del entrenamiento, datos y configuración.

Crear bloques reutilizables y módulos compuestos.

Revisar `state_dict`, carga y guardado de pesos.

Evitar lógica de entrenamiento dentro de `forward`.

Controlar inicialización de pesos.

Diseñar modelos que aceptan batches y shapes variables cuando procede.

Taller: construir MLP, CNN y bloque residual básico con `torch.nn`.

Seleccionar pérdidas para regresión, clasificación binaria, multiclase, multilabel, ranking o segmentación.

Entender diferencias entre logits, probabilidades y funciones con softmax o sigmoid integradas.

Aplicar pesos de clase, reducción, máscaras y pérdidas personalizadas.

Evitar combinar incorrectamente activaciones y pérdidas.

Diseñar objetivos compuestos para modelos multitarea.

Gestionar desequilibrio de clases con pérdidas, sampling o métricas adecuadas.

Revisar estabilidad numérica en pérdidas propias.

Interpretar la pérdida frente a métricas de negocio.

Validar la pérdida con casos sintéticos.

Taller: corregir un entrenamiento con pérdida mal configurada.

Usar SGD, Adam, AdamW y optimizadores habituales.

Entender learning rate, momentum, weight decay, betas y regularización.

Diferenciar weight decay clásico y desacoplado.

Aplicar schedulers por época, por step, warmup, cosine decay y reduce on plateau.

Evitar entrenamientos inestables por learning rate inadecuado.

Crear grupos de parámetros con configuraciones distintas.

Gestionar optimizadores en fine-tuning.

Registrar learning rate durante entrenamiento.

Comparar convergencia entre optimizadores.

Taller: mejorar un entrenamiento ajustando optimizer y scheduler.

Crear datasets personalizados con `Dataset` e iterables cuando aplica.

Usar `DataLoader` con batching, shuffle, num_workers, pin_memory y collate_fn.

Preparar transformaciones de datos para train, validation y test.

Evitar fugas de datos entre entrenamiento y validación.

Gestionar datasets grandes, carga bajo demanda y caching.

Crear collate functions para secuencias variables, imágenes o estructuras complejas.

Controlar reproducibilidad en loaders con workers.

Medir cuello de botella de I/O frente a cómputo GPU.

Diseñar estructura de carpetas y metadatos.

Taller: construir dataset personalizado con loader eficiente y validación de shapes.

Implementar ciclo train/validation/test con claridad y separación de responsabilidades.

Usar `model.train()` y `model.eval()` correctamente.

Controlar forward, loss, backward, optimizer step y scheduler step.

Gestionar métricas, logging, tqdm, acumulación y checkpoints.

Evitar calcular gradientes durante validación.

Guardar el mejor modelo según métrica relevante.

Reanudar entrenamiento desde checkpoint.

Gestionar interrupciones, errores y estado del optimizador.

Crear configuración externa para hiperparámetros.

Taller: construir training loop profesional reutilizable.

Diseñar splits de train, validation y test adecuados al problema.

Usar cross-validation cuando el caso lo justifica.

Seleccionar métricas alineadas con coste de error y objetivo de negocio.

Analizar matriz de confusión, curvas ROC/PR, calibración y errores por segmento.

Evitar reportar solo accuracy en datasets desbalanceados.

Separar evaluación offline, validación técnica y validación de negocio.

Crear informes de evaluación reproducibles.

Analizar ejemplos mal clasificados.

Medir estabilidad entre seeds o particiones.

Taller: evaluar modelo de clasificación con métricas completas y análisis de errores.

Fijar seeds en Python, NumPy, PyTorch y dataloaders.

Documentar versiones, hardware, dataset, parámetros y configuración.

Entender límites de reproducibilidad con GPU y operaciones no deterministas.

Versionar datasets, código, checkpoints y resultados.

Guardar configuración de cada experimento.

Evitar experimentos imposibles de repetir por cambios manuales.

Crear nombres y carpetas de experimento consistentes.

Registrar artefactos relevantes.

Comparar resultados con control de variabilidad.

Taller: reproducir un experimento desde cero con la misma métrica final.

Registrar pérdidas, métricas, learning rate, gradientes, hiperparámetros y tiempos.

Usar TensorBoard, MLflow, Weights & Biases o herramientas corporativas equivalentes.

Guardar checkpoints, modelos, gráficas, predicciones y evaluaciones.

Evitar depender de capturas sueltas de notebooks.

Comparar experimentos por configuración, dataset y métrica.

Registrar ejemplos cualitativos en visión o NLP.

Controlar privacidad de datos en logs y artefactos.

Crear reportes para equipo técnico y negocio.

Definir convención de experimentos.

Taller: instrumentar un proyecto PyTorch con tracking completo.

Cargar imágenes, etiquetas, transformaciones y aumentos de datos.

Crear CNNs y usar modelos preentrenados con `torchvision`.

Aplicar transfer learning y fine-tuning.

Gestionar clasificación, multilabel, detección o segmentación según alcance.

Evaluar errores por clase, iluminación, resolución, sesgos y calidad de imagen.

Evitar augmentations que rompen semántica del problema.

Optimizar dataloading para imágenes.

Visualizar predicciones, mapas de error y ejemplos difíciles.

Preparar inferencia por lotes.

Taller: entrenar clasificador de imágenes con fine-tuning y evaluación completa.

Preparar texto, tokenización, vocabulario, padding, máscaras y batches.

Diferenciar enfoques clásicos, embeddings, RNNs, CNNs, transformers y modelos preentrenados.

Crear datasets para clasificación de texto, análisis de sentimiento, intención o etiquetas.

Gestionar secuencias variables y collate functions.

Usar embeddings y pooling para tareas de clasificación.

Evitar fugas por duplicados o textos casi idénticos entre splits.

Evaluar errores por longitud, idioma, tema o clase.

Integrar modelos de Hugging Face cuando procede.

Controlar coste de entrenamiento y memoria en NLP.

Taller: entrenar clasificador de texto con PyTorch y embeddings.

Entender atención, self-attention, embeddings posicionales, encoder, decoder y transformer blocks.

Usar modelos preentrenados para clasificación, embeddings, generación o extracción.

Preparar fine-tuning con control de learning rate, freezing, capas y batch size.

Gestionar tokenización, truncamiento, padding y máscaras.

Evitar fine-tuning caro cuando embeddings o prompting resuelven el caso.

Evaluar overfitting y catastrophic forgetting.

Aplicar técnicas de eficiencia cuando procede.

Controlar privacidad y licencias de modelos preentrenados.

Medir latencia y coste de inferencia.

Taller: fine-tuning de transformer para clasificación corporativa.

Generar embeddings de texto, imagen o datos estructurados.

Evaluar similitud, clustering, recuperación y ranking.

Crear datasets de pares positivos y negativos cuando se entrena o ajusta un modelo.

Diseñar evaluación de retrieval con métricas como recall@k, MRR o nDCG.

Evitar confiar en embeddings sin validar semántica del dominio.

Normalizar vectores y seleccionar distancia adecuada.

Integrar embeddings con bases vectoriales o índices ANN.

Controlar actualización, versionado y drift de embeddings.

Aplicar embeddings a clasificación, recomendación, deduplicación o RAG.

Taller: construir sistema de búsqueda semántica con embeddings generados en PyTorch.

Preparar variables numéricas, categóricas, embeddings categóricos y escalado.

Diseñar MLPs para datos tabulares y compararlos con modelos clásicos.

Crear pipelines temporales con ventanas, lags, targets y features dinámicas.

Evitar fugas temporales en entrenamiento y validación.

Usar modelos recurrentes, convoluciones temporales o transformers ligeros cuando procede.

Evaluar predicción temporal con backtesting.

Gestionar datos faltantes, outliers y drift.

Comparar PyTorch con XGBoost, LightGBM o scikit-learn según caso.

Interpretar errores por segmento, periodo o categoría.

Taller: construir modelo tabular o temporal con validación correcta.

Crear autoencoders densos, convolucionales o variacionales básicos.

Usar reconstrucción para detección de anomalías.

Interpretar espacio latente y errores de reconstrucción.

Definir umbrales con validación y coste de falsos positivos.

Evitar usar anomalías sin feedback experto.

Aplicar reducción de dimensión para análisis exploratorio.

Gestionar datos desbalanceados y patrones raros.

Comparar autoencoders con métodos clásicos de anomalía.

Monitorizar drift en distribución de errores.

Taller: detectar anomalías en datos industriales o transaccionales simulados.

Entender conceptos de VAEs, GANs, diffusion models y modelos generativos autoregresivos.

Identificar casos de uso realistas: síntesis, augmentación, simulación, generación de contenido o prototipos.

Revisar riesgos de calidad, sesgo, privacidad y memorization.

Entrenar modelos generativos pequeños para comprender dinámica.

Evaluar resultados cualitativos y cuantitativos con prudencia.

Evitar prometer generación de alta calidad sin datos, cómputo y validación suficientes.

Controlar estabilidad de entrenamiento.

Usar modelos preentrenados cuando entrenar desde cero no es razonable.

Documentar procedencia de datos y licencias.

Taller: entrenar generador sencillo y analizar limitaciones.

Seleccionar modelo base según dominio, tamaño, licencia, rendimiento y coste.

Congelar capas, descongelar progresivamente y ajustar learning rates.

Preparar datasets pequeños con augmentación o estrategias de regularización.

Evitar fine-tuning con datos insuficientes o mal etiquetados.

Medir mejora frente a baseline simple.

Gestionar imbalance, overfitting y validación.

Aplicar técnicas de adaptación ligera cuando el ecosistema lo permite.

Documentar modelo base, cambios y datos usados.

Controlar riesgo de sesgos heredados del modelo base.

Taller: realizar fine-tuning de modelo preentrenado y comparar estrategias.

Usar automatic mixed precision para acelerar entrenamiento y reducir memoria.

Entender fp32, fp16, bf16 y riesgos de underflow u overflow.

Aplicar autocast y gradient scaling cuando corresponde.

Medir diferencias de velocidad, memoria y métrica.

Evitar mixed precision en operaciones inestables sin comprobación.

Combinar mixed precision con gradient accumulation.

Controlar reproducibilidad y pequeñas diferencias numéricas.

Integrar mixed precision en training loops reutilizables.

Revisar compatibilidad de hardware.

Taller: optimizar entrenamiento con mixed precision y comparar resultados.

Usar PyTorch Profiler para analizar CPU, GPU, dataloading, memoria y operaciones.

Detectar cuellos de botella por I/O, transforms, batch size, sincronizaciones o kernels.

Reducir overhead de Python y operaciones pequeñas repetitivas.

Optimizar dataloaders, pin_memory, num_workers y prefetching.

Medir uso de GPU y throughput.

Evitar optimizar sin medición previa.

Crear benchmarks reproducibles.

Comparar cambios de arquitectura, batch y dtype.

Documentar mejoras y costes.

Taller: perfilar un entrenamiento lento y aplicar mejoras justificadas.

Entender qué aporta `torch.compile` en PyTorch moderno.

Aplicar compilación a funciones o módulos con cambios mínimos.

Medir speedup, overhead inicial y comportamiento por backend.

Identificar graph breaks y patrones que dificultan compilación.

Evitar compilar sin benchmark ni validación de outputs.

Probar entrenamiento e inferencia compilada.

Analizar compatibilidad con modelos dinámicos o control flow.

Integrar `torch.compile` de forma opcional y configurable.

Documentar cuándo se activa y cómo se desactiva.

Taller: optimizar un modelo con `torch.compile` y analizar graph breaks.

Entender `torch.export` como captura AOT de modelos PyTorch.

Diferenciar exportación, serialización de pesos, tracing, scripting y despliegue.

Preparar modelos compatibles con exportación.

Gestionar dynamic shapes cuando el caso lo requiere.

Evitar control flow Python no exportable sin rediseño.

Validar equivalencia entre modelo original y programa exportado.

Documentar constraints y supuestos de entrada.

Relacionar `torch.export` con ONNX, ExecuTorch y pipelines de despliegue.

Crear tests de regresión para modelos exportados.

Taller: exportar modelo PyTorch y validar ejecución con entradas controladas.

Exportar modelos PyTorch a ONNX usando flujos actuales.

Entender qué representa ONNX y qué problemas resuelve en interoperabilidad.

Validar modelo exportado con runtime compatible.

Gestionar ops no soportadas, dynamic axes, control flow y diferencias numéricas.

Evitar asumir que exportar implica desplegar sin pruebas.

Comparar predicciones PyTorch frente a ONNX.

Documentar input/output schema.

Optimizar modelo exportado cuando procede.

Integrar ONNX en pipelines de serving o edge.

Taller: exportar modelo a ONNX y crear prueba de equivalencia.

Entender cuantización, sparsity, weight-only quantization y post-training quantization.

Revisar cuándo cuantizar para reducir memoria, acelerar inferencia o desplegar en hardware limitado.

Diferenciar cuantización para inferencia y entrenamiento.

Evaluar impacto en precisión, latencia y tamaño de modelo.

Evitar cuantizar sin dataset de calibración o evaluación representativa.

Usar herramientas del ecosistema TorchAO cuando encajan en el caso.

Comparar fp32, mixed precision y modelos cuantizados.

Documentar estrategia de cuantización y límites.

Preparar fallback si la degradación de calidad es inaceptable.

Taller: aplicar cuantización a modelo de inferencia y medir impacto.

Entender diferencias entre data parallel, DDP, FSDP y entrenamiento en una sola GPU.

Preparar código para DistributedDataParallel.

Configurar procesos, ranks, world size, backend y comunicación.

Usar distributed sampler en dataloaders.

Evitar errores por métricas duplicadas, seeds mal gestionadas o checkpoints por proceso.

Registrar logs solo desde proceso principal cuando procede.

Medir escalado, eficiencia y comunicación.

Gestionar fallos y relanzamiento de jobs.

Preparar scripts para multi-GPU y multi-node.

Taller: adaptar entrenamiento single-GPU a DDP.

Entender Fully Sharded Data Parallel y su diferencia frente a DDP.

Identificar cuándo FSDP ayuda por memoria y sharding de parámetros.

Configurar wrapping, mixed precision, checkpointing y estrategias de sharding.

Gestionar optimizador y estados distribuidos.

Evitar usar FSDP sin entender coste de comunicación y complejidad operativa.

Monitorizar memoria, throughput y estabilidad.

Diseñar checkpoints para entrenamiento y recuperación.

Combinar FSDP con activation checkpointing si procede.

Documentar configuración distribuida.

Taller: diseñar estrategia FSDP para modelo grande con memoria limitada.

Guardar `state_dict` de modelo, optimizador, scheduler, scaler y configuración.

Diferenciar checkpoint de entrenamiento, modelo final y artefacto de inferencia.

Reanudar entrenamiento desde punto intermedio.

Guardar best model por métrica y last checkpoint por recuperación.

Evitar guardar objetos Python completos difíciles de portar.

Gestionar checkpoints grandes y almacenamiento.

Versionar modelos con metadatos.

Validar carga en CPU y GPU.

Preparar migración entre versiones de código.

Taller: implementar checkpoint robusto y recuperación tras interrupción.

Aplicar técnicas de importancia de variables, saliency, Grad-CAM, perturbación o análisis de embeddings.

Diferenciar explicación técnica, explicación de negocio y explicación regulatoria.

Evitar usar explicaciones visuales como prueba absoluta.

Analizar errores por subgrupos, ejemplos y casos límite.

Crear informes de explicación para stakeholders.

Relacionar interpretabilidad con confianza, auditoría y mejora de datos.

Evaluar limitaciones de explicaciones en modelos profundos.

Usar explicabilidad para detectar sesgos o shortcuts.

Documentar método y límites.

Taller: generar explicación de predicciones en visión o tabular.

Identificar sesgos en datos, etiquetas, muestreo, proxies y feedback histórico.

Evaluar métricas por subgrupo, segmento, idioma, clase, dispositivo o región.

Detectar degradación de rendimiento en colectivos o casos minoritarios.

Evitar modelos que optimizan media global y fallan en segmentos críticos.

Diseñar mitigaciones: recolección de datos, weighting, sampling, thresholds o revisión humana.

Documentar limitaciones del dataset.

Crear model cards o fichas de modelo.

Coordinar evaluación con negocio, legal y compliance.

Medir impacto después del despliegue.

Taller: auditar fairness en un modelo de clasificación.

Minimizar datos personales en entrenamiento, logs, checkpoints y artefactos.

Controlar acceso a datasets, modelos, embeddings, predicciones y métricas.

Evitar memorization de datos sensibles en modelos.

Diseñar anonimización, seudonimización o datos sintéticos cuando procede.

Revisar riesgos de model inversion, membership inference y extracción.

Proteger credenciales, rutas, buckets y endpoints de inferencia.

Documentar finalidad, base de uso y retención de datos.

Integrar revisiones de seguridad en MLOps.

Preparar respuesta ante exposición de modelo o datos.

Taller: crear checklist de privacidad y seguridad para proyecto PyTorch.

Organizar código en módulos de datos, modelos, entrenamiento, evaluación, configuración e inferencia.

Separar notebooks exploratorios de código productivo.

Usar archivos de configuración para hiperparámetros y rutas.

Crear CLI para entrenar, evaluar, exportar e inferir.

Evitar scripts monolíticos difíciles de mantener.

Añadir tests unitarios para funciones críticas.

Documentar estructura, comandos y dependencias.

Preparar pyproject, requirements o gestión de entorno.

Aplicar linting, formatting y tipos cuando aporta valor.

Taller: refactorizar notebook a proyecto PyTorch mantenible.

Crear pruebas para datasets, transforms, shapes, forward pass, pérdidas y métricas.

Validar que un batch pequeño sobreentrena como prueba de sanity check.

Probar carga de checkpoints y equivalencia de inferencia.

Crear tests de no regresión para exportación y serving.

Evitar confiar solo en métricas finales sin pruebas de pipeline.

Simular errores de datos faltantes, clases nuevas o shapes incorrectas.

Añadir tests de rendimiento mínimos cuando procede.

Integrar tests en CI.

Documentar cobertura útil para proyectos de IA.

Taller: crear suite de tests para proyecto PyTorch.

Crear servicio de inferencia con FastAPI, Flask u otro framework corporativo.

Cargar modelo, preprocesar entradas, ejecutar inferencia y devolver respuesta estructurada.

Separar lógica de modelo, validación, transformación y endpoint.

Gestionar batching, warmup, timeout y errores.

Evitar cargar el modelo en cada petición.

Controlar CPU/GPU en inferencia.

Añadir logging, métricas, health checks y versionado.

Validar seguridad de entradas y límites de tamaño.

Preparar Dockerfile y configuración de despliegue.

Taller: desplegar modelo PyTorch como API de inferencia.

Medir latencia, throughput, uso de CPU/GPU y memoria.

Aplicar batching, caching, mixed precision, cuantización o compilación según caso.

Reducir preprocesamiento lento y copias innecesarias.

Evitar modelos sobredimensionados para requisitos de latencia.

Crear benchmarks reproducibles de inferencia.

Comparar PyTorch eager, compilado, ONNX o runtime optimizado.

Diseñar colas o workers para cargas variables.

Controlar cold start y warmup.

Documentar compromisos entre calidad, coste y velocidad.

Taller: optimizar API de inferencia reduciendo latencia medida.

Entender escenarios de inferencia en móviles, dispositivos embebidos, escritorio y edge.

Identificar cuándo tiene sentido desplegar fuera de servidor.

Preparar modelos para exportación y ejecución sin Python cuando aplica.

Revisar restricciones de memoria, energía, latencia, hardware y conectividad.

Comparar edge frente a cloud en privacidad, coste y rendimiento.

Evaluar cuantización y optimización para dispositivos limitados.

Diseñar pruebas de equivalencia y rendimiento en dispositivo objetivo.

Gestionar actualización de modelos en edge.

Documentar limitaciones y fallback.

Taller: diseñar plan de despliegue edge para modelo PyTorch.

Diseñar pipeline de datos, entrenamiento, evaluación, registro, despliegue y monitorización.

Integrar PyTorch con MLflow, DVC, Airflow, Prefect, Kubeflow o herramientas corporativas.

Versionar datos, código, configuración, modelos y métricas.

Crear gates de calidad antes de promover modelos.

Automatizar reentrenamiento con criterios claros.

Evitar pipelines automáticos sin revisión de datos y resultados.

Gestionar entornos reproducibles con Docker.

Preparar model registry y stages.

Documentar ciclo de vida completo.

Taller: diseñar pipeline MLOps para modelo PyTorch de producción.

Monitorizar latencia, errores, throughput, coste y disponibilidad.

Monitorizar distribución de entradas, drift, calidad de predicciones y degradación.

Comparar métricas online y offline cuando existen etiquetas posteriores.

Crear alertas de drift, errores anómalos o caída de rendimiento.

Evitar desplegar modelos sin plan de observabilidad.

Registrar predicciones con minimización de datos.

Diseñar revisión humana de casos críticos.

Preparar rollback o shadow deployment.

Crear dashboard de salud del modelo.

Taller: diseñar monitorización de modelo PyTorch desplegado.

Crear ficha de modelo con finalidad, datos, arquitectura, métricas, limitaciones y owner.

Documentar entrenamiento, validación, sesgos, riesgos, dependencias y versión.

Preparar model cards y datasheets cuando procede.

Definir aprobaciones antes de producción.

Mantener trazabilidad entre dataset, código, experimento y modelo desplegado.

Revisar modelos periódicamente.

Evitar modelos huérfanos sin responsable ni documentación.

Coordinar gobierno con Legal, Seguridad, Compliance y negocio.

Crear inventario de modelos PyTorch.

Taller: documentar modelo final con ficha técnica y checklist de gobierno.

Aplicar PyTorch a clasificación de imágenes para calidad industrial o inspección visual.

Crear modelo NLP para clasificar tickets, emails o documentos internos.

Diseñar predicción tabular para riesgo, demanda, abandono o scoring.

Crear embeddings para búsqueda semántica y deduplicación.

Desarrollar detector de anomalías para sensores o transacciones.

Preparar fine-tuning de modelo preentrenado para dominio corporativo.

Exportar modelo a ONNX y crear servicio de inferencia.

Optimizar un modelo para latencia y coste.

Diseñar pipeline MLOps completo con tracking y monitorización.

Taller: seleccionar tres casos sectoriales y resolverlos con arquitectura PyTorch.

Entrenar redes profundas cuando un modelo simple resuelve mejor el problema.

Usar datasets mal etiquetados, sesgados o con fugas de datos.

Medir solo métrica global sin análisis de errores ni subgrupos.

Crear notebooks imposibles de reproducir.

Ignorar shapes, devices, dtype y memoria hasta que el entrenamiento falla.

Hacer fine-tuning sin baseline ni validación.

Desplegar modelos sin monitorización ni plan de rollback.

Guardar datos sensibles en logs, checkpoints o artefactos.

Exportar modelos sin pruebas de equivalencia.

Taller: auditar un proyecto PyTorch mal planteado y rediseñarlo.

Evaluar madurez actual: Python, datos, GPUs, MLOps, seguridad, perfiles, casos de uso y herramientas.

Identificar quick wins: visión, NLP, embeddings, anomalías, predicción o optimización de modelos existentes.

Priorizar casos por valor, datos, riesgo, coste, complejidad y adopción.

Definir estándar de proyecto PyTorch con estructura, configuración, tests, tracking y documentación.

Preparar entorno base con Docker, CUDA, dependencias, CI/CD y acceso a datos.

Seleccionar piloto con dataset controlado, métrica clara y usuario de negocio implicado.

Medir calidad, coste, rendimiento, explicabilidad y capacidad de despliegue.

Ajustar estándares antes de escalar a más equipos.

Crear plan a 30, 60, 90 y 180 días.

Taller: construir roadmap corporativo de adopción PyTorch.

Definir un caso de uso empresarial con datos, objetivo, métrica, usuarios, restricciones, riesgos y criterio de éxito.

Preparar dataset con validación, limpieza, split, transforms, dataloaders, control de fugas y documentación.

Construir modelo PyTorch modular con `nn.Module`, configuración externa, entrenamiento, validación y métricas.

Implementar training loop profesional con optimizer, scheduler, mixed precision opcional, checkpoints y experiment tracking.

Evaluar modelo con métricas completas, análisis de errores, subgrupos, calibración o explicabilidad según caso.

Optimizar rendimiento con profiling, batch size, dataloading, GPU, `torch.compile` o estrategia equivalente.

Exportar modelo mediante `torch.export`, ONNX o formato adecuado, validando equivalencia de inferencia.

Crear servicio de inferencia con API, preprocesado, postprocesado, logs, métricas, health check y Docker.

Diseñar monitorización, model card, política de datos, riesgos, seguridad, rollback y plan de mantenimiento.

Presentar solución final con arquitectura, resultados, decisiones técnicas, limitaciones, costes, roadmap y mejoras futuras.