Aprendizaje Profundo Aplicado con PyTorch (De cero a maestría)

Descripción general: Esta lección fundamental presenta PyTorch y su estructura de datos central: el tensor. Comenzaremos estableciendo por qué PyTorch es el marco preferido para la investigación moderna en aprendizaje profundo, destacando su gráfico computacional dinámico. El enfoque técnico principal es dominar la manipulación de tensores. Los estudiantes aprenderán a inicializar tensores —desde escalares de 0D hasta matrices de dimensiones superiores— utilizando diversos métodos (por ejemplo, torch.zeros(), torch.rand()). Se cubrirán operaciones cruciales, incluyendo aritmética elemento a elemento (suma, multiplicación) y operaciones especializadas de álgebra lineal como la multiplicación de matrices (torch.matmul). También abordaremos técnicas de gestión estructural, como indexación, rebanado, redimensionamiento (.view(), .reshape()) y eliminación de dimensiones redundantes (.squeeze()). Finalmente, cubriremos el concepto crítico de utilizar diferentes dispositivos (CPU frente a GPU) mediante .to(), preparando a los estudiantes para cálculos acelerados en lecciones posteriores.

Resultados de aprendizaje:

• Explicar el papel de los tensores como la estructura de datos fundamental en el aprendizaje profundo y PyTorch.
• Crear e inicializar tensores de PyTorch de diversas dimensiones (escalares, vectores, matrices) usando métodos integrados.
• Realizar aritmética estándar con tensores y operaciones especializadas como la multiplicación de matrices.
• Manipular la estructura del tensor usando técnicas de indexación, rebanado, redimensionamiento y compresión.
• Mover tensores de forma eficiente entre dispositivos CPU y GPU para cálculos acelerados.

Descripción general: Esta lección establece el flujo de trabajo esencial y repetible de PyTorch al implementar un modelo de regresión lineal básico desde cero. Comenzamos con la preparación de datos, centrándonos en generar datos sintéticos y dividirlos en conjuntos de entrenamiento y prueba, enfatizando la importancia de la alineación de tipo de datos y dispositivo (CPU/GPU). Luego definimos la arquitectura del modelo heredando correctamente de torch.nn.Module e implementando el paso forward. El núcleo del flujo de trabajo implica seleccionar funciones de pérdida adecuadas (como nn.L1Loss para regresión) y optimizadores (Gradiente Estocástico Descendente o SGD). A continuación, construiremos meticulosamente el bucle de entrenamiento (paso forward, cálculo de pérdida, cero de gradientes, paso backward, paso del optimizador) y el bucle de prueba/evaluación para medir el rendimiento. Finalmente, concluiremos el marco aprendiendo a guardar diccionarios de estado de modelos entrenados usando torch.save() y cargarlos nuevamente para inferencia o reutilización, completando así todo el ciclo end-to-end de ML.

Resultados de aprendizaje:

• Estructurar e implementar los seis pasos fundamentales del flujo de trabajo de aprendizaje automático end-to-end de PyTorch.
• Construir un modelo lineal simple definiendo correctamente una clase que herede de torch.nn.Module.
• Aplicar funciones de pérdida adecuadas (nn.L1Loss) y optimizadores (torch.optim.SGD) para tareas básicas de regresión.
• Definir y ejecutar el bucle de entrenamiento, incluyendo retropropagación y descenso de gradiente, y el bucle de evaluación separado.
• Implementar funcionalidades para guardar y cargar diccionarios de estado de modelos usando utilidades de PyTorch para persistencia de modelos.

Descripción general: Esta lección aplica el flujo de trabajo de PyTorch para resolver problemas de clasificación no lineales, avanzando más allá de la regresión lineal simple. Comenzamos diferenciando entre escenarios binarios y multiclase, y demostramos cómo estructurar la capa de salida final usando activaciones Sigmoid (para binario) y Softmax (para multiclase). Se introduce el concepto crucial de no linealidad al integrar funciones de activación ReLU dentro de las capas ocultas, permitiendo que la red aprenda fronteras de decisión complejas. Los estudiantes implementarán las funciones de pérdida correctas para clasificación: BCEWithLogitsLoss y CrossEntropyLoss. El componente práctico implica generar y entrenar una red neuronal sobre un conjunto de datos sintético complejo (por ejemplo, el conjunto de datos 'moons') y trazar visualmente la superficie de decisión resultante para confirmar la capacidad de la red para separar puntos de datos no lineales de forma efectiva, asegurando un dominio completo de las arquitecturas fundamentales de modelos de aprendizaje profundo.

