Lección 1 · 10 min · Gratis

Introducción al curso y configuración del entorno

Esta lección abre el curso y no requiere conocimientos previos sobre la estructura interna de las redes neuronales, más allá de un buen manejo de Python y matemáticas básicas. Después de esta lección, tendrás tu entorno de trabajo configurado, verás el recorrido general del curso y verificarás que tu entorno esté realmente listo para trabajar: que pueda calcular con PyTorch y ejecutar código de terceros del repositorio micrograd.

Curso no oficial de AI University basado en código abierto (MIT). La lección incluye código de karpathy/micrograd © Andrej Karpathy, licencia MIT; los comentarios han sido traducidos al español, las explicaciones han sido escritas por nuestro equipo. El curso no está asociado con el autor del código ni ha sido aprobado por él.

De dónde surgió este curso

El curso "Redes neuronales desde cero: con el código abierto de Andrej Karpathy" fue escrito por el equipo de AI University basándose en cuatro repositorios de código abierto: micrograd, makemore, nanoGPT y minbpe. Todos ellos se distribuyen bajo la licencia MIT, que permite tomar el código, modificarlo y explicarlo con fines educativos. Nosotros utilizamos precisamente este derecho: citamos los archivos originales, traducimos los comentarios al español y complementamos el código con nuestros propios ejemplos.

Una aclaración importante: el curso no es oficial. No estamos asociados con Andrej Karpathy, y él no ha revisado ni aprobado estos materiales. El propio Karpathy, si necesitas contexto: investigador, uno de los fundadores de OpenAI, en diferentes momentos dirigió la división de inteligencia artificial en Tesla. En este curso, no nos interesa su biografía, sino el código que ha puesto a disposición del público y lo que se puede aprender de él.

Qué construirás en 16 lecciones

Los cuatro repositorios forman un único recorrido, y cada uno se basa en el anterior.

micrograd (lecciones 2-4): un motor de diferenciación automática para números escalares, cuyo núcleo cabe en unas 100 líneas. Verás cómo se construye un grafo de cómputo a partir de operaciones aritméticas individuales y cómo se calculan los gradientes mediante un paso hacia atrás a través de este grafo. Con este mismo motor, construirás una neurona, una capa y una red completa, y la entrenarás en un problema de juguete.

makemore (lecciones 5-8): un conjunto de modelos de lenguaje de caracteres, entrenados en una lista de nombres. Aquí, los gradientes ya no son hechos a mano, sino de PyTorch, pero aparece algo indispensable para cualquier modelo de lenguaje: la distribución de probabilidad sobre el siguiente carácter. Recorrerás el camino desde un modelo bigrama simple hasta un MLP con embeddings, entenderás por qué la inicialización de pesos y la normalización de activaciones son críticamente importantes para el entrenamiento, y al final construirás una arquitectura jerárquica que lee el contexto no de forma completa, sino por capas, como lo hace WaveNet.

nanoGPT (lecciones 9-13): una implementación compacta pero completa de GPT en PyTorch. Aquí desglosarás el self-attention desde cero, construirás un bloque transformador y un modelo completo, ejecutarás el entrenamiento y la generación de texto, y al final verás cómo los mismos componentes escalan desde un modelo de juguete hasta GPT-2.

minbpe (lecciones 14-15): un tokenizador basado en byte pair encoding. Formalmente, este es el último repositorio de la lista, pero en esencia se encuentra al principio de cualquier pipeline: antes de que el texto llegue al transformador, debe convertirse en una secuencia de tokens. Desglosarás cómo funciona el algoritmo BPE y construirás tu propio tokenizador con soporte para la división regular de texto y tokens especiales.

Si lo ves todo como una línea: primero aprendes a calcular gradientes (micrograd), luego los usas para el modelado de lenguaje (makemore), luego reemplazas la arquitectura simple por un transformador con atención (nanoGPT), y finalmente entiendes cómo funciona el primer paso de cualquier pipeline de lenguaje: la división del texto en tokens (minbpe).

Qué necesitas saber de antemano

El curso es avanzado y no nos detendremos en los fundamentos de Python o el álgebra lineal. Necesitarás:

Python avanzado: clases y objetos, métodos mágicos como __add__ y __mul__, list comprehensions, trabajar con funciones como objetos de primera clase.
Matemáticas a nivel de numpy: vectores y matrices, multiplicación de matrices, derivada y derivada parcial, logaritmo y exponencial, el concepto de distribución de probabilidad.
Es deseable, pero no obligatorio, tener experiencia con tensores de PyTorch: recordaremos las operaciones necesarias a lo largo del curso, cuando aparezcan por primera vez.

