Прогнозирование цен на финансовых рынках с помощью нейронных сетей

Дата публикации: 00:30:12

Содержание

1. Подготовка и анализ данных
2. Основные типы нейронных сетей для временных рядов
   • Классические рекуррентные сети (RNN)
   • Сети долгой краткосрочной памяти (LSTM)
   • Управляемый рекуррентный блок (GRU)
   • Сверточные нейронные сети (CNN) в гибридных решениях
   • Механизмы внимания (Attention)
3. Обучение моделей: шаг за шагом
4. Оценка качества прогноза
5. Обучение с подкреплением для предсказания направления тренда

Прогнозирование цен на финансовых рынках – одна из самых сложных и востребованных задач в современной экономике. Традиционные статистические модели (ARIMA, GARCH) часто не способны захватить нелинейные зависимости, характерные для рыночных данных. В последние годы нейронные сети стали основным инструментом для решения этой задачи, позволяя работать с большими объёмами исторических данных и извлекать скрытые паттерны.

В данной статье мы подробно рассмотрим, как построить и сравнить несколько популярных архитектур нейронных сетей, применимых к предсказанию цены акций или индексов, а также покажем, как реализовать весь процесс на языке Python с использованием библиотек pandas, numpy, scikit‑learn и TensorFlow/Keras.

Подготовка и анализ данных

Сбор данных

Для примера будем использовать исторические цены акций компании Apple (AAPL), полученные через API Alpha Vantage или Yahoo Finance. Необходимо собрать минимум 3‑5 лет дневных котировок, включающих:

• Open – цена открытия
• High – максимальная цена за день
• Low – минимальная цена за день
• Close – цена закрытия
• Volume – объём торгов

Предобработка

1. Заполнение пропусков – линейная интерполяция или удаление строк.
2. Нормализация – масштабируем данные к диапазону [0, 1] с помощью MinMaxScaler или к нулевому среднему и единичному отклонению (StandardScaler).
3. Создание признаков:
   • Технические индикаторы: SMA, EMA, RSI, MACD.
   • Лаговые признаки: цены за предыдущие n дней.
4. Разделение на обучающую, валидационную и тестовую выборки (пример: 70 % / 15 % / 15 %).

Ниже – пример кода, реализующего описанные шаги:

import pandas as pd
import numpy as np
from sklearn.preprocessing import MinMaxScaler
import yfinance as yf

ticker = "AAPL"
df = yf.download(ticker, start="2015-01-01", end="2025-12-31")
df = df[['Open','High','Low','Close','Volume']]

df['SMA_10'] = df['Close'].rolling(window=10).mean
df['EMA_10'] = df['Close'].ewm(span=10, adjust=False).mean
df['RSI_14'] = compute_rsi(df['Close'], period=14) # функция реализуется отдельно

df.fillna(method='bfill', inplace=True)

scaler = MinMaxScaler
scaled = scaler.fit_transform(df)

def create_sequences(data, seq_len=60):
 X, y = [], []
 for i in range(len(data)-seq_len):
 X.append(data[i:i+seq_len, :])
 y.append(data[i+seq_len, df.columns.get_loc('Close')]) # целевая переменная – закрытие
 return np.array(X), np.array(y)

SEQ_LEN = 60 # 60 дней = 3 месяца
X, y = create_sequences(scaled, SEQ_LEN)

train_size = int(0.7 * len(X))
val_size = int(0.15 * len(X))

X_train, y_train = X[:train_size], y[:train_size]
X_val, y_val = X[train_size:train_size+val_size], y[train_size:train_size+val_size]
X_test, y_test = X[train_size+val_size:], y[train_size+val_size:]

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

Классические рекуррентные сети (RNN)

RNN способны учитывать порядок следования данных, однако страдают от проблемы «затухающего градиента», что делает их непрактичными для длинных последовательностей (более 20‑30 шагов).

Сети долгой краткосрочной памяти (LSTM)

LSTM решают проблему затухающего градиента за счёт наличия ячейки памяти и трёх «врат» (input, forget, output). Это делает их идеальными для финансовых временных рядов, где важны как недавние, так и более отдалённые события.

Типичная архитектура LSTM для предсказания цены

