AutoML untuk Pipeline Perdagangan Sistematis

Blog ini telah lama membahas cara mencari: sampler mana yang akan digunakan dan kapan (crossover adalah biaya eval), cara memberi harga pada penelusuran yang Anda jalankan (Rasio Sharpe yang Dikempiskan), cara menilai prosedur seleksi itu sendiri (PBO), dan tempat seluruh peralatan mendarat dengan jujur (tidak ada keunggulan yang kuat).

Apa yang tidak pernah dicakupnya adalah apa yang Anda cari lebih. Semua artikel tersebut mengambil rangkaian fitur dan kelompok strategi sebagaimana adanya dan mengoptimalkan parameter di dalamnya. AutoML menyerang lapisan di atasnya — ini mengotomatiskan konstruksi kandidat itu sendiri. Tiga bagiannya tidak muncul di tempat lain di blog ini:

1. Ekstraksi fitur otomatis — tsfresh mengubah satu rangkaian harga menjadi ~794 fitur yang dikarakterisasi secara statistik, dan Featuretools menyusun fitur di seluruh tabel pasar terkait melalui Sintesis Fitur Mendalam.
2. AutoML yang sadar anggaran — Pengoptimalan Hemat Biaya FLAML, yang menemukan model terbaik sesuai anggaran komputasi dan bukannya tanpa memperhitungkan biaya.
3. Pabrik alfa yang diformulasikan — 101 Alfa Formula dari WorldQuant sebagai tata bahasa operator yang dapat dikomposisi dan dapat dihitung oleh mesin.

Segala sesuatu yang lain - fungsi tujuan, skema validasi, koreksi pengujian ganda - sudah diukur di tempat lain di sini, jadi artikel ini menghubungkan daripada mengajarkan kembali. Hal ini lebih penting dari biasanya, karena AutoML membuat jumlah uji coba melonjak, dan jumlah uji coba sama persis dengan keseluruhan cerita.

Apa yang Diotomatiskan AutoML

AutoML bukanlah algoritma tunggal. Ini adalah serangkaian teknik yang mengotomatiskan berbagai tahapan pipeline:

Premisnya adalah bahwa dalam perdagangan sistematis, ruang kandidat sangat besar — ​​satu seri OHLCV menghasilkan ratusan fitur teknis, dan banyak aset, data buku pesanan, dan sumber alternatif menjadikannya kombinatorial. Premisnya juga mengandung bahaya: setiap kandidat adalah sebuah ujian, dan ujian itulah yang menghasilkan penemuan-penemuan palsu.

Satu poin khusus AutoML pada tujuan: metrik yang dimaksimalkan penelusuran haruslah metrik finansial, karena penelusuran akan mengoptimalkan persis apa yang Anda tulis dan tidak ada yang Anda maksudkan. Skalar mana yang Anda pilih akan menentukan strategi Anda secara diam-diam — lihat Desain Fungsi-Tujuan, di mana Sharpe per-perdagangan yang naif memahkotai lotere eksposur sub-5% pada 56% dari 600 benih dan memposting Sharpe dalam sampel sebanyak 21 yang menyusut menjadi 0,13 dari sampel. Masukkan metrik keuangan ke dalam pencetak gol AutoML dari awal; jangan optimalkan roc_auc dan berharap itu ditransfer.

Rekayasa Fitur Otomatis

Rekayasa fitur adalah tempat sebagian besar alfa berada. Data harga mentah sama untuk semua orang. Transformasi data tersebut menjadi sinyal prediktif inilah yang membedakan strategi yang menguntungkan dan strategi yang tidak menguntungkan.

tsfresh: Dari Seri Satu Harga hingga 800+ Fitur

segar (Ekstraksi Fitur Rangkaian Waktu berdasarkan Uji Hipotesis yang Dapat Diskalakan) dibuat khusus untuk ekstraksi fitur rangkaian waktu. Ini menghitung 63 metode karakterisasi yang diperluas menjadi ~794 fitur secara default, termasuk:

• Momen statistik (mean, varians, skewness, kurtosis)
• Autokorelasi pada beberapa lag
• Koefisien Fourier dan energi spektral
• Ukuran kompleksitas (perkiraan entropi, entropi sampel)
• Fitur nonlinier (koefisien Friedrich, titik tetap maks Langevin)
• Ubah jumlah kuantil dan rentang

