> Machine Learning Guru|

В этой статье я хочу поделиться своим подходом к использованию вероятностных моделей для прогнозирования цен активов. Мы разберем, почему традиционные методы часто подводят, какие подходы применяют профессионалы в хедж-фондах, и как вы можете использовать Python для реализации таких моделей. Моя цель — создать подробное руководство, которое будет полезно как для профессионалов в области data science, так и для тех, кто хочет углубиться в количественную аналитику.

Почему вероятностные модели популярны в биржевой аналитике?

Прогнозирование цен биржевых активов — это задача, которая кажется простой только на первый взгляд. Многие начинающие аналитики полагаются на такие методы, как скользящие средние, RSI или уровни Фибоначчи, но я считаю эти подходы устаревшими и малоэффективными. Рынок — это не линейная система, и его поведение редко подчиняется простым правилам. Например, линейная регрессия или ARIMA часто дают ложное чувство уверенности, игнорируя нелинейные зависимости и стохастическую природу цен. Даже методы машинного обучения, такие как SVM, k-means или логистическая регрессия, редко справляются с задачей, так как не учитывают временную структуру данных и рыночные аномалии.

Вероятностные модели, напротив, позволяют нам работать с неопределенностью напрямую. Вместо того чтобы предсказывать точную цену актива, они дают распределение возможных исходов, что гораздо ближе к реальной природе финансовых рынков. Такие модели, как скрытые марковские модели (HMM) или байесовские подходы, помогают уловить скрытые закономерности в данных, которые не видны при использовании традиционных индикаторов.

Вероятностные модели позволяют:

1. Моделировать неопределенность через вероятностные распределения;
2. Учитывать скрытые рыночные состояния (например, бычий или медвежий рынок);
3. Интегрировать внешние факторы, такие как макроэкономические данные или новостной фон;
4. Создавать гибкие модели, которые адаптируются к изменяющимся рыночным условиям.

Например, вместо того чтобы прогнозировать, что цена актива завтра будет $100, вероятностная модель может сказать, что с вероятностью 60% цена будет в диапазоне $95–$105, а с вероятностью 20% — ниже $95. Такой подход позволяет принимать более обоснованные решения, особенно в условиях высокой волатильности.

Основные типы вероятностных моделей

Скрытые марковские модели (HMM)

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

HMM особенно полезны, когда мы хотим выявить смену рыночных режимов. Например, модель может определить, что рынок перешел из бычьего состояния в медвежье, что сигнализирует о необходимости пересмотра торговой стратегии.

Давайте разберем, как HMM работает на практике и как интерпретировать результаты. Ниже пример кода на Python реализации HMM для анализа цен акций Booking.com.

# Установите библиотеку
# !pip install hmmlearn

import yfinance as yf
import numpy as np
from hmmlearn import hmm
import matplotlib.pyplot as plt

# Загрузка данных
ticker = "BKNG"  # Booking
data = yf.Ticker(ticker).history(period="1y")["Close"]
returns = data.pct_change().dropna().values.reshape(-1, 1)  # Процентные изменения, без NaN

# Обучение HMM с нормальным распределением
model = hmm.GMMHMM(n_components=3, n_iter=50, covariance_type="diag", random_state=42)
model.fit(returns)

# Предсказание скрытых состояний
hidden_states = model.predict(returns)

# Визуализация
plt.figure(figsize=(14, 7))
plt.plot(data[1:].values, color="black", label="Цена закрытия")
for i in range(model.n_components):
    idx = (hidden_states == i)
    plt.plot(np.arange(1, len(data))[idx], data[1:].values[idx], 'o', markersize=6, label=f'Состояние {i}')

plt.title(f'Скрытые состояния рынка для {ticker} (HMM)')
plt.xlabel('День')
plt.ylabel('Цена закрытия')
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()

Рис. 1: График цен акций Booking с наложенными скрытыми состояниями Hidden Markov Model (HMM)

В приведенном выше коде мы использовали библиотеку hmmlearn для построения модели с 3-мя скрытыми состояниями. Результатом является график, где точки, соответствующие разным состояниям, показывают, как рынок переключается между фазами. Это дает нам интуитивное представление о том, как рынок меняет свое поведение, и позволяет адаптировать торговые стратегии. Например, если модель указывает на переход в «зеленую фазу», можно рассмотреть шорт-позиции или хеджирование портфеля.

