Sistematik Ticaret Pipeline'ları için AutoML

Bu blog nasıl arama yapılacağı: hangi örnekleyicinin kullanılacağı ve ne zaman kullanılacağı (geçiş değerlendirme maliyetidir), çalıştırdığınız aramanın nasıl fiyatlandırılacağı (Sönük Sharpe Oranı) ve seçim prosedürünün nasıl puanlanacağı konularında uzun bir araştırma yaptı. (PBO) ve tüm bu aygıtın dürüstçe indiği yer (sağlam bir üstünlük yok).

Hiçbir zaman kapsamadığı şey, üzerinden aradığınız şeydir. Bu makalelerin tümü özellik kümesini ve strateji ailesini verildiği gibi alır ve içindeki parametreleri optimize eder. AutoML yukarıdaki katmana saldırır; adayların oluşturulmasını otomatikleştirir. Bunun üç kısmı bu blogun başka hiçbir yerinde görünmüyor:

1. Otomatik özellik çıkarma — bir fiyat serisini ~794 istatistiksel olarak karakterize edilmiş özelliğe dönüştürüyor ve Özellik Araçları, Derin Özellik Sentezi yoluyla ilgili pazar tablolarında özellikler oluşturuyor.
2. Bütçeye duyarlı AutoML — FLAML'in Maliyet Tutumlu Optimizasyonu, maliyetten bağımsız olarak bilgi işlem bütçesi dahilinde en iyi modeli bulur.
3. Formülsel alfa fabrikası — Bir makinenin numaralandırabileceği şekillendirilebilir bir operatör dilbilgisi olarak WorldQuant'ın 101 Formülsel Alfası.

Diğer her şey - amaç fonksiyonu, doğrulama şeması, çoklu test düzeltmesi - burada başka bir yerde zaten ölçülüyor, dolayısıyla bu makale yeniden öğretmek yerine bağlantı veriyor. Bu her zamankinden daha önemli çünkü AutoML deneme sayısında patlama yaratıyor ve deneme sayısı tam olarak hikayenin geri kalanıyla ilgili.

AutoML Neleri Otomatikleştirir

AutoML tek bir algoritma değildir. İşlem hattının farklı aşamalarını otomatikleştiren bir teknikler ailesidir:

Buradaki öncül, sistematik ticarette aday alanının çok büyük olduğudur; tek bir OHLCV serisi yüzlerce teknik özellik üretir ve birden fazla varlık, sipariş defteri verileri ve alternatif kaynaklar onu kombinatoryal hale getirir. Önerme aynı zamanda tehlikedir: Her aday bir sınavdır ve denemeler yanlış keşiflere yol açar.

Hedefte AutoML'e özgü bir nokta: Aramanın en üst düzeye çıkardığı ölçüm finansal olmalıdır, çünkü arama tam olarak yazdıklarınızı optimize edecek ve kastettiğiniz hiçbir şeyi optimize etmeyecektir. Hangi skaleri seçeceğiniz sessizce stratejinizi seçer - bkz. Objective-Function Design, burada işlem başına saf bir Sharpe, 600 tohumun %56'sında %5'in altındaki maruz kalma piyangosunu taçlandırır ve numunenin 0,13'üne düşen 21'lik bir örnek içi Sharpe yayınlar. Mali metriği en başından itibaren AutoML puanlayıcıya aktarın; optimize etme roc_auc ve umarım transfer olur.

Otomatik Özellik Mühendisliği

Özellik mühendisliği çoğu alfanın yaşadığı yerdir. Ham fiyat verileri herkes için aynıdır. Bu verilerin tahmine dayalı sinyallere dönüştürülmesi, karlı stratejileri gürültüden ayıran şeydir.

tsfresh: Tek Fiyat Serisinden 800+ Özelliklere

taze (Ölçeklenebilir Hipotez Testlerine dayalı Zaman Serisi Özellik Çıkarımı), zaman serisi özellik çıkarımı için özel olarak tasarlanmıştır. Varsayılan olarak ~794 özelliğe genişleyen 63 karakterizasyon yöntemini hesaplar; bunlara aşağıdakiler dahildir:

• İstatistiksel anlar (ortalama, varyans, çarpıklık, basıklık)
• Çoklu gecikmelerde otokorelasyon
• Fourier katsayıları ve spektral enerji
• Karmaşıklık ölçüleri (yaklaşık entropi, numune entropisi)
• Doğrusal olmayan özellikler (Friedrich katsayıları, maksimum Langevin sabit noktası)
• Yüzdelik dilimleri ve aralık sayımlarını değiştirin

Finansal veriler için bu, tek bir fiyat serisinin yüzlerce aday özellik ürettiği anlamına gelir; bunların çoğu, manuel özellik mühendisliğinin kaçıracağı dinamikleri yakalar. Bu, spread modelleme ve DeepLOB'ta kullanılan el yapımı, alandan türetilmiş özellik setlerinden önemli ölçüde farklı bir yaklaşımdır: burada bir insan, sipariş defteri dengesizliğinin önemli olduğuna karar verir; burada bir kütüphane her şeyi sıralıyor ve bir hipotez testinin karar vermesine izin veriyor.

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 işlevi, tüm özellik pili genelinde yanlış keşif oranını kontrol etmek için Benjamini-Yekutieli prosedürünü uygular. Bu doğru bir içgüdüdür ve Deflated Sharpe makalesi ile aynı içgüdü strateji aramaları için de geçerlidir. Ne yapmadığını not edin: Özellik seçimi adımındaki FDR kontrolü, onu takip eden model aramanın deneme maliyeti hakkında hiçbir şey söylemez. Bunlar iki ayrı çokluktur ve her ikisinin de ödenmesi gerekir.

Özellik Araçları: Derin Özellik Sentezi

tsfresh zaman serisi karakterizasyonuna odaklanırken, Featuretools ilişkisel özellik mühendisliğinde üstündür; ilgili tablolarda ilkel işlemler oluşturarak özellikler oluşturur.

Ticaret için, çok tablolu verileriniz olduğunda bu çok güçlüdür: ticaret geçmişi, sipariş defteri anlık görüntüleri, fonlama oranları ve zincir üzeri ölçümler. Özellik Araçları, dönüşüm ve toplama ilkellerini istifleyen Derin Özellik Sentezini (DFS) uygular:

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 bildirim yük taşır: Özellik Araçları'nın yalnızca kesimde mevcut olan satırları kullanarak toplamaları hesaplamasına olanak tanıyan şeydir. Yanlış anladığınızda DFS mutlu bir şekilde gelecekten bir özellik oluşturacaktır: ileriye dönük önyargı sınıflandırmasında kataloglanan sızıntıların ilişkisel veri örneği.

Tsfresh (zaman serisi karakterizasyonu) ve Featuretools'un (ilişkisel sentez) birleşimi, size manuel gösterge kodlaması olmadan ham piyasa verilerinden binlerce aday sinyal üreten bir özellik fabrikası sunar.

Bütçe Farkına Sahip Otomatik ML: FLAML

Optuna ve Ağaç Yapılı Parzen Tahmincilerini arka plan olarak varsayıyoruz; türetme, örnekleyici karşılaştırması ve kıyaslama Koordinat İnişi ve Bayesian Optimizasyonuna içindedir. *Hangi örnekleyiciye ulaşılması gerektiği konusunda referans bu blogun kendi ölçümüdür ve folklor yanıtı değildir: çaprazlama, algoritma zekasına değil, değerlendirme maliyetine göre yönetilir - bir arka test neredeyse ücretsiz olduğunda, karıştırılmış Sobol üretimde kazanır (TPE için ~154'e karşı ~2.830 cfg/s) ve yalnızca pahalı değerlendirmeler örnek verimliliğinin karşılığını verir (Random vs Smart) Ara).

Bu çerçeveleme, FLAML'ı rakip bir örnekleyiciden ziyade farklı bir eksen haline getiren şeydir. Optuna bundan sonra nerede örnek alınacağını sorar; FLAML (Fast Lightweight AutoML), neyi örneklemeye gücüm yetebilir diye sorar. Değerlendirmesi ucuz olan yapılandırmalara erken öncelik veren ve yalnızca tahmini marjinal kazanç harcamayı haklı çıkardığında artan CFO'yu (Maliyet Tutumlu Optimizasyon) kullanarak bir zaman veya bilgi işlem bütçesi dahilinde en iyi modeli optimize eder.

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)

