Fundamentos de PyTorch: construir y entrenar modelos

PyTorch usa por defecto la ejecución eager: los tensores fluyen a través de operaciones de Python y puedes imprimir, recortar y depurar como datos ordinarios. Esto importa en finanzas, donde la mitad del trabajo es remodelar paneles desordenados de características y verificar que ninguna mirada al futuro (look-ahead) se cuele en el tensor que alimentas al modelo.

Contrasta esto con el antiguo flujo de trabajo de «construir un grafo estático, luego ejecutar una sesión». Los investigadores todavía exportan modelos para el despliegue, pero el trabajo diario se beneficia de la inmediatez: cambia una capa, vuelve a ejecutar una celda, inspecciona las activaciones.

Un tensor es un array multidimensional; requires_grad=True marca las hojas para las que quieres derivadas. Autograd registra las operaciones para construir un grafo hacia atrás de forma que loss.backward() rellena .grad en los parámetros.

import torch
x = torch.randn(32, 10, requires_grad=True)
w = torch.randn(10, 1, requires_grad=True)
y = (x @ w).mean()
y.backward()
print(w.grad.shape)

Coloca los tensores en cuda o mps cuando estén disponibles; mantén la colocación de dispositivos consistente para no mover accidentalmente tensores pequeños de un lado a otro en cada paso.

Crea una subclase de nn.Module, define las capas en __init__, y conéctalas en forward. El registro asegura que los parámetros aparecen en model.parameters() para los optimizadores.

import torch.nn as nn

class MLP(nn.Module):
    def __init__(self, n):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(n, 64), nn.ReLU(), nn.Linear(64, 1)
        )
    def forward(self, x):
        return self.net(x)

Para modelos de secuencias, las capas nn.LSTM y nn.TransformerEncoder son habituales; para alfa tabular, los MLP y el gradient boosting todavía compiten —elige por disciplina de validación, no por tendencia.

El entrenamiento es repetitivo a propósito: forward, loss, zero grad, backward, step. Los extras importan: model.train() frente a model.eval() activan o desactivan el dropout y el batch norm; torch.no_grad() envuelve la validación para ahorrar memoria.

Crea una subclase de Dataset para materializar características y etiquetas; envuélvela con DataLoader para el procesamiento por lotes. Para datos cronológicos, normalmente mantén shuffle=False en la validación y a menudo también en el entrenamiento si recortas ventanas contiguas —de lo contrario difuminas información a través del tiempo.

Si entrenas con datos tick de GaiaEx o feeds similares, alinea las barras a un único reloj, gestiona explícitamente las impresiones ausentes, y versiona tu código de características junto al checkpoint del modelo.

Para la inferencia de baja latencia, los equipos a menudo trazan (trace) o escriben (script) el modelo, y después lo ejecutan en un runtime de C++ o un servicio auxiliar (sidecar). Mantén el entorno de entrenamiento (versiones de bibliotecas) fijado a lo que usaste para exportar.

PyTorch Lightning y frameworks similares reducen el código repetitivo para el entrenamiento multi-GPU y el registro; no sustituyen un diseño cuidadoso de características. La ventaja en el trading normalmente viene de la higiene de datos y la conciencia de régimen, no de un optimizador ligeramente más sofisticado.