HMM базируются на предположении, что наблюдаемые данные (например, цены закрытия актива) зависят от скрытого состояния, которое само по себе не наблюдаемо. Каждое состояние имеет свое распределение (обычно нормальное или смесь нормальных распределений, как в GMM-HMM), а переходы между состояниями описываются матрицей вероятностей. Математически модель можно представить следующим образом:

$P(O | S) = \prod_{t=1}^T P(o_t | s_t), \quad P(S) = P(s_1) \prod_{t=2}^T P(s_t | s_{t-1}),$

где:

• O — наблюдаемые данные (цены или доходности);
• S — скрытые состояния;
• P(Ot|St) — вероятность перехода между состояниями.

Скрытые HMM модели — мощный инструмент для первичного анализа рынка, который позволяет быстро понять режимы движения активов. Однако эти модели не лишены недостатков:

1. Во-первых, они чувствительны к выбору количества состояний. Слишком малое число состояний упрощает модель и теряет детали, а слишком большое может привести к переобучению;
2. Во-вторых, HMM предполагают, что переходы между состояниями следуют марковскому процессу (будущее зависит только от текущего состояния), что не всегда соответствует реальным рынкам, где долгосрочные тренды тоже могут играть роль.

Несмотря на это, в хедж-фондах HMM часто используются как часть более сложных ансамблевых моделей, комбинируя их с другими подходами, такими как байесовские методы или нейронные сети.

Байесовские модели для прогнозирования цен

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

Байесовский подход основан на теореме Байеса:

$P(\theta | D) = \frac{P(D | \theta) P(\theta)}{P(D)},$

где:

• θ — параметры модели;
• D — наблюдаемые данные;
• P(θ) — априорное распределение параметров;
• P(D|θ) — правдоподобие данных.

В контексте прогнозирования цен это позволяет нам обновлять наши предположения о поведении актива по мере поступления новых данных.

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

Реализация байесовской модели с PyMC

Для реализации байесовских моделей я предпочитаю использовать библиотеку PyMC, которая позволяет гибко задавать вероятностные модели и проводить байесовский вывод с помощью методов Монте-Карло (MCMC). Давайте рассмотрим пример, где мы моделируем цену актива как случайное блуждание с дрейфом, учитывающим волатильность.

!pip install pymc arviz

import yfinance as yf
import pymc as pm
import numpy as np
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings("ignore")

# Загрузка данных
ticker = "BKNG"  # Booking
data = yf.Ticker(ticker).history(period="1y")["Close"].values
returns = np.diff(np.log(data))  # Логарифмические доходности

# Байесовская модель
with pm.Model() as model:
    mu = pm.Normal("mu", mu=0, sigma=0.1)
    sigma = pm.HalfNormal("sigma", sigma=0.1)
    
    # Наблюдаемые данные
    obs = pm.Normal("obs", mu=mu, sigma=sigma, observed=returns)

    # MCMC-сэмплирование
    trace = pm.sample(1000, tune=500, chains=2, cores=1, progressbar=True)

# Визуализация апостериорных распределений
pm.plot_posterior(trace, var_names=["mu", "sigma"], color="black")
plt.suptitle("Апостериорные распределения параметров")
plt.tight_layout()
plt.show()

# Прогноз цен на 10 дней вперед
n_forecast = 10
forecast = []
last_price = data[-1]

for _ in range(n_forecast):
    # Генерируем случайное значение из постериорного распределения
    mu_sample = np.random.choice(trace.posterior["mu"].values.flatten())
    sigma_sample = np.random.choice(trace.posterior["sigma"].values.flatten())
    
    sample_return = np.random.normal(mu_sample, sigma_sample)
    next_price = last_price * np.exp(sample_return)
    forecast.append(next_price)
    last_price = next_price

# Визуализация
plt.figure(figsize=(14, 7))
plt.plot(data, color="black", label="Исторические цены")
plt.plot(np.arange(len(data), len(data) + n_forecast), forecast, '--o', color="darkgray", label="Прогноз")
plt.title(f"Прогноз цен для {ticker} (Байесовский подход)")
plt.xlabel("День")
plt.ylabel("Цена закрытия")
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()

                                                                                                                   
  Progress                   Draws   Divergences   Step size   Grad evals   Sampling Speed    Elapsed   Remaining  
 ───────────────────────────────────────────────────────────────────────────────────────────────────────────────── 
  ━━━━━━━━━━━━━━━━━━━━━━━━   1500    0             0.94        3            1355.30 draws/s   0:00:01   0:00:00    
  ━━━━━━━━━━━━━━━━━━━━━━━━   1500    0             1.38        3            687.49 draws/s    0:00:02   0:00:00    

