2026-05-01 · 9 мин чтения · #methodology #hurst #adf #walk-forward #backtest #python

Hurst, ADF и walk-forward бэктест: практический гайд

Практическое руководство по Hurst exponent, ADF-тесту и walk-forward бэктесту для парного трейдинга крипты. С Python-кодом и реальными данными.

Большая часть «парного трейдинга» в крипто-контенте уходит в одну из двух крайностей: либо это маркетинговая копирайтерская работа («наш фирменный алгоритм находит выигрышные сделки!»), либо академический пейпер для PhD-аудитории. Этот пост посередине. Если ты слышал про mean-reversion testing, но никогда сам не кодил — здесь будет ровно столько математики, чтобы быть опасным, и рабочий Python на каждом шаге.

Разберём три вещи по порядку: как протестировать что пара mean-revert'ит (Hurst exponent + ADF), как объединить эти тесты с операционными фильтрами (ширина диапазона, чередующиеся касания), и как бэктестить полученную стратегию без lookahead bias.

Весь код запускается. Все ссылки — на реальные академические работы. В конце ты сможешь оценить любую крипто-пару сам в ~50 строк Python.

Что значит «mean-reversion в ratio»

Берём два актива, A и B. Считаем log-ratio:

import numpy as np
log_ratio = np.log(price_a / price_b)

Логарифм здесь важен. Без него ratio мультипликативное и отклонение от «справедливого значения» сидит несимметрично вокруг среднего. С log отклонения аддитивные, и стандартные статистические тесты работают чисто.

Пара «mean-revert'ит» если когда log_ratio уходит выше среднего, она имеет тенденцию возвращаться вниз (и наоборот). Визуально: представь log-ratio болтающийся внутри горизонтального диапазона, никогда не сбегающий из него. Вот картинка.

Если log-ratio дрейфует в одну сторону без возврата — как делал бы трендовый актив — пара не mean-revert'ит, и парный трейдинг на ней теряет деньги.

Вопрос становится: как отличить mean-reversion от тренда статистически?

Тест 1: Hurst exponent

Hurst exponent (H. E. Hurst, 1951, изначально разработан для наводнений Нила) измеряет долгую память временного ряда. Это одно число, обычно между 0 и 1:

H < 0.5: anti-persistent / mean-reverting (нам нужно)
H = 0.5: random walk (нет полезного паттерна)
H > 0.5: persistent / trending (фильтруем)

Есть несколько способов оценить Hurst. Самый классический — rescaled range (R/S) analysis:

import numpy as np

def hurst_exponent(series, max_lag=20):
    """Hurst через R/S analysis. < 0.5 = mean-reverting."""
    series = np.asarray(series)
    if len(series) < max_lag * 2:
        raise ValueError("Series too short")

    lags = range(2, max_lag)
    tau = []
    for lag in lags:
        diff = series[lag:] - series[:-lag]
        tau.append(np.sqrt(np.std(diff)))

    poly = np.polyfit(np.log(lags), np.log(tau), 1)
    return poly[0] * 2.0

Применять к log-ratio, не к сырым ценам:

log_ratio = np.log(price_a / price_b)
h = hurst_exponent(log_ratio)
print(f"Hurst: {h:.3f}")  # < 0.5 = mean-reverting

Практические наблюдения от прогона на реальных крипто-парах:

Мемы (DOGE, SHIB, PEPE, WIF) почти никогда не показывают H < 0.5. Они трендят в одну сторону агрессивно.
Cross-asset пары (крипта vs tokenized equities) кластеризуются вокруг H ≈ 0.4 — устойчиво mean-reverting, потому что underlying drivers (BTC dominance, USD strength) часто резетятся.
Чисто крипто-vs-крипто пары вокруг H ≈ 0.45, с высокой дисперсией.

Hurst R/S известно чувствителен к выбору max_lag. Разные lag'и дают слегка разные значения на одной серии. Default max_lag=20 хорошо работает на дневных данных; экспериментируй для интрадея.

Тест 2: Augmented Dickey-Fuller

