Fundamentos do PyTorch: Construindo e Treinando Modelos

O PyTorch usa execução eager por padrão: os tensores fluem por operações do Python e você pode imprimir, cortar (slice) e depurar como faria com dados comuns. Isso importa em finanças, onde boa parte do trabalho é reorganizar painéis de atributos desorganizados e verificar que nenhum look-ahead se infiltra no tensor que você alimenta no modelo.

Compare isso com o antigo fluxo de “construir um grafo estático, depois rodar uma sessão”. Pesquisadores ainda exportam modelos para produção, mas o trabalho do dia a dia se beneficia da imediatez: mude uma camada, execute a célula de novo, inspecione as ativações.

Um tensor é um array multidimensional; requires_grad=True marca as folhas para as quais você quer derivadas. O Autograd registra as operações para construir um grafo de backward, de modo que loss.backward() preenche .grad nos 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)

Coloque os tensores em cuda ou mps quando disponível; mantenha a alocação de dispositivo consistente para não mover tensores pequenos de um lado para o outro a cada passo por acidente.

Crie uma subclasse de nn.Module, defina as camadas em __init__ e conecte-as em forward. O registro garante que os parâmetros apareçam em model.parameters() para os otimizadores.

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 sequência, as camadas nn.LSTM e nn.TransformerEncoder são comuns; para alpha em dados tabulares, MLPs e gradient boosting continuam competindo — escolha com base em disciplina de validação, não em tendência.

O treinamento é repetitivo de propósito: forward, loss, zero grad, backward, step. Os detalhes extras importam: model.train() vs model.eval() alterna dropout e batch norm; torch.no_grad() envolve a validação para economizar memória.

Crie uma subclasse de Dataset para materializar atributos e rótulos; envolva com DataLoader para o agrupamento em batches. Para dados cronológicos, normalmente mantenha shuffle=False na validação e, muitas vezes, também no treinamento, se você estiver cortando janelas contíguas — caso contrário, você espalha informação através do tempo.

Se você treinar com dados de tick da GaiaEx ou feeds parecidos, alinhe as barras a um único relógio, trate explicitamente as cotações ausentes e versione o código dos atributos junto com o checkpoint do modelo.

Para inferência de baixa latência, as equipes costumam rastrear (trace) ou converter em script o modelo, e então executá-lo em um runtime C++ ou em um serviço auxiliar (sidecar). Mantenha o ambiente de treinamento (versões das bibliotecas) fixado no que você usou para exportar.

O PyTorch Lightning e frameworks parecidos reduzem código repetitivo para treinamento multi-GPU e logging; eles não substituem um bom design de atributos. A vantagem competitiva em trading normalmente vem da higiene dos dados e da percepção de regime de mercado, não de um otimizador ligeiramente mais sofisticado.