admin@guru-net.biz

Phone : +7 903 662-35-39

Разработка торговой стратегии по сентименту с помощью ИИ

Categories:

🤖 У индикатора рыночного сентимента для QUIK есть опция «Сохранение данных в БД». В этой статье разберём, как использовать накопленные данные для разработки торговой стратегии с помощью искусственного интеллекта — от выгрузки данных до бэктеста готовой системы.

📊 Шаг 1. Подготовка данных для ИИ

С помощью менеджера БД выгрузите таблицу data_sent в файл .txt или .csv. В ней накапливаются данные о соотношении покупок и продаж (B_S_AM), направлении крупнейшей сделки (DIR_MAX_DEAL) и другие параметры ордерного потока.

💬 Шаг 2. Обращение к ИИ

Отправьте модели запрос и прикрепите подготовленный файл:

«Представь, что ты профессиональный трейдер. Нужно придумать стратегию для получения дохода».

В ответ ИИ (DeepSeek) предложил стратегию на основе ордерного потока и импульса.

🧠 Стратегия «Order Flow Momentum»

Идея: находим моменты, когда крупные игроки проявляют активность в определённом направлении, и присоединяемся к движению, подтверждая его классическими индикаторами.

Инструменты:

  • B_S_AM — соотношение сумм покупок и продаж: > 1.5 — давление покупателей, < 0.67 — давление продавцов;
  • DIR_MAX_DEAL — направление крупнейшей сделки: 1 — покупка, -1 — продажа;
  • EMA(20) — краткосрочный тренд по цене закрытия;
  • RSI(14) — импульс (выше 50 — бычий, ниже 50 — медвежий);
  • Объём (VOL) — выше среднего за 5 периодов как подтверждение.

Вход LONG (все условия одновременно на закрытии 15-минутной свечи):

  1. B_S_AM > 1.8;
  2. DIR_MAX_DEAL = 1;
  3. цена выше EMA(20);
  4. RSI(14) выше 55;
  5. объём выше среднего за 5 периодов.

Вход SHORT (зеркально):

  1. B_S_AM < 0.55;
  2. DIR_MAX_DEAL = -1;
  3. цена ниже EMA(20);
  4. RSI(14) ниже 45;
  5. объём выше среднего за 5 периодов.

Стоп-лосс: для LONG — минимум предыдущей свечи (или фиксированный риск ~0.3%), для SHORT — максимум предыдущей свечи. Выход — по тейк-профиту с заданным соотношением риск/вознаграждение.

🐍 Шаг 3. Бэктест на Python

ИИ также сгенерировал код бэктеста (pandas/numpy/matplotlib), который загружает данные, рассчитывает EMA, RSI и средний объём, находит сигналы LONG/SHORT, симулирует сделки со стопами и тейк-профитами и выводит отчёт по ключевым метрикам. Запустить его можно в Jupyter Notebook — достаточно указать путь к файлу с данными.

Полный код бэктеста

import pandas as pd
import numpy as np
from datetime import datetime
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')