Untuk data keuangan, ini berarti satu rangkaian harga menghasilkan ratusan kandidat fitur — banyak di antaranya yang menangkap dinamika yang mungkin terlewatkan oleh rekayasa fitur manual. Ini adalah pendekatan yang sangat berbeda dari rangkaian fitur buatan tangan yang berasal dari domain yang digunakan dalam spread modeling dan DeepLOB: di mana manusia memutuskan bahwa ketidakseimbangan order-book itu penting; di sini perpustakaan menyebutkan semuanya dan membiarkan uji hipotesis memutuskan.

import pandas as pd
import numpy as np
from tsfresh import extract_features, select_features
from tsfresh.utilities.dataframe_functions import impute

def prepare_rolling_windows(df: pd.DataFrame, window_size: int = 20) -> pd.DataFrame:
    """Convert OHLCV DataFrame into rolling windows for tsfresh."""
    records = []
    for i in range(window_size, len(df)):
        window = df.iloc[i - window_size:i].copy()
        window["id"] = i  # window identifier
        window["time"] = range(window_size)
        records.append(window[["id", "time", "close", "volume", "high", "low"]])
    return pd.concat(records, ignore_index=True)

df_ohlcv = pd.read_csv("btc_1h.csv", parse_dates=["timestamp"])
df_rolled = prepare_rolling_windows(df_ohlcv, window_size=24)

features = extract_features(
    df_rolled,
    column_id="id",
    column_sort="time",
    n_jobs=8,  # parallel extraction
    disable_progressbar=False,
)

impute(features)

y = df_ohlcv["close"].pct_change(4).shift(-4).iloc[24:].reset_index(drop=True)
y_binary = (y > 0).astype(int)

features_selected = select_features(features, y_binary, fdr_level=0.05)
print(f"Selected {features_selected.shape[1]} features from {features.shape[1]}")

Itu select_features fungsi ini menerapkan prosedur Benjamini-Yekutieli untuk mengontrol tingkat penemuan palsu di seluruh baterai fitur — yang merupakan naluri yang benar, dan naluri yang sama juga diterapkan pada Artikel Deflated Sharpe untuk penelusuran strategi. Perhatikan apa yang tidak dilakukannya: Kontrol FDR pada langkah pemilihan fitur tidak menjelaskan apa pun tentang biaya uji coba pencarian model berikutnya. Itu adalah dua kelipatan yang terpisah dan keduanya harus dibayar.

Alat Fitur: Sintesis Fitur Mendalam

Meskipun tsfresh berfokus pada karakterisasi deret waktu, Alat Fitur unggul dalam rekayasa fitur relasional — membuat fitur dengan menyusun operasi primitif di seluruh tabel terkait.

Untuk perdagangan, ini berguna bila Anda memiliki data multi-tabel: riwayat perdagangan, cuplikan buku pesanan, tingkat pendanaan, dan metrik on-chain. Featuretools menerapkan Sintesis Fitur Mendalam (DFS), yang menumpuk primitif transformasi dan agregasi:

import featuretools as ft

es = ft.EntitySet(id="crypto_trading")

es = es.add_dataframe(
    dataframe_name="candles",
    dataframe=df_candles,
    index="candle_id",
    time_index="timestamp",
)

es = es.add_dataframe(
    dataframe_name="orderbook",
    dataframe=df_orderbook,
    index="snapshot_id",
    time_index="timestamp",
)

es = es.add_dataframe(
    dataframe_name="funding",
    dataframe=df_funding,
    index="funding_id",
    time_index="timestamp",
)

feature_matrix, feature_defs = ft.dfs(
    entityset=es,
    target_dataframe_name="candles",
    agg_primitives=["mean", "std", "max", "min", "skew", "trend"],
    trans_primitives=["percentile", "diff", "cum_mean"],
    max_depth=2,  # compose up to 2 primitives deep
    features_only=False,
)

print(f"Generated {len(feature_defs)} features via DFS")

Itu time_index deklarasi bersifat memuat: inilah yang memungkinkan Featuretools menghitung agregasi hanya dengan menggunakan baris yang ada pada batas waktu. Lakukan kesalahan dan DFS akan dengan senang hati membuat fitur di masa depan — contoh data relasional dari kebocoran yang dikatalogkan dalam taksonomi bias lihat ke depan.

