Temporal Fusion Transformer per la previsione multi-orizzonte di portafoglio

La frustrazione più grande nell'applicare il deep learning alla gestione del portafoglio è il problema della scatola nera. Addestri una rete neurale che produce Sharpe ratio impressionanti nei backtest, ma quando la strategia inizia a perdere denaro in produzione non hai idea del perche. Quali feature di input hanno guidato la previsione? Quali orizzonti temporali contano? Il modello stava reagendo a segnali macro o a rumore di microstruttura?

Google Research ha affrontato direttamente questo problema con il Temporal Fusion Transformer (TFT) -- un'architettura basata sull'attenzione che offre una solida previsione multi-orizzonte fornendo al contempo un'interpretabilità integrata attraverso i pesi di attenzione e i punteggi di importanza delle variabili. Nei benchmark originali, TFT ha ridotto la quantile loss del 7% (P50) e del 9% (P90) in media rispetto al modello immediatamente migliore, e ha migliorato la baseline concorrente più forte del 3-26% sui dataset di test. Per i gestori quantitativi di portafoglio, TFT offre qualcosa di raro: un modello che è al contempo potente e trasparente.

Questo articolo seziona l'architettura TFT, mostra come applicarla alla previsione multi-orizzonte di portafoglio, illustra un'implementazione Python con pytorch-forecasting e la confronta con le baseline LSTM e transformer classico.

Perche la previsione multi-orizzonte conta per i portafogli

La previsione tradizionale a singolo passo predice un valore al tempo $t+1$. Ma le decisioni di allocazione del portafoglio operano su più orizzonti contemporaneamente. Un gestore di portafoglio ha bisogno di sapere:

• Orizzonte di 1 giorno: per il ribilanciamento intraday e la gestione del rischio
• Orizzonte di 1 settimana: per gli spostamenti di allocazione tattica
• Orizzonte di 1 mese: per l'allocazione strategica e la rotazione settoriale
• Orizzonte di 1 trimestre: per il posizionamento guidato dalla macro

Ogni orizzonte ha caratteristiche di rapporto segnale-rumore diverse. I rendimenti a breve termine sono dominati dalla microstruttura e dall'order flow. I rendimenti a medio termine rispondono al momentum e al mean-reversion. I rendimenti a lungo termine sono guidati dai fondamentali e dai regimi macro.

Un modello che produce previsioni su tutti questi orizzonti contemporaneamente -- con stime a quantili dell'incertezza di previsione per ciascuno -- è fondamentalmente più utile di modelli separati per ogni orizzonte. Questo è esattamente ciò che TFT fornisce: data una finestra di encoder di osservazioni passate, restituisce un insieme di previsioni a quantili per $\tau = 1, 2, \ldots, \tau_{max}$ passi futuri.

Formalmente, data una serie temporale multivariata con osservazioni $\{y_{i,t}, \mathbf{x}_{i,t}, \mathbf{s}_i\}$ per l'entità $i$ al tempo $t$, dove $y$ è il target, $\mathbf{x}_t$ sono le feature variabili nel tempo e $\mathbf{s}_i$ sono i metadati statici, TFT apprende:

$\hat{y}_{i}(q, t, \tau) = f_q\left(y_{i,t-k:t}, \mathbf{x}_{i,t-k:t+\tau}, \mathbf{s}_i\right)$

dove $q$ è il quantile (che abilita previsioni probabilistiche), $k$ è la finestra di lookback e $\tau$ è l'orizzonte di previsione.

L'architettura TFT: lo stack completo

TFT non è un transformer generico appiccicato a una serie temporale. È un'architettura costruita su misura con cinque componenti specializzati, ciascuno dei quali affronta una sfida specifica nella previsione temporale.

1. Gated Residual Network (GRN)

La GRN è il blocco costruttivo fondamentale di TFT, usato in tutta l'architettura ovunque sia necessaria un'elaborazione non lineare. A differenza di un layer feed-forward standard, la GRN incorpora skip connection e meccanismi di gating che consentono alla rete di controllare in modo adattivo il flusso di informazioni.