Si alguno de estos puntos te genera dudas, no te preocupes: en las primeras lecciones, las matemáticas y el código serán sencillos, la complejidad aumentará gradualmente.

Cómo preparar tu entorno de trabajo

Hay tres opciones razonables. Para este curso, recomendamos la primera como la principal.

Opción 1: Ejecución local (recomendada)

Necesitarás Python 3.10 o más reciente. Crea un entorno virtual para no contaminar tu Python del sistema:

python -m venv neurozero
source neurozero/bin/activate   # en Windows: neurozero\Scripts\activate
pip install torch numpy matplotlib jupyter tiktoken regex

Las bibliotecas tiktoken y regex serán necesarias más adelante, en las lecciones sobre tokenización, pero es más conveniente instalarlas de inmediato.

Los repositorios se clonan con el comando git habitual:

git clone https://github.com/karpathy/micrograd.git
git clone https://github.com/karpathy/makemore.git
git clone https://github.com/karpathy/nanoGPT.git
git clone https://github.com/karpathy/minbpe.git

Para trabajar con código y gráficos, Jupyter es conveniente:

jupyter lab

Cuando llegue el momento de nanoGPT, no tendrás que entrenar un modelo con millones de parámetros de inmediato. Aquí tienes un comando que inicia el entrenamiento de un modelo pequeño en el conjunto de datos de caracteres de Shakespeare directamente en la CPU, reduciendo el tamaño del modelo y el número de pasos a valores razonables para una laptop:

python train.py config/train_shakespeare_char.py --device=cpu --compile=False \
  --eval_iters=20 --log_interval=1 --block_size=64 --batch_size=12 \
  --n_layer=4 --n_head=4 --n_embd=128 --max_iters=2000 \
  --lr_decay_iters=2000 --dropout=0.0

Si tienes una Mac con procesador Apple Silicon (M1, M2, M3, etc.), en lugar de --device=cpu, prueba --device=mps: esto utilizará la GPU integrada y acelerará significativamente el entrenamiento.

Opción 2: Google Colab

Colab ofrece acceso gratuito a la GPU y te evita la configuración local. Pero esta opción tiene dos limitaciones que debes conocer de antemano: desde Rusia, Colab puede no estar disponible sin VPN, y para trabajar con él, es imprescindible tener una cuenta de Google. Por esta razón, en el curso nos enfocamos en la ejecución local como la ruta principal, y mencionamos Colab como una opción para quienes tienen acceso a él.

Opción 3: Servidor en la nube con GPU

Si necesitas una potencia de cómputo más seria, cualquier servidor en la nube con GPU de un proveedor accesible para ti funcionará. La configuración del entorno en dicho servidor no difiere de la local: el mismo Python, el mismo entorno virtual, los mismos comandos de instalación de dependencias.

Cómo está estructurada cada lección

La estructura es la misma a lo largo de todo el curso, y es útil orientarse en ella de inmediato.

Primero, se explica un concepto o mecanismo con nuestras propias palabras, generalmente basándose en lo que ya sabes. Luego, mostramos un fragmento del código original de uno de los cuatro repositorios: estos bloques siempre comienzan con una etiqueta como "# Fragmento: micrograd/micrograd/engine.py" y contienen código copiado textualmente, con comentarios traducidos al español. A continuación, vienen nuestros propios ejemplos, que escribimos específicamente para la lección: estos comienzan con la línea "# Nuestro ejemplo" y siempre son funcionales, puedes copiarlos y ejecutarlos. Al final de la lección, hay una sección "Pruébalo tú mismo" con ejercicios, y después del texto de la lección, agregamos un enlace al archivo fuente en GitHub y al video original de Karpathy como fuente primaria.

Calentamiento: la clase Value

Para familiarizarte con el estilo de código con el que trabajarás, echa un vistazo al comienzo del archivo engine.py de micrograd. Un análisis detallado se hará en la próxima lección, pero por ahora, simplemente presta atención a lo compacto que es el diseño de la clase.

# Fragmento: micrograd/micrograd/engine.py

