09 · Tensores y PyTorch

Nivel 2 — Deep learning · Ruta de Aprendizaje

Antes de empezar. Arreglos y formas del módulo 00 y la separación entre ajustar y predecir del 02. Aquí construiremos el primer entrenamiento en CPU; el módulo 10 explicará cómo se calculan sus gradientes.

En los modelos anteriores, fit ocultaba la actualización de parámetros. PyTorch permite escribirla y observarla. Seguiremos un lote desde que se carga hasta que modifica los pesos: las formas de los arreglos siguen siendo las del módulo 00, y ahora también importa cómo se construyó cada cálculo.

1. Calcular una media para cada variable
1. Calcular una media para cada variable

En la columna A, (1 + 3 + 5 + 7) / 4 = 4. Las medias de A, B y C son 4, 8 y 25; no se mezclan columnas.

2. Restar las medias a una fila
2. Restar las medias a una fila

La primera fila pasa de [1, 5, 20] a [−3, −3, −5]: cada valor resta la media de su propia columna.

3. Reutilizar esa fila de medias
3. Reutilizar esa fila de medias

Broadcasting reutiliza la forma (1, 3) al operar con (4, 3). El resultado conserva cuatro filas y tres columnas; la media de cada columna queda en cero.

En la figura, una fila de tres medias se reutiliza en las cuatro filas de X: el primer resultado es (1−4, 5−8, 20−25). No se mezclan columnas. PyTorch usa esta misma regla de broadcasting para combinar formas compatibles.

De arreglos a tensores

Un tensor es un arreglo de números con uno o más ejes; un escalar tiene cero ejes. Muchas operaciones de PyTorch se parecen a las de NumPy, aunque los nombres y algunos valores por defecto cambian. Aquí nos interesan dos capacidades:

  1. Puede vivir en la GPU.
  2. Puede recordar cómo se calculó, para que se le puedan sacar gradientes.
# bloque: fragmento
import numpy as np
import torch
 
a = torch.tensor([[1., 2., 3.],
                  [4., 5., 6.]])
print(a.shape, a.dtype, a.device)     # torch.Size([2, 3]) torch.float32 cpu
 
# ida y vuelta con NumPy (comparten memoria: cuidado)
t = torch.from_numpy(np.array([1., 2., 3.]))
v = t.numpy()

En este ejemplo, torch.tensor recibe decimales de Python y crea float32 con la configuración habitual. NumPy crea float64 a partir de una lista así. Una lista de enteros tiene otro tipo, y torch.from_numpy conserva el tipo del arreglo: t es float64. Cuando una capa y sus entradas requieren el mismo tipo, conviene elegirlo explícitamente, por ejemplo dtype=torch.float32.

from_numpy comparte memoria con el arreglo original. La conversión t.numpy() del ejemplo también comparte esos datos: modificar uno puede modificar el otro. torch.tensor(arreglo) crea una copia. Para convertir un tensor que participa en gradientes o vive en GPU, se usa tensor.detach().cpu().numpy(); el traslado a CPU y la desconexión del gradiente cumplen funciones distintas.

Leer formas en PyTorch

NumPy usa axis para elegir un eje; muchas operaciones de PyTorch lo llaman dim. Reducirlo combina sus valores. dim=-1 nombra el último eje y -2 el penúltimo: no son números de ejemplos. En una tabla, reducir el último eje resume cada fila.

# bloque: probado; id: formas_pytorch
import torch
 
tabla = torch.tensor([[1., 2., 3.], [4., 5., 6.]])
por_fila = tabla.sum(dim=-1)
con_eje = tabla.sum(dim=-1, keepdim=True)
print(por_fila, por_fila.shape)  # [6,15], (2,)
print(con_eje, con_eje.shape)    # [[6],[15]], (2,1)
columna = por_fila.unsqueeze(-1)
print(columna.shape)            # (2,1): añade un eje, no nuevos valores
print(tabla.transpose(0, 1))     # [[1,4],[2,5],[3,6]]

keepdim=True conserva con tamaño uno el eje reducido. unsqueeze añade un eje de tamaño uno al tensor ya calculado; squeeze(dim) puede quitarlo si ese eje mide uno. Elegirlo explícitamente evita borrar por accidente el eje del lote cuando solo hay un ejemplo. reshape conserva la cantidad de elementos; transpose cambia qué eje ocupa cada lugar.

Un modelo que empieza equivocándose