Dato un input primario $\mathbf{a}$ e un vettore di contesto opzionale $\mathbf{c}$, la GRN calcola:

$\text{GRN}_\omega(\mathbf{a}, \mathbf{c}) = \text{LayerNorm}\left(\mathbf{a} + \text{GLU}_\omega(\boldsymbol{\eta}_1)\right)$

dove:

$\boldsymbol{\eta}_1 = \mathbf{W}_{1,\omega} \boldsymbol{\eta}_2 + \mathbf{b}_{1,\omega}$

$\boldsymbol{\eta}_2 = \text{ELU}\left(\mathbf{W}_{2,\omega} \mathbf{a} + \mathbf{W}_{3,\omega} \mathbf{c} + \mathbf{b}_{2,\omega}\right)$

La Gated Linear Unit (GLU) è il meccanismo di gating chiave:

$\text{GLU}(\boldsymbol{\gamma}) = \sigma(\mathbf{W}_{4} \boldsymbol{\gamma} + \mathbf{b}_4) \odot (\mathbf{W}_{5} \boldsymbol{\gamma} + \mathbf{b}_5)$

dove $\sigma$ è la funzione sigmoide e $\odot$ denota la moltiplicazione elemento per elemento. Il gate sigmoide apprende quali dimensioni dell'input sopprimere, consentendo al modello di saltare interamente l'elaborazione non lineare superflua quando i dati non la richiedono. Questo è cruciale per i dati finanziari, dove alcune feature sono informative solo in determinati regimi.

2. Variable Selection Network (VSN)

Questo è probabilmente il componente più prezioso per le applicazioni di portafoglio. I dataset finanziari sono notoriamente rumorosi, con decine di feature potenziali -- indicatori tecnici, rapporti fondamentali, variabili macro, punteggi di sentiment -- molti dei quali sono ridondanti o irrilevanti in un dato momento.

La VSN calcola pesi di selezione soft su tutte le feature di input:

$\mathbf{v}_{\chi_t} = \text{Softmax}\left(\text{GRN}_{v_\chi}\left(\boldsymbol{\Xi}_t, \mathbf{c}_s\right)\right)$

dove $\boldsymbol{\Xi}_t$ è il vettore appiattito di tutte le feature di input trasformate al tempo $t$, e $\mathbf{c}_s$ è un vettore di contesto derivato dai metadati statici. Ogni singola feature viene inoltre elaborata attraverso la propria GRN:

$\tilde{\boldsymbol{\xi}}^{(j)}_t = \text{GRN}_{\tilde{\xi}^{(j)}}\left(\boldsymbol{\xi}^{(j)}_t\right)$

La rappresentazione selezionata finale è la somma pesata:

$\tilde{\boldsymbol{\xi}}_t = \sum_{j=1}^{m_\chi} v_{\chi_t}^{(j)} \tilde{\boldsymbol{\xi}}^{(j)}_t$

In un contesto di portafoglio, $v_{\chi_t}^{(j)}$ ti dice direttamente: "al tempo $t$, il modello ha pesato la feature $j$ di questa quantità." Potresti scoprire che l'RSI domina durante i mercati laterali, mentre le feature macro della curva dei rendimenti dominano durante le transizioni di regime. Questa non è una spiegazione a posteriori -- è integrata nell'architettura.

Ci sono VSN separate per le covariate statiche, gli input osservati nel passato e gli input futuri noti. Questa separazione rispetta la struttura causale del problema di previsione: non puoi usare osservazioni future, ma puoi usare eventi futuri noti (date di pubblicazione degli utili, riunioni del FOMC, scadenze delle opzioni, effetti del giorno della settimana).

3. Static Covariate Encoder