FLAML'in ticarete yönelik avantajı, heterojen model türleri arasında bilgi işlem tahsisidir. LightGBM yapılandırmaları CatBoost'tan 10 kat daha hızlı değerlendirirse, FLAML daha fazla LightGBM'yi erken keşfeder ve yalnızca marjinal iyileşmenin maliyeti haklı çıkaracağını tahmin ettiğinde geçiş yapar. Bu, çapraz makalenin genelleştirilmiş ucuz rejim anlayışıdır: verimlilik, arama bütçesinde birinci sınıf bir terimdir, bir uygulama ayrıntısı değildir.

Yörünge günlüğü tutulmaya değer kısımdır. get_output_from_log size deneme sayınız olan tam yapılandırma geçmişini verir ve deneme sayısı, borçlu olduğunuz her deflasyonun girişidir.

Ticaret Modelleri için Sinir Mimarisi Araması

Sinir Mimarisi Araması, sabit bir topolojinin ayarlanması yerine ağ topolojilerinin tasarımını otomatikleştirir. Finansal seriler için mimari seçimi gerçekten açık değildir - durağan değildir, düşük sinyal-gürültü, karışık frekanslar ve dakikalardan aylara kadar uzanan bağımlılıkların tümü farklı yönlere çeker - ancak bu motivasyon zaten başka bir yerde somut olarak tartışılmıştır: TFT'nin LSTM'nin Vanilya Transformer'ı yendiği zaman hakkında Temporal Fusion Transformer'e bakın ve Dikkatlice elle tasarlanmış sabit mimarilerin zaten başardığı şey için CNN+Inception+LSTM ödünleşimi hakkında DeepLOB. NAS'ın argümanı ise bu tercihin bizzat aranması gerektiğidir.

[Hisse Senedi Getirisi Tahmini için Nöroevrim NAS] Araştırması(https://arxiv.org/html/2410.17212v1), EXAMM (Artırıcı Bellek Modellerinin Evrimsel e-Keşfi) aracılığıyla geliştirilen RNN'lerin, basit uzun-kısa stratejiler kullanarak hem ayı (2022) hem de boğa (2023) pazarlarında DJI ve S&P 500'den daha iyi performans gösterdiğini bildiriyor. Bunu burada tekrarlanan bir sonuç olarak değil, bir üçüncü taraf iddiası olarak değerlendirin; bu, herhangi bir deflasyon bildirilmeyen en iyi arama rakamıdır.

Ticaret için NAS Arama Alanı

Ticaret modelleri için pratik bir NAS arama alanı şunları içerir:

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}

Microsoft'un NNI (Sinir Ağı Zekası) ile bu alanı tanımlayabilir ve arayabilirsiniz:

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)

Arama algoritması (ENAS, DARTS veya evrimsel), aday mimarileri bir finansal hedef kullanarak bir doğrulama kümesinde değerlendirir ve ardından yüksek performanslı topolojilere doğru giderek daraltır. Bu makaledeki diğer her şeyle karşılaştırıldığında maliyet asimetrisine dikkat edin: NAS, örnek verimli örnekleyicilerin ve çoklu doğruluk budamanın gerçekten kendilerini amorti ettiği tek rejim olan değerlendirme-maliyet ekseninin en pahalı ucunda yer alır.

WorldQuant Alfa Fabrika Yaklaşımı

WorldQuant'ın alfa keşfine yaklaşımı, AutoML ilkelerinin finans alanında en endüstriyel ölçekte uygulanmasıdır. Igor Tulchinsky tarafından kurulan WorldQuant, milyonlarca tahmine dayalı sinyalin üretilmesi, test edilmesi ve birleştirilmesi için sistematik bir süreç olan "alfa fabrikası" adını verdikleri şeyi işletiyor.

Felsefe: Üstel Alfa Üretimi ve Düzeltilmesi

WorldQuant, yılda yalnızca birkaç bin alfa ürettiği bir dönemde, 2010 yılında bir milyon alfaya ulaşma hedefini belirledi. Bu hedefe 2016'da ulaştılar. Felsefe, aktif yönetimin temel yasasına dayanıyor:

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

Neresi $IR$ bilgi oranıdır, $IC$ bilgi katsayısı ve $BR$ genişlik — bağımsız bahislerin sayısı. Her birey $\alpha_i$ zayıf bir tahmin edicidir; iddia, yeterince zayıf ilişkili olanları birleştirmenin, küçük IC'leri anlamlı bir riske göre ayarlanmış getiri halinde birleştirdiğidir.

