Разработка модели прогнозирования волатильности

Разработка модели прогнозирования волатильности

Прогнозирование волатильности — отдельная и высокоценная задача в трейдинге. Знание ожидаемой волатильности позволяет: адаптировать размер позиции, выбирать оптимальную ширину спреда для маркет-мейкинга, правильно ценить опционы и планировать риск-менеджмент.

Метрики волатильности

Realized Volatility — историческая волатильность, вычисленная из исторических returns:

import numpy as np
import pandas as pd

def realized_volatility(returns, window=24, annualize=True):
    """
    Парковс оценка RV — стандарт для дневных данных
    """
    rv = returns.rolling(window).std()
    if annualize:
        rv = rv * np.sqrt(365 * 24)  # annualized для hourly данных
    return rv

def realized_volatility_parkinson(highs, lows, window=24, annualize=True):
    """
    Parkinson estimator использует High/Low — более эффективная оценка
    """
    log_hl = (np.log(highs) - np.log(lows)) ** 2
    rv_parkinson = np.sqrt(log_hl.rolling(window).mean() / (4 * np.log(2)))
    if annualize:
        rv_parkinson = rv_parkinson * np.sqrt(365 * 24)
    return rv_parkinson

def realized_volatility_garman_klass(opens, highs, lows, closes, window=24):
    """
    Garman-Klass: использует O/H/L/C — наиболее эффективный estimator
    """
    log_hl = 0.5 * (np.log(highs/lows)) ** 2
    log_co = (2*np.log(2) - 1) * (np.log(closes/opens)) ** 2
    gk = np.sqrt((log_hl - log_co).rolling(window).mean() * 365 * 24)
    return gk

GARCH модели

GARCH(1,1) — классическая модель условной волатильности. Волатильность сегодня зависит от волатильности вчера и квадрата вчерашнего return:

from arch import arch_model
import warnings

def fit_garch_model(returns, model_type='GARCH', p=1, q=1, vol='GARCH', dist='t'):
    """
    dist='t': распределение Стьюдента лучше описывает fat tails крипты
    """
    # returns в процентах для численной стабильности
    returns_pct = returns * 100
    
    model = arch_model(
        returns_pct,
        vol=vol,          # 'GARCH', 'EGARCH', 'GJR-GARCH'
        p=p, q=q,
        dist=dist,        # 'normal', 't', 'ged'
        mean='Constant'
    )
    
    with warnings.catch_warnings():
        warnings.simplefilter('ignore')
        result = model.fit(disp='off', options={'maxiter': 500})
    
    return result

def forecast_volatility_garch(garch_result, horizon=24):
    """Прогноз волатильности на следующие N периодов"""
    forecast = garch_result.forecast(horizon=horizon, reindex=False)
    
    # Conditional variance (потом берём sqrt для std)
    variance_forecast = forecast.variance.values[-1]
    vol_forecast = np.sqrt(variance_forecast) / 100  # обратно в доли
    
    return vol_forecast

# EGARCH: ассиметричная модель (bad news > good news in volatility)
# GJR-GARCH: аналогично, leverage effect

ML модели для волатильности

HAR-RV (Heterogeneous Autoregressive Realized Volatility): линейная модель с разными горизонтами:

def create_har_features(realized_vol, horizons=[1, 5, 22]):
    """
    HAR модель: RV предсказывается через свои же лаговые средние
    """
    features = {}
    for h in horizons:
        features[f'rv_avg_{h}d'] = realized_vol.rolling(h).mean().shift(1)
    
    return pd.DataFrame(features).dropna()

from sklearn.linear_model import Ridge

def train_har_model(rv_series, horizons=[1, 5, 22]):
    X = create_har_features(rv_series, horizons)
    y = rv_series.shift(-1).dropna()  # предсказываем завтрашнюю RV
    
    # Выравниваем индексы
    common_idx = X.index.intersection(y.index)
    X, y = X.loc[common_idx], y.loc[common_idx]
    
    model = Ridge(alpha=0.1)
    model.fit(X, y)
    return model

LSTM для волатильности: захватывает нелинейные паттерны и долгосрочную память:

import torch
import torch.nn as nn

class VolatilityLSTM(nn.Module):
    def __init__(self, input_size=10, hidden_size=64, output_horizon=24):
        super().__init__()
        self.lstm = nn.LSTM(input_size, hidden_size, 2, batch_first=True, dropout=0.2)
        self.fc = nn.Sequential(
            nn.Linear(hidden_size, 32),
            nn.ReLU(),
            nn.Linear(32, output_horizon)  # предсказываем весь горизонт
        )
    
    def forward(self, x):
        out, _ = self.lstm(x)
        return self.fc(out[:, -1, :])

Realized GARCH (комбинированный подход)

Объединяет преимущества GARCH и Realized Volatility:

def realized_garch_forecast(returns, rv_history, omega=0.1, alpha=0.1, 
                              beta=0.8, gamma=0.5):
    """
    Упрощённая Realized GARCH:
    h_t = omega + alpha * rv_{t-1} + beta * h_{t-1} + gamma * z_{t-1}^2
    """
    h = np.zeros(len(returns))
    h[0] = rv_history.iloc[0] ** 2
    
    for t in range(1, len(returns)):
        h[t] = (omega + 
                alpha * rv_history.iloc[t-1] ** 2 + 
                beta * h[t-1] + 
                gamma * returns.iloc[t-1] ** 2)
    
    return np.sqrt(h)

Оценка качества прогнозов волатильности

def evaluate_vol_forecast(actual_rv, predicted_rv):
    """Метрики для оценки качества прогноза волатильности"""
    mse = np.mean((actual_rv - predicted_rv) ** 2)
    mae = np.mean(np.abs(actual_rv - predicted_rv))
    
    # Mincer-Zarnowitz regression (forecast unbiasedness)
    from scipy.stats import linregress
    slope, intercept, r_value, p_value, _ = linregress(predicted_rv, actual_rv)
    
    # QLIKE (quasi-likelihood) — стандарт��ая метрика для vol forecasting
    qlike = np.mean(actual_rv / predicted_rv - np.log(actual_rv / predicted_rv) - 1)
    
    return {
        'mse': mse, 'mae': mae, 'r_squared': r_value**2,
        'mz_slope': slope, 'mz_intercept': intercept,
        'qlike': qlike
    }

Применение в торговле

Position sizing: при высокой прогнозируемой волатиль��ости → уменьшаем размер позиции:

def vol_adjusted_position_size(base_size, predicted_vol, target_vol=0.02):
    scaling = target_vol / max(predicted_vol, 1e-8)
    return base_size * min(scaling, 2.0)  # max 2x от базового

Dynamic stop-loss: стоп на N × predicted_vol от входа.

Options pricing: для крипто-опционов predicted_vol используется как implied volatility estimate.

Разрабатываем систему прогнозирования волатильности: GARCH/EGARCH, HAR-RV, LSTM модели, ensemble averaging, integration с position sizing и мониторинг forecast accuracy.