Nella previsione di portafoglio, le covariate statiche rappresentano i metadati a livello di entità che non cambiano nel tempo: classe di attività, settore, borsa, fascia di capitalizzazione di mercato o regione geografica. TFT le elabora attraverso GRN dedicate per produrre quattro distinti vettori di contesto:

• $\mathbf{c}_s$ -- contesto per la selezione delle variabili temporali
• $\mathbf{c}_e$ -- contesto per l'arricchimento statico delle feature temporali (applicato dopo l'LSTM)
• $\mathbf{c}_c$ -- inizializzazione del cell state per l'LSTM
• $\mathbf{c}_h$ -- inizializzazione dell'hidden state per l'LSTM

È così che TFT gestisce l'informazione cross-sectional. Quando si prevede un portafoglio di 500 azioni, gli static encoder consentono al modello di apprendere che le azioni tecnologiche e quelle delle utility hanno dinamiche temporali fondamentalmente diverse, senza bisogno di modelli separati.

4. Elaborazione temporale: LSTM + Interpretable Multi-Head Attention

TFT utilizza una pipeline di elaborazione temporale a due stadi che combina i punti di forza delle architetture ricorrenti e di quelle basate sull'attenzione.

Stadio 1: elaborazione locale con LSTM

Un encoder-decoder LSTM sequence-to-sequence elabora la serie temporale per catturare pattern temporali locali -- momentum a breve termine, mean-reversion e struttura autoregressiva. L'encoder elabora la finestra di lookback; il decoder elabora gli input futuri noti. Entrambi vengono inizializzati con i vettori di contesto statici $\mathbf{c}_c$ (cell state) e $\mathbf{c}_h$ (hidden state).

Stadio 2: dipendenze a lungo raggio con Interpretable Multi-Head Attention

Dopo l'elaborazione locale, TFT applica un meccanismo di self-attention modificato per apprendere le dipendenze a lungo raggio. La modifica chiave riguarda il modo in cui le attention head vengono aggregate. La multi-head attention standard concatena gli output delle head:

$\text{MultiHead}(\mathbf{Q}, \mathbf{K}, \mathbf{V}) = [\text{head}_1; \ldots; \text{head}_H] \mathbf{W}_O$

TFT invece condivide i value tra le head e media i pesi di attenzione:

$\text{InterpretableMultiHead}(\mathbf{Q}, \mathbf{K}, \mathbf{V}) = \tilde{\mathbf{H}} \mathbf{W}_H$

$\tilde{\mathbf{H}} = \frac{1}{H} \sum_{h=1}^{H} \text{Attention}\left(\mathbf{Q} \mathbf{W}_Q^{(h)}, \mathbf{K} \mathbf{W}_K^{(h)}, \mathbf{V} \mathbf{W}_V\right)$

$\text{Attention}(\mathbf{Q}, \mathbf{K}, \mathbf{V}) = \text{Softmax}\left(\frac{\mathbf{Q} \mathbf{K}^\top}{\sqrt{d_{\text{attn}}}}\right) \mathbf{V}$

Nota: $\mathbf{W}_V$ non ha apice di head -- tutte le head condividono la stessa proiezione dei value. Questo significa che i pesi di attenzione di ciascuna head possono essere mediati e interpretati in modo significativo come punteggi di importanza temporale. Per una data previsione, puoi visualizzare esattamente quali passi temporali passati il modello osserva, e come i pattern di attenzione differiscono tra le head.

Per la previsione di portafoglio, questo rivela se il modello sta osservando l'azione recente dei prezzi (momentum), pattern storici lontani (stagionalità) o eventi specifici del calendario. Ogni head può specializzarsi in un diverso pattern temporale.

5. Quantile Output Layer

Il layer finale restituisce previsioni a quantili multipli, ottimizzate con la quantile loss:

$\mathcal{L}(\Omega) = \sum_{y_t \in \Omega} \sum_{q \in \mathcal{Q}} \sum_{\tau=1}^{\tau_{\max}} \frac{QL(y_t, \hat{y}(q, t-\tau, \tau), q)}{|\Omega| \cdot \tau_{\max}}$

