AutoML untuk Saluran Paip Dagangan Sistematik

Blog ini telah menghabiskan masa yang panjang untuk cara mencari: pensampel yang manakah hendak digunakan dan bila (silang ialah kos eval), cara menetapkan harga carian yang anda jalankan (the Deflated Sharpe Ratio prosedur itu sendiri (PBO), dan di mana keseluruhan radas itu mendarat secara jujur (tiada kelebihan teguh).

Perkara yang tidak pernah dibincangkan ialah perkara yang anda cari selepas. Artikel tersebut semuanya mengambil set ciri dan keluarga strategi seperti yang diberikan dan mengoptimumkan parameter di dalamnya. AutoML menyerang lapisan di atas — ia mengautomasikan pembinaan calon itu sendiri. Tiga bahagian itu tidak muncul di tempat lain di blog ini:

1. Pengekstrakan ciri automatik — tsfresh menukar satu siri harga kepada ~794 ciri berciri statistik, dan Featuretools mengarang ciri merentas jadual pasaran berkaitan melalui Sintesis Ciri Dalam.
2. AutoML Sedar Belanjawan — Pengoptimuman Jimat Kos FLAML, yang mencari model terbaik dalam bajet pengiraan dan bukannya tanpa mengira kos.
3. Kilang alfa formula — 101 Alpha Formulaik WorldQuant sebagai tatabahasa pengendali boleh gubah yang boleh dihitung oleh mesin.

Segala-galanya — fungsi objektif, skema pengesahan, pembetulan ujian berbilang — sudah diukur di tempat lain di sini, jadi artikel ini memaut dan bukannya mengajar semula. Itu lebih penting daripada biasa, kerana AutoML menjadikan kiraan percubaan meletup, dan kiraan percubaan adalah tepat mengenai arka yang lain.

Perkara yang AutoML Automates

AutoML bukan algoritma tunggal. Ia adalah sekumpulan teknik yang mengautomasikan pelbagai peringkat saluran paip:

Premisnya ialah dalam perdagangan sistematik ruang calon sangat besar — ​​satu siri OHLCV menjana ratusan ciri teknikal, dan berbilang aset, data buku pesanan dan sumber alternatif menjadikannya kombinatorial. Premis juga bahaya: setiap calon adalah percubaan, dan percubaan adalah apa yang menghasilkan penemuan palsu.

Satu perkara khusus AutoML pada objektif: metrik yang dimaksimumkan oleh carian mestilah metrik kewangan, kerana carian akan mengoptimumkan perkara yang anda tulis dan tiada apa yang anda maksudkan. Skalar yang anda pilih secara senyap memilih strategi anda — lihat Reka Bentuk Fungsi Objektif, di mana Sharpe per dagangan yang naif memenangi loteri pendedahan sub-5% dalam 56% daripada 600 biji dan menyiarkan Sharpe dalam sampel sebanyak 21 daripada 20 sampel yang runtuh.13ses. Sambungkan metrik kewangan ke dalam penjaring AutoML dari awal; tidak mengoptimumkan roc_auc dan berharap ia dipindahkan.

Kejuruteraan Ciri Automatik

Kejuruteraan ciri adalah tempat tinggal kebanyakan alfa. Data harga mentah adalah sama untuk semua orang. Transformasi data tersebut kepada isyarat ramalan adalah perkara yang memisahkan strategi yang menguntungkan daripada hingar.

tsfresh: Daripada Satu Siri Harga kepada 800+ Ciri

tsfresh (Pengeluaran Ciri Siri Masa berdasarkan Ujian Hipotesis Boleh Skala) dibina khusus untuk pengekstrakan ciri siri masa. Ia mengira 63 kaedah pencirian yang berkembang menjadi ~794 ciri secara lalai, termasuk:

• Momen statistik (min, varians, kecondongan, kurtosis)
• Autokorelasi pada beberapa ketinggalan
• Pekali Fourier dan tenaga spektrum
• Ukuran kerumitan (anggaran entropi, sampel entropi)
• Ciri bukan linear (pekali Friedrich, titik tetap Langevin maksimum)
• Tukar kuantiti dan kiraan julat

Untuk data kewangan, ini bermakna satu siri harga menghasilkan beratus-ratus ciri calon — banyak menangkap dinamik yang kejuruteraan ciri manual akan terlepas. Ini adalah pendekatan yang berbeza secara material daripada set ciri buatan tangan, terbitan domain yang digunakan dalam pemodelan penyebaran dan DeepLOB: ada manusia memutuskan bahawa ketidakseimbangan buku pesanan adalah penting; di sini perpustakaan menyenaraikan segala-galanya dan membiarkan ujian 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]}")