Kombinasi tsfresh (karakterisasi rangkaian waktu) dan Featuretools (sintesis relasional) memberi Anda pabrik fitur yang menghasilkan ribuan kandidat sinyal dari data pasar mentah tanpa pengkodean indikator manual.

AutoML Sadar Anggaran: FLAML

Kami mengasumsikan Optuna dan Estimator Parzen Terstruktur Pohon sebagai latar belakang — derivasi, perbandingan sampel, dan tolok ukur ada di Penurunan Koordinat vs Optimasi Bayesian. Pada yang mana sampler yang harus dijangkau, pengukuran milik blog ini adalah referensinya dan ini bukan jawaban cerita rakyat: persilangan diatur oleh biaya evaluasi, bukan kepintaran algoritma — ketika backtest hampir gratis, Sobol yang diacak menang dalam hal throughput (~2.830 cfg/s melawan ~154 untuk TPE), dan hanya evaluasi mahal yang membuat efisiensi sampel membayar (Acak vs Cerdas Pencarian).

Pembingkaian itulah yang menjadikan FLAML sebagai sumbu yang berbeda dibandingkan sampler pesaing. Optuna bertanya di mana harus mengambil sampel selanjutnya; NYALA (AutoML Ringan Cepat) menanyakan apa yang mampu saya sampel. Ini mengoptimalkan model terbaik dalam waktu atau menghitung anggaran menggunakan CFO (Cost-Frugal Optimization), yang memprioritaskan konfigurasi murah untuk dievaluasi lebih awal dan meningkat hanya ketika perkiraan keuntungan marjinal membenarkan pengeluaran tersebut.

from flaml import AutoML
from sklearn.metrics import make_scorer
import numpy as np

def sharpe_score(y_true, y_pred):
    """Custom scorer: Sharpe ratio of predicted signals."""
    signal = np.sign(y_pred - 0.5)
    returns = signal * y_true  # y_true contains forward returns
    if returns.std() == 0:
        return 0.0
    return np.sqrt(252) * returns.mean() / returns.std()

sharpe_scorer = make_scorer(sharpe_score, greater_is_better=True)

automl = AutoML()
automl_settings = {
    "time_budget": 300,          # 5 minutes
    "metric": sharpe_scorer,     # optimize the financial objective, not accuracy
    "task": "classification",
    "estimator_list": [
        "lgbm", "xgboost", "rf", "extra_tree", "catboost",
    ],
    "eval_method": "cv",
    "split_type": "time",        # time series split (no future leakage)
    "n_splits": 5,
    "log_file_name": "flaml_trading.log",
    "seed": 42,
}

automl.fit(
    X_train=X_train,
    y_train=y_train,
    **automl_settings,
)

print(f"Best model: {automl.best_estimator}")
print(f"Best config: {automl.best_config}")

from flaml.data import get_output_from_log
time_history, best_valid_loss_history, valid_loss_history, config_history, metric_history = \
    get_output_from_log(filename="flaml_trading.log", time_budget=300)

Keuntungan FLAML untuk perdagangan adalah alokasi komputasi di seluruh jenis model yang heterogen. Jika konfigurasi LightGBM dievaluasi 10x lebih cepat dibandingkan CatBoost, FLAML mengeksplorasi lebih banyak LightGBM lebih awal dan beralih hanya jika memperkirakan peningkatan marjinal yang sesuai dengan biayanya. Itulah wawasan rezim murahan dari artikel crossover, yang digeneralisasikan: throughput adalah istilah kelas satu dalam anggaran pencarian, bukan detail implementasi.

Log lintasan adalah bagian yang patut disimpan. get_output_from_log memberi Anda riwayat konfigurasi lengkap, yang merupakan jumlah uji coba Anda — dan jumlah uji coba adalah masukan untuk setiap deflasi yang harus Anda bayar.

Pencarian Arsitektur Neural untuk Model Perdagangan

