Módulo 3: Neural Networks & Deep Learning

1. Introducción al Módulo: Neural Networks & Deep Learning

Descripción

Bienvenido al Módulo 3: Neural Networks & Deep Learning. Este es el módulo donde todo empieza a conectarse: en Módulo 1 viste qué es AI, en Módulo 2 entendiste Machine Learning (supervised, unsupervised, training vs inference), y ahora vas a entender qué son las redes neuronales y cómo funcionan.

Las redes neuronales son la tecnología detrás de prácticamente todo el AI moderno que usas: ChatGPT, DALL-E, reconocimiento facial, traducción automática, recomendaciones de Netflix, coches autónomos, etc. Si no entiendes cómo funcionan, no podrás trabajar efectivamente como AI Engineer.

Lo más importante: Este módulo es conceptual y visual, NO matemático. No verás fórmulas de backpropagation ni derivadas; verás diagramas, analogías y razonamiento arquitectural. El objetivo NO es que aprendas a entrenar redes neuronales desde cero (eso lo hacen otros roles); el objetivo es que entiendas cómo funcionan para poder integrarlas, optimizarlas y comunicarte con equipos técnicos.

¿Por qué necesitas entender Neural Networks?

1. Contexto: Todo el AI moderno usa Neural Networks

Cuando trabajas con AI hoy (2024-2026), casi todo lo que usas son redes neuronales profundas (Deep Learning):

LLMs (ChatGPT, Claude, Gemini): Redes neuronales Transformer con miles de millones de parámetros.
Generación de imágenes (DALL-E, Stable Diffusion, Midjourney): Redes neuronales generativas (GANs, Diffusion Models).
Reconocimiento de voz (Siri, Alexa): Redes neuronales para procesar audio.
Visión computacional (reconocimiento facial, detección de objetos): CNNs (Convolutional Neural Networks).
Traducción automática (Google Translate): Transformers (verás en Módulo 4).

Si no entiendes qué es una red neuronal, cómo está organizada, y cómo aprende, trabajar con estos modelos es como usar un coche sin saber qué hace el motor: funciona, pero no puedes diagnosticar problemas, optimizar, o tomar decisiones técnicas informadas.

2. Como AI Engineer, necesitas entender arquitecturas

Tu trabajo NO es diseñar redes neuronales nuevas desde cero (eso lo hacen Research Scientists). Tu trabajo es:

Integrar modelos pre-entrenados en aplicaciones (ej. usar un modelo de Hugging Face para clasificar texto).
Optimizar modelos para producción (reducir latencia, costos, tamaño).
Fine-tunar modelos cuando sea necesario (ajustar un modelo pre-entrenado a tu dominio específico).
Diagnosticar problemas (ej. el modelo es lento → ¿cuántas capas tiene? ¿cuántos parámetros? ¿puedo usar una versión más pequeña?).
Comunicar decisiones técnicas (ej. explicar a producto por qué necesitas GPU, por qué un modelo tarda X segundos, por qué fine-tuning requiere datos etiquetados).

Para hacer todo esto, necesitas entender arquitecturas de redes neuronales:

¿Qué es una capa?
¿Qué son parámetros (weights)?
¿Qué significa "red profunda" (deep)?
¿Qué arquitecturas existen (CNN, RNN, Transformer) y cuándo usar cada una?
¿Cómo aprende una red neuronal (forward pass, backpropagation)?
¿Por qué algunas redes son más lentas que otras?

Sin este conocimiento, eres un "copy-paste engineer": Sigues tutoriales sin entender qué hacen, y cuando algo falla no sabes por qué ni cómo arreglarlo.

3. Ejemplo concreto: Debugging

Imagina que integras un modelo de clasificación de imágenes (ej. identificar si una foto es de un perro o un gato) y el modelo es lento (tarda 2 segundos por imagen). Producto te pregunta: "¿Podemos hacerlo más rápido?"

Si entiendes Neural Networks:

Revisas la arquitectura: el modelo tiene 50 capas convolucionales (ResNet-50), 25 millones de parámetros.
Sabes que cada capa agrega latencia (forward pass: pasar la imagen por 50 capas toma tiempo).
Propones soluciones:
- Usar un modelo más pequeño (ResNet-18: 18 capas, 11M parámetros → más rápido pero menos preciso).
- Reducir resolución de entrada (de 512x512 a 256x256 → menos píxeles procesados por cada capa).
- Usar técnicas de optimización (model quantization: reducir precisión de parámetros de float32 a int8 → más rápido, menor precisión).
Explicas trade-offs a producto: "Podemos reducir latencia a 0.5 segundos usando ResNet-18, pero perderemos 2% de accuracy. ¿Es aceptable?"