Рис. 2: Апостерирорные распределения параметров

Рис. 3: Прогноз цен акций Booking (Байесовский подход)

Этот код загружает исторические данные цен закрытия акций Booking.com (BKNG) и строит байесовскую модель, предполагающую, что логарифмические доходности следуют нормальному распределению с неизвестными параметрами μ (mu, дрейф) и σ (sigma, волатильность).

Мы задаем априорные распределения для этих параметров, используя нормальное распределение для μ и полунормальное для σ. Затем с помощью MCMC мы получаем апостериорные распределения параметров и используем их для прогнозирования цен на 10 дней вперед. Результатом является график апостериорных распределений параметров и прогноз цен, который учитывает неопределенность.

В отличие от традиционных методов, таких как скользящие средние, этот подход дает нам не только точечный прогноз, но и распределение возможных цен, что позволяет оценить риски. Например, мы можем вычислить доверительные интервалы для прогноза, что особенно полезно для управления рисками в портфеле.

Нейронные сети с вероятностным уклоном

Глубокие нейронные сети, особенно с вероятностным уклоном, сегодня стали стандартным инструментом в хедж-фондах благодаря их способности моделировать сложные нелинейные зависимости.

Вероятностные нейронные сети, такие как Bayesian Neural Networks (BNN) или Variational Autoencoders (VAE), позволяют не только предсказывать цены, но и оценивать их распределение. Это критически важно для финансов, где точечные прогнозы часто вводят в заблуждение.

Реализация LSTM с вероятностным выводом

Для демонстрации я покажу, как использовать рекуррентную нейронную сеть LSTM (Long Short-Term Memory) с библиотекой PyTorch для прогнозирования цен актива. Мы добавим вероятностный слой, чтобы модель возвращала не только прогноз, но и доверительные интервалы.

import numpy as np
import pandas as pd
import yfinance as yf
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset, random_split
from tqdm import tqdm

# Загрузка данных
ticker = 'BKNG'
start_date = '2022-05-15'
end_date = '2025-05-15'
df = yf.download(ticker, start=start_date, end=end_date)
prices = df['Close'].values.reshape(-1, 1)

# Масштабирование
scaler = MinMaxScaler()
prices_scaled = scaler.fit_transform(prices)

# Параметры
window_size = 30
batch_size = 64
hidden_size = 64
num_layers = 3
num_epochs = 250
learning_rate = 0.001

# Подготовка последовательностей
def create_sequences(data, window):
    X, y = [], []
    for i in range(len(data) - window):
        X.append(data[i:i+window])
        y.append(data[i+window])
    return np.array(X), np.array(y)

X, y = create_sequences(prices_scaled, window_size)
X_tensor = torch.tensor(X, dtype=torch.float32)
y_tensor = torch.tensor(y, dtype=torch.float32)

# Разделение на train/val
dataset = TensorDataset(X_tensor, y_tensor)
train_size = int(len(dataset) * 0.8)
val_size = len(dataset) - train_size
train_ds, val_ds = random_split(dataset, [train_size, val_size])
train_loader = DataLoader(train_ds, batch_size=batch_size, shuffle=True)
val_loader = DataLoader(val_ds, batch_size=batch_size, shuffle=False)

# Улучшенная модель
class ImprovedProbLSTM(nn.Module):
    def __init__(self, input_size=1, hidden_size=64, num_layers=2):
        super().__init__()
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers=num_layers, batch_first=True, dropout=0.2)
        self.dropout = nn.Dropout(0.3)
        self.fc_mean = nn.Linear(hidden_size, 1)
        self.fc_std = nn.Linear(hidden_size, 1)
        self.softplus = nn.Softplus()

    def forward(self, x):
        out, _ = self.lstm(x)
        out = self.dropout(out[:, -1, :])
        mean = self.fc_mean(out)
        std = self.softplus(self.fc_std(out)) + 1e-6  # избегаем нуля
        return mean, std

model = ImprovedProbLSTM(input_size=1, hidden_size=hidden_size, num_layers=num_layers)
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

# Потери
def gaussian_nll(y_true, mean, std):
    var = std ** 2
    return 0.5 * torch.mean((y_true - mean) ** 2 / var + torch.log(var) + np.log(2 * np.pi))

