Tizimli savdo quvurlari uchun AutoML

Tizimli savdo quvurlari uchun # AutoML

This blog has spent a long arc on how to search: which sampler to use and when (the crossover is eval cost), how to price the search you ran (the Deflated Sharpe Ratio), how to score the selection procedure itself (PBO), and where that whole apparatus honestly lands (no robust edge).

U hech qachon qamrab olmagan narsa - siz qidirayotgan narsa * ustidan*. Ushbu maqolalarning barchasi berilgan xususiyatlar to'plami va strategiyalar oilasini oladi va undagi parametrlarni optimallashtiradi. AutoML yuqoridagi qatlamga hujum qiladi - u nomzodlarning o'zini qurishni avtomatlashtiradi. Uning uchta qismi ushbu blogda boshqa hech qanday joyda ko'rinmaydi:

1. Avtomatlashtirilgan xususiyatni ajratib olish — tsfresh bir narx seriyasini ~794 statistik xarakterli xususiyatga aylantiradi va Deep Feature Synthesis orqali tegishli bozor jadvallari boʻylab xususiyatlarni yaratuvchi Featuretools.
2. Byudjetdan xabardor AutoML — FLAMLning xarajat-tejamkor optimallashtirishi, u xarajatdan qat'iy nazar hisoblash byudjeti doirasida eng yaxshi modelni topadi.
3. Formulaviy alfa zavodi — WorldQuantning 101 formulali alfasi, kompozisiyalanuvchi operator grammatikasi sifatida mashina sanab berishi mumkin.

Qolgan hamma narsa - maqsad funktsiyasi, tekshirish sxemasi, ko'p sinovli tuzatish - bu erda allaqachon boshqa joyda o'lchanadi, shuning uchun ushbu maqola qayta o'rgatish o'rniga havola qiladi. Bu odatdagidan ko'ra muhimroq, chunki AutoML sinovlar sonini portlatib yuboradi va sinovlar soni kamonning qolgan qismi bilan bog'liq.

! ZXQKEEP0QXZ

AutoML nimani avtomatlashtiradi

AutoML yagona algoritm emas. Bu quvur liniyasining turli bosqichlarini avtomatlashtiradigan texnikalar oilasi:

Buning asosi shundaki, tizimli savdoda nomzodlar maydoni juda katta - bitta OHLCV seriyasi yuzlab texnik xususiyatlarni yaratadi va bir nechta aktivlar, buyurtmalar kitobi ma'lumotlari va muqobil manbalar uni kombinatsion qiladi. Asosiy shart ham xavf: har bir nomzod sinovdir va sinovlar yolg'on kashfiyotlarni keltirib chiqaradi.

One AutoML-specific point on the objective: the metric the search maximizes must be the financial one, because the search will optimize exactly what you wrote down and nothing you meant. Which scalar you pick silently selects your strategy — see Objective-Function Design, where a naive per-trade Sharpe crowns a sub-5%-exposure lottery in 56% of 600 seeds and posts an in-sample Sharpe of 21 that collapses to 0.13 out of sample. Wire the financial metric into the AutoML scorer from the start; do not optimize roc_auc and hope it transfers.

Avtomatlashtirilgan xususiyat muhandisligi

Xususiyat muhandisligi eng alfa yashaydigan joy. Xom narx ma'lumotlari hamma uchun bir xil. Ushbu ma'lumotlarni bashorat qiluvchi signallarga aylantirish foydali strategiyalarni shovqindan ajratib turadigan narsadir.

! ZXQKEEP0QXZ

tsfresh: Bitta narx seriyasidan 800+ funksiyagacha

tsfresh (Time Series Feature Extraction based on Scalable Hypothesis Tests) is purpose-built for time series feature extraction. It computes 63 characterization methods that expand into ~794 features by default, including:

• Statistik momentlar (o'rtacha, dispersiya, egrilik, kurtoz)
• Ko'p laglarda avtokorrelyatsiya
• Furye koeffitsientlari va spektral energiya
• Murakkablik o'lchovlari (taxminan entropiya, namuna entropiyasi)
• Nochiziqli xususiyatlar (Fridrix koeffitsientlari, maksimal Langevin sobit nuqtasi)
• Miqdorlar va diapazonlarni o'zgartiring

For financial data, this means a single price series produces hundreds of candidate features — many capturing dynamics that manual feature engineering would miss. This is a materially different approach from the hand-crafted, domain-derived feature sets used in spread modeling and DeepLOB: there a human decides that order-book imbalance matters; here a library enumerates everything and lets a hypothesis test decide. For financial data, this means a single price series produces hundreds of candidate features — many capturing dynamics that manual feature engineering would miss. This is a materially different approach from the hand-crafted, domain-derived feature sets used in spread modeling and DeepLOB : there a human decides that order-book imbalance matters; here a library enumerates everything and lets a hypothesis test decide.

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 function applies a Benjamini-Yekutieli procedure to control the false discovery rate across the whole feature battery — which is the right instinct, and the same instinct the Deflated Sharpe article applies to strategy searches. Note what it does not do: FDR control on the feature-selection step says nothing about the trial cost of the model search that follows it. Those are two separate multiplicities and both have to be paid.

Featuretools: Chuqur xususiyat sintezi

While tsfresh focuses on time series characterization, Featuretools excels at relational feature engineering — constructing features by composing primitive operations across related tables.

Savdo uchun, bu ko'p jadvalli ma'lumotlarga ega bo'lganingizda kuchli bo'ladi: savdo tarixi, buyurtmalar kitobining suratlari, moliyalashtirish stavkalari va zanjirdagi ko'rsatkichlar. Featuretools o'zgartirish va yig'ish primitivlarini to'playdigan chuqur xususiyat sintezini (DFS) qo'llaydi: For trading, this is powerful when you have multi-table data: trade history, order book snapshots, funding rates, and on-chain metrics. Featuretools applies Deep Feature Synthesis (DFS), which stacks transformation and aggregation primitives:

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 declaration is load-bearing: it is what lets Featuretools compute aggregations using only rows that existed at the cutoff. Get it wrong and DFS will happily build a feature out of the future — the relational-data instance of the leaks catalogued in the look-ahead bias taxonomy.

Tsfresh (vaqt seriyasining tavsifi) va Featuretools (relyatsion sintez) kombinatsiyasi sizga qo'lda indikator kodlashsiz xom bozor ma'lumotlaridan minglab nomzod signallarini ishlab chiqaradigan xususiyat zavodini beradi.

Byudjetdan xabardor AutoML: FLAML

We assume Optuna and Tree-structured Parzen Estimators as background — the derivation, sampler comparison and benchmark are in Coordinate Descent vs Bayesian Optimization. On which sampler to reach for, this blog's own measurement is the reference and it is not the folklore answer: the crossover is governed by evaluation cost, not algorithm cleverness — when a backtest is nearly free, scrambled Sobol wins on throughput (~2,830 cfg/s against ~154 for TPE), and only expensive evaluations make sample efficiency pay (Random vs Smart Search).

! ZXQKEEP0QXZ

That framing is what makes FLAML a different axis rather than a competing sampler. Optuna asks where to sample next; FLAML (Fast Lightweight AutoML) asks what can I afford to sample at all. It optimizes for the best model within a time or compute budget using CFO (Cost-Frugal Optimization), which prioritizes cheap-to-evaluate configurations early and escalates only when the estimated marginal gain justifies the spend. That framing is what makes FLAML a different axis rather than a competing sampler. Optuna asks where to sample next; FLAML (Fast Lightweight AutoML) asks what can I afford to sample at all. It optimizes for the best model within a time or compute budget using CFO (Cost-Frugal Optimization), which prioritizes cheap-to-evaluate configurations early and escalates only when the estimated marginal gain justifies the spend.

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 ning savdo uchun afzalligi heterojen model turlari bo'yicha hisoblash taqsimotidir. Agar LightGBM konfiguratsiyalari CatBoost-ga qaraganda 10 baravar tezroq baholansa, FLAML ko'proq LightGBM-ni erta o'rganadi va faqat marjinal yaxshilanish xarajatlarni oqlaganida o'tadi. Bu krossover maqolasidan olingan arzon rejim tushunchasi, umumlashtirilgan: o'tkazish qobiliyati qidiruv byudjetidagi birinchi darajali atama bo'lib, amalga oshirish tafsilotlari emas.

Traektoriya jurnali saqlashga arziydigan qismdir. ZXQKEEP0QXZ sizga to'liq konfiguratsiya tarixini taqdim etadi, bu sizning sinov sanangiz - va sinovlar soni siz qarzdor bo'lgan har bir deflyatsiyaga kirishdir.

Savdo modellari uchun neyron arxitektura qidiruvi

Neural Architecture Search automates the design of network topologies rather than the tuning of a fixed one. Architecture choice for financial series is genuinely non-obvious — non-stationarity, low signal-to-noise, mixed frequencies and dependencies spanning minutes to months all pull in different directions — but that motivation is already argued concretely elsewhere: see Temporal Fusion Transformer on when TFT beats LSTM beats vanilla Transformer, and DeepLOB on the CNN+Inception+LSTM tradeoff, for what carefully hand-designed fixed architectures already achieve. NAS is the argument that this choice should itself be searched.

Research on Neuroevolution NAS for Stock Return Prediction reports that RNNs evolved via EXAMM (Evolutionary eXploration of Augmenting Memory Models) outperformed the DJI and S&P 500 in both bear (2022) and bull (2023) markets using simple long-short strategies. Treat that as a third-party claim, not as a result reproduced here — it is a best-of-search figure with no deflation reported.

Savdo uchun NAS qidiruv maydoni

Savdo modellari uchun amaliy NAS qidiruv maydoni quyidagilarni o'z ichiga oladi: A practical NAS search space for trading models includes:

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-dan NNI (Neural Network Intelligence) yordamida siz ushbu bo'shliqni aniqlashingiz va qidirishingiz mumkin: With NNI (Neural Network Intelligence) from Microsoft, you can define and search this space:

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)