class OrderFlowMomentumStrategy:
    """Класс для бэктеста стратегии Order Flow Momentum"""
    
    def __init__(self, initial_capital=1000000, contract_size=1):
        """
        Инициализация стратегии
        
        Parameters:
        -----------
        initial_capital : float
            Начальный капитал
        contract_size : int
            Количество контрактов
        """
        self.initial_capital = initial_capital
        self.capital = initial_capital
        self.contract_size = contract_size
        self.positions = []
        self.trades = []
        self.current_position = None
        
        # Параметры стратегии
        self.params = {
            'b_s_am_long': 1.8,        # Порог для LONG
            'b_s_am_short': 0.55,      # Порог для SHORT
            'rsi_long': 55,            # RSI для LONG
            'rsi_short': 45,           # RSI для SHORT
            'ema_period': 20,          # Период EMA
            'rsi_period': 14,          # Период RSI
            'volume_period': 5,        # Период для среднего объема
            'risk_reward_ratio': 2.0,  # Соотношение риск/вознаграждение
            'stop_loss_pct': 0.003,    # Стоп-лосс в процентах
        }
    
    def calculate_indicators(self, df):
        """Расчет всех индикаторов"""
        # EMA
        df['EMA'] = df['CLOSE'].ewm(span=self.params['ema_period'], adjust=False).mean()
        
        # RSI
        delta = df['CLOSE'].diff()
        gain = (delta.where(delta > 0, 0)).rolling(window=self.params['rsi_period']).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(window=self.params['rsi_period']).mean()
        rs = gain / loss
        df['RSI'] = 100 - (100 / (1 + rs))
        
        # Средний объем
        df['VOL_MA'] = df['VOL'].rolling(window=self.params['volume_period']).mean()
        
        # Сигналы
        df['LONG_SIGNAL'] = (
            (df['B_S_AM'] > self.params['b_s_am_long']) &
            (df['DIR_MAX_DEAL'] == 1) &
            (df['CLOSE'] > df['EMA']) &
            (df['RSI'] > self.params['rsi_long']) &
            (df['VOL'] > df['VOL_MA'])
        ).astype(int)
        
        df['SHORT_SIGNAL'] = (
            (df['B_S_AM'] < self.params['b_s_am_short']) &
            (df['DIR_MAX_DEAL'] == -1) &
            (df['CLOSE'] < df['EMA']) &
            (df['RSI'] < self.params['rsi_short']) &
            (df['VOL'] > df['VOL_MA'])
        ).astype(int)
        
        return df
    
    def run_backtest(self, df):
        """Запуск бэктеста"""
        
        # Расчет индикаторов
        df = self.calculate_indicators(df.copy())
        
        # Сброс состояния
        self.capital = self.initial_capital
        self.positions = []
        self.trades = []
        self.current_position = None
        
        # Проход по всем строкам
        for i in range(1, len(df)):
            current_date = df.index[i]
            current_row = df.iloc[i]
            prev_row = df.iloc[i-1]
            
            # Проверка на закрытие позиции
            if self.current_position is not None:
                self._check_exit_conditions(current_row, prev_row, current_date)
            
            # Проверка на открытие новой позиции (только если нет текущей)
            if self.current_position is None:
                self._check_entry_conditions(current_row, current_date)
        
        # Закрытие последней позиции в конце данных
        if self.current_position is not None:
            self._close_position(df.iloc[-1]['CLOSE'], df.index[-1])
        
        return self._generate_results(df)
    
    def _check_entry_conditions(self, row, date):
        """Проверка условий входа"""
        
        # LONG сигнал
        if row['LONG_SIGNAL'] == 1:
            entry_price = row['CLOSE']
            stop_loss = entry_price * (1 - self.params['stop_loss_pct'])
            take_profit = entry_price + (entry_price - stop_loss) * self.params['risk_reward_ratio']
            
            position = {
                'type': 'LONG',
                'entry_date': date,
                'entry_price': entry_price,
                'stop_loss': stop_loss,
                'take_profit': take_profit,
                'contracts': self.contract_size
            }
            
            self.current_position = position
            print(f"LONG открыта: {date}, Цена: {entry_price:.2f}, SL: {stop_loss:.2f}, TP: {take_profit:.2f}")
        
        # SHORT сигнал
        elif row['SHORT_SIGNAL'] == 1:
            entry_price = row['CLOSE']
            stop_loss = entry_price * (1 + self.params['stop_loss_pct'])
            take_profit = entry_price - (stop_loss - entry_price) * self.params['risk_reward_ratio']
            
            position = {
                'type': 'SHORT',
                'entry_date': date,
                'entry_price': entry_price,
                'stop_loss': stop_loss,
                'take_profit': take_profit,
                'contracts': self.contract_size
            }
            
            self.current_position = position
            print(f"SHORT открыта: {date}, Цена: {entry_price:.2f}, SL: {stop_loss:.2f}, TP: {take_profit:.2f}")
    
    def _check_exit_conditions(self, current_row, prev_row, date):
        """Проверка условий выхода"""
        
        position = self.current_position
        current_price = current_row['CLOSE']
        current_low = current_row['LOW']
        current_high = current_row['HIGH']
        
        exit_reason = None
        exit_price = None
        
        # Для LONG позиции
        if position['type'] == 'LONG':
            # Стоп-лосс (по минимуму свечи)
            if current_low <= position['stop_loss']:
                exit_reason = 'STOP_LOSS'
                exit_price = position['stop_loss']
            
            # Тейк-профит (по максимуму свечи)
            elif current_high >= position['take_profit']:
                exit_reason = 'TAKE_PROFIT'
                exit_price = position['take_profit']
            
            # Противоположный сигнал
            elif current_row['SHORT_SIGNAL'] == 1:
                exit_reason = 'OPPOSITE_SIGNAL'
                exit_price = current_price
        
        # Для SHORT позиции
        elif position['type'] == 'SHORT':
            # Стоп-лосс (по максимуму свечи)
            if current_high >= position['stop_loss']:
                exit_reason = 'STOP_LOSS'
                exit_price = position['stop_loss']
            
            # Тейк-профит (по минимуму свечи)
            elif current_low <= position['take_profit']:
                exit_reason = 'TAKE_PROFIT'
                exit_price = position['take_profit']
            
            # Противоположный сигнал
            elif current_row['LONG_SIGNAL'] == 1:
                exit_reason = 'OPPOSITE_SIGNAL'
                exit_price = current_price
        
        # Закрытие позиции, если есть причина
        if exit_reason:
            self._close_position(exit_price, date, exit_reason)
    
    def _close_position(self, exit_price, date, exit_reason='END_OF_DATA'):
        """Закрытие текущей позиции"""
        
        position = self.current_position
        
        # Расчет P&L
        if position['type'] == 'LONG':
            pnl = (exit_price - position['entry_price']) * position['contracts']
        else:  # SHORT
            pnl = (position['entry_price'] - exit_price) * position['contracts']
        
        # Обновление капитала
        self.capital += pnl
        
        # Сохранение сделки
        trade = {
            'type': position['type'],
            'entry_date': position['entry_date'],
            'entry_price': position['entry_price'],
            'exit_date': date,
            'exit_price': exit_price,
            'pnl': pnl,
            'exit_reason': exit_reason,
            'capital_after': self.capital
        }
        
        self.trades.append(trade)
        
        print(f"{position['type']} закрыта: {date}, Причина: {exit_reason}, "
              f"Вход: {position['entry_price']:.2f}, Выход: {exit_price:.2f}, "
              f"P&L: {pnl:+.2f}, Капитал: {self.capital:.2f}")
        
        # Сброс текущей позиции
        self.current_position = None
    
    def _generate_results(self, df):
        """Генерация результатов бэктеста"""
        
        if not self.trades:
            print("Нет сделок для анализа")
            return None
        
        # Создание DataFrame со сделками
        trades_df = pd.DataFrame(self.trades)
        
        # Расчет метрик
        total_trades = len(trades_df)
        winning_trades = trades_df[trades_df['pnl'] > 0]
        losing_trades = trades_df[trades_df['pnl'] < 0]
        
        win_rate = len(winning_trades) / total_trades * 100 if total_trades > 0 else 0
        
        total_pnl = trades_df['pnl'].sum()
        avg_win = winning_trades['pnl'].mean() if len(winning_trades) > 0 else 0
        avg_loss = losing_trades['pnl'].mean() if len(losing_trades) > 0 else 0
        
        # Максимальная просадка
        capital_history = [self.initial_capital]
        for trade in self.trades:
            capital_history.append(trade['capital_after'])
        
        drawdowns = []
        peak = capital_history[0]
        
        for capital in capital_history:
            if capital > peak:
                peak = capital
            drawdown = (peak - capital) / peak * 100
            drawdowns.append(drawdown)
        
        max_drawdown = max(drawdowns) if drawdowns else 0
        
        # Коэффициент Шарпа (упрощенный)
        returns = trades_df['pnl'].values / self.initial_capital
        sharpe_ratio = np.mean(returns) / np.std(returns) * np.sqrt(252) if np.std(returns) > 0 else 0
        
        # Profit Factor
        gross_profit = winning_trades['pnl'].sum() if len(winning_trades) > 0 else 0
        gross_loss = abs(losing_trades['pnl'].sum()) if len(losing_trades) > 0 else 0
        profit_factor = gross_profit / gross_loss if gross_loss > 0 else float('inf')
        
        results = {
            'total_trades': total_trades,
            'winning_trades': len(winning_trades),
            'losing_trades': len(losing_trades),
            'win_rate': win_rate,
            'total_pnl': total_pnl,
            'final_capital': self.capital,
            'return_pct': (self.capital - self.initial_capital) / self.initial_capital * 100,
            'avg_win': avg_win,
            'avg_loss': avg_loss,
            'max_drawdown': max_drawdown,
            'sharpe_ratio': sharpe_ratio,
            'profit_factor': profit_factor
        }
        
        return results, trades_df
    
    def plot_results(self, df, trades_df):
        """Визуализация результатов"""
        
        fig, axes = plt.subplots(3, 1, figsize=(15, 12))
        
        # 1. График цены и сделок
        ax1 = axes[0]
        ax1.plot(df.index, df['CLOSE'], label='Цена закрытия', alpha=0.7)
        ax1.plot(df.index, df['EMA'], label=f"EMA({self.params['ema_period']})", alpha=0.5)
        
        # Отметки сделок
        for _, trade in trades_df.iterrows():
            color = 'green' if trade['pnl'] > 0 else 'red'
            marker = '^' if trade['type'] == 'LONG' else 'v'
            ax1.scatter(trade['entry_date'], trade['entry_price'], 
                       color=color, marker=marker, s=100, zorder=5)
            ax1.scatter(trade['exit_date'], trade['exit_price'], 
                       color=color, marker='o', s=80, zorder=5)
            ax1.plot([trade['entry_date'], trade['exit_date']], 
                    [trade['entry_price'], trade['exit_price']], 
                    color=color, alpha=0.3, linewidth=2)
        
        ax1.set_title('Цена и сделки')
        ax1.set_ylabel('Цена')
        ax1.legend()
        ax1.grid(True, alpha=0.3)
        
        # 2. График индикаторов
        ax2 = axes[1]
        ax2.plot(df.index, df['RSI'], label='RSI', color='purple', alpha=0.7)
        ax2.axhline(y=70, color='r', linestyle='--', alpha=0.3)
        ax2.axhline(y=30, color='g', linestyle='--', alpha=0.3)
        ax2.axhline(y=50, color='gray', linestyle='-', alpha=0.5)
        ax2.set_ylabel('RSI')
        ax2.set_ylim(0, 100)
        ax2.legend()
        ax2.grid(True, alpha=0.3)
        
        # 3. График B_S_AM
        ax3 = axes[2]
        ax3.plot(df.index, df['B_S_AM'], label='B_S_AM', color='orange', alpha=0.7)
        ax3.axhline(y=self.params['b_s_am_long'], color='g', linestyle='--', alpha=0.3, label='LONG порог')
        ax3.axhline(y=self.params['b_s_am_short'], color='r', linestyle='--', alpha=0.3, label='SHORT порог')
        ax3.set_ylabel('B_S_AM')
        ax3.set_xlabel('Дата')
        ax3.legend()
        ax3.grid(True, alpha=0.3)
        
        plt.tight_layout()
        plt.show()