Penelusuran Arsitektur Neural mengotomatiskan desain topologi jaringan, bukan penyetelan topologi tetap. Pilihan arsitektur untuk rangkaian finansial benar-benar tidak jelas — non-stasioneritas, signal-to-noise yang rendah, frekuensi campuran, dan ketergantungan yang mencakup beberapa menit hingga berbulan-bulan, semuanya mengarah ke arah yang berbeda — namun motivasi tersebut telah diperdebatkan secara konkret di tempat lain: lihat Temporal Fusion Transformer ketika TFT mengalahkan LSTM mengalahkan Vanilla Transformer, dan DeepLOB tentang trade-off CNN+Inception+LSTM, untuk apa yang telah dicapai oleh arsitektur tetap yang dirancang dengan cermat dan cermat. NAS adalah argumen bahwa pilihan ini sendiri harus dicari.

Penelitian tentang Neuroevolution NAS untuk Prediksi Return Saham melaporkan bahwa RNN yang berevolusi melalui EXAMM (Evolutionary eXploration of Augmenting Memory Models) mengungguli DJI dan S&P 500 di pasar bearish (2022) dan bull (2023) dengan menggunakan strategi panjang-pendek yang sederhana. Perlakukan hal tersebut sebagai klaim pihak ketiga, bukan sebagai hasil yang direproduksi di sini — ini adalah angka penelusuran terbaik tanpa ada laporan deflasi.

Ruang Pencarian NAS untuk Perdagangan

Ruang pencarian NAS yang praktis untuk model perdagangan meliputi:

Search Space:
  - Cell types: {LSTM, GRU, Temporal Conv, Transformer block, Linear}
  - Number of layers: [1, 8]
  - Hidden dimensions: {32, 64, 128, 256}
  - Attention heads (if Transformer): {2, 4, 8}
  - Dropout rate: [0.0, 0.5]
  - Skip connections: {True, False}
  - Normalization: {BatchNorm, LayerNorm, None}
  - Activation: {ReLU, GELU, SiLU, Mish}
  - Lookback window: {20, 60, 120, 252}

Dengan NNI (Neural Network Intelligence) dari Microsoft, Anda dapat menentukan dan mencari ruang ini:

import nni
from nni.nas.nn.pytorch import LayerChoice, InputChoice
import torch
import torch.nn as nn

class TradingNASModel(nn.Module):
    """NAS-searchable model for financial time series."""

    def __init__(self, input_dim: int, seq_len: int):
        super().__init__()
        self.input_proj = nn.Linear(input_dim, 128)

        self.temporal_block = LayerChoice([
            nn.LSTM(128, 128, num_layers=2, batch_first=True, dropout=0.1),
            nn.GRU(128, 128, num_layers=2, batch_first=True, dropout=0.1),
            nn.TransformerEncoder(
                nn.TransformerEncoderLayer(d_model=128, nhead=4, batch_first=True),
                num_layers=2,
            ),
        ], label="temporal_cell")

        self.head = LayerChoice([
            nn.Sequential(nn.Linear(128, 64), nn.ReLU(), nn.Linear(64, 1)),
            nn.Sequential(nn.Linear(128, 32), nn.GELU(), nn.Linear(32, 1)),
            nn.Linear(128, 1),
        ], label="prediction_head")

        self.skip = InputChoice(n_candidates=2, n_chosen=1, label="skip_conn")
        self.skip_proj = nn.Linear(input_dim, 128)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        h = self.input_proj(x)
        out = self.temporal_block(h)

        if isinstance(out, tuple):
            out = out[0]

        last = out[:, -1, :]

        skip_val = self.skip_proj(x[:, -1, :])
        last = self.skip([last, last + skip_val])

        return self.head(last).squeeze(-1)

Algoritme pencarian (ENAS, DARTS, atau evolusioner) mengevaluasi kandidat arsitektur pada set validasi menggunakan tujuan finansial, kemudian secara progresif mempersempit topologi berperforma tinggi. Perhatikan asimetri biaya dibandingkan semua hal lain dalam artikel ini: NAS berada di ujung sumbu eval-cost yang paling mahal, yaitu sistem di mana pengambilan sampel yang efisien sampel dan pemangkasan multi-fidelitas benar-benar menghasilkan keuntungan.

Pendekatan Pabrik WorldQuant Alpha

Pendekatan WorldQuant terhadap penemuan alfa adalah penerapan prinsip AutoML di bidang keuangan yang paling berskala industri. Didirikan oleh Igor Tulchinsky, WorldQuant mengoperasikan apa yang mereka sebut sebagai "pabrik alfa" — sebuah proses sistematis untuk menghasilkan, menguji, dan menggabungkan jutaan sinyal prediktif.