The select_features fungsi menggunakan prosedur Benjamini-Yekutieli untuk mengawal kadar penemuan palsu merentas keseluruhan bateri ciri — yang merupakan naluri yang betul, dan naluri yang sama artikel Deflated Sharpe digunakan pada carian strategi. Perhatikan perkara yang tidak lakukan: Kawalan FDR pada langkah pemilihan ciri tidak menyatakan apa-apa tentang kos percubaan carian model yang mengikutinya. Itu adalah dua kelipatan yang berasingan dan kedua-duanya perlu dibayar.

Alat Ciri: Sintesis Ciri Dalam

Walaupun tsfresh memfokuskan pada pencirian siri masa, Featuretools cemerlang dalam kejuruteraan ciri hubungan — membina ciri dengan mengarang operasi primitif merentas jadual berkaitan.

Untuk perdagangan, ini sangat berkesan apabila anda mempunyai data berbilang jadual: sejarah perdagangan, petikan buku pesanan, kadar pembiayaan dan metrik dalam rantaian. Featuretools menggunakan Sintesis Ciri Dalam (DFS), yang menyusun primitif transformasi dan pengagregatan:

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

The time_index pengisytiharan adalah menanggung beban: inilah yang membolehkan Featuretools mengira pengagregatan menggunakan hanya baris yang wujud pada cutoff. Silap silap dan DFS dengan senang hati akan membina ciri dari masa hadapan — contoh data hubungan kebocoran yang dikatalogkan dalam taksonomi bias pandang ke hadapan.

Gabungan tsfresh (pencirian siri masa) dan Featuretools (sintesis perhubungan) memberi anda kilang ciri yang menghasilkan beribu-ribu isyarat calon daripada data pasaran mentah tanpa pengekodan penunjuk manual.

AutoML Sedar Belanjawan: FLAM

Kami menganggap Optuna dan Penganggar Parzen berstruktur Pokok sebagai latar belakang — terbitan, perbandingan pensampel dan penanda aras adalah dalam Keturunan Koordinat vs Pengoptimuman Bayesian. Mengenai pensampel mana yang hendak dicapai, ukuran blog ini sendiri adalah rujukannya dan ia bukan jawapan cerita rakyat: persilangan dikawal oleh kos penilaian, bukan kepintaran algoritma — apabila ujian belakang hampir percuma, Sobol hancur menang pada throughput (~2,830 cfg/s berbanding ~154 untuk TPE[Random] membuat sampel kecekapan (penilaian secara rawak) dan hanya membuat penilaian yang mahal (penilaian secara rawak) Carian](/en/blog/post/search-method-crossover-eval-cost)).

Pembingkaian itulah yang menjadikan FLAM sebagai paksi yang berbeza dan bukannya sampel yang bersaing. Optuna bertanya di mana untuk mengambil sampel seterusnya; FLAML (Fast Lightweight AutoML) bertanya apa yang saya mampu untuk mencuba sama sekali. Ia mengoptimumkan model terbaik dalam masa atau mengira belanjawan menggunakan CFO (Cost-Frugal Optimization), yang mengutamakan konfigurasi murah untuk dinilai awal dan meningkat hanya apabila anggaran keuntungan marginal membenarkan perbelanjaan.

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)