Bunu yapan ya da bozan düzeltme ve formülün safça okunmasının gizlediği düzeltme: genişlik deneme sayımı değildir. $BR$ bağımsız bahisleri sayar ve oluşturulan alfalar bağımsız değildir; aynı fiyat ve hacim alanlarındaki aynı operatörlerden oluşurlar, dolayısıyla birbirlerinin korelasyon yapısını miras alırlar. Bu blog, etkiyi doğrudan Sinyal Korelasyonu ile ölçtü: etkili genişlik: $N_{eff} = N / C_f$ve tipik bir kripto korelasyon faktörüyle $C_f \approx 3$, on sinyal yaklaşık 3,3 bağımsız sinyal değerindedir. $\sqrt{BR}$ terim, ürettiğiniz alfa sayısına göre artmaz; kaç ilişkisiz olanın hayatta kaldığıyla birlikte artar. Bir milyon ilişkili alfa size formülün reklamını yaptığından çok daha azını satın alır.

Bu nedenle aşağıdaki 3. adım (mevcut kitaplığa karşı korelasyonun bozulması) alfa fabrikasında bir hijyen adımı değildir. Genişliği ilk etapta sağlayan adımdır.

101 Formülsel Alfa

["101 Formülik Alfa"] makalesi(https://arxiv.org/pdf/1601.00991Kakushadze (WorldQuant araştırmasıyla ilişkili) tarafından bir dizi formülsel alfa ifadesi (fiyat, hacim ve temel veriler üzerinden matematiksel ifadeler) yayınlandı:

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

Bunu AutoML için ilginç kılan şey bir gramer olmasıdır. Alfalar küçük bir operatör kümesinin bileşimleridir (rank, delta, ts_rank, stddev, correlation, signedpower) küçük bir alan kümesi üzerinde (close, volume, vwap, returns, adv20). Dilbilgisi numaralandırılabilir; bu, arama alanının "iyi bir özellik düşünmenin" mümkün olmadığı bir şekilde makine tarafından oluşturulabileceği anlamına gelir. Bir AutoML sistemi şunları yapabilir:

1. Veri alanları üzerinde operatörler oluşturarak aday ifadeler oluşturun

2. Her ifadenin IC'sini, cirosunu ve düşüşünü değerlendirin

3. İstatistiksel testlerden sağ çıkan ve ifadeler için filtre, mevcut kitaplıkla yeterince ilişkisizdir

4. Hayatta kalanları bir portföyde birleştirin

5. ve 2. adımların kolay adımlar olduğunu ve 3. adımın değerin olduğu yer olduğunu unutmayın; yukarıdaki genişlik düzeltmesine bakın.

LLM-Geliştirilmiş Alfa Keşfi

WorldQuant, büyük dil modellerini alfa fabrikasına entegre etmeye başladı. Finansal basında bildirildiği üzere firma, yüksek lisansların nasıl "farklı alanlardaki alfaları dönüştürüp keşfedebileceğini" araştırıyor; yeni ifadeler üretiyor, araştırma makalelerini test edilebilir hipotezlere dönüştürüyor ve saf bir numaralandırmalı aramanın gözden kaçıracağı alanlar arası ilişkileri ortaya çıkarıyor. Bu, bu blogun Kazanç Çağrılarında LLM Alfa Madenciliği bölümünde ele aldığı metinden sinyal çıkarmaktan farklı bir mekanizmadır; burada Yüksek Lisans özelliği değil formülü yazar.

Kendi Mini Alfa Fabrikanızı Kurmak

Operatör dilbilgisi üzerinde kompakt ama işlevsel bir alfa fabrikası:

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

Beş pencerede altı şablon, 30 konfigürasyonlu bir taramadır. Ürettiği rapor şu şematik şekle sahiptir; alanlar fabrikanın yaydığı alanlardır ve hiçbir sayı burada ölçülmediği için doldurulmamıştır:

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>
  ...

30 konfigürasyonlu bir taramanın en üst alfasının ham Sharpe'ı bir sonuç değildir — maksimum 30 beraberliktir ve 1.000 sıfır kenarlı stratejide en iyi yıllık Sharpe ortalaması 1,63 iken, saf test %100'lük bir keşif beyan eder (Deflated Sharpe Ratio). Bu nedenle bir fabrikanın dürüst çıktısı "bir alfa bulduk" değil, deflasyondan kaç alfanın sağ kurtulduğu: IC dağıtımı, deneme sayısı, kazananın bu sayıma göre DSR'si ve seçimin PBO'sudur. Bu bölümün hala borçlu olduğu ölçüm budur.

Korkuluklar: Zaten Borcunuz Var

AutoML, keşif ve aşırı uyumu eşit ölçüde artırır ve bunu, farkın çok ince olmadığı deneme sayımlarında yapar. Bunların her biri başka bir yerde derinlemesine ele alınmıştır; Buradaki nokta, AutoML'in hepsini tavsiye etmek yerine zorunlu hale getirmesidir.

Aramayı yalnızca düzeltmeyin, fiyatlandırın. Özellik-model-hiperparametre taraması bir deneme sayımıdır ve deneme sayımı çıtayı yükseltir - bkz. Deflated Sharpe Oranı.

Tasfiye ve ambargo ile geçici olarak doğrulayın. Saf bir zamansal bölünmeden sonra hayatta kalan sızıntılar için İleriye Doğru Optimizasyon ve İleriye Bakış Önyargı Taksonomisi'ye bakın.

Yalnızca kazananı değil, prosedürü puanlayın. Arka Test Aşırı Uyum Olasılığı'na bakın ve yük taşıma düzeltmesini gerçekleştirin: PBO'nun sıfır değeri 1 değil 0,5 — yarısı "yarı fazla uyum" değil, tamamen aşırı uyum, yazı-tura.

Orada olmayan zirvelere dikkat edin. Gürültünün hakim olduğu bir yüzeyi verimli bir şekilde aramak, daha keskin yanılsamaları daha hızlı bulmanızı sağlar (Plato Analizi); bu, en çok strateji parametrelerini ve en az da ML hiperparametrelerini etkiler; FLAML ve Optuna aslında bunun için tasarlanmıştır.

Arama alanını kısıtlayın. Minimum yaprak örnekleri, sınırlı derinlik ve tahminci sayıları, özellik bütçesi, ciro cezası; aramayı düzenli hale getirmek, daha sonra söndürmekten daha ucuzdur.

Sonuç

AutoML, otomasyonu bir düzeye taşır: sabit bir adayın içindeki parametrelerin ayarlanmasından adayların kendilerinin oluşturulmasına kadar. Üç bileşen çabaya değer: özellik oluşturma için tsfresh ve Özellik Araçları, FLAML'in bütçeye duyarlı model seçimi için uygun maliyetli araması ve numaralandırılabilir alfa yapısı için formülsel operatör dilbilgisi. NAS, yalnızca sinyal-gürültü oranınız bunu haklı çıkardığında hesaplamaya değer hale gelir ve değerlendirme maliyet ekseninin pahalı ucunda, numune verimliliğinin nihayet karşılığını verdiği yerde yaşar.

WorldQuant'ın genişlik argümanı bu blogun kendi ölçümleriyle yalnızca düzeltilmiş haliyle varlığını sürdürüyor: $IR \approx IC\sqrt{BR}$ Neresi $BR$ bağımsız bahisleri sayar ve bir fabrikanın çıktısı hiçbir şekilde bağımsız değildir. Bir milyon alfa oluşturmak işin kolay yarısıdır. Genişlik olarak sayılacak kadar korelasyonsuz olduklarının belirlenmesi, formülün bir anlam ifade edip etmediğini belirleyen yarıdır.

Ve dürüst uyarı ahlaki değil, ölçülü bir sonuçtur. Bu blog, arama ve aşırı uyum eğrisini The Honest Negative'de sonucuna kadar yürüttü: beş ana dalda on binlerce geriye dönük test, ~37.000 denemede DSR = 0,00, PBO 0,264 ve 0,327 ve sağlam bir üstünlük yok. AutoML, deneme sayısını büyük miktarlarda artırır. Ne bulursa bulsun, buna karşılık olarak daha büyük bir deflasyona borçlu olacaktır - ve bir alfa fabrikasının yararlı çıktısı, ondan önceki en üst sıra değil, bu deflasyondan sonraki hayatta kalma oranıdır.