from tensorflow.keras;models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout

model = Sequential([
 LSTM(128, input_shape=(SEQ_LEN, X_train.shape[2]), return_sequences=True),
 Dropout(0.2),
 LSTM(64),
 Dropout(0.2),
 Dense(32, activation='relu'),
 Dense(1) # предсказываем нормализованную цену закрытия
])
model.compile(optimizer='adam', loss='mse')
model.summary

Управляемый рекуррентный блок (GRU)

GRU – упрощённый вариант LSTM, объединяющий забывающие и входные ворота в один «update gate». Он быстрее обучается и часто даёт сопоставимую точность.

from tensorflow.keras.layers import GRU

model_gru = Sequential([
 GRU(128, input_shape=(SEQ_LEN, X_train.shape[2]), return_sequences=True),
 Dropout(0.2),
 GRU(64),
 Dropout(0.2),
 Dense(1)
])

model_gru.compile(optimizer='adam', loss='mse')

Сверточные нейронные сети (CNN) в гибридных решениях

Сверточные слои способны извлекать локальные паттерны (например, «спайки» объёма) и часто комбинируются с LSTM/GRU:

from tensorflow.keras.layers import Conv1D, MaxPooling1D, Flatten

model_cnn_lstm = Sequential([
 Conv1D(filters=64, kernel_size=3, activation='relu', input_shape=(SEQ_LEN, X_train.shape[2])),
 MaxPooling1D(pool_size=2),
 LSTM(64),
 Dense(1)
])

model_cnn_lstm.compile(optimizer='adam', loss='mse')

Механизмы внимания (Attention)

Attention позволяет модели «фокусироваться» на наиболее информативных временных шагах. В Keras реализовано через слой Attention или через кастомные блоки.

from tensorflow.keras.layers import Attention, Concatenate

input_seq = Input(shape=(SEQ_LEN, X_train.shape[2]))
lstm_out = LSTM(64, return_sequences=True)(input_seq)
attention = Attention([lstm_out, lstm_out])
context = Concatenate([lstm_out, attention])
flat = Flatten(context)
output = Dense(1)(flat)
model_att = Model(inputs=input_seq, outputs=output)
model_att.compile(optimizer='adam', loss='mse')

Обучение моделей: шаг за шагом

Выбор функции потерь и оптимизатора

• Mean Squared Error (MSE) – стандарт для регрессии.
• Mean Absolute Error (MAE) – менее чувствителен к выбросам.
• Оптимизатор adam обычно обеспечивает быстрый и стабильный спуск.

Техника ранней остановки (Early Stopping)

Для предотвращения переобучения используем колбэк EarlyStopping с мониторингом валидационной потери;

from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint

es = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True)
mc = ModelCheckpoint('best_model.h5', monitor='val_loss', save_best_only=True)

history = model.fit(
 X_train, y_train,
 epochs=200,
 batch_size=32,
 validation_data=(X_val, y_val),
 callbacks=[es, mc],
 verbose=1
)

Визуализация процесса обучения

import matplotlib.pyplot as plt

plt.figure(figsize=(10,4))
plt.plot(history.history['loss'], label='Train loss')
plt.plot(history.history['val_loss'], label='Val loss')
plt.title('График сходимости модели')
plt.xlabel('Эпоха')
plt.ylabel('MSE')
plt.legend
plt.show

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

Для финансовых задач важны не только абсолютные ошибки, но и способность модели предсказывать направление движения цены.

Метрики регрессии

• RMSE = √MSE – удобна для сравнения разных моделей.
• MAE – средняя абсолютная ошибка.
• R² (коэффициент детерминации) – показывает долю объяснённой дисперсии.

Метрики классификации направления

Мы преобразуем предсказание в бинарный сигнал:

y_pred = model.predict(X_test).flatten

y_pred_rescaled = scaler.inverse_transform(
 np.concatenate([np.zeros((len(y_pred), df.shape[1]-1)), y_pred.reshape(-1,1)], axis=1)
)[:,-1]


y_true_rescaled = scaler.inverse_transform(
 np;concatenate([np.zeros((len(y_test), df.shape[1]-1)), y_test.reshape(-1,1)], axis=1)
)[:,-1]