Kelebihan FLAM untuk perdagangan ialah mengira peruntukan merentasi jenis model heterogen. Jika konfigurasi LightGBM menilai 10x lebih cepat daripada CatBoost, FLAML meneroka lebih awal LightGBM dan bertukar hanya apabila ia menganggarkan peningkatan kecil membenarkan kos. Itulah cerapan rejim murah daripada artikel silang, digeneralisasikan: throughput ialah istilah kelas pertama dalam belanjawan carian, bukan butiran pelaksanaan.

Log trajektori adalah bahagian yang patut disimpan. get_output_from_log memberikan anda sejarah konfigurasi penuh, iaitu kiraan percubaan anda — dan kiraan percubaan ialah input kepada setiap deflasi yang akan anda berhutang.

Carian Senibina Neural untuk Model Dagangan

Carian Seni Bina Neural mengautomasikan reka bentuk topologi rangkaian dan bukannya penalaan yang tetap. Pilihan seni bina untuk siri kewangan adalah benar-benar tidak jelas — tidak pegun, isyarat-ke-bunyi rendah, frekuensi bercampur dan kebergantungan yang menjangkau beberapa minit hingga beberapa bulan semuanya ditarik ke arah yang berbeza — tetapi motivasi itu telah dipertikaikan secara konkrit di tempat lain: lihat [Temporal Fusion Transformer](/en/blog/post/temporal-fusion-transformer-transformer dan FT) pada perdagangan Transformer LS dan FT. DeepLOB pada pertukaran CNN+Inception+LSTM, untuk perkara yang telah dicapai oleh seni bina tetap rekaan tangan dengan teliti. NAS adalah hujah bahawa pilihan ini sendiri harus dicari.

Penyelidikan tentang Neuroevolution NAS untuk Ramalan Pulangan Saham melaporkan bahawa RNN berkembang melalui EXAMM (Evolutionary eXploration of Augmenting Memory Models) mengatasi prestasi DJI dan S&P 500 dalam kedua-dua pasaran bear (2022) dan bull (2023) menggunakan strategi jangka pendek yang mudah. Anggap itu sebagai tuntutan pihak ketiga, bukan sebagai hasil yang diterbitkan semula di sini — ia adalah angka carian terbaik tanpa deflasi dilaporkan.

Ruang Carian NAS untuk Dagangan

Ruang carian NAS praktikal untuk model perdagangan termasuk:

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) daripada Microsoft, anda boleh 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)

Algoritma carian (ENAS, DARTS atau evolusi) menilai seni bina calon pada set pengesahan menggunakan objektif kewangan, kemudian secara beransur-ansur mengecil ke arah topologi berprestasi tinggi. Perhatikan asimetri kos berbanding segala-galanya dalam artikel ini: NAS terletak di hujung paksi kos eval yang paling mahal, yang merupakan satu rejim di mana pensampel cekap sampel dan pemangkasan berbilang kesetiaan membayar untuk diri mereka sendiri.

Pendekatan Kilang Alpha WorldQuant

Pendekatan WorldQuant terhadap penemuan alfa ialah pelaksanaan paling berskala industri bagi prinsip AutoML dalam kewangan. Diasaskan oleh Igor Tulchinsky, WorldQuant mengendalikan apa yang mereka panggil "kilang alfa" — proses sistematik untuk menjana, menguji dan menggabungkan berjuta-juta isyarat ramalan.

Falsafah: Penjanaan Alfa Eksponen, dan Pembetulannya

WorldQuant menetapkan sasaran pada tahun 2010 untuk mencapai satu juta alfa, pada masa apabila ia hanya menghasilkan beberapa ribu setiap tahun. Mereka mencapai sasaran itu pada tahun 2016. Falsafahnya terletak pada undang-undang asas pengurusan aktif:

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

di mana $IR$ ialah nisbah maklumat, $IC$ pekali maklumat, dan $BR$ keluasan — bilangan pertaruhan bebas. Setiap individu $\alpha_i$ adalah peramal yang lemah; dakwaan adalah bahawa menggabungkan yang cukup berkorelasi lemah menggabungkan IC kecil menjadi pulangan terlaras risiko yang bermakna.

Pembetulan yang membuat atau memecahkan ini, dan bahawa bacaan naif formula menyembunyikan: keluasan bukan kiraan percubaan. $BR$ mengira pertaruhan bebas, dan alfa yang dijana bukan bebas — ia terdiri daripada operator yang sama pada medan harga dan volum yang sama, jadi ia mewarisi struktur korelasi antara satu sama lain. Blog ini mengukur kesan secara langsung dalam Korelasi Isyarat: keluasan berkesan ialah $N_{eff} = N / C_f$, dan dengan faktor korelasi crypto tipikal $C_f \approx 3$, sepuluh isyarat bernilai kira-kira 3.3 isyarat bebas. The $\sqrt{BR}$ jangka tidak berkembang dengan bilangan alfa yang anda hasilkan; ia berkembang dengan berapa banyak yang tidak berkorelasi terselamat. Sejuta alpha berkorelasi membeli anda jauh lebih rendah daripada formula yang diiklankan.

Inilah sebabnya mengapa langkah 3 di bawah — perkaitan dengan perpustakaan sedia ada — bukanlah langkah kebersihan di kilang alfa. Ia adalah langkah yang menghasilkan keluasan di tempat pertama.

101 Alfa Formulaik

Kertas itu "101 Formulaic Alphas" oleh Kakushadze (dikaitkan dengan penyelidikan WorldQuant) menerbitkan satu set ungkapan alfa formula — ungkapan matematik berbanding harga, volum dan data asas:

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 menjadikan ini menarik untuk AutoML ialah ia adalah tatabahasa. Alfa ialah gubahan set operator kecil (rank, delta, ts_rank, stddev, correlation, signedpower) di atas set medan kecil (close, volume, vwap, returns, adv20). Tatabahasa boleh dikira, yang bermaksud ruang carian boleh dijana mesin dengan cara yang "memikirkan ciri yang baik" tidak. Sistem AutoML boleh:

1. Jana ekspresi calon dengan mengarang operator ke atas medan data
2. Nilai IC, perolehan dan pengeluaran setiap ungkapan
3. Tapis untuk ungkapan yang bertahan dalam ujian statistik dan cukup tidak berkorelasi dengan perpustakaan sedia ada
4. Gabungkan mereka yang terselamat ke dalam portfolio

Ambil perhatian bahawa langkah 1 dan 2 adalah yang mudah dan langkah 3 ialah di mana nilainya — lihat pembetulan keluasan di atas.

Penemuan Alfa Dipertingkat LLM

WorldQuant telah mula menyepadukan model bahasa besar ke dalam kilang alfa. Seperti yang dilaporkan dalam akhbar kewangan, firma itu sedang meneroka bagaimana LLM boleh "mengubah dan menemui alfa merentas domain yang berbeza" — menjana ungkapan novel, menterjemah kertas penyelidikan ke dalam hipotesis yang boleh diuji dan menimbulkan hubungan merentas domain yang akan terlepas daripada carian enumeratif tulen. Ini adalah mekanisme yang berbeza daripada mengekstrak isyarat daripada teks, yang blog ini diliputi dalam LLM Alpha Mining on Earnings Calls; di sini LLM menulis formula, bukan ciri.

Membina Kilang Mini Alpha Anda Sendiri

Berikut ialah kilang alfa yang padat tetapi berfungsi berbanding tatabahasa 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 dalam lima tetingkap ialah sapuan 30 konfigurasi. Laporan yang dihasilkannya mempunyai bentuk skema ini — medan ialah apa yang dipancarkan oleh kilang dan tiada nombor diisi kerana tiada satu pun 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 alfa teratas daripada sapuan 30 konfigurasi adalah bukan hasil — ia adalah maksimum 30 cabutan, dan pada 1,000 strategi tepi sifar, purata Sharpe tahunan terbaik ialah 1.63 manakala ujian naif mengisytiharkan penemuan 100% pada setiap masa (Deflated Sharpe Nisbah). Oleh itu, penghantaran jujur ​​dari kilang bukanlah "kami menemui alfa" tetapi berapa banyak alfa terselamat daripada deflasi: pengedaran IC, kiraan percubaan, DSR pemenang terhadap kiraan itu dan PBO pemilihan. Itulah ukuran bahagian ini masih berhutang.

