Conceptos básicos de PyTorch

10 ejemplos para empezar con Deep Learning: 7 básicos y 3 intermedios.

Prerrequisitos

uv venv && source .venv/bin/activate
uv pip install "torch>=2.6" "torchvision>=0.21"
python -c "import torch; print(torch.__version__, torch.cuda.is_available())"

• Python 3.14.0 con PyTorch 2.6+.
• GPU CUDA opcional pero recomendada para entrenamiento (CPU funciona para ejemplos pequeños).

Ejemplos básicos

1. Crear un Tensor

Los tensores son la estructura de datos principal de PyTorch, como los arrays de NumPy con soporte para GPU.

import torch
 
x = torch.tensor([1.0, 2.0, 3.0])
matrix = torch.zeros(3, 4)
rand = torch.randn(2, 3, generator=torch.Generator().manual_seed(42))
print(x.shape, x.dtype, x.device)

• torch.tensor crea a partir de listas de Python; torch.zeros/randn asignan memoria.
• .shape, .dtype y .device describen los metadatos del tensor.
• Establece una semilla de generador para tensores aleatorios reproducibles.

Relacionado: Autograd - los tensores rastrean gradientes

2. Operaciones con Tensores

Las operaciones elemento a elemento y de matrices funcionan como en NumPy.

a = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
b = torch.tensor([[5.0, 6.0], [7.0, 8.0]])
print(a + b)
print(a @ b.T)  # multiplicación de matrices

• @ es multiplicación de matrices; * es elemento a elemento.
• dim=0 reduce a lo largo de las filas (medias de columnas).
• La difusión aplica tensores más pequeños a través de otros más grandes automáticamente.

3. Mover Tensores a la GPU

Acelera la computación colocando tensores en dispositivos CUDA.

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
x = torch.randn(1000, 1000, device=device)
y = x @ x.T
print(y.device)

• Crea o mueve siempre los tensores al dispositivo de destino antes de las operaciones.
• Mezclar tensores de CPU y GPU genera errores; mantén todo en un solo dispositivo.
• torch.cuda.is_available() devuelve False en máquinas solo con CPU.

Relacionado: GPUs y Precisión Mixta - CUDA y autocast

4. Convertir NumPy y PyTorch

Conecta los ecosistemas con cero copias cuando sea posible.

import numpy as np
 
np_arr = np.array([1.0, 2.0, 3.0])
tensor = torch.from_numpy(np_arr)
back = tensor.numpy()

• from_numpy comparte memoria con el array de NumPy (los cambios in situ afectan a ambos).
• .numpy() requiere un tensor de CPU y puede copiar si hay gradientes adjuntos.
• Usa .detach().cpu().numpy() para tensores con requires_grad=True.

5. Indexación y Remodelación

Selecciona, corta y remodela las dimensiones del tensor.

x = torch.arange(12).reshape(3, 4)
print(x[1, 2])       # elemento único
print(x[:, 1])       # columna
print(x.view(2, 6))  # remodelar (contiguo)
print(x.unsqueeze(0

• reshape y view cambian la forma; view requiere memoria contigua.
• unsqueeze/squeeze añaden/eliminan dimensiones de tamaño 1.
• La dimensión del lote suele ser la primera: (lote, canales, altura, anchura).

6. Habilitar Rastreo de Gradientes

Los tensores que necesitan gradientes establecen requires_grad=True.

w = torch.tensor([2.0, 3.0], requires_grad=True)
loss = (w ** 2).sum()
loss.backward()
print(w.grad)  # tensor([4., 6.])

• .backward() calcula gradientes a través de autograd.
• .grad contiene el gradiente después de la retropropagación.
• Envuelve los parámetros en nn.Parameter para el entrenamiento del modelo.

Relacionado: Autograd - grafos computacionales

7. Construir una Capa con nn.Module

torch.nn proporciona bloques de construcción diferenciables.

import torch.nn as nn
 
layer = nn.Linear(10, 5)
x = torch.randn(32, 10)  # lote de 32
out = layer(x)
print(out.shape)  # (32, 5)
print(layer.weight.shape)  # (5, 10)

• nn.Linear aplica y = xW^T + b.
• La primera dimensión es siempre el tamaño del lote.
• Las capas son invocables: layer(x) ejecuta la computación hacia adelante.

Relacionado: Construcción de Modelos con nn.Module - modelos completos

Ejemplos intermedios

8. Paso de Entrenamiento Simple

Paso hacia adelante, pérdida, retropropagación y paso del optimizador manuales.

import torch.nn as nn
import torch.optim as optim
 
model = nn.Linear(10, 1)
optimizer = optim.SGD(model.parameters(), lr=0.01)
loss_fn = nn.MSELoss()
 
x = torch.randn(32

• zero_grad() borra los gradientes anteriores antes de cada paso.
• loss.item() extrae un float de Python de un tensor escalar.
• Este es el bucle interno de cada ejecución de entrenamiento.

Relacionado: Bucles de Entrenamiento - bucles de época completos

9. Guardar y Cargar Puntos de Control de Tensores

Persiste el estado del modelo para su uso posterior.

import torch.nn as nn
 
model = nn.Linear(10, 1)
torch.save(model.state_dict(), "linear.pt")
loaded = nn.Linear(10, 1)
loaded.load_state_dict(torch.load("linear.pt", weights_only=True))
loaded.eval()

• state_dict() guarda solo los parámetros aprendibles.
• weights_only=True (PyTorch 2.6+) evita la carga insegura de pickle.
• Llama a .eval() antes de la inferencia para deshabilitar el comportamiento de dropout.

Relacionado: Guardar, Cargar y Exportar - patrones completos de puntos de control

10. Compilar un Modelo con torch.compile

PyTorch 2.x puede optimizar modelos JIT para una ejecución más rápida.

import torch
import torch.nn as nn
 
model = nn.Sequential(nn.Linear(784, 256), nn.ReLU(), nn.Linear(256, 10))
model = torch.compile(model)
x = torch.randn(64, 784)
out = model(x)  

• torch.compile fusiona operaciones a través de TorchInductor.
• La primera pasada hacia adelante tiene sobrecarga de compilación.
• Las mejores ganancias se obtienen en GPU con inferencia repetida o bucles de entrenamiento.

Versiones de la pila: Esta página se escribió para Python 3.14.0 (estable 3.14, mantenimiento 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+ y uv 0.6+.