Qidiruv algoritmi (ENAS, DARTS yoki evolyutsion) nomzod arxitekturasini moliyaviy maqsaddan foydalangan holda tekshirish to'plamida baholaydi, so'ngra yuqori samarali topologiyalar tomon asta-sekin torayadi. Ushbu maqoladagi boshqa hamma narsaga nisbatan xarajat assimetriyasiga e'tibor bering: NAS baholash o'qining eng qimmat oxirida joylashgan, ya'ni namunali samarali namuna oluvchilar va ko'p aniqlikdagi budama o'zlari uchun haq to'laydigan yagona rejim.

WorldQuant Alpha Factory yondashuvi

WorldQuantning alfa kashfiyotiga yondashuvi moliya sohasida AutoML tamoyillarini eng sanoat miqyosda amalga oshirishdir. Igor Tulchinskiy tomonidan asos solingan WorldQuant ular "alfa-zavod" deb ataydigan tizimni boshqaradi - millionlab bashoratli signallarni ishlab chiqarish, sinovdan o'tkazish va birlashtirish uchun tizimli jarayon.

Falsafa: eksponensial alfa avlodi va uni tuzatish

WorldQuant 2010 yilda bir million alfaga erishishni maqsad qilgan, bir vaqtning o'zida ular yiliga atigi bir necha ming ishlab chiqargan. Ular bu maqsadga 2016 yilda erishdilar. Falsafa faol boshqaruvning asosiy qonuniga tayanadi:

ZXQKEEP0QXZ

bu yerda ZXQKEEP0QXZ axborot nisbati, ZXQKEEP1QXZ axborot koeffitsienti va ZXQKEEP2QXZ kengligi — mustaqil garovlar soni. Har bir alohida ZXQKEEP3QXZ zaif bashoratchi hisoblanadi; da'vo shundaki, etarlicha zaif korrelyatsiya qilinganlarni birlashtirib, kichik IC'larni mazmunli xavfga moslashtirilgan daromadga aylantiradi.