Pengawal: Apa yang Anda Sudah Berhutang

AutoML menguatkan penemuan dan pemasangan berlebihan dalam ukuran yang sama, dan ia melakukannya pada kiraan percubaan apabila perbezaannya berhenti menjadi halus. Setiap satu daripada ini diliputi secara mendalam di tempat lain; Maksudnya di sini ialah AutoML menjadikan kesemuanya wajib dan bukannya digalakkan.

Hargakan carian, jangan hanya membetulkannya. Sapuan model ciri-hiperparameter ialah kiraan percubaan dan kiraan percubaan menggerakkan bar — lihat Nisbah Tajam Kempis.

Sahkan secara sementara, dengan pembersihan dan sekatan. Lihat Pengoptimuman Walk-Forward dan Taxonomy Bias Look-Ahead untuk mengetahui kebocoran yang kekal dalam perpecahan temporal yang naif.

Skor prosedur, bukan hanya pemenang. Lihat Kebarangkalian Backtest Overfitting, dan bawa pembetulan galas bebannya: Nol PBO ialah 0.5, bukan 1 — separuh bukan "half overfit," ia overfit sepenuhnya, flip syiling.

Perhatikan puncak yang tiada. Mencari permukaan yang dikuasai hingar dengan cekap hanya menemui ilusi yang lebih tajam dengan lebih pantas (Analisis Plateau); ini menggigit paling sukar pada parameter strategi dan paling tidak pada hiperparameter ML, yang mana FLAML dan Optuna sebenarnya dibina untuknya.

Kekang ruang carian. Sampel daun minimum, kedalaman yang dihadkan dan kiraan penganggar, belanjawan ciri, penalti pusing ganti — menyelaraskan carian adalah lebih murah daripada mengecilkannya selepas itu.

Kesimpulan

AutoML meningkatkan automasi ke tahap: daripada menala parameter dalam calon tetap kepada menjana calon itu sendiri. Tiga komponen berbaloi dengan usaha — tsfresh dan Featuretools untuk penjanaan ciri, pencarian kos FLAML yang menjimatkan untuk pemilihan model yang sedar bajet, dan tatabahasa pengendali formula untuk pembinaan alfa yang terbilang. NAS menjadi bernilai pengiraannya hanya apabila nisbah isyarat-ke-bunyi anda membenarkannya, dan ia hidup pada hujung paksi kos eval yang mahal di mana kecekapan sampel akhirnya membayar.

Argumen keluasan WorldQuant kekal bersentuhan dengan ukuran blog ini sendiri hanya dalam bentuk yang diperbetulkan: $IR \approx IC\sqrt{BR}$ di mana $BR$ mengira pertaruhan bebas, dan keluaran kilang adalah hampir bebas. Menjana sejuta alfa adalah separuh mudah. Menetapkan bahawa ia cukup tidak berkorelasi untuk dikira sebagai keluasan ialah separuh yang menentukan sama ada formula itu bermakna apa-apa.

Dan kaveat yang jujur ​​bukanlah moral, ia adalah hasil yang diukur. Blog ini menjalankan arka carian-dan-overfit ke kesimpulannya dalam The Honest Negative: berpuluh-puluh ribu ujian belakang merentasi lima jurusan, DSR = 0.00 pada ~37,000 percubaan, PBO 0.264 dan 0.3bustdge edge. AutoML meningkatkan kiraan percubaan mengikut urutan magnitud. Walau apa pun yang ditemuinya, ia akan berhutang deflasi yang sama besar — ​​dan keluaran berguna bagi kilang alfa ialah kadar kelangsungan hidup selepas deflasi itu, bukan barisan teratas sebelum itu.