Tenemos tres observaciones: para entradas −1, 0 y 1, las respuestas son −1, 1 y 3. Queremos ajustar predicción = w × entrada + b. En estos datos la regla es y=2x+1, pero el entrenamiento solo recibirá los pares de números.

Empecemos con w=0 y b=0. El modelo predice cero en las tres filas:

EntradaRespuestaError²
−1−11
011
139

La pérdida MSE es (1+1+9)/3 = 11/3. Resume el error de esas tres predicciones. Ajustar significa cambiar w y b, manteniendo los datos. Una nn.Linear(1, 1) guarda justamente un peso y un sesgo para esta regla.

El bucle de entrenamiento: del error a un cambio de pesos

Primero hacemos una predicción (forward) y calculamos su pérdida. backward() obtiene las pendientes respecto de w y b; todavía no cambia los pesos. El optimizador SGD los actualiza restando learning_rate × gradiente. El siguiente forward usa esos pesos nuevos. Este programa es completo:

# bloque: probado; id: primer_entrenamiento
import torch
from torch import nn
 
X = torch.tensor([[-1.], [0.], [1.]])   # (3, 1): tres ejemplos, una variable
y = torch.tensor([[-1.], [1.], [3.]])   # una respuesta por ejemplo
modelo = nn.Linear(1, 1)
with torch.no_grad():
    modelo.weight.zero_()
    modelo.bias.zero_()
perdida = nn.MSELoss()
optimizador = torch.optim.SGD(modelo.parameters(), lr=0.1)
historial = []
for paso in range(100):
    salida = modelo(X)
    valor = perdida(salida, y)
    historial.append(valor.item())    # pérdida ANTES de esta actualización
    optimizador.zero_grad()
    valor.backward()
    optimizador.step()
with torch.no_grad():
    pred_final = modelo(X)
print(modelo.weight.item(), modelo.bias.item())  # aproximadamente 2 y 1
print(pred_final.flatten())                     # aproximadamente [-1, 1, 3]

parameters() entrega los pesos que SGD podrá modificar. lr=0.1 fija el tamaño del paso; en el módulo 10 veremos por qué uno muy grande puede empeorar la pérdida. Inicializar en cero sirve para esta regresión, pero no es una regla general para capas ocultas de una red.

La capa conserva weight y bias. modelo(X) devuelve predicciones, sin reemplazar X ni actualizar los pesos por sí mismo. La pérdida es un tensor con un número; .item() obtiene un número de Python para registrarlo. El optimizador es otro objeto, con referencias a los parámetros que puede mover.

OperaciónQué cambia
Forwardcalcula predicciones con los pesos actuales
backward()acumula derivadas en .grad
step()modifica los pesos usando las derivadas
zero_grad()limpia gradientes; conserva los pesos

PyTorch acumula cada gradiente en .grad: zero_grad() limpia los anteriores para que este paso use solamente el cálculo actual. Puede ir antes del forward; debe ocurrir antes del backward que queremos usar por separado. En el módulo 15 acumularemos varios lotes deliberadamente.

Aquí bajar MSE confirma que ajustamos esos tres ejemplos. No demuestra generalización a datos reales: todos siguen una regla exacta y no hay ruido. Puedes probar modelo(torch.tensor([[2.]])): la regla del ejemplo da 5. En una tarea real se reservarían datos como en el módulo 05. La receta Bucle de entrenamiento en PyTorch reúne un ciclo con entrenamiento y validación.

Dataset y DataLoader: dividir los mismos datos en lotes

Hasta ahora cada actualización usó las tres filas juntas. Un lote es el grupo usado para calcular una pérdida y su gradiente. Podemos dividir las mismas tres observaciones en lotes de dos:

# bloque: probado; id: primeros_lotes
from torch.utils.data import DataLoader, TensorDataset
 
# Continúa con X e y del programa anterior.
cargador = DataLoader(TensorDataset(X, y), batch_size=2, shuffle=False)
lotes = list(cargador)
for lote_X, lote_y in lotes:
    print(lote_X.flatten().tolist(), lote_y.flatten().tolist())
# [-1.0, 0.0] [-1.0, 1.0]
# [1.0] [3.0]

TensorDataset conserva juntas entrada y respuesta; DataLoader selecciona índices y agrupa las filas. La última tanda tiene solo una: batch_size=2 es el máximo, no una promesa de que todos los lotes tendrán ese tamaño. Una época recorre el cargador. Para entrenar por lotes, el cuerpo del programa anterior iría dentro de ese recorrido y usaría lote_X, lote_y. Habría dos actualizaciones por época, en lugar de una sobre las tres filas.