Filsafat: Generasi Alfa Eksponensial dan Koreksinya

WorldQuant menetapkan target pada tahun 2010 untuk mencapai satu juta alfa, pada saat mereka hanya memproduksi beberapa ribu alfa per tahun. Mereka mencapai target tersebut pada tahun 2016. Filosofi ini bertumpu pada hukum dasar manajemen aktif:

$IR \approx IC \cdot \sqrt{BR}$

Di mana $IR$ adalah rasio informasi, $IC$ koefisien informasi, dan $BR$ luasnya — jumlah taruhan independen. Setiap individu $\alpha_i$ merupakan prediktor yang lemah; klaimnya adalah bahwa menggabungkan IC yang berkorelasi cukup lemah akan menghasilkan IC yang kecil menjadi keuntungan yang disesuaikan dengan risiko.

Koreksi yang membuat atau menghancurkan hal ini, dan yang disembunyikan oleh pembacaan rumus yang naif: luasnya bukan hitungan percobaan. $BR$ menghitung taruhan independen, dan alfa yang dihasilkan tidak independen — mereka terdiri dari operator yang sama pada bidang harga dan volume yang sama, sehingga mereka mewarisi struktur korelasi satu sama lain. Blog ini mengukur efeknya secara langsung di Korelasi Sinyal: luas efektifnya adalah $N_{eff} = N / C_f$, dan dengan faktor korelasi kripto yang khas $C_f \approx 3$, sepuluh sinyal bernilai sekitar 3,3 sinyal independen. Itu $\sqrt{BR}$ jangka waktu tidak bertambah seiring dengan banyaknya alfa yang Anda hasilkan; itu tumbuh seiring dengan berapa banyak tidak berkorelasi yang bertahan. Satu juta alpha yang berkorelasi memberi Anda jauh lebih sedikit daripada formula yang diiklankan.

Inilah sebabnya mengapa langkah 3 di bawah ini — dekorelasi terhadap perpustakaan yang ada — bukanlah langkah yang higienis di pabrik alfa. Ini adalah langkah pertama yang menghasilkan keluasan.

101 Formula Alfa

Makalah "101 Formula Alfa" oleh Kakushadze (terkait dengan penelitian WorldQuant) menerbitkan serangkaian ekspresi alfa formula — ekspresi matematika atas harga, volume, dan data fundamental:

Alpha#1:  (rank(Ts_ArgMax(SignedPower(((returns < 0) ? stddev(returns, 20)
          : close), 2.), 5)) - 0.5)

Alpha#7:  ((adv20 < volume) ? ((-1 * ts_rank(abs(delta(close, 7)), 60))
          * sign(delta(close, 7))) : (-1 * 1))

Alpha#42: (rank(vwap - close) / rank(vwap + close))

Apa yang membuat AutoML menarik adalah tata bahasa. Alfa adalah komposisi dari himpunan operator kecil (rank, delta, ts_rank, stddev, correlation, signedpower) pada kumpulan bidang kecil (close, volume, vwap, returns, adv20). Tata bahasa dapat dihitung, yang berarti ruang pencarian dapat dihasilkan oleh mesin dengan cara yang tidak dapat "dianggap sebagai fitur yang bagus". Sistem AutoML dapat:

1. Hasilkan ekspresi kandidat dengan menyusun operator pada kolom data
2. Evaluasi IC, turnover, dan drawdown setiap ekspresi
3. Filter untuk ekspresi yang bertahan dalam pengujian statistik dan cukup tidak berkorelasi dengan pustaka yang ada
4. Gabungkan para penyintas ke dalam portofolio

Perhatikan bahwa langkah 1 dan 2 adalah langkah yang mudah dan langkah 3 adalah tempat nilainya — lihat koreksi luasnya di atas.

Penemuan Alfa yang Ditingkatkan LLM