$QL(y, \hat{y}, q) = q \max(0, y - \hat{y}) + (1 - q) \max(0, \hat{y} - y)$

dove $\mathcal{Q}$ è l'insieme dei quantili target (ad esempio $\{0.1, 0.5, 0.9\}$). Questo ti fornisce non solo una previsione puntuale, ma una stima a quantili dell'intervallo predittivo per ogni orizzonte. Per la gestione del rischio di portafoglio, le previsioni del 10° e del 90° percentile informano il dimensionamento delle posizioni e i livelli di stop-loss.

Un'avvertenza che vale la pena enunciare subito: minimizzare la pinball loss produce stime dei quantili condizionali, ma non garantisce una copertura out-of-sample calibrata. Su mercati non stazionari e con cambi di regime questi intervalli sono frequentemente mal calibrati -- l'intervallo nominale all'80% può coprire molto meno (o molto più) dell'80% delle realizzazioni. Tratta i quantili come stime da validare empiricamente con test di copertura/affidabilità, e restringili con la conformal prediction se hai bisogno di garanzie di copertura. Torniamo su questo nella sezione sulla produzione.

TFT vs LSTM vs transformer classico

Capire dove si colloca TFT rispetto alle altre architetture aiuta a decidere quando usarlo.

Quando l'LSTM vince ancora

Gli LSTM rimangono competitivi per la previsione a brevissimo termine (a livello di tick, sub-minuto), dove la finestra di lookback è corta e domina la struttura autoregressiva locale. Sono inoltre più semplici da mettere in produzione, con latenza inferiore in inferenza. Per un bot di market making che ha bisogno di previsioni sub-millisecondo, un LSTM è ancora la scelta pratica.

Quando i transformer classici non bastano

I transformer standard applicati in modo ingenuo a serie temporali finanziarie tendono spesso a fare overfitting. Mancano dei bias induttivi necessari per i dati temporali -- nessun concetto di feature statiche contro variabili nel tempo, nessuna selezione delle variabili, e la multi-head attention concatenata standard produce mappe di attenzione difficili da interpretare in modo significativo.

Quando TFT eccelle

TFT è ottimale quando hai: (1) molteplici tipi di input eterogenei, (2) dati cross-sectional (molte attività), (3) la necessità di previsioni probabilistiche multi-orizzonte e (4) un requisito di interpretabilità del modello. Questo descrive essenzialmente ogni problema istituzionale di previsione di portafoglio.

Implementazione Python con PyTorch Forecasting

Ecco un'implementazione pratica di TFT per la previsione dei rendimenti di un portafoglio multi-asset usando la libreria pytorch-forecasting.

Preparazione dei dati

Nota l'uso deliberato di autentici input futuri noti -- day_of_week, days_to_earnings, is_fomc, days_to_expiry. Si tratta di valori che conosciamo in anticipo per la finestra di previsione, e fornirli come known reals/categoricals è proprio la capacità di TFT attorno a cui è costruita l'architettura. Rimuoviamo il time_idx grezzo dai known reals: add_relative_time_idx=True inietta già un indice di posizione relativo, e un contatore monotono grezzo per lo più fa trapelare il trend.

import pandas as pd
import numpy as np
import lightning.pytorch as pl
from lightning.pytorch.callbacks import EarlyStopping, LearningRateMonitor
from lightning.pytorch.loggers import TensorBoardLogger

from pytorch_forecasting import (
    TimeSeriesDataSet,
    TemporalFusionTransformer,
    QuantileLoss,
    GroupNormalizer,
)


max_encoder_length = 60   # 60 trading days lookback (~3 months)
max_prediction_length = 20 # 20 trading days ahead (~1 month)

training_cutoff = df["time_idx"].max() - max_prediction_length

training = TimeSeriesDataSet(
    df[lambda x: x.time_idx <= training_cutoff],
    time_idx="time_idx",
    target="log_return",
    group_ids=["asset_id"],
    min_encoder_length=max_encoder_length // 2,
    max_encoder_length=max_encoder_length,
    min_prediction_length=1,
    max_prediction_length=max_prediction_length,

    static_categoricals=["sector", "market_cap_bucket"],

    time_varying_known_categoricals=["day_of_week", "is_fomc"],
    time_varying_known_reals=["days_to_earnings", "days_to_expiry"],

    time_varying_unknown_reals=[
        "log_return",
        "rsi_14",
        "macd",
        "bb_width",
        "pe_ratio",
        "earnings_yield",
        "vix",
        "yield_spread",
        "dxy",
    ],

    target_normalizer=GroupNormalizer(
        groups=["asset_id"],
        transformation="softplus",
    ),
    add_relative_time_idx=True,
    add_target_scales=True,
    add_encoder_length=True,
)

validation = TimeSeriesDataSet.from_dataset(
    training, df, predict=True, stop_randomization=True
)

batch_size = 64
train_dataloader = training.to_dataloader(
    train=True, batch_size=batch_size, num_workers=4
)
val_dataloader = validation.to_dataloader(
    train=False, batch_size=batch_size * 4, num_workers=4
)

Definizione e addestramento del modello

tft = TemporalFusionTransformer.from_dataset(
    training,
    learning_rate=1e-3,
    hidden_size=64,
    attention_head_size=4,
    dropout=0.1,
    hidden_continuous_size=32,
    output_size=7,  # 7 quantiles
    loss=QuantileLoss(quantiles=[0.02, 0.1, 0.25, 0.5, 0.75, 0.9, 0.98]),
    log_interval=10,
    optimizer="Ranger",
    reduce_on_plateau_patience=4,
)

print(f"Number of parameters: {tft.size() / 1e3:.1f}k")

early_stop_callback = EarlyStopping(
    monitor="val_loss",
    min_delta=1e-4,
    patience=10,
    verbose=False,
    mode="min",
)

lr_logger = LearningRateMonitor()
logger = TensorBoardLogger("lightning_logs")

trainer = pl.Trainer(
    max_epochs=100,
    accelerator="auto",
    enable_model_summary=True,
    gradient_clip_val=0.1,
    callbacks=[lr_logger, early_stop_callback],
    logger=logger,
)

trainer.fit(
    tft,
    train_dataloaders=train_dataloader,
    val_dataloaders=val_dataloader,
)

Estrazione degli output interpretabili

La chiamata di interpretabilità ha un requisito non ovvio: interpret_output() consuma il dict di output raw (con chiavi come encoder_variables, decoder_variables, static_variables, encoder_attention, ...), che predict() produce solo in modalità mode="raw". Calcolalo una volta, poi riutilizza lo stesso oggetto sia per l'importanza delle variabili sia per l'attenzione.

best_model_path = trainer.checkpoint_callback.best_model_path
best_tft = TemporalFusionTransformer.load_from_checkpoint(best_model_path)

raw_predictions, x = best_tft.predict(val_dataloader, mode="raw", return_x=True)

interpretation = best_tft.interpret_output(raw_predictions, reduction="sum")

best_tft.plot_interpretation(interpretation)

preds = raw_predictions.output["prediction"]

Dalle previsioni ai pesi di portafoglio

def forecasts_to_portfolio_weights(
    predictions: dict,
    index: pd.DataFrame,
    risk_aversion: float = 2.0,
) -> pd.DataFrame:
    """
    Convert TFT multi-horizon quantile forecasts into long-only portfolio
    weights using a mean-variance-INSPIRED score (not a full optimization:
    there is no covariance matrix here, only a per-asset risk-adjusted score).

    Uses the median forecast as the expected return and (q90 - q10) as a
    proxy for forecast uncertainty.
    """
    preds = predictions["prediction"]

    median_return = preds[:, :, 3].mean(dim=1).numpy()  # avg across horizons
    q90 = preds[:, :, 5].mean(dim=1).numpy()
    q10 = preds[:, :, 1].mean(dim=1).numpy()
    forecast_uncertainty = q90 - q10  # width of 80% PI

    scores = median_return / (risk_aversion * forecast_uncertainty + 1e-8)

    result = index[["asset_id"]].copy()
    result["score"] = scores
    result["raw_weight"] = np.maximum(scores, 0)  # long-only

    total = result["raw_weight"].sum()
    result["weight"] = result["raw_weight"] / (total + 1e-8)

    return result[["asset_id", "weight", "score"]]

Interpretabilità nella pratica: cosa rivela TFT sui mercati

Gli output di interpretabilità di TFT non sono curiosità accademiche -- forniscono informazioni utilizzabili ai gestori di portafoglio.

Importanza delle variabili tra i regimi

Quando esamini i pesi di selezione delle variabili nel tempo, emergono pattern che si allineano con l'intuizione di mercato:

• Durante il ciclo di rialzo dei tassi del 2022: le feature della curva dei rendimenti (yield_spread, fed_funds_rate) hanno dominato l'importanza delle variabili, rappresentando il 35-40% del peso di selezione. Gli indicatori tecnici sono scesi sotto il 10%.
• Durante il rally trainato dall'AI del 2024: le feature di momentum (rsi_14, macd) sono balzate in importanza. Anche le covariate statiche a livello settoriale sono diventate significative, dato che il rally era fortemente concentrato nella tecnologia.
• Durante i periodi laterali: gli indicatori di mean-reversion (bb_width, relative_value) hanno ricevuto i pesi più alti, mentre le feature trend-following sono state soppresse dal meccanismo di gating.

Questo è il gating della GRN in azione. Quando le feature di momentum non portano alcun segnale, i gate della GLU spingono il loro contributo verso lo zero, e il modello passa automaticamente a feature alternative. (Questi sono pattern illustrativi ricavati da run esplorativi, non risultati di benchmark -- verificali sui tuoi dati.)

Pattern di attenzione temporale

La visualizzazione dei pesi di attenzione rivela la struttura di memoria effettiva del modello:

• Picchi di attenzione a breve termine: una forte attenzione ai lag 1-5 riflette l'autocorrelazione e gli effetti di momentum/reversal a breve termine.
• Pattern settimanali: i picchi di attenzione ai lag 5, 10, 15 corrispondono agli effetti di calendario settimanali.
• Pattern mensili: un picco di attenzione costante intorno al lag 21 (un mese di trading) cattura i flussi di ribilanciamento mensile e gli effetti della scadenza delle opzioni.
• Ciclo degli utili: per i singoli titoli, l'attenzione mostra picchi netti a lag di circa 63 e 126 giorni, corrispondenti alle date trimestrali degli utili.

Questi pattern forniscono una validazione indipendente del fatto che il modello ha appreso una struttura temporale significativa piuttosto che adattarsi al rumore.

Prestazioni e applicazioni nel mondo reale

Risultati dei benchmark

Dal paper originale e dalla ricerca successiva, TFT dimostra prestazioni solide e ben documentate:

• Quantile loss più bassa del 7% per P50 e del 9% per P90 in media rispetto al modello immediatamente migliore sui dataset di benchmark del paper (electricity, traffic, retail, volatility), e miglioramento del 3-26% rispetto alla baseline concorrente più forte a seconda del dataset. Il concorrente specifico varia in base al dataset -- per esempio, DeepAR è tra le baseline più deboli su electricity e traffic ma più competitivo su retail e volatility -- quindi il numero in evidenza è il guadagno rispetto al modello immediatamente migliore, non rispetto a una singola baseline fissa.
• Supera costantemente le baseline classiche ARIMA, ETS e Prophet sulle metriche multi-orizzonte.

Direzioni di ricerca in finanza

TFT ha dato origine a una linea di ricerca attiva specifica per la finanza. Alcuni filoni rappresentativi, con le loro metriche effettivamente riportate (cita e riproduci prima di fare affidamento su una qualsiasi di esse):

• TFT adattivo / multi-scala per le criptovalute. Lavori come Adaptive Temporal Fusion Transformers for Cryptocurrency Price Prediction (arXiv:2509.10542) riportano miglioramenti rispetto alle baseline TFT a lunghezza fissa e LSTM nella previsione dei prezzi delle cripto. Tratta i numeri di redditività del trading come specifici del paper e dipendenti dal regime piuttosto che universali -- evitiamo deliberatamente di citare qui un delta di Sharpe assoluto, perche le cifre che circolano in letteratura spesso confondono l'accuratezza di previsione con lo Sharpe realizzato.
• Obiettivi Sharpe-aware. La linea di lavoro "multi-sensor TFT / adaptive Sharpe ratio" di MDPI Sensors ottimizza direttamente verso un obiettivo in stile Sharpe; nota che il suo risultato in evidenza è all'incirca un miglioramento del 18% nell'accuratezza di previsione dello Sharpe ratio, che è una quantità diversa da un aumento dello Sharpe assoluto.
• Modelli ibridi TFT-GNN. Combinare TFT con graph neural network per catturare le dipendenze tra le attività, con ibridi che si riporta superino il TFT autonomo nella previsione cross-sectional dei titoli.
• Fusione temporale cross-modale. Integrare dati di prezzo strutturati con dati non strutturati (notizie, trascrizioni delle earnings call) attraverso layer di fusione transformer, estendendo il paradigma TFT ai dati finanziari multimodali.

Queste direzioni sono reali, ma nessuna di esse è un vantaggio chiavi in mano. Riproduci le metriche sul tuo universo e sui tuoi costi prima di metterle in produzione.

Considerazioni pratiche per la produzione

Requisiti dei dati: TFT necessita di una quantità sostanziale di dati di addestramento. Pianifica almeno 2-3 anni di dati giornalieri per attività, oppure 6-12 mesi di dati orari. I dati cross-sectional (molte attività) aiutano considerevolmente -- addestrare su 500 titoli contemporaneamente è più efficace che addestrare 500 modelli separati.

Feature engineering: sebbene TFT esegua automaticamente la selezione delle variabili, la qualità delle feature candidate conta comunque. Includi un insieme di feature diversificato che spazi tra dati tecnici, fondamentali, macro e alternativi. Lascia che sia la VSN a determinare cosa è utile.

Costo computazionale: TFT è più costoso da addestrare rispetto a un LSTM ma comparabile ai transformer classici. Su una singola GPU A100, l'addestramento su 500 titoli con 3 anni di dati giornalieri richiede dell'ordine di poche ore per 100 epoche. L'inferenza è veloce -- generare previsioni per l'intero universo richiede ben meno di un secondo.

Valida la calibrazione, non darla per scontata. Prima che un qualsiasi quantile guidi il dimensionamento delle posizioni, controlla la copertura empirica su dati out-of-sample: l'intervallo nominale all'80% contiene effettivamente circa l'80% dei rendimenti realizzati? Su mercati non stazionari spesso non lo farà. Esegui i reliability diagram per orizzonte, e considera di avvolgere il modello nella conformal prediction per ripristinare le garanzie di copertura.

Adattamento ai regimi: TFT non modella esplicitamente i cambi di regime (a differenza degli HMM). Tuttavia, il meccanismo di gating fornisce un adattamento implicito ai regimi. In pratica, riaddestrare mensilmente con una finestra in espansione cattura efficacemente i cambiamenti strutturali.

Mitigazione dell'overfitting: i dati finanziari sono rumorosi e non stazionari. Usa una regolarizzazione aggressiva: dropout di 0.1-0.3, gradient clipping a 0.1, early stopping con una pazienza di 10-15 epoche. La walk-forward validation è essenziale -- non usare mai split casuali train/test su serie temporali.

Mettere tutto insieme: una pipeline di portafoglio basata su TFT

Una pipeline di produzione per la gestione del portafoglio basata su TFT si presenta così:

1. Ingestione dei dati: raccogli quotidianamente dati OHLCV, fondamentali, macro e alternativi. Calcola le feature (200+ candidate), incluso un autentico calendario futuro noto (utili, FOMC, scadenze, giorno della settimana).
2. Feature store: mantieni un feature store normalizzato e indicizzato nel tempo. Gestisci i dati mancanti, le corporate action e il survivorship bias.
3. Addestramento del modello: riaddestra TFT mensilmente usando la metodologia walk-forward. Usa i 3-5 anni di dati più recenti con una finestra in espansione.
4. Generazione delle previsioni: inferenza giornaliera che produce previsioni a quantili agli orizzonti di 1, 5, 10 e 20 giorni per l'intero universo di attività.
5. Controllo della calibrazione: traccia la copertura di ogni intervallo a quantili per orizzonte. Ricalibra (o applica un aggiustamento conformal) quando la copertura va alla deriva.
6. Dashboard di interpretabilità: visualizza l'importanza delle variabili e i pesi di attenzione. Segnala le anomalie (ad esempio, spostamenti improvvisi nell'importanza delle feature).
7. Ottimizzazione del portafoglio: converti le previsioni in pesi usando mean-variance, Black-Litterman o risk parity, con i quantili di TFT che forniscono gli input di rendimento e incertezza.
8. Overlay di rischio: usa le previsioni del 2° e 98° percentile per la valutazione del tail risk. Riduci le dimensioni delle posizioni quando gli intervalli di previsione si allargano.
9. Esecuzione: passa i pesi target al motore di esecuzione. Monitora il tracking error tra portafoglio target e realizzato.

Conclusione

Il Temporal Fusion Transformer rappresenta un autentico passo avanti per la gestione quantitativa del portafoglio. Non è solo l'ennesimo modello di deep learning lanciato sui dati finanziari -- è un'architettura progettata da zero per le sfide specifiche della previsione temporale multi-orizzonte: input eterogenei, struttura cross-sectional, output probabilistici e la necessità critica di interpretabilità.

Le variable selection network ti dicono cosa il modello sta osservando. I pesi di attenzione ti dicono quando sta guardando. I meccanismi di gating garantiscono che gestisca con eleganza le feature irrilevanti e i cambi di regime. E gli output a quantili ti forniscono stime di incertezza per la gestione del rischio -- a patto che tu ne validi la calibrazione invece di darla per buona sulla fiducia.

TFT non è una bacchetta magica. I mercati finanziari rimangono ambienti avversari in cui qualsiasi vantaggio predittivo è temporaneo e dipendente dal regime. Ma TFT fornisce un framework di principio per costruire sistemi di previsione che sono al contempo potenti e comprensibili -- e nel trading in produzione, capire perche il tuo modello sta facendo una scommessa è tanto importante quanto la scommessa stessa.

Riferimenti

1. Lim, B., Arik, S.O., Loeff, N., & Pfister, T. (2021). "Temporal Fusion Transformers for Interpretable Multi-horizon Time Series Forecasting." International Journal of Forecasting, 37(4), 1748-1764. arXiv:1912.09363
2. Oreshkin, B.N., Carpov, D., Chapados, N., & Bengio, Y. (2020). "N-BEATS: Neural basis expansion analysis for interpretable time series forecasting." ICLR 2020.
3. Salinas, D., Flunkert, V., Gasthaus, J., & Januschowski, T. (2020). "DeepAR: Probabilistic forecasting with autoregressive recurrent networks." International Journal of Forecasting, 36(3), 1181-1191.
4. pytorch-forecasting documentation -- TFT implementation with PyTorch Lightning.
5. google-research/tft -- Original TFT reference implementation.