ADF (Dickey & Fuller, 1979) — unit-root тест. Интуиция: если у ряда есть unit root, он ведёт себя как random walk и не возвращается к стабильному среднему. Если можем отвергнуть unit-root гипотезу (низкое p-value), ряд стационарен — у него есть стабильное среднее к которому возвращаться.

Используем statsmodels:

from statsmodels.tsa.stattools import adfuller

def adf_pvalue(series):
    result = adfuller(series, autolag='AIC')
    return result[1]  # p-value

p = adf_pvalue(log_ratio)
print(f"ADF p-value: {p:.3f}")  # ниже = более стационарно

Здесь я расхожусь со стандартной академической практикой. Стандартный ADF-порог p < 0.05. Для крипто-данных это слишком строго.

Крипто-таймсерии шумнее equity-серий — отдельные плохие свечи, low-volume gap'ы, exchange-specific quirks вносят шум, влияющий на ADF p-value не затрагивая реальное mean-reversion поведение. Если использовать p < 0.05 строго, отвергаешь genuinely mean-reverting пары.

Мы используем p < 0.7 в комбинации с другими фильтрами. Мягкий порог плюс комплементарные фильтры дают более качественную дискриминацию, чем строгий ADF в одиночку. К этому пришли после прогона фильтра на сотнях пар и сравнения классификаций с визуальной инспекцией графиков log-ratio.

Если бы у тебя был только ADF и больше ничего, p < 0.05 был бы оправдан. С Hurst плюс операционными фильтрами в миксе p < 0.7 — правильный уровень.

Операционные фильтры: ширина диапазона и чередующиеся касания

Два фильтра, которые не статистические, но критичны операционно:

Ширина диапазона. Log-ratio должен охватывать минимум 40% его исторического диапазона. Если ratio колеблется только ±5%, даже идеальный тайминг не превысит 0.1% × 2 fee на round-trip.

def range_width(log_ratio):
    return np.max(log_ratio) - np.min(log_ratio)

Чередующиеся касания границ. Серия должна касаться и верхней и нижней границы своего диапазона несколько раз попеременно. Это отличает реально осциллирующую серию от той, что один раз посетила экстремум и осталась на одной стороне (что сгенерировало бы одну сделку, а не стратегию).

def alternating_touches(log_ratio, p_low_pct=5, p_high_pct=95):
    low = np.percentile(log_ratio, p_low_pct)
    high = np.percentile(log_ratio, p_high_pct)

    touches_low, touches_high = 0, 0
    last = None  # 'low', 'high', or None

    for value in log_ratio:
        if value <= low and last != 'low':
            touches_low += 1
            last = 'low'
        elif value >= high and last != 'high':
            touches_high += 1
            last = 'high'

    return touches_low, touches_high

Требуем ≥ 2 чередующихся касания на сторону. Плюс underlying volume-фильтр ($1M+ дневной спот для обеих ног) чтобы держать slippage под контролем.

Объединяем фильтры

def is_mean_reverting(price_a, price_b,
                     hurst_max=0.5,
                     adf_max=0.7,
                     min_range=0.4,
                     min_touches=2):
    log_ratio = np.log(np.asarray(price_a) / np.asarray(price_b))

    h = hurst_exponent(log_ratio)
    if h >= hurst_max:
        return False, f"Hurst {h:.3f} >= {hurst_max}"

    p = adf_pvalue(log_ratio)
    if p >= adf_max:
        return False, f"ADF p {p:.3f} >= {adf_max}"

    rw = range_width(log_ratio)
    if rw < min_range:
        return False, f"Range {rw:.3f} < {min_range}"

    low, high = alternating_touches(log_ratio)
    if low < min_touches or high < min_touches:
        return False, f"Touches {low}/{high} < {min_touches}"

    return True, f"H={h:.3f}, p={p:.3f}, range={rw:.3f}, touches={low}/{high}"

Около 30-40% пар проходят Hurst и ADF фильтры в любом окне. Это падает до 10-15% после добавления range и volume фильтров. Так что комбинация четырёх фильтров достаточно ограничительна чтобы давать уверенность, но не настолько строга чтобы тебе нечего было торговать.

Сложная часть: walk-forward бэктест

Это секция, где большая часть retail-targeted парного трейдинга делает критическую ошибку. Они запускают «in-sample» бэктест где entry/exit пороги считаются из полного семпла, включая будущие данные. Это даёт inflated returns, потому что в момент решения t ты по факту читишь, зная полный исторический диапазон.

Правильный подход — walk-forward. На каждой decision point t используем только данные до t для определения порогов. Перцентильные границы пересчитываются каждый день на скользящем окне. Это единственный способ честно симулировать «что было бы если бы я гонял это в реальном времени».

Разница в коде. Неправильный путь:

# WRONG — использует full-sample percentiles, has lookahead
p5_full = np.percentile(log_ratio, 5)
p95_full = np.percentile(log_ratio, 95)

for t in range(len(log_ratio)):
    # использует p5_full и p95_full — выведенные из БУДУЩИХ данных!
    position = (log_ratio[t] - p5_full) / (p95_full - p5_full)
    ...

Правильный путь:

# RIGHT — rolling percentiles, no lookahead
def walk_forward_backtest(price_a, price_b,
                          lookback=540,
                          entry_low=0.2,
                          entry_high=0.8,
                          fee_pct=0.001,
                          initial_a=100.0):
    log_ratio = np.log(np.asarray(price_a) / np.asarray(price_b))

    a_qty = initial_a
    b_qty = 0.0
    holding_a = True
    trades = []

    for t in range(lookback, len(log_ratio)):
        # КРИТИЧНО: только данные до (не включая) t
        window = log_ratio[t - lookback:t]
        p5 = np.percentile(window, 5)
        p95 = np.percentile(window, 95)

        current = log_ratio[t]
        if p95 > p5:
            position = (current - p5) / (p95 - p5)
        else:
            position = 0.5

        if position < entry_low and not holding_a:
            ratio = np.exp(current)
            a_qty = b_qty * ratio * (1 - fee_pct)
            b_qty = 0.0
            holding_a = True
            trades.append(('B->A', t, position))

        elif position > entry_high and holding_a:
            ratio = np.exp(current)
            b_qty = a_qty / ratio * (1 - fee_pct)
            a_qty = 0.0
            holding_a = False
            trades.append(('A->B', t, position))

    return a_qty, b_qty, trades

Критическая строка — window = log_ratio[t - lookback:t]. Если напишешь [t - lookback:t + 1] вместо неё — включая индекс t — ты ввёл lookahead. Результаты бэктеста будут на 10-30% лучше реального исполнения. Это #1 источник fake alpha в retail-бэктестах.

Как проверить что в твоём бэктесте нет lookahead bias

Самый коварный баг. Легко пропустить на ревью. Легко проверить тестом.

Тест: запустить бэктест дважды. Во второй раз заменить все цены после некоторого midpoint мусорными значениями. Затем сравнить сделки до midpoint между двумя прогонами. Они должны быть идентичны.

def test_no_lookahead(backtest_fn, price_a, price_b, midpoint=700):
    """Если сделки до midpoint меняются когда будущие данные
    закорраптены — у бэктеста есть lookahead bias."""

    pa_corrupted = price_a.copy()
    pb_corrupted = price_b.copy()
    pa_corrupted[midpoint:] = 999999.0
    pb_corrupted[midpoint:] = 0.0001

    _, _, trades_clean = backtest_fn(price_a, price_b)
    _, _, trades_corrupted = backtest_fn(pa_corrupted, pb_corrupted)

    trades_clean_before = [t for t in trades_clean if t[1] < midpoint]
    trades_corr_before = [t for t in trades_corrupted if t[1] < midpoint]

    assert trades_clean_before == trades_corr_before, "LOOKAHEAD BIAS"

Если этот тест проходит — бэктест честный. Если падает — где-то баг, который сливает будущую информацию в прошлые решения.

Я выложил полную имплементацию включая этот тест на github.com/pairscan/ratio-mean-reversion под MIT. Файл tests/test_no_lookahead.py — самый важный, это гейт, защищающий от subtle bias bug'ов в проде.

Собираем всё вместе: реальный пример

Запустим полный pipeline на ETH/USDT и BTC/USDT, 540 дней дневных свечей с Binance:

import ccxt
import numpy as np

binance = ccxt.binance()
since = binance.parse8601('2024-11-01T00:00:00Z')

eth = binance.fetch_ohlcv('ETH/USDT', '1d', since=since, limit=540)
btc = binance.fetch_ohlcv('BTC/USDT', '1d', since=since, limit=540)

eth_close = np.array([c[4] for c in eth])
btc_close = np.array([c[4] for c in btc])

# Шаг 1: Mean-revert'ит ли пара?
passed, reason = is_mean_reverting(eth_close, btc_close)
print(f"Pair ETH/BTC: {passed}, {reason}")

# Шаг 2: Если да — walk-forward бэктест
if passed:
    a, b, trades = walk_forward_backtest(eth_close, btc_close)
    print(f"Final ETH: {a:.2f}, BTC: {b:.5f}")
    print(f"Trades: {len(trades)}")

Типичный результат для ETH/BTC за 540 дней: H ≈ 0.43, ADF p ≈ 0.45, ширина диапазона ≈ 50%, 4 чередующихся касания, проходит фильтр — и 2-3 сделки в walk-forward бэктесте. Это не high-frequency. Это «своп раз в пару месяцев когда ratio растягивается».

Где этот подход не работает

Несколько честных ограничений:

Размер семпла. Меньше 200 дней — это шум, не сигнал. Меньше 540 надо использовать очень мягкие Hurst/ADF пороги. Больше 3 лет — начинаются regime changes, которые делают сам тест менее значимым.

Selection bias. Пары, проходящие фильтр сегодня, не обязательно всегда проходили. Некоторые пары которые раньше проходили теперь сломаны (делистинги, коллапсы нарративов). Survivorship bias реален.

Тесты дескриптивны, не предиктивны. Пара, mean-revert'ившая в последние 540 дней, может не делать этого в следующие 540. Walk-forward только частично решает это — рынки regime-shift'ят.

Hurst R/S имеет дисперсию. Разные max_lag дают разные Hurst на одной серии. Robust к lag-выбору когда пара сильно mean-reverting; чувствителен на borderline-парах.

Реальное исполнение отличается от бэктеста. Slippage, exchange downtime, partial fills, withdrawal limits — ничего из этого нет в простом бэктесте. Реальные returns обычно на 10-30% ниже claim'ов бэктеста.

Что дальше

Если хочешь глубже, ниже references откуда я учил материал:

Lo, A.W. & MacKinlay, A.C. (1988). Stock Market Prices Do Not Follow Random Walks. Foundational random-walk vs mean-reversion paper.
Gatev, Goetzmann & Rouwenhorst (2006). Pairs Trading: Performance of a Relative-Value Arbitrage Rule. Классический empirical study на equity-парах.
Krauss, C. (2017). Statistical Arbitrage Pairs Trading Strategies: Review and Outlook. Полный обзор поля включая современные подходы.
Для глубокого treatment'а cointegration'a (мы здесь не используем, но близко связано), Engle & Granger (1987) — foundational paper.

Если хочешь пропустить реализацию: скринер на pairscan.io гоняет полный four-filter pipeline плюс walk-forward бэктест на 170+ парах каждые 6 часов, включая cross-asset пары с tokenized US equities. Free показывает топ-3 пары ежедневно.

Но математика полностью открыта. Любой может реализовать это за один вечер с кодом выше. Прогони на своих данных. Прогони на синтетических Ornstein-Uhlenbeck и Geometric Brownian Motion рядах для проверки что фильтр классифицирует их корректно. Смысл этого поста — показать, что методология не proprietary, это семьдесят лет публичной статистики применённой к относительно новому asset class'у.