# Обучение
for epoch in range(num_epochs):
    model.train()
    train_loss = 0
    for xb, yb in tqdm(train_loader, desc=f"Epoch {epoch+1}/{num_epochs}"):
        xb = xb.view(-1, window_size, 1)
        optimizer.zero_grad()
        mean, std = model(xb)
        loss = gaussian_nll(yb, mean, std)
        loss.backward()
        optimizer.step()
        train_loss += loss.item()

    # Валидация
    model.eval()
    val_loss = 0
    with torch.no_grad():
        for xb, yb in val_loader:
            xb = xb.view(-1, window_size, 1)
            mean, std = model(xb)
            val_loss += gaussian_nll(yb, mean, std).item()
    
    print(f"Train loss: {train_loss/len(train_loader):.4f} | Val loss: {val_loss/len(val_loader):.4f}")

# Прогноз
model.eval()
X_all = torch.tensor(X, dtype=torch.float32).view(-1, window_size, 1)
with torch.no_grad():
    mean_pred, std_pred = model(X_all)
    mean_pred = mean_pred.numpy()
    std_pred = std_pred.numpy()

# Обратное масштабирование
mean_pred = scaler.inverse_transform(mean_pred)
std_pred = std_pred * (scaler.data_max_ - scaler.data_min_)

true_prices = prices[window_size:]
lower_bound = mean_pred.flatten() - 1.96 * std_pred.flatten()
upper_bound = mean_pred.flatten() + 1.96 * std_pred.flatten()

# Визуализация
plt.figure(figsize=(14,6))
plt.plot(true_prices, label='Истинная цена', color='black')
plt.plot(mean_pred, label='Прогноз', color='red')
plt.fill_between(np.arange(len(mean_pred)), lower_bound, upper_bound, color='blue', alpha=0.3, label='95% ДИ')
plt.title('Вероятностный прогноз цен акций BKNG')
plt.xlabel('Дни')
plt.ylabel('Цена')
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()

Рис. 4: Вероятностный прогноз котировок BKNG построенный с помощью нейронной сети LSTM

Этот код реализует LSTM-модель с вероятностным слоем. Мы загружаем данные цен закрытия акций Booking (BKNG), нормализуем их с помощью MinMaxScaler, создаем последовательности для обучения LSTM и обучаем модель. Вероятностный слой позволяет получить не только средний прогноз, но и доверительные интервалы, которые показывают неопределенность предсказаний.

Результатом является график, где черная линия показывает реальные цены, красная — прогноз, а затененная синяя область — 95% доверительный интервал. Такой подход позволяет трейдерам оценить не только ожидаемую цену, но и потенциальные риски, что особенно полезно при высокой волатильности, характерной для акций Booking.

Ансамблевые модели в прогнозировании цен активов

В своей практике я часто сталкиваюсь с тем, что ни одна модель, какой бы мощной она ни была, не способна в одиночку идеально описать поведение финансовых рынков. Ансамблевые модели объединяют несколько алгоритмов, чтобы повысить точность прогнозов, снизить риски переобучения и учесть различные аспекты рыночной динамики.

Ансамблевые модели работают по принципу «мудрости толпы»: они комбинируют предсказания от разных алгоритмов, таких как скрытые марковские модели (HMM), байесовские сети или нейронные сети, чтобы получить более устойчивый и точный результат.

Например, одна модель может быть хороша в выявлении краткосрочных трендов, другая — в анализе долгосрочной волатильности, а третья — в учете внешних факторов, таких как новостной фон. Объединяя их, мы получаем прогноз, который лучше справляется с хаотичной природой рынка.

Типы ансамблевых моделей

В биржевой аналитике чаще всего используют три типа ансамблевых подходов: stacking, boosting и bagging, адаптированные под задачи финансового моделирования. Давайте разберем каждый из них и посмотрим, как они применяются для прогнозирования цен активов.

Stacking: объединение сильных сторон моделей

Stacking (или мета-ансамбли) предполагает обучение нескольких базовых моделей, а затем использование их предсказаний как входных данных для мета-модели, которая делает финальный прогноз.

В контексте финансов это может выглядеть так: мы обучаем HMM для выявления скрытых состояний рынка, LSTM для анализа временных зависимостей и байесовскую модель для учета макроэкономических факторов. Затем мета-модель (например, градиентный бустинг или даже простая линейная регрессия) объединяет их предсказания, присваивая веса в зависимости от их производительности.

Stacking особенно полезен, когда нужно учесть разные типы данных. Например, HMM может анализировать цены закрытия, LSTM — последовательности объемов торгов, а байесовская модель — новостной сентимент. В хедж-фондах такие модели часто настраиваются на специфические активы, чтобы максимизировать их предсказательную силу. Однако stacking требует тщательной настройки, чтобы избежать переобучения, и может быть вычислительно затратным.