direction_true = np.sign(np.diff(y_true_rescaled))
direction_pred = np.sign(np.diff(y_pred_rescaled))

from sklearn.metrics import accuracy_score, f1_score
acc = accuracy_score(direction_true, direction_pred)
f1 = f1_score(direction_true, direction_pred, average='binary')
print(f'Accuracy: {acc:.3f}, F1: {f1:.3f}')

Таблица сравнения моделей

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

Обучение с подкреплением для предсказания направления тренда

Подход Reinforcement Learning (RL) рассматривает задачу как игру, где агент (трейдер) выбирает действие (купить/продать/держать) и получает вознаграждение в виде прибыли.

Краткая схема

1. Состояние s_t – вектор признаков за последние n дней (цены, индикаторы).
2. Действие a_t ∈ {‑1, 0, +1} (продать, держать, купить).
3. Вознаграждение r_t = изменение портфеля после действия.
4. Цель – максимизировать суммарное дисконтированное вознаграждение ∑γ^t r_t.

Пример реализации с использованием stable-baselines3

import gym
import numpy as np
from stable_baselines3 import PPO

class StockTradingEnv(gym.Env):
 def __init__(self, data, window=60, initial_balance=10000):
 super.__init__
 self.data = data
 self.window = window
 self.initial_balance = initial_balance
 self;action_space = gym.spaces.Discrete(3) # sell, hold, buy
 self.observation_space = gym.spaces.Box(low=-np.inf, high=np.inf,
 shape=(window, data.shape[1]), dtype=np.float32)

 def reset(self):
 self.current_step = self.window
 self.balance = self.initial_balance
 self.shares_held = 0
 self.net_worth = self.initial_balance
 return self._next_observation

 def _next_observation(self):
 obs = self.data[self.current_step-self.window:self.current_step]
 return obs

 def step(self, action):
 current_price = self.data[self.current_step][3] # Close price
 # Выполняем действие
 if action == 0: # sell
 self.balance += self.shares_held * current_price
 self.shares_held = 0
 elif action == 2: # buy
 max_shares = self.balance // current_price
 self.shares_held += max_shares
 self.balance -= max_shares * current_price
 # else: hold – ничего не делаем
 self.current_step += 1
 self.net_worth = self.balance + self.shares_held * current_price
 reward = self;net_worth ⎻ self.initial_balance # простое вознаграждение
 done = self.current_step >= len(self.data), 1
 obs = self._next_observation
 return obs, reward, done, {}

env = StockTradingEnv(scaled, window=SEQ_LEN)
model = PPO('MlpPolicy', env, verbose=1)
model.learn(total_timesteps=20000)

После обучения агент способен генерировать сигналы, которые часто превосходят простые модели LSTM в части определения направления, однако их стабильность сильно зависит от гиперпараметров и качества данных.

Нейронные сети уже доказали свою эффективность в задаче предсказания цен на финансовых рынках. Ключевые выводы:

• Для большинства наборов данных LSTM и GRU являются базовыми, надёжными решениями.
• Гибридные модели (CNN+LSTM, LSTM+Attention) позволяют улучшить точность за счёт извлечения как локальных, так и глобальных паттернов.
• Правильная подготовка данных (технические индикаторы, лаговые признаки, масштабирование) оказывает решающее влияние на качество прогноза.
• Оценка модели должна включать как регрессионные метрики (RMSE, MAE, R²), так и метрики направления (Accuracy, F1), поскольку инвесторы часто интересуются именно направлением движения цены.
• Обучение с подкреплением открывает новые возможности для построения торговых стратегий, однако требует более тщательной валидации и контроля риска.

В дальнейшем исследователи и практики могут обратить внимание на:

1. Внедрение трансформеров (например, Temporal Fusion Transformer) для ещё более качественного захвата долгосрочных зависимостей.
2. Использование мульти‑модальных данных (новостные тексты, соцсети, макроэкономические индикаторы) в сочетании с нейронными сетями.
3. Разработку интерпретируемых моделей (SHAP, LIME) для понимания, какие факторы влияют на прогноз.

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

Автор: ИИ‑ассистент, 2026