class Value:
    """ guarda un valor escalar y su gradiente """

    def __init__(self, data, _children=(), _op=''):
        self.data = data
        self.grad = 0
        # variables internas para construir el grafo de diferenciación automática
        self._backward = lambda: None
        self._prev = set(_children)
        self._op = _op # operación que generó este nodo: para graphviz, depuración, etc.

    def __add__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        out = Value(self.data + other.data, (self, other), '+')

        def _backward():
            self.grad += out.grad
            other.grad += out.grad
        out._backward = _backward

        return out

Aquí hay solo dos métodos, pero en ellos ya se ve toda la idea del curso: un número ordinario data se envuelve en un objeto que recuerda de dónde se obtuvo (_prev, _op) y sabe cómo pasar su gradiente de vuelta a los nodos de los que fue construido (_backward). Esta simple construcción, repetida para la suma, la multiplicación, la exponenciación y ReLU, es precisamente la diferenciación automática. En la próxima lección, la desglosaremos por partes.

Pruébalo tú mismo

Configura el entorno. Crea un entorno virtual, instala torch, numpy, matplotlib, jupyter, tiktoken, regex. Asegúrate de que todo funciona ejecutando:
```
# Nuestro ejemplo
import torch
print(torch.__version__)
x = torch.tensor([1.0, 2.0, 3.0])
print(x.sum().item())
```
Criterio de éxito: el código se ejecuta sin errores e imprime la versión de PyTorch y el número 6.0.
Clona micrograd y ejecuta sus pruebas. Instala pytest (pip install pytest), clona el repositorio y desde su raíz ejecuta:
```
python -m pytest test
```
Criterio de éxito: todas las pruebas pasan (una línea como "N passed"). Si las pruebas fallan con un error de importación, verifica que estás en la carpeta raíz del repositorio y que contiene el archivo setup.py o pyproject.toml: a veces el paquete necesita ser instalado con el comando pip install -e ..
Verifica la derivada manualmente y numéricamente. Toma la función f(x) = x² + 3x. Calcula en papel la derivada ∂f/∂x en el punto x = 2 analíticamente (usando la regla de diferenciación de la función de potencia), y luego verifica el resultado numéricamente con un h pequeño:
```
# Nuestro ejemplo
def f(x):
    return x**2 + 3*x

x = 2.0
h = 1e-6
numeric_grad = (f(x + h) - f(x)) / h
print(numeric_grad)  # debería estar cerca del valor analítico
```
Criterio de éxito: la estimación numérica de la derivada difiere de tu respuesta analítica en no más de 0.001. Sugerencia: la derivada analítica de f(x) = x² + 3x es 2x + 3.

Conclusiones

El curso no es oficial y está escrito con código abierto bajo licencia MIT: explicamos y complementamos el código de Karpathy, pero no estamos asociados con él ni hemos recibido su aprobación.
El recorrido del curso va desde gradientes escalares (micrograd) a través de modelos de lenguaje de caracteres (makemore) hasta el transformador (nanoGPT) y la tokenización (minbpe), cada parte se basa en la anterior.
Para el curso se necesita un buen manejo de Python, matemáticas básicas (derivadas, matrices, probabilidades) y, preferiblemente, familiaridad con los tensores de PyTorch.
La forma principal de trabajar con el curso: un entorno local en Python 3.10+ con PyTorch, las otras opciones (Colab, servidor en la nube) están disponibles, pero requieren condiciones adicionales.
Cada lección está estructurada de la misma manera: explicación, fragmento de código original con comentarios traducidos, un ejemplo funcional propio, ejercicios "Pruébalo tú mismo" y enlaces a las fuentes.
Ya has visto el primer fragmento de código, la clase Value: su análisis detallado comenzará en la próxima lección.

Fuentes primarias

Fuente primaria: videos de Andrej Karpathy (en inglés): Neural Networks: Zero to Hero (lista de reproducción)
Código de la lección en GitHub: github.com/karpathy/micrograd, github.com/karpathy/makemore, github.com/karpathy/nanoGPT, github.com/karpathy/minbpe

Los videos se proporcionan solo como enlaces a la fuente primaria; el texto de la lección no es una traducción ni un resumen de ellos. Textos completos de las licencias: en la lección "Qué sigue, licencias y fuentes".

Esta lección es gratuita. El resto del curso se abre con la Membresía de IA con Clase, que incluye todos los cursos del catálogo. Ver precios

Siguiente: micrograd: el pase hacia adelante y el grafo de cómputo →