Resultados de aprendizaje:

• Diferenciar e implementar modelos de PyTorch para tareas de clasificación binaria y multiclase.
• Explicar la necesidad de funciones de activación no lineales (ReLU, Sigmoid, Softmax) para habilitar fronteras de decisión complejas.
• Aplicar funciones de pérdida adecuadas (BCEWithLogitsLoss, CrossEntropyLoss) y calcular métricas de precisión de clasificación.
• Implementar todo el flujo de trabajo de clasificación de PyTorch sobre un conjunto de datos no lineal.
• Visualizar la frontera de decisión aprendida por un modelo e interpretar su capacidad para clasificar puntos de datos.

Descripción general: Esta sesión marca la transición crítica de manejar datos estructurados a procesar datos de imagen de alta dimensión, lo que requiere arquitecturas especializadas de aprendizaje profundo. Comenzaremos desmitificando la representación de imágenes como tensores multidimensionales de PyTorch, centrándonos intensamente en la notación estándar de forma (N, C, H, W: tamaño del lote, canales, altura, ancho). El núcleo teórico introduce Redes Neuronales Convolucionales (CNNs) explicando cómo las capas convolucionales (nn.Conv2d) extraen eficientemente características espaciales locales, y cómo las capas de pooling (nn.MaxPool2d) reducen la dimensionalidad preservando información importante. A través de un enfoque basado en código, construiremos y entrenaremos una arquitectura completa y pequeña de CNN —una réplica de TinyVGG— desde cero, proporcionando un ejemplo práctico de un modelo funcional de visión por computadora. Finalmente, compararemos las diferencias fundamentales entre esta estructura de CNN y las redes lineales utilizadas anteriormente para afianzar la intuición sobre por qué las CNNs son excelentes en el reconocimiento de patrones en imágenes.

Resultados de aprendizaje:

• Explicar y utilizar el formato de tensor (N, C, H, W) para representar datos de imagen en PyTorch.
• Implementar capas convolucionales (nn.Conv2d) y de pooling (nn.MaxPool2d) dentro de un modelo de PyTorch.
• Construir y entrenar una arquitectura completa de CNN de pequeña escala (una réplica de TinyVGG) para una tarea de clasificación.
• Articular las diferencias fundamentales en la extracción de características y capacidades de compartición de pesos entre capas lineales y CNNs.

Descripción general: Esta sesión crucial cierra la brecha entre ejemplos estructurados de juguete (como MNIST) y datos reales complejos e inestructurados, preparando el terreno para el proyecto práctico de visión por computadora "FoodVision". Comenzaremos aprendiendo a estructurar directorios de datos correctamente para PyTorch, utilizando la clase altamente eficiente torchvision.datasets.ImageFolder para carga automática y deducción de etiquetas desde rutas de archivos. Crucialmente, dominaremos el concepto de la clase personalizada torch.utils.data.Dataset, que otorga control total sobre la lógica de carga de datos, preprocesamiento y manejo de etiquetas para formatos de datos arbitrarios. Luego introduciremos DataLoader para gestionar el agrupamiento eficiente de datos, mezcla y carga multi-hilo. Finalmente, la sesión cubrirá técnicas esenciales de aumento de datos y transformaciones de PyTorch, que son vitales para expandir el tamaño efectivo de conjuntos de datos limitados y mejorar la generalización y robustez del modelo.

Resultados de aprendizaje:

• Estructurar datos de imágenes del mundo real en el formato de directorio esperado por las utilidades de PyTorch.
• Utilizar torchvision.datasets.ImageFolder para cargar eficientemente conjuntos de datos de imágenes personalizados desde disco.
• Implementar una clase personalizada torch.utils.data.Dataset para manejar requisitos únicos o complejos de carga de datos.
• Aplicar una variedad de torchvision.transforms para preprocesamiento (redimensionamiento, conversión a tensor) y aumento de datos (rotación, volteo).
• Integrar la clase Dataset con DataLoader para gestionar agrupamiento, mezcla y carga paralela optimizada de datos.

Descripción general: Esta sesión es clave para pasar del código experimental de Jupyter Notebook hacia prácticas sostenibles de ingeniería de software listas para producción dentro del ecosistema de PyTorch. Cubriremos los pasos obligatorios para refactorizar el código monolítico de cuadernos en scripts Python estructurados y reutilizables. El concepto central implica establecer una estructura de proyecto de PyTorch estandarizada, separando preocupaciones en módulos dedicados. Los módulos clave a desarrollar incluyen data_setup.py (manejo de carga de datos, transformaciones y DataLoaders), model_builder.py (conteniendo definiciones de modelos que heredan de nn.Module) y engine.py (gestionando los bucles de entrenamiento y prueba). Finalmente, los estudiantes aprenderán a inicializar y ejecutar todo el flujo de entrenamiento —incluyendo definición de hiperparámetros y selección de dispositivo— directamente desde la línea de comandos usando la ejecución estándar de Python, lo cual es esencial para el despliegue y experimentación a gran escala.

Resultados de aprendizaje:

• Explicar las diferencias entre el código experimental de cuadernos y la arquitectura de scripts Python organizados y modulares.
• Implementar una estructura de directorio de proyecto de PyTorch estándar diseñada para escalabilidad y colaboración.
• Refactorizar la lógica existente de entrenamiento de modelos en módulos distintos y reutilizables (por ejemplo, data_setup.py, model_builder.py, engine.py).
• Configurar un script principal para ejecutar todo el proceso de entrenamiento a través de la línea de comandos.
• Describir las ventajas prácticas del código modular respecto a pruebas, control de versiones y listo para despliegue en producción.

Descripción general: La Transferencia de Aprendizaje es una técnica poderosa que nos permite aprovechar el conocimiento obtenido de modelos entrenados en grandes conjuntos de datos, como ImageNet, y aplicarlo de forma eficiente a problemas más pequeños y especializados. Esta sesión introduce la teoría básica, enfatizando por qué los pesos preentrenados (específicamente de modelos como ResNet o EfficientNet a través de torchvision.models) son cruciales para lograr resultados de vanguardia con menos datos y tiempo de cómputo. La implementación práctica se centra en Extracción de características: los estudiantes aprenderán a cargar un modelo, congelar los parámetros de sus capas base convolucionales usando requires_grad=False de PyTorch, y luego reemplazar estratégicamente y entrenar únicamente la cabeza de clasificación final adaptada a un nuevo dominio objetivo, como el proyecto en curso de "FoodVision". También contrastaremos este método con el enfoque más intensivo en cómputo de Fine-tuning de toda la red.

Resultados de aprendizaje:

• Explicar la ventaja teórica y los escenarios comunes donde la Transferencia de Aprendizaje es necesaria.
• Cargar e inspeccionar arquitecturas de modelos preentrenados comunes usando la utilidad torchvision.models de PyTorch.
• Implementar la Extracción de Características con éxito al congelar los parámetros de las capas convolucionales base.
• Modificar la cabeza de clasificador de un modelo preentrenado para manejar tareas de clasificación personalizadas.
• Diferenciar entre estrategias de Extracción de Características (congelamiento) y Fine-tuning (descongelamiento).

Descripción general: A medida que avanzamos desde entrenar modelos individuales hasta realizar comparaciones sofisticadas (por ejemplo, comparar una CNN básica con un modelo de Transferencia de Aprendizaje), el registro manual se vuelve insuficiente. Esta lección establece la práctica crucial de seguimiento sistemático de experimentos. Introduciremos e implementaremos la solución nativa de PyTorch, torch.utils.tensorboard.SummaryWriter, para registrar y gestionar datos de rendimiento. Los estudiantes aprenderán a instrumentar sus bucles de entrenamiento para registrar métricas escalares vitales, como pérdida de entrenamiento y prueba por época, precisión y tasas de aprendizaje. El objetivo principal es dominar el lanzamiento y uso de la interfaz TensorBoard para comparar visualmente los resultados de múltiples ejecuciones lado a lado, permitiendo un análisis objetivo de cambios en hiperparámetros, decisiones arquitectónicas y estrategias de optimización, asegurando así reproducibilidad y acelerando la mejora del modelo.