Boosting: последовательное улучшение прогнозов

Boosting подразумевает под собой такие алгоритмы XGBoost, LightGBM или CatBoost. В бустингах базовые модели (обычно деревья решений) обучаются так, чтобы каждая последующая модель корректировала ошибки предыдущей. Это делает их особенно эффективными для задач, где данные зашумлены, что идеально подходит для финансовых рынков.

Представьте, что вы пытаетесь предсказать цену криптовалюты, например Bitcoin, где волатильность может быть вызвана как рыночными факторами, так и твитами известных личностей. Boosting-модель, такая как XGBoost, может сначала выявить общие тренды, а затем сосредоточиться на аномалиях, таких как резкие скачки цен после новостей.

В хедж-фондах бустинги часто комбинируют с масштабным feature engineering, чтобы включить такие переменные, как волатильность, фильтры, объем торгов, корреляцию с другими активами и даже альтернативные данные (например, объем поисковых запросов в Google, сентимент на Bloomberg и т. д).

Bagging: снижение дисперсии через усреднение

Bagging (Bootstrap Aggregating) работает путем обучения нескольких моделей на подвыборках данных и усреднения их предсказаний. Классическим примером является Random Forest, хотя в хедж-фондах чаще используют более сложные варианты, такие как ансамбли нейронных сетей или деревьев решений с кастомными весами.

Bagging помогает снизить дисперсию прогнозов, что особенно важно при работе с высокочастотными данными, где рыночный шум в котировках может быть очень большим. Например, если вы прогнозируете цену актива на основе минутных данных, bagging может помочь сгладить единичные колебания котировок.

В хедж-фондах bagging часто используется как часть более сложных ансамблей, где он комбинируется с другими методами, такими как stacking или boosting, для достижения максимальной устойчивости.

Реализация ансамблевой модели с XGBoost и HMM

Чтобы показать, как ансамблевые модели применяются на практике, я реализую комбинацию HMM и XGBoost для прогнозирования цен акций. HMM будет использоваться для выявления скрытых состояний рынка, а XGBoost — для финального прогноза на основе этих состояний и дополнительных признаков, таких как объем торгов и волатильность.

import yfinance as yf
import numpy as np
import pandas as pd
from hmmlearn import hmm
import xgboost as xgb
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import TimeSeriesSplit
import matplotlib.pyplot as plt

# Загрузка данных
ticker = "BKNG"
data = yf.Ticker(ticker).history(period="3y")
data = data.dropna()
prices = data["Close"].values
volumes = data["Volume"].values
returns = data["Close"].pct_change().dropna().values.reshape(-1, 1)

# Обучение HMM
model_hmm = hmm.GMMHMM(n_components=3, n_iter=300, random_state=12)
model_hmm.fit(returns)
state_probs = model_hmm.predict_proba(returns)

# Синхронизация
data = data[1:]  # удаляем NaN после pct_change
data = data.iloc[29:]  # отступ для rolling окон
returns = returns[29:]
volumes = volumes[30:]
prices = prices[30:]
state_probs = state_probs[29:]

# Базовые признаки
features = pd.DataFrame({
    "returns": returns.flatten(),
    "volume": volumes,
    "volatility": data["Close"].rolling(window=30).std().values
})

# Лаги
for lag in range(1, 6):
    features[f'returns_lag_{lag}'] = features["returns"].shift(lag)
    features[f'volume_lag_{lag}'] = features["volume"].shift(lag)

# Кумулятивная доходность
features["cumulative_return_5"] = features["returns"].rolling(window=5).sum()

# Изменение волатильности
features["volatility_change"] = features["volatility"].diff()

# Календарные признаки
features["dayofweek"] = data.index.dayofweek.values
features["month"] = data.index.month.values

# Признаки из HMM
state_probs_df = pd.DataFrame(state_probs, columns=[f'state_prob_{i}' for i in range(state_probs.shape[1])])
features = pd.concat([features.reset_index(drop=True), state_probs_df.reset_index(drop=True)], axis=1)

# Целевая переменная: returns
target = features["returns"]

# Удаляем строки с NaN (из-за лагов и rolling)
features.dropna(inplace=True)
target = target[-len(features):]
base_prices = prices[-len(features):]

# Модель и TimeSeriesSplit
tscv = TimeSeriesSplit(n_splits=5)
pred_returns, true_returns = [], []
start_prices = []
test_lengths = []