shuffle=True cambia el orden entre épocas sin separar entradas de respuestas. Se suele usar con ejemplos independientes; puede ser inadecuado si el modelo mantiene estado temporal entre lotes. drop_last=True omitiría aquí la última fila. En validación, conservar el orden facilita alinear predicciones e IDs; barajar no cambia una media bien calculada, pero comparar contra etiquetas recogidas en otro orden sí cambia su significado.

El dispositivo

# bloque: fragmento
dispositivo = "cuda" if torch.cuda.is_available() else "cpu"
 
modelo = modelo.to(dispositivo)
X = X.to(dispositivo)
y = y.to(dispositivo)
optimizador = torch.optim.SGD(modelo.parameters(), lr=0.1)

En una capa como nn.Linear, sus pesos y las entradas deben estar en el mismo dispositivo. También hay que ubicar allí las etiquetas usadas para calcular la pérdida. .to(dispositivo) devuelve el tensor en el dispositivo solicitado; por eso se asigna el resultado. Si aparece un error de dispositivo, inspecciona los tensores concretos que llegan a esa operación.

El condicional elige CUDA si está disponible y CPU en caso contrario. Así podemos estudiar ejemplos pequeños en una máquina sin GPU. Una GPU puede acelerar lotes grandes, pero transferir datos también cuesta; no toda operación será más rápida. Esta preparación va antes del entrenamiento que quieras realizar en ese dispositivo: crea el optimizador después de ubicar los parámetros. Si cargas lotes en CPU, mueve cada lote y sus etiquetas antes del forward. La plantilla del repositorio incluye esta selección:

Abrir la plantilla en Colab.

Ampliación: cargar archivos cuando hacen falta

Para cargar archivos a medida que hacen falta, podemos definir un Dataset. cargar representa una función que tendrás que adaptar al formato de archivo:

# bloque: fragmento
from torch.utils.data import Dataset
 
class MiDataset(Dataset):
    def __init__(self, rutas, etiquetas):
        self.rutas = rutas
        self.etiquetas = etiquetas
 
    def __len__(self):
        return len(self.rutas)
 
    def __getitem__(self, i):
        x = cargar(self.rutas[i])          # leer del disco recién acá
        return x, self.etiquetas[i]

__getitem__(i) define cómo obtener un ejemplo. El cargador decide qué índices pedir. En una época común sin reemplazo recorre cada ejemplo una vez, pero un muestreo personalizado puede repetirlos y drop_last=True puede omitir el lote final. Una época es un recorrido definido por ese cargador, no una promesa de que todos los programas llamen exactamente una vez a cada índice.

Guardar rutas y metadatos en __init__ cuesta poco. Cargar todas las imágenes allí puede agotar RAM; leerlas al pedirlas mantiene acotado el uso de memoria. Una transformación fija puede precalcularse o cachearse si cabe, mientras que una transformación aleatoria suele repetirse durante el entrenamiento.

shuffle=True mezcla el orden de los ejemplos: suele ser útil cuando pueden tratarse de forma independiente. Si el modelo conserva estado temporal entre lotes, barajar puede romper el problema. En validación, shuffle=False facilita conservar ids y orden. Barajar no cambia una media correctamente calculada, pero sí desalinearía predicciones y etiquetas recogidas por separado.

.item(), .detach() y no_grad()

El grafo de cálculo registra operaciones conectadas por sus entradas y salidas. Estas tres herramientas permiten separar entrenamiento y observación:

# bloque: fragmento
total += valor.item()          # sacar UN número de un tensor de un elemento
vector = tensor.detach()       # un tensor igual, pero fuera del grafo
 
with torch.no_grad():          # bloque entero sin construir grafo: para EVALUAR
    predicciones = modelo(X_val)

.item() obtiene un número de un tensor con un solo elemento; sirve para registrar una pérdida. .detach() produce un tensor desconectado del historial de gradientes, pero comparte sus datos: no es una copia independiente. no_grad() evita registrar nuevas operaciones para derivarlas, por ejemplo al predecir en validación.

Guardar tensores conectados al grafo puede retener memoria que no necesitas; backward() libera normalmente los valores intermedios usados para derivar, pero no conviene conservar historiales completos para registrar números. no_grad() reduce ese trabajo en evaluación. El modo de capas como dropout se controla aparte con eval(), como veremos en el módulo 11.

⚠️ Las tres trampas (los tres tracebacks)

