Fondamenti di PyTorch: Costruire e Addestrare Modelli

PyTorch usa di default l'esecuzione eager: i tensori fluiscono attraverso le operazioni Python e puoi stamparli, tagliarli, e debuggarli come dati ordinari. Questo conta nella finanza, dove metà del lavoro è rimodellare pannelli disordinati di feature e verificare che nessun look-ahead si infiltri nel tensore che dai in pasto al modello.

Confrontalo con il vecchio flusso di lavoro «costruisci un grafo statico, poi esegui una sessione». I ricercatori esportano ancora i modelli per il deployment, ma il lavoro quotidiano beneficia dell'immediatezza: cambia un layer, riesegui una cella, ispeziona le attivazioni.

Un tensore è un array multidimensionale; requires_grad=True marca le foglie per cui vuoi le derivate. Autograd registra le operazioni per costruire un grafo backward così che loss.backward() popola .grad sui parametri.

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)

Posiziona i tensori su cuda o mps quando disponibili; mantieni il posizionamento del device consistente così da non spostare accidentalmente piccoli tensori avanti e indietro ad ogni step.

Fai il subclassing di nn.Module, definisci i layer in __init__, e collegali in forward. La registrazione garantisce che i parametri appaiano in model.parameters() per gli optimizer.

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)

Per i modelli sequenziali, i layer nn.LSTM e nn.TransformerEncoder sono comuni; per l'alpha tabellare, MLP e gradient boosting competono ancora — scegli in base alla disciplina di validazione, non alla moda.

L'addestramento è ripetitivo apposta: forward, loss, zero grad, backward, step. I dettagli extra contano: model.train() contro model.eval() attiva/disattiva dropout e batch norm; torch.no_grad() avvolge la validazione per risparmiare memoria.

Fai il subclassing di Dataset per materializzare feature ed etichette; avvolgilo con DataLoader per il batching. Per i dati cronologici, generalmente mantieni shuffle=False sulla validazione e spesso anche sull'addestramento se ritagli finestre contigue — altrimenti spalmi informazione attraverso il tempo.

Se addestri su dati tick provenienti da GaiaEx o feed simili, allinea le barre a un unico orologio, gestisci esplicitamente le stampe mancanti, e versiona il tuo codice delle feature insieme al checkpoint del modello.

Per l'inferenza a bassa latenza, i team spesso tracciano o compilano lo script del modello, poi lo eseguono in un runtime C++ o in un servizio sidecar. Mantieni l'ambiente di addestramento (versioni delle librerie) fissato a qualsiasi cosa tu abbia usato per l'export.

PyTorch Lightning e framework simili riducono il codice boilerplate per l'addestramento multi-GPU e il logging; non sostituiscono un design attento delle feature. Il vantaggio nel trading di solito arriva dall'igiene dei dati e dalla consapevolezza del regime, non da un optimizer leggermente più sofisticato.