def load_and_prepare_data(file_path):
    """Загрузка и подготовка данных"""
    
    # Загрузка данных
    df = pd.read_csv(file_path, sep=';')
    
    # Преобразование даты и времени
    df['DATETIME'] = pd.to_datetime(df['DATE'] + ' ' + df['TIME'], format='%Y.%m.%d %H:%M:%S')
    df.set_index('DATETIME', inplace=True)
    
    # Убедимся, что данные отсортированы по времени
    df.sort_index(inplace=True)
    
    return df


def print_results(results, trades_df):
    """Печать результатов"""
    
    print("=" * 60)
    print("РЕЗУЛЬТАТЫ БЭКТЕСТА")
    print("=" * 60)
    
    print(f"Всего сделок: {results['total_trades']}")
    print(f"Прибыльных сделок: {results['winning_trades']}")
    print(f"Убыточных сделок: {results['losing_trades']}")
    print(f"Win Rate: {results['win_rate']:.2f}%")
    print(f"Общий P&L: {results['total_pnl']:+.2f}")
    print(f"Конечный капитал: {results['final_capital']:.2f}")
    print(f"Доходность: {results['return_pct']:.2f}%")
    print(f"Средняя прибыль: {results['avg_win']:.2f}")
    print(f"Средний убыток: {results['avg_loss']:.2f}")
    print(f"Максимальная просадка: {results['max_drawdown']:.2f}%")
    print(f"Коэффициент Шарпа: {results['sharpe_ratio']:.2f}")
    print(f"Profit Factor: {results['profit_factor']:.2f}")
    
    print("\n" + "=" * 60)
    print("СТАТИСТИКА ПО СДЕЛКАМ")
    print("=" * 60)
    
    print(trades_df[['type', 'entry_date', 'entry_price', 'exit_date', 
                     'exit_price', 'pnl', 'exit_reason']].to_string())
    
    # Статистика по причинам выхода
    exit_stats = trades_df['exit_reason'].value_counts()
    print("\nРаспределение по причинам выхода:")
    print(exit_stats)