1. Forma.

# bloque: error-deliberado; id: forma_incorrecta
import torch.nn as nn
capa = nn.Linear(4, 2)
capa(torch.randn(3, 5))
# RuntimeError: mat1 and mat2 shapes cannot be multiplied (3x5 and 4x2)

El lote tiene tres ejemplos con cinco features, pero nn.Linear(4, 2) espera cuatro features por ejemplo y devuelve dos. Con una entrada (3, 4) produciría (3, 2). La corrección depende de qué representan las columnas: cambiar un reshape hasta que ejecute puede ocultar que mezclaste ejemplos y features.

2. Tipo. Una capa lineal con pesos float32 no admite sin más entradas float64. Para cross_entropy con una clase correcta por ejemplo, las etiquetas son índices enteros long, entre 0 y n_clases−1. Los objetivos de regresión son valores flotantes; otras variantes de clasificación usan distribuciones como objetivo y tienen otro contrato.

3. Dispositivo. Puede faltar mover un lote, una etiqueta o un tensor creado dentro del modelo. Lee qué operación falla y compara los device de sus entradas, junto con shape y dtype.

Estas propiedades expresan decisiones del problema: qué es una muestra, qué significa su respuesta y dónde se realiza el cálculo. Interpretarlas permite reparar la causa del error.

🏋️ Práctica

Una primera variación local

Cambia las respuestas del programa a [-4, -1, 2], conservando las entradas. Antes de ejecutarlo, busca la recta que pasa por los tres pares. ¿Qué debería predecir para entrada 2? Después prueba lotes de tamaño 2: compara el número de actualizaciones, no solo el número de épocas.

Para profundizar

#EjercicioFuenteQué practica
1Tutorial de PyTorch: Tensors y Datasetspytorch.org/tutorialsconectar los conceptos con la API oficial
2Reescribe tu solución del módulo 02 con una nn.Linear y el bucle a manoBucle de entrenamiento en PyTorchel ciclo entero, sin magia
3⭐ Ajusta y = 2x + 1 y comprueba que el modelo aprende w≈2, b≈1—ver que el bucle funciona de verdad
4Escribe un Dataset propio que lea imágenes del discoKaggle Digit Recognizerel caso en que los datos no caben
5Provoca los tres tracebacks a propósito y aprende a leerlos—que dejen de darte miedo

En el quinto ejercicio, dos arreglos con la misma cantidad de números pueden representar problemas distintos. Explica qué significa cada eje antes de proponer una forma que la capa acepte.

🎯 Mini-desafío (formato IOAI)

Este desafío amplía el bucle de la clase. Conviene retomarlo después del módulo 10, que introduce las capas y activaciones de un MLP.

Tarea principal: Robot Chasing (IOAI 2026, individual). Predecir la próxima acción de cada uno de seis robots. Métrica: promedio de las seis accuracies por robot. Baseline local: evalúa la acción constante 0 en tu propia validación. Separa el 20% de las observaciones con semilla 0, manteniendo representados los robots; si identificas observaciones de un mismo episodio, separa por episodio para evitar fuga. El número de ejemplos y el resultado de cada robot permiten interpretar qué está resumiendo el promedio.

Aplana la grilla 8×8×2 y añade representaciones de robot_id, direction y carrying. Son categorías, no magnitudes ordenadas: una representación one-hot pone un 1 en la categoría elegida y ceros en las demás. El módulo 12 compara esa idea con embeddings. Entrena un MLP con el bucle a mano. Como primera adaptación omite el lenguaje y mide qué se pierde: no asumas que esta simplificación superará el baseline oficial.

Extensión distinta: Robot Delivery Academy (at-home). Aquí una política controla al robot durante episodios y se evalúan entregas exitosas. Requiere integrar la política con el simulador y ejecutar episodios completos. No uses la accuracy de seis robots de Chasing como métrica de Delivery; una buena predicción de acciones aisladas no prueba que complete una entrega. Reserva esta extensión para después de validar el flujo de inferencia del simulador.

Para explorar

Cambia una sola dimensión, un dtype y un dispositivo en el bucle. Antes de correr, anticipa qué operación fallará y qué información del traceback permite localizarla.

Baraja un cargador de validación conservando juntos datos y etiquetas; después compara contra etiquetas guardadas en otro orden. El contraste explica por qué el orden importa para alinear filas, aunque no cambie una media bien calculada.


← 08 - Sin etiquetas · Ruta de Aprendizaje · 10 - Gradientes y backpropagation →