WorldQuant telah mulai mengintegrasikan model bahasa besar ke dalam pabrik alfa. Seperti diberitakan di media keuangan, perusahaan ini sedang menjajaki bagaimana LLM dapat "mengubah dan menemukan alfa di berbagai domain" — menghasilkan ekspresi baru, menerjemahkan makalah penelitian menjadi hipotesis yang dapat diuji, dan memunculkan hubungan lintas domain yang tidak dapat dilakukan oleh penelusuran enumeratif murni. Ini adalah mekanisme yang berbeda dengan mengekstraksi sinyal dari teks, yang dibahas blog ini di LLM Alpha Mining on Earnings Calls; di sini LLM menulis rumus, bukan fitur.

Membangun Pabrik Mini Alpha Anda Sendiri

Berikut adalah pabrik alfa yang ringkas namun fungsional atas tata bahasa operator:

import itertools
from dataclasses import dataclass
from typing import Callable, List
import pandas as pd
import numpy as np
from scipy.stats import spearmanr

@dataclass
class Alpha:
    name: str
    expression: Callable[[pd.DataFrame], pd.Series]
    ic: float = 0.0
    turnover: float = 0.0
    sharpe: float = 0.0

def ts_rank(series: pd.Series, window: int) -> pd.Series:
    return series.rolling(window).apply(lambda x: pd.Series(x).rank().iloc[-1] / len(x))

def ts_delta(series: pd.Series, period: int) -> pd.Series:
    return series.diff(period)

def ts_std(series: pd.Series, window: int) -> pd.Series:
    return series.rolling(window).std()

def cs_rank(series: pd.Series) -> pd.Series:
    return series.rank(pct=True)

def ts_mean(series: pd.Series, window: int) -> pd.Series:
    return series.rolling(window).mean()

ALPHA_TEMPLATES = [
    ("momentum_{w}",
     lambda df, w: cs_rank(ts_delta(df["close"], w))),
    ("mean_reversion_{w}",
     lambda df, w: -cs_rank(df["close"] / ts_mean(df["close"], w) - 1)),
    ("vol_surprise_{w}",
     lambda df, w: cs_rank(df["volume"] / ts_mean(df["volume"], w))),
    ("price_vol_divergence_{w}",
     lambda df, w: cs_rank(ts_delta(df["close"], w)) * -cs_rank(ts_delta(df["volume"], w))),
    ("volatility_rank_{w}",
     lambda df, w: -cs_rank(ts_std(df["close"].pct_change(), w))),
    ("high_low_range_{w}",
     lambda df, w: cs_rank(ts_mean(df["high"] - df["low"], w) / df["close"])),
]

WINDOWS = [5, 10, 20, 60, 120]

def generate_alphas(df: pd.DataFrame, forward_returns: pd.Series) -> List[Alpha]:
    """Generate and evaluate all alpha candidates."""
    alphas = []

    for (name_tpl, expr_fn), window in itertools.product(ALPHA_TEMPLATES, WINDOWS):
        name = name_tpl.format(w=window)
        try:
            signal = expr_fn(df, window)
            signal = signal.replace([np.inf, -np.inf], np.nan)

            valid = signal.notna() & forward_returns.notna()
            if valid.sum() < 100:
                continue

            ic, _ = spearmanr(signal[valid], forward_returns[valid])
            turnover = signal.diff().abs().mean()

            ret = (signal * forward_returns).dropna()
            sharpe = np.sqrt(252) * ret.mean() / (ret.std() + 1e-9)

            alphas.append(Alpha(
                name=name,
                expression=lambda df, fn=expr_fn, w=window: fn(df, w),
                ic=ic,
                turnover=turnover,
                sharpe=sharpe,
            ))
        except Exception:
            continue

    alphas.sort(key=lambda a: abs(a.ic), reverse=True)
    return alphas

Enam templat di lima jendela berarti sapuan 30 konfigurasi. Laporan yang dihasilkan memiliki bentuk skema berikut ini — kolom adalah kolom yang dikeluarkan oleh pabrik, dan tidak ada angka yang diisi karena tidak ada yang diukur di sini:

SCHEMATIC — illustrative format only, not a measurement

Generated <N> alphas from <N> candidate configurations

Top by |IC|:
  <alpha_name>   IC=<±0.0xxx>   Sharpe=<±x.xxx>   Turnover=<0.0xxx>
  ...

Sharpe mentah dari alpha teratas dari sapuan 30 konfigurasi adalah bukan hasil — ini adalah maksimum 30 kali seri, dan pada 1.000 strategi zero-edge, rata-rata Sharpe tahunan terbaik adalah 1,63 sedangkan tes naif menyatakan penemuan 100% setiap saat (Rasio Sharpe yang Dikempiskan). Oleh karena itu, hasil yang jujur ​​dari sebuah pabrik bukanlah "kami menemukan alpha" tetapi berapa banyak alpha yang selamat dari deflasi: distribusi IC, jumlah percobaan, DSR pemenang terhadap jumlah tersebut, dan PBO seleksi. Itulah ukuran yang masih harus dibayar bagian ini.

Pagar Pembatas: Hutang Anda

AutoML memperkuat penemuan dan overfitting dalam ukuran yang sama, dan hal ini dilakukan pada hitungan uji coba ketika perbedaannya tidak lagi terlihat kentara. Masing-masing hal ini dibahas secara mendalam di tempat lain; intinya di sini adalah AutoML menjadikan semuanya wajib daripada disarankan.

Hargai penelusuran, jangan hanya mengoreksinya. Sapuan fitur-model-hiperparameter adalah penghitungan uji coba dan penghitungan uji coba mengubah standar — lihat Rasio Sharpe yang Dikempiskan.

Validasi untuk sementara, dengan penghapusan menyeluruh dan embargo. Lihat Optimasi Berjalan ke Depan dan Taksonomi Bias Menatap ke Depan untuk mengetahui kebocoran yang bertahan dari pemisahan sementara yang naif.

Nilai prosedurnya, bukan hanya pemenangnya. Lihat Probabilitas Backtest Overfitting, dan lakukan koreksi bebannya: Nol PBO adalah 0,5, bukan 1 — setengahnya bukan "setengah overfit", melainkan overfit sepenuhnya, seperti lemparan koin.

Perhatikan puncak yang sebenarnya tidak ada. Menelusuri permukaan yang didominasi kebisingan secara efisien akan menemukan ilusi yang lebih tajam dengan lebih cepat (Analisis Dataran Tinggi); hal ini paling berdampak pada parameter strategi dan paling tidak pada hyperparameter ML, yang merupakan kasus FLAML dan Optuna sebenarnya dibuat.

Membatasi ruang pencarian. Sampel daun minimum, kedalaman terbatas dan jumlah estimator, anggaran fitur, penalti turnover — mengatur pencarian lebih murah daripada menguranginya setelahnya.

Kesimpulan

AutoML meningkatkan otomatisasi: mulai dari menyetel parameter di dalam kandidat tetap hingga menghasilkan kandidat itu sendiri. Ada tiga komponen yang sepadan dengan usaha ini — tsfresh dan Featuretools untuk pembuatan fitur, pencarian FLAML yang hemat biaya untuk pemilihan model yang hemat anggaran, dan tata bahasa operator formula untuk konstruksi alfa yang dapat dihitung. NAS menjadi layak untuk dihitung hanya ketika rasio signal-to-noise Anda membenarkannya, dan NAS berada di ujung sumbu eval-cost yang mahal di mana efisiensi sampel pada akhirnya membuahkan hasil.

Argumen keluasan WorldQuant tetap bertahan jika dibandingkan dengan pengukuran milik blog ini hanya dalam bentuk yang telah diperbaiki: $IR \approx IC\sqrt{BR}$ Di mana $BR$ menghitung taruhan independen, dan output pabrik sama sekali tidak independen. Menghasilkan satu juta alpha adalah hal yang mudah. Menetapkan bahwa keduanya cukup tidak berkorelasi untuk dihitung sebagai luasnya adalah separuh yang menentukan apakah rumus tersebut mempunyai arti.

Dan peringatan yang jujur ​​bukanlah sebuah moral, itu adalah hasil yang terukur. Blog ini menjalankan penelusuran dan overfit hingga kesimpulannya di The Honest Negative: puluhan ribu backtest di lima jurusan, DSR = 0,00 pada ~37.000 uji coba, PBO 0,264 dan 0,327, dan tidak ada keunggulan yang kuat. AutoML meningkatkan jumlah uji coba berdasarkan besarnya. Apa pun yang ditemukan, negara tersebut akan mengalami deflasi yang lebih besar – dan keluaran yang berguna dari pabrik alfa adalah tingkat kelangsungan hidup setelah deflasi tersebut, bukan angka tertinggi sebelumnya.