# Основная функция для запуска бэктеста
def main():
    """Основная функция"""
    
    # 1. Загрузка данных
    print("Загрузка данных...")
    file_path = "RTS-9.23_Sentiment_And_Lenta_Data_full_file.txt"  # Укажите путь к вашему файлу
    df = load_and_prepare_data(file_path)
    
    print(f"Загружено {len(df)} строк данных")
    print(f"Период: {df.index[0]} - {df.index[-1]}")
    
    # 2. Инициализация стратегии
    print("\nИнициализация стратегии...")
    strategy = OrderFlowMomentumStrategy(
        initial_capital=1000000,
        contract_size=1
    )
    
    # 3. Оптимизация параметров (опционально)
    # Вы можете экспериментировать с параметрами:
    # strategy.params['b_s_am_long'] = 1.5
    # strategy.params['b_s_am_short'] = 0.67
    # strategy.params['rsi_long'] = 60
    # strategy.params['rsi_short'] = 40
    
    # 4. Запуск бэктеста
    print("\nЗапуск бэктеста...")
    results, trades_df = strategy.run_backtest(df)
    
    # 5. Вывод результатов
    if results:
        print_results(results, trades_df)
        
        # 6. Визуализация
        print("\nГенерация графиков...")
        strategy.plot_results(df, trades_df)
        
        # 7. Сохранение результатов
        trades_df.to_csv('backtest_results.csv', index=False)
        print("\nРезультаты сохранены в backtest_results.csv")
    else:
        print("Бэктест не дал результатов")


if __name__ == "__main__":
    main()

📈 Результаты бэктеста

На данных фьючерса RTS (49 014 строк, период 2020–2023):

Метрика Значение
Всего сделок 2 376
Win Rate 34,22%
Общий P&L +38 833,56
Доходность 3,88%
Максимальная просадка 2,71%
Коэффициент Шарпа 0,46
Profit Factor 1,07
Результаты теста стратегии по сентименту

🤖 Шаг 4. Следующий шаг — торговый робот

Если разработанная стратегия показала перспективы, можно переходить к написанию торгового робота — это сложнее. Заявку на разработку можно отправить на admin@guru-net.biz.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *