Temporal Fusion Transformer untuk Peramalan Portofolio Multi-Horizon

Frustrasi terbesar dalam menerapkan deep learning pada manajemen portofolio adalah masalah kotak hitam. Anda melatih sebuah jaringan saraf yang menghasilkan rasio Sharpe yang mengesankan dalam backtest, tetapi ketika strategi mulai merugi di lingkungan produksi, Anda sama sekali tidak tahu mengapa. Fitur input mana yang menggerakkan ramalan? Horizon waktu mana yang penting? Apakah model bereaksi terhadap sinyal makro atau noise mikrostruktur?

Google Research mengatasi masalah ini secara langsung dengan Temporal Fusion Transformer (TFT) -- sebuah arsitektur berbasis attention yang menghasilkan peramalan multi-horizon yang kuat sekaligus menyediakan interpretabilitas bawaan melalui bobot attention dan skor pentingnya variabel. Dalam benchmark aslinya, TFT memangkas quantile loss sebesar 7% (P50) dan 9% (P90) rata-rata dibandingkan model terbaik berikutnya, dan meningkat 3-26% atas baseline pesaing terkuat di seluruh dataset uji. Bagi manajer portofolio kuantitatif, TFT menawarkan sesuatu yang langka: sebuah model yang sekaligus kuat dan transparan.

Tulisan ini membedah arsitektur TFT, menunjukkan cara menerapkannya pada peramalan portofolio multi-horizon, menelusuri implementasi Python dengan pytorch-forecasting, dan membandingkannya dengan baseline LSTM dan transformer biasa.

Mengapa Peramalan Multi-Horizon Penting untuk Portofolio

Peramalan satu langkah tradisional memprediksi satu nilai pada waktu $t+1$. Namun keputusan alokasi portofolio beroperasi pada beberapa horizon secara bersamaan. Seorang manajer portofolio perlu mengetahui:

• Horizon 1 hari: Untuk rebalancing intraday dan manajemen risiko
• Horizon 1 minggu: Untuk pergeseran alokasi taktis
• Horizon 1 bulan: Untuk alokasi strategis dan rotasi sektor
• Horizon 1 kuartal: Untuk pemosisian yang digerakkan oleh makro

Setiap horizon memiliki karakteristik signal-to-noise yang berbeda. Imbal hasil jangka pendek didominasi oleh mikrostruktur dan order flow. Imbal hasil jangka menengah merespons momentum dan mean-reversion. Imbal hasil jangka panjang digerakkan oleh fundamental dan rezim makro.

Sebuah model yang menghasilkan ramalan di seluruh horizon ini secara bersamaan -- dengan estimasi kuantil ketidakpastian ramalan pada masing-masing horizon -- secara fundamental lebih berguna daripada model terpisah untuk setiap horizon. Inilah persis yang disediakan TFT: dengan diberikan jendela encoder berisi observasi masa lalu, ia menghasilkan satu set ramalan kuantil untuk $\tau = 1, 2, \ldots, \tau_{max}$ langkah ke depan.

Secara formal, dengan diberikan deret waktu multivariat berisi observasi $\{y_{i,t}, \mathbf{x}_{i,t}, \mathbf{s}_i\}$ untuk entitas $i$ pada waktu $t$, di mana $y$ adalah target, $\mathbf{x}_t$ adalah fitur yang berubah terhadap waktu, dan $\mathbf{s}_i$ adalah metadata statis, TFT mempelajari:

$\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)$

di mana $q$ adalah kuantil (yang memungkinkan ramalan probabilistik), $k$ adalah jendela lookback, dan $\tau$ adalah horizon ramalan.

Arsitektur TFT: Tumpukan Lengkap

TFT bukanlah transformer generik yang sekadar ditempelkan pada deret waktu. Ia adalah arsitektur yang dibangun khusus dengan lima komponen terspesialisasi, masing-masing menangani tantangan spesifik dalam peramalan temporal.

1. Gated Residual Network (GRN)

GRN adalah blok pembangun fundamental dari TFT, digunakan di seluruh arsitektur di mana pun pemrosesan nonlinear dibutuhkan. Tidak seperti lapisan feed-forward standar, GRN menggabungkan skip connection dan mekanisme gating yang memungkinkan jaringan mengontrol aliran informasi secara adaptif.

Dengan diberikan input utama $\mathbf{a}$ dan vektor konteks opsional $\mathbf{c}$, GRN menghitung:

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

di mana:

$\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)$

Gated Linear Unit (GLU) adalah mekanisme gating kuncinya:

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

di mana $\sigma$ adalah fungsi sigmoid dan $\odot$ menyatakan perkalian elemen demi elemen. Gerbang sigmoid mempelajari dimensi input mana yang harus ditekan, memungkinkan model melewati pemrosesan nonlinear yang tidak diperlukan sepenuhnya ketika data tidak membutuhkannya. Ini krusial untuk data keuangan di mana beberapa fitur hanya informatif dalam rezim tertentu.

2. Variable Selection Network (VSN)

Inilah komponen yang bisa dibilang paling berharga untuk aplikasi portofolio. Dataset keuangan terkenal penuh noise, dengan puluhan fitur potensial -- indikator teknikal, rasio fundamental, variabel makro, skor sentimen -- yang banyak di antaranya redundan atau tidak relevan pada waktu tertentu.

VSN menghitung bobot seleksi lunak atas semua fitur input:

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

di mana $\boldsymbol{\Xi}_t$ adalah vektor terpipihkan dari semua fitur input yang telah ditransformasi pada waktu $t$, dan $\mathbf{c}_s$ adalah vektor konteks yang diturunkan dari metadata statis. Setiap fitur individual juga diproses melalui GRN-nya sendiri:

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

Representasi akhir yang terseleksi adalah jumlah berbobot:

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

Dalam konteks portofolio, $v_{\chi_t}^{(j)}$ secara langsung memberi tahu Anda: "pada waktu $t$, model memberi bobot sebesar ini pada fitur $j$." Anda mungkin menemukan bahwa RSI mendominasi selama pasar ranging, sementara fitur kurva imbal hasil makro mendominasi selama transisi rezim. Ini bukan penjelasan post-hoc -- ia tertanam langsung di dalam arsitektur.

Terdapat VSN terpisah untuk kovariat statis, input observasi masa lalu, dan input masa depan yang diketahui. Pemisahan ini menghormati struktur kausal dari masalah peramalan: Anda tidak dapat menggunakan observasi masa depan, tetapi Anda dapat menggunakan peristiwa masa depan yang diketahui (tanggal laba, rapat FOMC, kedaluwarsa opsi, efek hari dalam minggu).

3. Static Covariate Encoder

Dalam peramalan portofolio, kovariat statis mewakili metadata tingkat entitas yang tidak berubah terhadap waktu: kelas aset, sektor, bursa, bucket kapitalisasi pasar, atau wilayah geografis. TFT memproses ini melalui GRN khusus untuk menghasilkan empat vektor konteks yang berbeda:

• $\mathbf{c}_s$ -- konteks untuk seleksi variabel temporal
• $\mathbf{c}_e$ -- konteks untuk pengayaan statis dari fitur temporal (diterapkan setelah LSTM)
• $\mathbf{c}_c$ -- inisialisasi cell state untuk LSTM
• $\mathbf{c}_h$ -- inisialisasi hidden state untuk LSTM

Inilah cara TFT menangani informasi cross-sectional. Saat meramalkan portofolio berisi 500 saham, static encoder memungkinkan model mempelajari bahwa saham teknologi dan saham utilitas memiliki dinamika temporal yang secara fundamental berbeda, tanpa membutuhkan model terpisah.

4. Pemrosesan Temporal: LSTM + Interpretable Multi-Head Attention

TFT menggunakan pipeline pemrosesan temporal dua tahap yang menggabungkan kekuatan arsitektur rekuren dan berbasis attention.

Tahap 1: Pemrosesan Lokal dengan LSTM

Sebuah encoder-decoder LSTM sequence-to-sequence memproses deret waktu untuk menangkap pola temporal lokal -- momentum jangka pendek, mean-reversion, dan struktur autoregresif. Encoder memproses jendela lookback; decoder memproses input masa depan yang diketahui. Keduanya diinisialisasi dengan vektor konteks statis $\mathbf{c}_c$ (cell state) dan $\mathbf{c}_h$ (hidden state).

Tahap 2: Dependensi Jarak Jauh dengan Interpretable Multi-Head Attention

Setelah pemrosesan lokal, TFT menerapkan mekanisme self-attention yang dimodifikasi untuk mempelajari dependensi jarak jauh. Modifikasi kuncinya terletak pada cara head attention diagregasi. Multi-head attention standar menggabungkan keluaran head secara konkatenasi:

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

TFT sebagai gantinya berbagi value di seluruh head dan merata-ratakan bobot attention:

$\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}$

Perhatikan: $\mathbf{W}_V$ tidak memiliki superskrip head -- semua head berbagi proyeksi value yang sama. Ini berarti bobot attention dari setiap head dapat dirata-ratakan secara bermakna dan diinterpretasikan sebagai skor pentingnya temporal. Untuk suatu prediksi tertentu, Anda dapat memvisualisasikan secara tepat langkah waktu masa lalu mana yang diperhatikan model, dan bagaimana pola attention berbeda di antara head.

Untuk peramalan portofolio, ini mengungkapkan apakah model memperhatikan pergerakan harga terkini (momentum), pola historis yang jauh (musiman), atau peristiwa kalender tertentu. Setiap head dapat berspesialisasi pada pola temporal yang berbeda.

5. Lapisan Keluaran Kuantil

Lapisan terakhir menghasilkan prediksi pada beberapa kuantil, dioptimalkan dengan 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)$

di mana $\mathcal{Q}$ adalah himpunan kuantil target (misalnya, $\{0.1, 0.5, 0.9\}$). Ini memberi Anda bukan sekadar ramalan titik, melainkan estimasi kuantil dari interval prediktif pada setiap horizon. Untuk manajemen risiko portofolio, ramalan persentil ke-10 dan ke-90 menjadi masukan bagi penentuan ukuran posisi dan level stop-loss.

Satu catatan penting yang patut dinyatakan di awal: meminimalkan pinball loss menghasilkan estimasi kuantil bersyarat, tetapi hal itu tidak menjamin cakupan out-of-sample yang terkalibrasi. Pada pasar yang non-stasioner dan berganti rezim, interval-interval ini kerap salah terkalibrasi -- interval 80% nominal mungkin mencakup jauh lebih sedikit (atau lebih banyak) daripada 80% dari realisasi. Perlakukan kuantil sebagai estimasi yang harus divalidasi secara empiris dengan uji cakupan/reliabilitas, dan perketat dengan conformal prediction jika Anda membutuhkan jaminan cakupan. Kita akan kembali ke topik ini di bagian produksi.

TFT vs LSTM vs Transformer Biasa

Memahami di mana posisi TFT relatif terhadap arsitektur lain membantu dalam memutuskan kapan menggunakannya.

Kapan LSTM Masih Unggul

LSTM tetap kompetitif untuk peramalan jangka sangat pendek (tingkat tick, sub-menit) di mana jendela lookback pendek dan struktur autoregresif lokal mendominasi. LSTM juga lebih sederhana untuk di-deploy, dengan latensi lebih rendah dalam inferensi. Untuk bot market-making yang membutuhkan prediksi sub-milidetik, LSTM masih merupakan pilihan praktis.

Kapan Transformer Biasa Kurang Memadai

Transformer standar yang diterapkan secara naif pada deret waktu keuangan sering mengalami overfit. Mereka kekurangan bias induktif yang dibutuhkan untuk data temporal -- tidak ada konsep fitur statis vs yang berubah terhadap waktu, tidak ada seleksi variabel, dan multi-head attention terkonkatenasi standar menghasilkan peta attention yang sulit diinterpretasikan secara bermakna.

Kapan TFT Unggul

TFT optimal ketika Anda memiliki: (1) beberapa jenis input yang heterogen, (2) data cross-sectional (banyak aset), (3) kebutuhan akan ramalan probabilistik multi-horizon, dan (4) persyaratan akan interpretabilitas model. Ini menggambarkan pada dasarnya setiap masalah peramalan portofolio institusional.

Implementasi Python dengan PyTorch Forecasting

Berikut adalah implementasi praktis TFT untuk peramalan imbal hasil portofolio multi-aset menggunakan library pytorch-forecasting.

Persiapan Data

Perhatikan penggunaan input masa depan yang benar-benar diketahui secara sengaja -- day_of_week, days_to_earnings, is_fomc, days_to_expiry. Ini adalah nilai-nilai yang kita ketahui sebelumnya untuk jendela ramalan, dan memberikannya sebagai known reals/categoricals justru merupakan kapabilitas TFT yang menjadi pusat dari arsitektur ini. Kita membuang time_idx mentah dari known reals: add_relative_time_idx=True sudah menyuntikkan indeks posisi relatif, dan penghitung monoton mentah sebagian besar membocorkan tren.

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   # lookback 60 hari perdagangan (~3 bulan)
max_prediction_length = 20 # 20 hari perdagangan ke depan (~1 bulan)

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
)

Definisi dan Pelatihan Model

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 kuantil
    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,
)

Mengekstrak Keluaran yang Dapat Diinterpretasi

Pemanggilan interpretabilitas memiliki satu syarat yang tidak kentara: interpret_output() mengonsumsi dict keluaran mentah (dengan kunci seperti encoder_variables, decoder_variables, static_variables, encoder_attention, ...), yang hanya dihasilkan predict() di bawah mode="raw". Hitung sekali, lalu gunakan kembali objek yang sama baik untuk pentingnya variabel maupun attention.

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"]

Dari Ramalan ke Bobot Portofolio

def forecasts_to_portfolio_weights(
    predictions: dict,
    index: pd.DataFrame,
    risk_aversion: float = 2.0,
) -> pd.DataFrame:
    """
    Mengonversi ramalan kuantil multi-horizon TFT menjadi bobot portofolio
    long-only menggunakan skor BERINSPIRASI mean-variance (bukan optimisasi
    penuh: tidak ada matriks kovarians di sini, hanya skor yang disesuaikan
    risiko per-aset).

    Menggunakan ramalan median sebagai imbal hasil yang diharapkan dan
    (q90 - q10) sebagai proksi untuk ketidakpastian ramalan.
    """
    preds = predictions["prediction"]

    median_return = preds[:, :, 3].mean(dim=1).numpy()  # rata-rata lintas horizon
    q90 = preds[:, :, 5].mean(dim=1).numpy()
    q10 = preds[:, :, 1].mean(dim=1).numpy()
    forecast_uncertainty = q90 - q10  # lebar PI 80%

    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"]]

Interpretabilitas dalam Praktik: Apa yang Diungkap TFT tentang Pasar

Keluaran interpretabilitas dari TFT bukanlah keingintahuan akademis -- mereka menyediakan intelijen yang dapat ditindaklanjuti bagi manajer portofolio.

Pentingnya Variabel Lintas Rezim

Saat Anda memeriksa bobot seleksi variabel dari waktu ke waktu, muncul pola-pola yang selaras dengan intuisi pasar:

• Selama siklus kenaikan suku bunga 2022: fitur kurva imbal hasil (yield_spread, fed_funds_rate) mendominasi pentingnya variabel, menyumbang 35-40% dari bobot seleksi. Indikator teknikal turun di bawah 10%.
• Selama reli yang digerakkan AI pada 2024: fitur momentum (rsi_14, macd) melonjak pentingnya. Kovariat statis tingkat sektor juga menjadi signifikan karena reli sangat terkonsentrasi di teknologi.
• Selama periode range-bound: indikator mean-reversion (bb_width, relative_value) menerima bobot tertinggi, sementara fitur trend-following ditekan oleh mekanisme gating.

Inilah gating GRN dalam aksinya. Ketika fitur momentum tidak membawa sinyal, gerbang GLU menggiring kontribusinya menuju nol, dan model secara otomatis beralih ke fitur alternatif. (Ini adalah pola ilustratif dari run eksploratif, bukan hasil yang ter-benchmark -- verifikasi pada data Anda sendiri.)

Pola Attention Temporal

Visualisasi bobot attention mengungkap struktur memori efektif dari model:

• Puncak attention jangka pendek: Attention kuat pada lag 1-5 mencerminkan autokorelasi dan efek momentum/reversal jangka pendek.
• Pola mingguan: Lonjakan attention pada lag 5, 10, 15 berkaitan dengan efek kalender mingguan.
• Pola bulanan: Puncak attention yang konsisten di sekitar lag 21 (satu bulan perdagangan) menangkap aliran rebalancing bulanan dan efek kedaluwarsa opsi.
• Siklus laba: Untuk saham individual, attention menunjukkan lonjakan tajam pada lag ~63 dan ~126 hari, berkaitan dengan tanggal laba kuartalan.

Pola-pola ini menyediakan validasi independen bahwa model telah mempelajari struktur temporal yang bermakna alih-alih mencocokkan noise.

Performa dan Aplikasi Dunia Nyata

Hasil Benchmark

Dari makalah asli dan riset selanjutnya, TFT menunjukkan performa yang kuat dan terdokumentasi dengan baik:

• Quantile loss P50 7% lebih rendah dan P90 9% lebih rendah rata-rata dibandingkan model terbaik berikutnya di seluruh dataset benchmark makalah (listrik, lalu lintas, ritel, volatilitas), dan peningkatan 3-26% atas baseline pesaing terkuat bergantung pada dataset. Pesaing spesifiknya bervariasi menurut dataset -- misalnya, DeepAR termasuk di antara baseline yang lebih lemah pada listrik dan lalu lintas tetapi lebih kompetitif pada ritel dan volatilitas -- sehingga angka utamanya adalah keunggulan atas model terbaik berikutnya, bukan atas satu baseline tetap mana pun.
• Secara konsisten mengungguli baseline klasik ARIMA, ETS, dan Prophet pada metrik multi-horizon.

Arah Riset di Bidang Keuangan

TFT telah memunculkan jalur riset spesifik-keuangan yang aktif. Beberapa untaian representatif, beserta metrik yang sebenarnya dilaporkan (kutip dan reproduksi sebelum mengandalkan salah satunya):

• TFT adaptif / multi-skala untuk kripto. Karya seperti Adaptive Temporal Fusion Transformers for Cryptocurrency Price Prediction (arXiv:2509.10542) melaporkan peningkatan atas baseline TFT panjang-tetap dan LSTM pada prediksi harga kripto. Perlakukan angka profitabilitas trading sebagai spesifik-makalah dan bergantung-rezim alih-alih universal -- kami sengaja tidak mengutip delta Sharpe absolut di sini, karena angka-angka yang beredar dalam literatur sering mencampuradukkan akurasi prediksi dengan Sharpe yang terealisasi.
• Objektif yang sadar Sharpe. Untaian karya MDPI Sensors "multi-sensor TFT / adaptive Sharpe ratio" mengoptimalkan menuju objektif bergaya Sharpe secara langsung; perhatikan bahwa hasil utamanya kira-kira peningkatan 18% dalam akurasi prediksi rasio Sharpe, yang merupakan kuantitas berbeda dari peningkatan Sharpe absolut.
• Model hibrida TFT-GNN. Menggabungkan TFT dengan graph neural network untuk menangkap dependensi antar-aset, dengan hibrida yang dilaporkan mengungguli TFT mandiri pada prediksi saham cross-sectional.
• Fusi temporal lintas-modal. Mengintegrasikan data harga terstruktur dengan data tidak terstruktur (berita, transkrip earnings call) melalui lapisan fusi transformer, memperluas paradigma TFT ke data keuangan multimodal.

Arah-arah ini nyata, tetapi tidak satu pun dari mereka merupakan keunggulan siap pakai. Reproduksi metriknya pada universe dan biaya Anda sendiri sebelum men-deploy.

Pertimbangan Praktis untuk Produksi

Kebutuhan data: TFT membutuhkan data pelatihan yang substansial. Rencanakan setidaknya 2-3 tahun data harian per aset, atau 6-12 bulan data per jam. Data cross-sectional (banyak aset) sangat membantu -- melatih pada 500 saham secara bersamaan lebih efektif daripada melatih 500 model terpisah.

Feature engineering: Meskipun TFT melakukan seleksi variabel secara otomatis, kualitas fitur kandidat tetap penting. Sertakan himpunan fitur yang beragam mencakup data teknikal, fundamental, makro, dan alternatif. Biarkan VSN menentukan apa yang berguna.

Biaya komputasi: TFT lebih mahal untuk dilatih daripada LSTM tetapi sebanding dengan transformer biasa. Pada satu GPU A100, pelatihan pada 500 saham dengan 3 tahun data harian memakan waktu beberapa jam untuk 100 epoch. Inferensi cepat -- menghasilkan ramalan untuk seluruh universe memakan waktu jauh di bawah satu detik.