for train_idx, test_idx in tscv.split(features):
    X_train, X_test = features.iloc[train_idx], features.iloc[test_idx]
    y_train, y_test = target.iloc[train_idx], target.iloc[test_idx]
    p_test = base_prices[test_idx]

    model_xgb = xgb.XGBRegressor(
        n_estimators=500,
        learning_rate=0.01,
        max_depth=4,
        subsample=0.8,
        colsample_bytree=0.8,
        random_state=12
    )
    model_xgb.fit(X_train, y_train)

    y_pred = model_xgb.predict(X_test)
    pred_returns.extend(y_pred)
    true_returns.extend(y_test)

    start_prices.append(p_test[0])         # начальная цена для фолда
    test_lengths.append(len(test_idx))     # длина фолда

# Восстановление цен
predicted_prices = []
real_prices = []

index = 0
for p0, n in zip(start_prices, test_lengths):
    pred_segment = np.array(pred_returns[index:index + n])
    true_segment = np.array(true_returns[index:index + n])

    pred_prices = p0 * np.cumprod(1 + pred_segment)
    true_prices = p0 * np.cumprod(1 + true_segment)

    predicted_prices.extend(pred_prices)
    real_prices.extend(true_prices)
    index += n

# Оценка
mse = mean_squared_error(real_prices, predicted_prices)
print(f"Mean Squared Error (прогноз returns → цены): {mse:.2f}")

# Визуализация
plt.figure(figsize=(14, 7))
plt.plot(real_prices, color="black", label="Реальные цены")
plt.plot(predicted_prices, color="darkgray", label="Прогноз")
plt.title(f"Прогноз цен для {ticker} (returns → цены)")
plt.xlabel("Наблюдение")
plt.ylabel("Цена закрытия")
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()

Mean Squared Error (прогноз returns → цены): 25316.85

Рис. 5: Прогноз цен акций Booking построенный с помощью ансамблевой модели XGBoost + HMM

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

Мы загружаем данные цен закрытия и объемов для акций Booking (BKNG) через yfinance, вычисляем волатильность как стандартное отклонение за 30 дней и создаем датафрейм с признаками. XGBoost затем использует эти признаки для прогнозирования цен. Результатом является график, где черная линия показывает реальные цены, а оранжевая — прогнозы ансамблевой модели. Метрика MSE (Mean Squared Error) позволяет оценить качество прогноза.

Этот подход демонстрирует, как ансамблевые модели могут объединять сильные стороны HMM (выявление рыночных режимов) и XGBoost (работа с нелинейными зависимостями), что делает его типичным примером инструмента, используемого в хедж-фондах.

Практическое применение вероятностных моделей

Интеграция с внешними данными

Одно из главных преимуществ вероятностных моделей — их способность интегрировать внешние данные. Например, в хедж-фондах часто комбинируют цены активов с макроэкономическими индикаторами (уровень инфляции, процентные ставки) или альтернативными данными (настроения в соцсетях, новостной фон). Байесовские модели и нейронные сети особенно хорошо справляются с этой задачей, так как позволяют задавать сложные зависимости между переменными.

Представьте, что вы управляете портфелем и хотите учесть влияние новостей о компании на цену актива. Байесовская модель может включать новостной сентимент как дополнительную переменную, обновляя распределение цен с учетом этой информации. Аналогично, нейронные сети могут использовать эмбеддинги текстов новостей как входные данные, улучшая качество прогнозов.

Управление рисками

Вероятностные модели особенно полезны для управления рисками. Вместо того чтобы полагаться на точечные прогнозы, которые часто ошибочны, мы можем использовать распределения вероятностей для оценки VaR (Value at Risk) или CVaR (Conditional Value at Risk). Например, если наша модель показывает, что с вероятностью 5% цена актива упадет ниже определенного уровня, мы можем скорректировать позиции или добавить хеджирование.

Таблица ниже показывает сравнение преимуществ и недостатков вероятностных и традиционных подходов к моделированию временных рядов:

Заключение

В этой статье мы рассмотрели, как вероятностные модели, такие как скрытые марковские модели, байесовские подходы и нейронные сети с вероятностным уклоном, могут улучшить прогнозирование цен биржевых активов. Эти методы, в отличие от традиционных индикаторов и простых статистических моделей, позволяют работать с неопределенностью, улавливать скрытые закономерности и интегрировать внешние данные. Мы также показали, как реализовать эти модели на Python с использованием библиотек yfinance, hmmlearn, PyMC и Pytorch.

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