The correction that makes or breaks this, and that the naive reading of the formula hides: breadth is not trial count. $BR$ counts independent bets, and generated alphas are not independent — they are composed from the same operators over the same price and volume fields, so they inherit each other's correlation structure. This blog measured the effect directly in Signal Correlation: effective breadth is $N_{eff} = N / C_f$, and with a typical crypto correlation factor $C_f \approx 3$, ten signals are worth about 3.3 independent ones. The $\sqrt{BR}$ term does not grow with how many alphas you generated; it grows with how many uncorrelated ones survived. A million correlated alphas buy you far less than the formula advertises.

Shuning uchun quyida keltirilgan 3-bosqich - mavjud kutubxona bilan dekoratsiya - alfa zavodida gigiena bosqichi emas. Bu birinchi navbatda kenglikni keltirib chiqaradigan qadamdir.

101 formulali alfa

The paper "101 Formulaic Alphas" by Kakushadze (associated with WorldQuant research) published a set of formulaic alpha expressions — mathematical expressions over price, volume and fundamental data: The paper "101 Formulaic Alphas" by Kakushadze (associated with WorldQuant research) published a set of formulaic alpha expressions — mathematical expressions over price, volume and fundamental data:

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

Buni AutoML uchun qiziqarli qiladigan narsa shundaki, u grammatika. Alfalar kichik operatorlar to'plamining ( ZXQKEEP0QXZ , ZXQKEEP1QXZ , ZXQKEEP2QXZ , ZXQKEEP3QXZ , ZXQKEEP4QXZ , ZXQKEEP5QXZ ) kichik maydonlar to'plamidagi ( ZXQKEEP6QKEEP5QXZ , Z7QX , Z8QX ) kompozitsiyalaridir. , ZXQKEEP9QXZ , ZXQKEEP10QXZ ). Grammatikani sanab o'tish mumkin, ya'ni qidiruv maydoni "yaxshi xususiyat haqida o'ylash" bo'lmagan tarzda mashinada yaratilishi mumkin. AutoML tizimi quyidagilarni amalga oshirishi mumkin:

1. Maʼlumotlar maydonlari ustida operatorlar tuzish orqali Nomzod ifodalarini yaratish
2. Baholash har bir ifodaning IC, aylanmasi va qisqarishi
3. Filtr statistik sinovdan o‘tgan va mavjud kutubxona bilan yetarli darajada bog‘liq bo‘lmagan ifodalar uchun
4. Omon qolganlarni portfelga birlashtiring

E'tibor bering, 1 va 2-bosqichlar oson, 3-qadam esa qiymat qaerda - yuqoridagi kenglikdagi tuzatishga qarang.

LLM - Kengaytirilgan Alpha Discovery

WorldQuant has begun integrating large language models into the alpha factory. As reported in financial press, the firm is exploring how LLMs can "transform and discover alphas across different domains" — generating novel expressions, translating research papers into testable hypotheses, and surfacing cross-domain relationships that a pure enumerative search would miss. This is a different mechanism from extracting signals from text, which this blog covers in LLM Alpha Mining on Earnings Calls; here the LLM writes the formula, not the feature.

O'z Mini Alpha zavodingizni qurish

Mana operator grammatikasi bo'yicha ixcham, ammo funktsional alfa zavodi: Here is a compact but functional alpha factory over the operator grammar:

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

Beshta oynadan ortiq oltita shablon 30 ta konfiguratsiyadan iborat. U ishlab chiqaradigan hisobotda bu sxematik shakl mavjud - maydonlar zavod chiqaradigan va hech qanday raqamlar to'ldirilmagan, chunki bu erda hech kim o'lchanmagan: Six templates over five windows is a 30-configuration sweep. The report it produces has this schematic shape — the fields are what the factory emits, and no numbers are filled in because none have been measured here:

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