Si NO entiendes Neural Networks:

No sabes por qué el modelo es lento.
No sabes qué significa "ResNet-50" o "25M parámetros".
No puedes proponer soluciones técnicas.
Dependes completamente de otros (ML Engineer, Stack Overflow, tutoriales).

Moraleja: Entender arquitecturas te da autonomía técnica y capacidad de tomar decisiones informadas.

4. Diferencia con cursos tradicionales de ML/Deep Learning

Cursos académicos (ej. Stanford CS231n, la plataforma global de cursos Deep Learning):

Enseñan matemáticas (álgebra lineal, cálculo, derivadas, gradiente descendiente).
Enseñan a implementar backpropagation desde cero.
Objetivo: Formar Research Scientists o ML Engineers que diseñen arquitecturas nuevas.

Este módulo:

Enseña conceptos (qué es una neurona, cómo se organiza en capas, cómo fluye la información).
Enseña a razonar sobre arquitecturas (cuándo usar CNN, RNN, feedforward).
Objetivo: Formar AI Engineers que integren modelos existentes en aplicaciones.

Analogía: Cursos tradicionales te enseñan a diseñar motores de coche. Este módulo te enseña cómo funciona un motor para que puedas conducir, diagnosticar problemas, y elegir el coche adecuado para cada situación.

¿Necesitas aprender las matemáticas? Solo si quieres investigar o diseñar arquitecturas nuevas. Para AI Engineering (integración, optimización, fine-tuning), NO necesitas implementar backpropagation desde cero; frameworks (PyTorch, TensorFlow) lo hacen por ti. Pero sí necesitas entender conceptos (qué es backpropagation, por qué importa, cómo afecta el entrenamiento).

¿Qué aprenderás en este módulo?

Conceptos clave (8 cápsulas)

#	Cápsula	Qué aprenderás
01	Introducción al módulo	Por qué necesitas entender NNs, roadmap del módulo (esta cápsula)
02	¿Qué es una Neural Network?	Neurona artificial, inspiración biológica, perceptrón, cómo decide
03	Capas y arquitectura	Input layer, hidden layers, output layer, fully connected, parámetros
04	Funciones de activación	Por qué importan, ReLU, sigmoid, tanh, no-linealidad (sin fórmulas)
05	Forward pass	Cómo los datos fluyen de input a output, cálculo de predicción
06	Backpropagation	Cómo la red aprende (ajusta pesos según error), conceptual sin derivadas
07	Arquitecturas especializadas	CNN (imágenes), RNN (secuencias), feedforward (tablas), cuándo usar cada una
08	Ejercicio integrador	Diseñar arquitecturas para problemas dados, identificar errores

Lo que NO verás (y por qué no lo necesitas)

❌ Fórmulas matemáticas de backpropagation (derivadas, gradientes): Frameworks (PyTorch, TensorFlow) las implementan automáticamente. Tú usas .backward() o .fit() y el framework calcula gradientes.
❌ Álgebra lineal avanzada (multiplicación de matrices, eigenvalues): Útil para entender internals de frameworks, pero NO necesario para usar modelos pre-entrenados o hacer fine-tuning.
❌ Implementar redes neuronales desde cero (sin frameworks): Útil como ejercicio académico, pero en la práctica usas PyTorch, TensorFlow, Keras, Hugging Face Transformers.

¿Por qué no lo necesitas? Porque tu rol (AI Engineer) es integrar modelos existentes, NO diseñar arquitecturas desde cero. Es como aprender a conducir: no necesitas diseñar el motor, pero sí necesitas entender qué hace el acelerador, el freno, y el volante.

Si quieres aprenderlo (opcional): Al final de cada cápsula hay recursos adicionales (ej. 3Blue1Brown: Neural Networks, Fast.ai, Stanford CS231n).

Roadmap del módulo

Fase 1: Fundamentos (Cápsulas 02-03)

Objetivo: Entender qué es una neurona artificial y cómo se organiza en capas.

Cápsula 02: ¿Qué es una neurona? Inspiración biológica (neurona real), modelo simplificado (perceptrón), cómo decide (inputs → pesos → suma → activación → output).
Cápsula 03: ¿Cómo se organizan neuronas? Capas (input, hidden, output), fully connected (cada neurona conectada a todas las de la siguiente capa), parámetros (weights + biases).

Analogía central: Neurona = trabajador que decide sí/no según inputs. Red neuronal = fábrica con departamentos (capas) que procesan información secuencialmente.

Fase 2: Cómo aprenden (Cápsulas 04-06)

Objetivo: Entender cómo una red neuronal procesa datos (forward pass) y cómo aprende (backpropagation).

Cápsula 04: ¿Por qué funciones de activación? Sin activación, la red es lineal (solo puede aprender relaciones lineales). Con activación (ReLU, sigmoid), la red puede aprender relaciones complejas (no-lineales).
Cápsula 05: ¿Cómo fluye la información? Forward pass: datos entran por input layer, pasan por hidden layers (cada capa transforma los datos), salen por output layer (predicción).
Cápsula 06: ¿Cómo aprende? Backpropagation (conceptual): calcular error (predicción vs realidad), propagar error hacia atrás (de output a input), ajustar pesos para reducir error.

Analogía central: Forward pass = fábrica procesa un producto (datos → capas → output). Backpropagation = jefe da feedback (error), feedback se propaga a departamentos (capas) para mejorar.

Fase 3: Arquitecturas especializadas (Cápsula 07)

Objetivo: Entender qué arquitecturas existen y cuándo usar cada una.

CNNs (Convolutional Neural Networks): Para imágenes (captan patrones espaciales: bordes, texturas, formas). Ejemplos: ResNet, VGG, MobileNet.
RNNs (Recurrent Neural Networks): Para secuencias (captan dependencias temporales: predicción de serie temporal, texto). Ejemplos: LSTM, GRU.
Feedforward (Fully Connected): Para datos tabulares (tablas con filas y columnas). Ejemplos: predicción de precio de casa, clasificación binaria.

Cuándo usar cada una:

Clasificar imágenes → CNN
Procesar texto secuencial → RNN (o Transformer, lo verás en Módulo 4)
Predecir precio de casa (datos tabulares) → Feedforward

Fase 4: Práctica (Cápsula 08)

Objetivo: Aplicar conceptos diseñando arquitecturas para problemas reales.

Ejercicios:

Dado un problema (ej. "clasificar correos como spam/no-spam"), elige arquitectura (feedforward, CNN, RNN), justifica.
Dado un modelo (ej. "ResNet-50"), interpreta qué significa (CNN, 50 capas, arquitectura residual).
Identifica errores comunes (ej. usar feedforward para imágenes, no usar activación, overfitting por red muy profunda).

Por qué importa para un AI Engineer

Situaciones donde usarás este conocimiento

1. Selección de modelos:

Vas a Hugging Face, ves modelos de clasificación de texto:

bert-base-uncased: Transformer, 12 capas, 110M parámetros.
distilbert-base-uncased: Transformer, 6 capas, 66M parámetros (versión más pequeña de BERT).

¿Cuál eliges? Depende de trade-offs:

BERT: Más preciso, más lento, más caro (110M parámetros → más cómputo).
DistilBERT: Menos preciso (pierde ~2-3% accuracy), más rápido, más barato (66M parámetros → menos cómputo).

Sin entender arquitecturas: No sabes qué significa "12 capas" ni "110M parámetros" → eliges al azar o copias lo que dice un tutorial.

Con entendimiento: Sabes que más capas → más expresividad pero más latencia. Más parámetros → más cómputo. Puedes razonar: "Si latencia no es crítica, uso BERT. Si necesito respuestas en <100ms, uso DistilBERT."

2. Debugging:

Tu clasificador de imágenes falla (65% accuracy en test set). ¿Por qué?

Posibles causas:

Arquitectura inadecuada: Usaste feedforward (red simple) en vez de CNN (especializada en imágenes) → la red no capta patrones espaciales (bordes, texturas).
Underfitting: Red muy simple (ej. 1 capa hidden con 10 neuronas) → no tiene capacidad para aprender patrones complejos.
Overfitting: Red muy compleja (ej. 100 capas) sin regularización → aprende ruido del training set, no generaliza a test set.
Datos insuficientes: 100 imágenes de entrenamiento → red no tiene suficientes ejemplos para aprender.

Sin entender arquitecturas: No sabes diagnosticar el problema → pruebas cambios al azar (cambiar learning rate, agregar capas) sin entender por qué.

Con entendimiento: Identificas el problema (ej. underfitting), propones solución (usar CNN, agregar capas), explicas por qué a tu equipo.

3. Optimización:

Tu app de clasificación de imágenes es lenta (2 segundos por imagen). Producto pide reducir a <500ms.

Análisis:

Modelo: ResNet-50 (50 capas, 25M parámetros).
Cuello de botella: Forward pass (pasar imagen por 50 capas toma tiempo).

Soluciones:

Usar modelo más pequeño: ResNet-18 (18 capas, 11M parámetros) → más rápido, menos preciso.
Reducir resolución: De 512x512 a 256x256 → menos píxeles procesados por cada capa.
Model quantization: Reducir precisión de parámetros (float32 → int8) → más rápido, menor precisión.

Trade-offs: Menos capas/parámetros → menos accuracy. Eliges según prioridad de producto (velocidad vs precisión).

Sin entender arquitecturas: No sabes por qué el modelo es lento ni cómo optimizarlo.

Con entendimiento: Identificas cuello de botella (50 capas), propones soluciones con trade-offs claros.

4. Fine-tuning:

Necesitas ajustar un modelo pre-entrenado (ej. BERT) a tu dominio (ej. clasificar reviews de productos tech en español).

Decisiones técnicas:

¿Qué capas ajustar? Últimas capas (aprenden características específicas de tu problema). Capas tempranas (aprenden características generales del lenguaje) se dejan fijas.
¿Cuántos datos necesitas? Fine-tuning requiere menos datos que entrenar desde cero (porque el modelo ya aprendió características generales). Ej. 1.000-10.000 ejemplos vs millones para entrenar desde cero.
¿Qué learning rate usar? Menor que en entrenamiento desde cero (porque ya estás cerca de un buen punto; solo ajustas).

Sin entender arquitecturas: No sabes qué capas ajustar, cuántos datos necesitas, o por qué el learning rate debe ser pequeño.

Con entendimiento: Sabes que las últimas capas aprenden características específicas → las ajustas. Sabes que fine-tuning es más eficiente → propones solución con menos datos.

Errores frecuentes al aprender Neural Networks

1. Pensar que necesitas las matemáticas desde el principio

Error: Empezar leyendo papers académicos sobre backpropagation con derivadas, álgebra lineal, cálculo de gradientes.

Realidad: Para AI Engineering, primero necesitas conceptos visuales (qué hace cada componente, cómo se conecta, cuándo usar cada arquitectura). Las matemáticas son útiles si quieres investigar, pero NO para integrar modelos pre-entrenados.

Consejo: Empieza con conceptos (este módulo). Si luego quieres profundizar, estudia matemáticas (recursos al final del módulo).

2. Confundir "entender" con "implementar desde cero"

Error: Pensar que no entiendes Neural Networks si no puedes implementar backpropagation desde cero en NumPy.

Realidad: Implementar desde cero es útil como ejercicio académico, pero en la práctica usas frameworks (PyTorch, TensorFlow) que lo hacen por ti. Lo importante es entender qué hace cada componente (qué es una capa, qué son pesos, cómo se ajustan).

Analogía: No necesitas saber construir un motor de coche para conducir efectivamente.

3. Asumir que más capas = siempre mejor

Error: Pensar que redes más profundas (más capas) siempre son mejores.

Realidad: Más capas → más expresividad (pueden aprender patrones más complejos) PERO también → más cómputo (más lento), más riesgo de overfitting (si no tienes suficientes datos o regularización), más difícil entrenar (problemas de vanishing/exploding gradients).

Regla general: Empieza con arquitecturas simples; agrega complejidad solo si es necesario.

4. No entender la distinción training vs inference (otra vez)

Error: Confundir entrenamiento (ajustar pesos de la red usando backpropagation) con inferencia (usar la red ya entrenada para hacer predicciones).

Realidad (repaso del Módulo 2):

Training: Costoso (días, GPUs caras), requiere datos etiquetados, ajusta pesos. LO HACEN OTROS (OpenAI, Google, Meta).
Inference: Barato (milisegundos, CPU suficiente para modelos pequeños), usa red ya entrenada, genera predicciones. LO HACES TÚ (AI Engineer).

Consecuencia: Como AI Engineer, NO entrenas desde cero (usas modelos pre-entrenados). Pero sí haces inference (integras modelos en apps) y ocasionalmente fine-tuning (ajuste ligero con tus datos).

Preguntas frecuentes

¿Necesito saber programar para este módulo?

No. Este módulo es conceptual (sin código). Solo necesitas entender conceptos básicos de programación (qué es una variable, una función, un array) para seguir analogías.

En módulos futuros del bootcamp (no de esta guía) sí verás código (Python, PyTorch, Hugging Face), pero esta guía es preparación conceptual.

¿Veré código en este módulo?

No. Este módulo usa diagramas, analogías y visualizaciones. El objetivo es que entiendas conceptos sin distraerte con sintaxis de código.

Recursos opcionales con código: Si quieres experimentar, al final de cada cápsula hay recursos (ej. TensorFlow Playground: interfaz visual sin código; Fast.ai: curso práctico con código).

¿Cuánto tarda aprender esto?

Este módulo: 3 horas (2.5h lectura + 0.5h ejercicios).

Para dominar Deep Learning (implementación, arquitecturas avanzadas): 3-6 meses (cursos como Fast.ai, Stanford CS231n, experiencia práctica).

Para AI Engineering (integrar modelos pre-entrenados): Este módulo + Módulos 4-6 de esta guía (Transformers, LLMs, APIs) = fundamentos suficientes. Luego práctica en proyectos reales (bootcamp).

¿Puedo saltar este módulo y pasar directo a Transformers (Módulo 4)?

No recomendado. Transformers (arquitectura de GPT-4, BERT, Claude) son un tipo de red neuronal. Si no entiendes qué es una neurona, una capa, forward pass, backpropagation, te costará entender attention (mecanismo clave de Transformers).

Progresión lógica:

Módulo 2: Machine Learning (training, supervised, etc.)
        ↓
Módulo 3: Neural Networks (neurona, capas, forward/backward)  ← ESTÁS AQUÍ
        ↓
Módulo 4: Transformers (attention, encoder-decoder)
        ↓
Módulo 5: LLMs (GPT, Claude, tokenización)

Cada módulo construye sobre el anterior.

Evidencia de éxito

Sabes que has aprovechado bien este módulo cuando:

Puedes explicar a alguien no-técnico qué es una red neuronal y cómo aprende (usando analogías, sin fórmulas).
Puedes diagramar una red neuronal simple (ej. 3 capas: input, hidden, output) con pesos y activaciones.
Puedes identificar qué arquitectura usar para un problema dado (CNN → imágenes, RNN → secuencias, feedforward → tablas).
Puedes interpretar documentación de modelos (ej. "ResNet-50 con 50 capas convolucionales, 25M parámetros").
Puedes diagnosticar problemas básicos (ej. "el modelo es lento porque tiene 100 capas", "usa feedforward en vez de CNN para imágenes").

Si al final del módulo (Cápsula 08) puedes resolver el ejercicio integrador sin consultar cápsulas anteriores, estás listo para Módulo 4 (Transformers).

Resumen de esta cápsula

Por qué necesitas entender Neural Networks:

Todo el AI moderno (LLMs, visión, recomendaciones) usa redes neuronales.
Como AI Engineer, integras modelos pre-entrenados → necesitas entender arquitecturas para seleccionar, optimizar, diagnosticar.
Este módulo es conceptual (sin matemáticas complejas) enfocado en razonamiento arquitectural.

Qué aprenderás:

Neurona artificial, capas, arquitectura (Cápsulas 02-03)
Forward pass, backpropagation conceptual (Cápsulas 04-06)
CNNs, RNNs, feedforward: cuándo usar cada una (Cápsula 07)
Práctica: diseñar arquitecturas (Cápsula 08)

Próximo paso: Pasa a Cápsula 02: ¿Qué es una Neural Network? donde verás qué es una neurona artificial y cómo decide.

Recursos adicionales (opcionales)

3Blue1Brown: Neural Networks — Serie de 4 videos visuales sobre NNs. En inglés con subtítulos. Excelente para visualización.
TensorFlow Playground — Interfaz visual para experimentar con NNs (sin código). Puedes ver cómo una red aprende en tiempo real. En inglés, pero muy intuitivo.
Fast.ai: Practical Deep Learning for Coders — Curso práctico de Deep Learning. En inglés. Más técnico (con código Python/PyTorch).
Stanford CS231n: Convolutional Neural Networks — Curso académico sobre CNNs. En inglés. Muy técnico (con matemáticas).
Deep Learning Book (Goodfellow et al.) — Libro de referencia sobre Deep Learning. En inglés. Muy técnico (álgebra lineal, cálculo).

Nota: NO necesitas estos recursos para AI Engineering; este módulo cubre lo esencial. Son opcionales si quieres profundizar.

← Anterior7. Ejercicio: Clasificar Problemas de Machine Learning Siguiente →2. ¿Qué es una Neural Network?