Validasi kalibrasi, jangan diasumsikan. Sebelum kuantil mana pun menggerakkan penentuan ukuran posisi, periksa cakupan empiris pada data out-of-sample: apakah interval 80% nominal benar-benar memuat ~80% dari imbal hasil terealisasi? Pada pasar non-stasioner, seringkali tidak. Jalankan reliability diagram per horizon, dan pertimbangkan membungkus model dengan conformal prediction untuk memulihkan jaminan cakupan.

Adaptasi rezim: TFT tidak memodelkan pergantian rezim secara eksplisit (tidak seperti HMM). Namun, mekanisme gating menyediakan adaptasi rezim implisit. Dalam praktik, melatih ulang setiap bulan dengan jendela yang meluas menangkap perubahan struktural secara efektif.

Mitigasi overfitting: Data keuangan penuh noise dan non-stasioner. Gunakan regularisasi yang agresif: dropout 0.1-0.3, gradient clipping pada 0.1, early stopping dengan patience 10-15 epoch. Validasi walk-forward sangat penting -- jangan pernah menggunakan pembagian train/test acak pada deret waktu.

Menyatukan Semuanya: Pipeline Portofolio Berbasis TFT

Sebuah pipeline produksi untuk manajemen portofolio berbasis TFT terlihat seperti ini:

1. Ingesti data: Kumpulkan data OHLCV, fundamental, makro, dan alternatif setiap hari. Hitung fitur (200+ kandidat), termasuk kalender masa depan yang benar-benar diketahui (laba, FOMC, kedaluwarsa, hari dalam minggu).
2. Feature store: Pelihara feature store yang ternormalisasi dan terindeks-waktu. Tangani data yang hilang, aksi korporasi, dan survivorship bias.
3. Pelatihan model: Latih ulang TFT setiap bulan menggunakan metodologi walk-forward. Gunakan data 3-5 tahun terkini dengan jendela yang meluas.
4. Pembangkitan ramalan: Inferensi harian yang menghasilkan ramalan kuantil pada horizon 1, 5, 10, dan 20 hari untuk seluruh universe aset.
5. Pemeriksaan kalibrasi: Lacak cakupan setiap interval kuantil per horizon. Kalibrasi ulang (atau terapkan penyesuaian conformal) ketika cakupan menyimpang.
6. Dashboard interpretabilitas: Visualisasikan pentingnya variabel dan bobot attention. Tandai anomali (mis., pergeseran mendadak dalam pentingnya fitur).
7. Optimisasi portofolio: Konversi ramalan menjadi bobot menggunakan mean-variance, Black-Litterman, atau risk parity, dengan kuantil TFT menyediakan masukan imbal hasil dan ketidakpastian.
8. Overlay risiko: Gunakan ramalan persentil ke-2 dan ke-98 untuk penilaian tail risk. Kurangi ukuran posisi ketika interval prediksi melebar.
9. Eksekusi: Teruskan bobot target ke mesin eksekusi. Pantau tracking error antara portofolio target dan yang terealisasi.

Kesimpulan

Temporal Fusion Transformer mewakili kemajuan yang sejati untuk manajemen portofolio kuantitatif. Ia bukan sekadar model deep learning lain yang dilemparkan ke data keuangan -- ia adalah arsitektur yang dirancang dari dasar untuk tantangan spesifik dari peramalan temporal multi-horizon: input yang heterogen, struktur cross-sectional, keluaran probabilistik, dan kebutuhan krusial akan interpretabilitas.

Variable selection network memberi tahu Anda apa yang diperhatikan model. Bobot attention memberi tahu Anda kapan ia melihat. Mekanisme gating memastikan ia menangani fitur tidak relevan dan perubahan rezim dengan anggun. Dan keluaran kuantil memberi Anda estimasi ketidakpastian untuk manajemen risiko -- asalkan Anda memvalidasi kalibrasinya alih-alih menerimanya begitu saja.

TFT bukanlah peluru perak. Pasar keuangan tetap merupakan lingkungan yang adversarial di mana keunggulan prediktif apa pun bersifat sementara dan bergantung-rezim. Namun TFT menyediakan kerangka kerja yang berprinsip untuk membangun sistem peramalan yang sekaligus kuat dan dapat dipahami -- dan dalam trading produksi, memahami mengapa model Anda mengambil suatu taruhan sama pentingnya dengan taruhan itu sendiri.

Referensi

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. dokumentasi pytorch-forecasting -- implementasi TFT dengan PyTorch Lightning.
5. google-research/tft -- implementasi referensi TFT asli.