The raw Sharpe of the top alpha out of a 30-configuration sweep is not a result — it is the maximum of 30 draws, and on 1,000 zero-edge strategies the best annualized Sharpe averages 1.63 while the naive test declares a discovery 100% of the time (Deflated Sharpe Ratio). The honest deliverable from a factory is therefore not "we found an alpha" but how many alphas survived deflation: the IC distribution, the trial count, the winner's DSR against that count, and the PBO of the selection. That is the measurement this section still owes.

Guardrails: Siz allaqachon qarzdorsiz

AutoML kashfiyot va haddan tashqari moslashishni teng darajada kuchaytiradi va buni farq unchalik sezilmaydigan bo'lgan sinovlarda amalga oshiradi. Ularning har biri boshqa joylarda chuqur yoritilgan; Gap shundaki, AutoML ularning barchasini tavsiya qilishdan ko'ra majburiy qiladi.

Price the search, do not merely correct it. A feature-model-hyperparameter sweep is a trial count and the trial count moves the bar — see The Deflated Sharpe Ratio.

Validate temporally, with purging and embargo. See Walk-Forward Optimization and the Look-Ahead Bias Taxonomy for the leaks that survive a naive temporal split.

Score the procedure, not just the winner. See Probability of Backtest Overfitting, and carry its load-bearing correction: PBO's null is 0.5, not 1 — half is not "half overfit," it is fully overfit, a coin flip.

Watch for peaks that are not there. Searching a noise-dominated surface efficiently just finds sharper illusions faster (Plateau Analysis); this bites hardest on strategy parameters and least on ML hyperparameters, which is the case FLAML and Optuna are actually built for.

Qidiruv maydonini cheklang. Minimal barg namunalari, chegaralangan chuqurlik va hisoblagichlar soni, funksiyalar byudjeti, aylanma jarima — qidiruvni tartibga solish uni keyinroq o‘chirishdan ko‘ra arzonroqdir.

Xulosa

AutoML avtomatlashtirishni bir darajaga ko'taradi: sobit nomzod ichidagi parametrlarni sozlashdan nomzodlarning o'zlarini yaratishgacha. Uchta komponent kuch sarflashga arziydi — xususiyatlarni yaratish uchun tsfresh va Featuretools, byudjetni hisobga oladigan model tanlash uchun FLAML-ning tejamkor qidiruvi va sanab o'tiladigan alfa qurilishi uchun formulali operator grammatikasi. NAS faqat sizning signal-shovqin nisbati uni oqlagandagina hisoblab chiqishga arziydi va u namunaviy samaradorlik nihoyat to'lanadigan baho-xarajat o'qining qimmat oxirida yashaydi.

WorldQuant kengligi argumenti ushbu blogning o'z o'lchovlari bilan aloqa qilganda faqat tuzatilgan shaklda saqlanib qoladi: ZXQKEEP0QXZ bu erda ZXQKEEP1QXZ mustaqil garovlarni hisoblaydi va zavod mahsuloti mustaqil emas. Bir million alfa yaratish - bu oson yarmi. Ularning kenglik sifatida hisoblash uchun etarli darajada o'zaro bog'liq emasligini aniqlash, formulaning biror narsani anglatishini aniqlaydigan yarmidir.

And the honest caveat is not a moral, it is a measured result. This blog ran the search-and-overfit arc to its conclusion in The Honest Negative: tens of thousands of backtests across five majors, DSR = 0.00 at ~37,000 trials, PBO 0.264 and 0.327, and no robust edge. AutoML raises the trial count by orders of magnitude. Whatever it finds, it will owe a correspondingly larger deflation — and the useful output of an alpha factory is the survival rate after that deflation, not the top line before it. And the honest caveat is not a moral, it is a measured result. This blog ran the search-and-overfit arc to its conclusion in The Honest Negative : tens of thousands of backtests across five majors, DSR = 0.00 at ~37,000 trials, PBO 0.264 and 0.327, and no robust edge. AutoML raises the trial count by orders of magnitude. Whatever it finds, it will owe a correspondingly larger deflation — and the useful output of an alpha factory is the survival rate after that deflation, not the top line before it.