Resultados de aprendizaje:

• Explicar la necesidad de un seguimiento sistemático de experimentos para garantizar la reproducibilidad y eficiencia del aprendizaje profundo.
• Implementar la clase torch.utils.tensorboard.SummaryWriter para registrar métricas escalares (pérdida, precisión) dentro de un bucle de entrenamiento de PyTorch.
• Iniciar y navegar la interfaz TensorBoard para visualizar curvas de métricas y comparar el rendimiento de diferentes ejecuciones experimentales.
• Aplicar técnicas de seguimiento para comparar sistemáticamente el impacto de ajustes de hiperparámetros (por ejemplo, tamaño de lote, tasa de aprendizaje) y arquitecturas de modelos.

Descripción general: Esta lección sirve como cima del curso, desafiando a los estudiantes a traducir la investigación teórica de aprendizaje profundo en código funcional al replicar una arquitectura moderna a partir de un artículo científico. Comenzaremos desmitificando la estructura de un artículo típico de IA, centrándonos específicamente en cómo extraer detalles arquitectónicos y formulaciones matemáticas de la sección de Método. La tarea técnica principal consiste en mapear ecuaciones matemáticas complejas —como las que gobiernan mecanismos de atención o tipos de capas novedosos— directamente a módulos de PyTorch usando clases nn.Module personalizadas. Un ejemplo moderno, como el Vision Transformer (ViT), será utilizado como caso de estudio para la implementación. Se pondrá énfasis en estrategias sistemáticas de depuración requeridas para modelos complejos y multifuncionales, abordando desafíos como compatibilidad de formas, inicialización de pesos y verificación del flujo de gradientes, asegurando que los estudiantes puedan implementar con éxito modelos de vanguardia desde cero.

Resultados de aprendizaje:

• Descomponer y analizar las descripciones arquitectónicas y notaciones matemáticas presentadas en artículos de investigación de aprendizaje automático.
• Traducir pasos algorítmicos complejos y fórmulas (por ejemplo, mecanismos de auto-atención) directamente a código idiomático de PyTorch usando clases nn.Module personalizadas.
• Implementar e integrar todos los componentes necesarios de una arquitectura moderna y compleja de aprendizaje profundo (por ejemplo, Vision Transformer) completamente desde cero.
• Aplicar estrategias avanzadas de depuración para resolver errores de forma, errores de dispositivo y fallos lógicos encontrados al replicar modelos de vanguardia.

Descripción general: Esta lección final se centra en la transición de un modelo de PyTorch entrenado del entorno de investigación a una aplicación web interactiva accesible públicamente. Comenzaremos aprendiendo los pasos cruciales para preparar un modelo para el despliegue, centrándonos en la carga eficiente e inferencia para producción. La actividad principal consiste en crear una demostración funcional de web usando herramientas de prototipado rápido como Gradio o Streamlit, permitiendo a los usuarios finales ingresar datos y recibir predicciones instantáneas. Cubriremos estrategias prácticas para alojar estas aplicaciones, aprovechando plataformas como Hugging Face Spaces. Finalmente, dedicaremos tiempo a explorar el futuro del marco, específicamente mirando las mejoras de rendimiento y funciones de compilación introducidas en PyTorch 2.0, demostrando cómo innovaciones como 'torch.compile' ofrecen ganancias significativas en velocidad tanto para entrenamiento como para despliegue.

Resultados de aprendizaje:

• Preparar un artefacto de modelo entrenado de PyTorch para una carga y inferencia eficientes en producción.
• Desarrollar una interfaz funcional e interactiva de demostración web usando Gradio o Streamlit.
• Alojar la aplicación de aprendizaje automático desarrollada en una plataforma pública (por ejemplo, Hugging Face Spaces).
• Explicar el concepto central y el mecanismo de la función 'torch.compile' de PyTorch 2.0.
• Integrar el conocimiento de despliegue con las prácticas anteriores de código modular para crear un proyecto final end-to-end.