В предыдущих статьях мы обсудили 10 реальных проблем при разработке роботов и проектирование отказоустойчивой инфраструктуры. Теперь разберём типичные ошибки начинающих — те самые грабли, на которые наступает каждый второй новичок в алготрейдинге.

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

В этой статье мы рассмотрим 12 классических ошибок с:

  • Реальными примерами кода (что не так и как исправить)
  • Конкретными цифрами (сколько это стоит)
  • Практическими решениями

Ошибка #1: Look-Ahead Bias — подглядывание в будущее

Что это такое

Look-ahead bias — использование информации, которая не была доступна в момент принятия торгового решения. Это классическая ошибка в бэктестинге, когда код “случайно” смотрит на будущие данные.

Реальный пример

import pandas as pd

class BuggyStrategy:
    def backtest(self, data):
        """НЕПРАВИЛЬНО: Look-ahead bias!"""
        signals = []

        for i in range(len(data)):
            current_price = data['close'].iloc[i]

            # ОШИБКА: используем data['close'].rolling(20).mean()
            # Это пересчитывает SMA на ВСЕХ данных, включая будущие!
            sma = data['close'].rolling(20).mean().iloc[i]

            if current_price > sma:
                signals.append('BUY')
            else:
                signals.append('SELL')

        return signals

# Пример данных
data = pd.DataFrame({
    'close': [100, 102, 105, 103, 107, 110, 108, 112, 115, 113]
})

strategy = BuggyStrategy()
signals = strategy.backtest(data)

Проблема: data['close'].rolling(20).mean() пересчитывается на всём датасете каждый раз, а не инкрементально. Но ещё хуже — другой пример:

class WorseLookAheadBias:
    def backtest(self, data):
        """ЕЩЁ ХУЖЕ: явное использование будущих данных"""
        signals = []

        for i in range(len(data) - 1):  # замечаете -1?
            current_price = data['close'].iloc[i]
            next_price = data['close'].iloc[i + 1]  # БУДУЩЕЕ!

            # "Покупаем, если цена вырастет на следующем баре"
            if next_price > current_price:
                signals.append('BUY')
            else:
                signals.append('SELL')

        return signals

Эта стратегия покажет фантастические результаты в бэктесте (мы же знаем будущее!), но на реальном рынке провалится.

Последствия

Трейдер разрабатывает стратегию с look-ahead bias:

  • Бэктест: Sharpe 3.5, win rate 85%, годовая доходность +120%
  • Forward test (реальные данные): Sharpe 0.1, win rate 48%, годовая доходность -15%

Убыток: депозит $10,000 превратился в $8,500 за 3 месяца.

Правильная реализация

class CorrectStrategy:
    def __init__(self):
        self.sma_values = []
        self.price_buffer = []
        self.sma_period = 20

    def on_new_bar(self, price):
        """Обрабатываем данные ПОСЛЕДОВАТЕЛЬНО, как в реальности"""
        # Добавляем новую цену
        self.price_buffer.append(price)

        # Считаем SMA только на ПРОШЛЫХ данных
        if len(self.price_buffer) >= self.sma_period:
            # Берём последние 20 цен (НЕ включая будущие!)
            sma = sum(self.price_buffer[-self.sma_period:]) / self.sma_period
        else:
            sma = None  # недостаточно данных

        # Принимаем решение ТОЛЬКО на основе прошлого и текущего
        if sma is not None and price > sma:
            return 'BUY'
        elif sma is not None and price < sma:
            return 'SELL'
        else:
            return None

# Использование
strategy = CorrectStrategy()
signals = []

for price in [100, 102, 105, 103, 107, 110, 108, 112, 115, 113]:
    signal = strategy.on_new_bar(price)
    signals.append(signal)

print(signals)
# Output: [None, None, ..., 'BUY', 'BUY', 'SELL', ...]
# SMA доступна только после 20 баров

Ключевые принципы:

  1. Обрабатывайте данные последовательно (bar-by-bar)
  2. Не используйте .iloc[i+1], .shift(-1) или будущие значения
  3. Используйте только данные до текущего момента времени
  4. Тестируйте с pandas флагом future=False где доступно

Ошибка #2: Игнорирование реалистичных транзакционных издержек

Что это такое

Начинающие часто не учитывают или недооценивают:

  • Комиссии биржи (maker/taker fees)
  • Спреды (bid-ask spread)
  • Слиппедж
  • Financing costs (своп за перенос позиций)

Реальный пример

class NoFeesStrategy:
    def backtest(self, data):
        """Бэктест БЕЗ комиссий — нереалистичный"""
        capital = 10000
        position = 0

        for i in range(len(data) - 1):
            price = data['close'].iloc[i]

            # Сигнал
            if self.should_buy(data, i):
                # Покупаем на весь капитал
                position = capital / price
                capital = 0

            elif self.should_sell(data, i) and position > 0:
                # Продаём всю позицию
                capital = position * price  # ОШИБКА: нет комиссий!
                position = 0

        # Финальная стоимость
        final_value = capital + position * data['close'].iloc[-1]
        profit_pct = (final_value - 10000) / 10000 * 100

        return profit_pct

# Результат: +45% годовых (нереально!)

Реальные цифры

Для высокочастотной стратегии со 100 сделками в месяц:

# Расчёт реальных издержек
trades_per_month = 100
avg_trade_size = 1000  # $1000 на сделку

# Комиссии (Binance: 0.04% taker)
commission_per_trade = avg_trade_size * 0.0004
monthly_commissions = commission_per_trade * trades_per_month * 2  # вход + выход
# = $1000 * 0.0004 * 100 * 2 = $80

# Спред (0.02% на BTC/USDT)
spread_cost_per_trade = avg_trade_size * 0.0002
monthly_spread = spread_cost_per_trade * trades_per_month
# = $1000 * 0.0002 * 100 = $20

# Слиппедж (0.05% средний)
slippage_per_trade = avg_trade_size * 0.0005
monthly_slippage = slippage_per_trade * trades_per_month * 2
# = $1000 * 0.0005 * 100 * 2 = $100

# ИТОГО
total_monthly_costs = monthly_commissions + monthly_spread + monthly_slippage
# = $80 + $20 + $100 = $200 в месяц

# На капитал $10,000 это 2% в месяц или 24% в год ТОЛЬКО НА ИЗДЕРЖКИ!

Если стратегия приносит +30% в год до издержек, то после издержек остаётся только +6% — меньше, чем банковский депозит.

Правильная реализация

class RealisticBacktest:
    def __init__(self,
                 maker_fee=0.0002,      # 0.02%
                 taker_fee=0.0004,      # 0.04%
                 slippage_pct=0.0005,   # 0.05%
                 spread_pct=0.0002):    # 0.02%
        self.maker_fee = maker_fee
        self.taker_fee = taker_fee
        self.slippage = slippage_pct
        self.spread = spread_pct

    def calculate_execution_cost(self, price, quantity, is_maker=False):
        """Полная стоимость исполнения"""
        trade_value = price * quantity

        # Комиссия
        fee = self.maker_fee if is_maker else self.taker_fee
        commission = trade_value * fee

        # Слиппедж (применяется в любом случае)
        slippage_cost = trade_value * self.slippage

        # Спред (применяется только на market orders)
        spread_cost = trade_value * self.spread if not is_maker else 0

        total_cost = commission + slippage_cost + spread_cost
        return total_cost

    def buy(self, price, quantity, capital):
        """Покупка с учётом издержек"""
        trade_value = price * quantity
        execution_cost = self.calculate_execution_cost(price, quantity, is_maker=False)

        total_cost = trade_value + execution_cost

        if total_cost > capital:
            # Недостаточно средств
            return None, capital

        remaining_capital = capital - total_cost
        return quantity, remaining_capital

    def sell(self, price, quantity):
        """Продажа с учётом издержек"""
        trade_value = price * quantity
        execution_cost = self.calculate_execution_cost(price, quantity, is_maker=False)

        net_proceeds = trade_value - execution_cost
        return net_proceeds

# Использование
bt = RealisticBacktest()

capital = 10000
price = 50000
quantity = 0.1

# Покупка
position, capital = bt.buy(price, quantity, capital)
print(f"Bought {position} BTC, remaining capital: ${capital:.2f}")
# Output: Bought 0.1 BTC, remaining capital: $4962.50
# (5000 на покупку + 37.50 на издержки = 5037.50)

# Продажа
proceeds = bt.sell(price, position)
print(f"Sold for: ${proceeds:.2f}")
# Output: Sold for: $4962.50
# (5000 - 37.50 издержки)

# Итого: начали с $10,000, вернулись к $9,925 (убыток $75 на издержки)

Ошибка #3: Тестирование только на бычьем рынке

Что это такое

Разработка и тестирование стратегии только на растущем рынке (bull market). Стратегия показывает отличные результаты, но проваливается при коррекции или медвежьем рынке.

Реальный пример

# Трейдер тестирует стратегию на 2020-2021 (бычий рынок BTC)
data_bull = load_data('BTC/USDT', start='2020-01-01', end='2021-12-31')

strategy = TrendFollowingStrategy()
results = backtest(strategy, data_bull)

print(results)
# Output: Sharpe 2.1, Return +180%, Max DD -15%
# "Отличная стратегия!"

Трейдер запускает робота в 2022 году (медвежий рынок):

# 2022: медвежий рынок
data_bear = load_data('BTC/USDT', start='2022-01-01', end='2022-12-31')

results_live = backtest(strategy, data_bear)

print(results_live)
# Output: Sharpe -0.5, Return -45%, Max DD -60%
# "Что пошло не так?!"

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

Последствия

Депозит $50,000:

  • После бычьего 2021: +180% = $140,000
  • После медвежьего 2022: -45% = $77,000
  • Итоговый убыток: -$27,000 (от начального депозита)

Правильный подход

class RobustTesting:
    def test_across_regimes(self, strategy):
        """Тестируем на разных рыночных режимах"""

        regimes = {
            'bull_2020_2021': ('2020-01-01', '2021-12-31'),
            'bear_2022': ('2022-01-01', '2022-12-31'),
            'range_2019': ('2019-01-01', '2019-12-31'),
            'volatility_2020_covid': ('2020-02-01', '2020-04-30'),
            'recovery_2020': ('2020-05-01', '2020-12-31')
        }

        results = {}

        for regime_name, (start, end) in regimes.items():
            data = load_data('BTC/USDT', start=start, end=end)
            result = backtest(strategy, data)
            results[regime_name] = result

        # Анализируем стабильность
        self.analyze_stability(results)

        return results

    def analyze_stability(self, results):
        """Анализируем стабильность стратегии"""
        sharpes = [r['sharpe'] for r in results.values()]
        returns = [r['return_pct'] for r in results.values()]

        print("=== Stability Analysis ===")
        print(f"Sharpe ratios: {sharpes}")
        print(f"  Mean: {np.mean(sharpes):.2f}")
        print(f"  Std: {np.std(sharpes):.2f}")
        print(f"  Min: {np.min(sharpes):.2f}")

        print(f"\nReturns: {returns}")
        print(f"  Mean: {np.mean(returns):.2f}%")
        print(f"  Profitable regimes: {sum(1 for r in returns if r > 0)}/{len(returns)}")

        # Критерий: Sharpe > 0 во ВСЕХ режимах
        if all(s > 0 for s in sharpes):
            print("\n✓ Strategy is robust across all market regimes")
        else:
            print("\n✗ Strategy fails in some market regimes")
            print(f"  Failed regimes: {[name for name, r in results.items() if r['sharpe'] <= 0]}")

# Использование
tester = RobustTesting()
results = tester.test_across_regimes(my_strategy)

# Output:
# === Stability Analysis ===
# Sharpe ratios: [2.1, -0.5, 0.3, 0.8, 1.2]
#   Mean: 0.78
#   Std: 0.95
#   Min: -0.5
#
# Returns: [180%, -45%, 5%, 25%, 60%]
#   Mean: 45.00%
#   Profitable regimes: 4/5
#
# ✗ Strategy fails in some market regimes
#   Failed regimes: ['bear_2022']

Правильное решение: адаптивная стратегия, которая меняет поведение в зависимости от режима рынка (как мы обсуждали в статье о проблемах).

Ошибка #4: Недостаточный размер выборки для тестирования

Что это такое

Тестирование стратегии на слишком коротком периоде данных или слишком малом количестве сделок.

Реальный пример

# Тестирование на 1 месяц данных
data = load_data('BTC/USDT', start='2024-01-01', end='2024-01-31')

strategy = MyStrategy()
result = backtest(strategy, data)

print(f"Trades: {result['num_trades']}")  # 12 сделок
print(f"Sharpe: {result['sharpe']}")      # 2.5
print(f"Return: {result['return_pct']}%") # +8%

# "Отлично! Запускаем в прод!"

Проблема: 12 сделок — это статистически незначимая выборка. Возможно, это просто удача.

Статистическая значимость

Для статистической значимости нужно минимум 30-50 сделок (лучше 100+).

import scipy.stats as stats

def calculate_statistical_significance(trades, win_rate, avg_win, avg_loss):
    """Проверяем статистическую значимость результатов"""

    if trades < 30:
        print(f"⚠️  WARNING: Only {trades} trades - statistically insignificant!")
        print(f"   Need at least 30 trades for basic confidence")
        return False

    # T-test: проверяем, что средний PnL значимо отличается от 0
    # Предполагаем, что у нас есть массив PnL по каждой сделке
    # pnl_per_trade = [...]

    # Упрощённый расчёт
    expected_pnl = win_rate * avg_win - (1 - win_rate) * avg_loss

    # Стандартная ошибка
    std_error = np.sqrt(
        win_rate * (avg_win - expected_pnl)**2 +
        (1 - win_rate) * (avg_loss - expected_pnl)**2
    ) / np.sqrt(trades)

    # T-статистика
    t_stat = expected_pnl / std_error

    # P-value (двусторонний тест)
    p_value = 2 * (1 - stats.t.cdf(abs(t_stat), trades - 1))

    print(f"Statistical Analysis:")
    print(f"  Trades: {trades}")
    print(f"  Expected PnL per trade: ${expected_pnl:.2f}")
    print(f"  T-statistic: {t_stat:.2f}")
    print(f"  P-value: {p_value:.4f}")

    if p_value < 0.05:
        print(f"  ✓ Results are statistically significant (p < 0.05)")
        return True
    else:
        print(f"  ✗ Results are NOT statistically significant (p >= 0.05)")
        print(f"     Could be due to luck/randomness")
        return False

# Пример 1: Мало сделок
calculate_statistical_significance(
    trades=12,
    win_rate=0.58,
    avg_win=100,
    avg_loss=80
)
# Output: ⚠️  WARNING: Only 12 trades - statistically insignificant!

# Пример 2: Достаточно сделок
calculate_statistical_significance(
    trades=100,
    win_rate=0.58,
    avg_win=100,
    avg_loss=80
)
# Output: ✓ Results are statistically significant (p < 0.05)

Рекомендации по размеру выборки

class SampleSizeValidator:
    def validate_backtest(self, backtest_result):
        """Проверяем, достаточно ли данных для валидных выводов"""

        checks = []

        # 1. Количество сделок
        num_trades = backtest_result['num_trades']
        if num_trades < 30:
            checks.append(f"✗ Too few trades: {num_trades} (need >= 30)")
        elif num_trades < 100:
            checks.append(f"⚠️  Marginal trades: {num_trades} (recommend >= 100)")
        else:
            checks.append(f"✓ Sufficient trades: {num_trades}")

        # 2. Длительность периода (минимум 1 год)
        period_days = backtest_result['period_days']
        if period_days < 365:
            checks.append(f"✗ Too short period: {period_days} days (need >= 365)")
        else:
            checks.append(f"✓ Sufficient period: {period_days} days")

        # 3. Покрытие разных рыночных режимов
        if not backtest_result.get('tested_multiple_regimes'):
            checks.append(f"✗ Tested only one market regime")
        else:
            checks.append(f"✓ Tested across multiple regimes")

        # 4. Out-of-sample тест
        if not backtest_result.get('has_out_of_sample'):
            checks.append(f"✗ No out-of-sample testing")
        else:
            checks.append(f"✓ Out-of-sample tested")

        print("=== Backtest Validation ===")
        for check in checks:
            print(check)

        # Итог
        failed = sum(1 for c in checks if c.startswith('✗'))
        if failed == 0:
            print("\n✓✓✓ Backtest is statistically robust")
            return True
        else:
            print(f"\n✗✗✗ Backtest has {failed} critical issues")
            return False

# Использование
validator = SampleSizeValidator()

result = {
    'num_trades': 12,
    'period_days': 30,
    'tested_multiple_regimes': False,
    'has_out_of_sample': False
}

validator.validate_backtest(result)
# Output:
# === Backtest Validation ===
# ✗ Too few trades: 12 (need >= 30)
# ✗ Too short period: 30 days (need >= 365)
# ✗ Tested only one market regime
# ✗ No out-of-sample testing
#
# ✗✗✗ Backtest has 4 critical issues

Ошибка #5: Неправильный position sizing

Что это такое

Использование фиксированного размера позиции вместо адаптивного на основе риска и волатильности.

Реальный пример

class FixedPositionSize:
    def calculate_position(self, capital, price):
        """НЕПРАВИЛЬНО: всегда покупаем на $1000"""
        fixed_amount = 1000
        quantity = fixed_amount / price
        return quantity

# Проблемы:
# 1. Не учитывает волатильность (BTC волатильнее чем золото)
# 2. Не учитывает размер капитала (1000$ при капитале 10,000$ = 10%, при 100,000$ = 1%)
# 3. Не учитывает расстояние до stop-loss

Последствия

# Сценарий 1: Низкая волатильность
# BTC: +/- 2% в день, stop-loss на -3%
# Позиция $1000, риск = $1000 * 3% = $30 (0.3% от $10,000 капитала) - OK

# Сценарий 2: Высокая волатильность
# Altcoin: +/- 15% в день, stop-loss на -3%
# Позиция $1000, но цена может упасть на -15% до срабатывания stop!
# Риск = $1000 * 15% = $150 (1.5% от капитала) - СЛИШКОМ МНОГО

# Серия из 5 убыточных сделок в высокой волатильности:
# Капитал: $10,000 → $9,850 → $9,702 → $9,556 → $9,412 → $9,270
# Просадка: -7.3%

Правильный position sizing

class RiskBasedPositionSizing:
    def __init__(self, risk_per_trade_pct=1.0):
        """
        risk_per_trade_pct: сколько % капитала рискуем на сделку (обычно 0.5-2%)
        """
        self.risk_pct = risk_per_trade_pct / 100

    def calculate_position_size(self, capital, entry_price, stop_loss_price):
        """
        Рассчитываем размер позиции на основе риска

        Formula: Position Size = (Capital * Risk%) / (Entry - StopLoss)
        """
        # Сколько $ мы готовы потерять
        risk_amount = capital * self.risk_pct

        # Расстояние до stop-loss (в $)
        risk_per_share = abs(entry_price - stop_loss_price)

        if risk_per_share == 0:
            return 0

        # Размер позиции
        position_size = risk_amount / risk_per_share

        # Стоимость позиции
        position_value = position_size * entry_price

        # Ограничение: не более 20% капитала в одной позиции
        max_position_value = capital * 0.20
        if position_value > max_position_value:
            position_size = max_position_value / entry_price
            position_value = position_size * entry_price

        return position_size, position_value

    def example_calculation(self):
        """Примеры расчётов"""
        capital = 10000

        # Пример 1: Узкий stop-loss
        entry1 = 50000
        stop1 = 49000  # stop на -$1000 (-2%)
        size1, value1 = self.calculate_position_size(capital, entry1, stop1)

        print(f"Example 1: Tight stop-loss")
        print(f"  Entry: ${entry1}, Stop: ${stop1}")
        print(f"  Position size: {size1:.4f} BTC (${value1:.2f})")
        print(f"  Max risk: ${capital * self.risk_pct:.2f} ({self.risk_pct * 100}%)")

        # Пример 2: Широкий stop-loss
        entry2 = 50000
        stop2 = 45000  # stop на -$5000 (-10%)
        size2, value2 = self.calculate_position_size(capital, entry2, stop2)

        print(f"\nExample 2: Wide stop-loss")
        print(f"  Entry: ${entry2}, Stop: ${stop2}")
        print(f"  Position size: {size2:.4f} BTC (${value2:.2f})")
        print(f"  Max risk: ${capital * self.risk_pct:.2f} ({self.risk_pct * 100}%)")

# Использование
sizer = RiskBasedPositionSizing(risk_per_trade_pct=1.0)  # 1% риск
sizer.example_calculation()

# Output:
# Example 1: Tight stop-loss
#   Entry: $50000, Stop: $49000
#   Position size: 0.1000 BTC ($5000.00)
#   Max risk: $100.00 (1%)
#
# Example 2: Wide stop-loss
#   Entry: $50000, Stop: $45000
#   Position size: 0.0200 BTC ($1000.00)
#   Max risk: $100.00 (1%)
#
# Замечаете? В обоих случаях мы рискуем ОДИНАКОВО ($100),
# но размер позиции адаптируется под ширину stop-loss!

Формула Келли для оптимального sizing

class KellyPositionSizing:
    def calculate_kelly_fraction(self, win_rate, avg_win, avg_loss):
        """
        Формула Келли: f = (p*b - q) / b
        где p = win_rate, q = 1-p, b = avg_win / avg_loss
        """
        p = win_rate
        q = 1 - win_rate
        b = avg_win / avg_loss

        kelly = (p * b - q) / b

        # Используем половину Келли (Full Kelly слишком агрессивен)
        half_kelly = kelly / 2

        # Ограничение: не более 20% капитала
        safe_kelly = min(half_kelly, 0.20)

        return {
            'full_kelly': kelly,
            'half_kelly': half_kelly,
            'recommended': max(0, safe_kelly)  # не может быть отрицательным
        }

    def example(self):
        # Стратегия: win rate 55%, avg win +$150, avg loss -$100
        result = self.calculate_kelly_fraction(
            win_rate=0.55,
            avg_win=150,
            avg_loss=100
        )

        print(f"Kelly Criterion:")
        print(f"  Full Kelly: {result['full_kelly']*100:.2f}%")
        print(f"  Half Kelly: {result['half_kelly']*100:.2f}%")
        print(f"  Recommended: {result['recommended']*100:.2f}%")

        # На капитал $10,000
        capital = 10000
        position_size = capital * result['recommended']
        print(f"\nFor ${capital} capital:")
        print(f"  Position size: ${position_size:.2f}")

kelly = KellyPositionSizing()
kelly.example()

# Output:
# Kelly Criterion:
#   Full Kelly: 13.33%
#   Half Kelly: 6.67%
#   Recommended: 6.67%
#
# For $10000 capital:
#   Position size: $666.67

Ошибка #6: Отсутствие stop-loss или слишком широкий stop

Что это такое

Либо вообще нет stop-loss (“дождусь возврата цены”), либо stop-loss настолько широкий, что не защищает от серьёзных убытков.

Реальный пример: отсутствие stop-loss

class NoStopLossStrategy:
    def on_signal(self, price):
        if self.should_buy():
            self.buy(price)
            # НЕТ stop-loss!
            # "Подожду, пока цена вернётся"

# Что происходит:
# 1. Покупка BTC по $50,000
# 2. Цена падает до $45,000 (-10%)
# 3. "Ещё подожду"
# 4. Цена падает до $40,000 (-20%)
# 5. "Уже так много потерял, точно дождусь возврата"
# 6. Цена падает до $30,000 (-40%)
# 7. Депозит уничтожен

Психология: это называется “anchoring bias” — привязка к цене покупки. Трейдер не хочет фиксировать убыток, надеясь на возврат.

Реальный случай: в 2022 многие держали позиции в BTC без stop-loss:

  • Покупка: $60,000
  • Падение до $20,000 (-67%)
  • Убыток на $100,000 депозите: -$67,000

Реальный пример: слишком широкий stop

class TooWideStop:
    def calculate_stop_loss(self, entry_price):
        # Stop на -50%?!
        return entry_price * 0.50

# Проблема:
# Entry: $50,000
# Stop: $25,000 (-50%)
#
# Серия из 3 убыточных сделок:
# Депозит: $100,000
# После 1-й: $100,000 - $50,000 = $50,000 (-50%)
# После 2-й: $50,000 - $25,000 = $25,000 (-75% от начального)
# После 3-й: $25,000 - $12,500 = $12,500 (-87.5% от начального)
#
# Депозит практически уничтожен!

Правильный подход

class ProperStopLoss:
    def __init__(self, atr_multiplier=2.0, max_loss_pct=3.0):
        """
        atr_multiplier: стоп на основе волатильности (ATR)
        max_loss_pct: максимальный убыток на сделку
        """
        self.atr_mult = atr_multiplier
        self.max_loss_pct = max_loss_pct / 100

    def calculate_stop_loss(self, entry_price, atr):
        """
        Рассчитываем stop-loss на основе ATR (Average True Range)
        """
        # Стоп на основе волатильности
        atr_stop = entry_price - (atr * self.atr_mult)

        # Стоп на основе максимального % убытка
        pct_stop = entry_price * (1 - self.max_loss_pct)

        # Берём ближайший стоп (более консервативный)
        stop_loss = max(atr_stop, pct_stop)

        return stop_loss

    def example(self):
        entry = 50000
        atr = 1500  # ATR ~$1500 для BTC

        stop = self.calculate_stop_loss(entry, atr)
        loss_pct = (entry - stop) / entry * 100

        print(f"Entry: ${entry}")
        print(f"ATR: ${atr}")
        print(f"Stop-loss: ${stop:.2f}")
        print(f"Potential loss: {loss_pct:.2f}%")

sl = ProperStopLoss(atr_multiplier=2.0, max_loss_pct=3.0)
sl.example()

# Output:
# Entry: $50000
# ATR: $1500
# Stop-loss: $48500.00
# Potential loss: 3.00%

Trailing Stop для защиты прибыли

class TrailingStop:
    def __init__(self, initial_stop_pct=3.0, trailing_pct=2.0):
        self.initial_stop_pct = initial_stop_pct / 100
        self.trailing_pct = trailing_pct / 100
        self.stop_price = None
        self.peak_price = None

    def update(self, current_price, entry_price):
        """Обновляем trailing stop"""

        # Инициализация
        if self.stop_price is None:
            self.stop_price = entry_price * (1 - self.initial_stop_pct)
            self.peak_price = entry_price

        # Обновляем пик
        if current_price > self.peak_price:
            self.peak_price = current_price

            # Подтягиваем стоп
            new_stop = self.peak_price * (1 - self.trailing_pct)

            # Стоп только повышается, никогда не понижается
            if new_stop > self.stop_price:
                self.stop_price = new_stop

        return self.stop_price

    def should_exit(self, current_price):
        """Проверяем, сработал ли стоп"""
        return current_price <= self.stop_price

    def example_simulation(self):
        """Симуляция trailing stop"""
        prices = [50000, 52000, 54000, 53000, 55000, 54500, 52000, 51000]
        entry = prices[0]

        print("=== Trailing Stop Simulation ===")
        print(f"Entry: ${entry}, Initial Stop: ${entry * 0.97:.0f} (-3%)")
        print()

        for i, price in enumerate(prices):
            stop = self.update(price, entry)
            profit_pct = (price - entry) / entry * 100

            print(f"Bar {i+1}: Price ${price}, Stop ${stop:.0f}, Profit {profit_pct:+.2f}%")

            if self.should_exit(price):
                final_profit = (price - entry) / entry * 100
                print(f"\n✓ STOP TRIGGERED at ${price}")
                print(f"  Final profit: {final_profit:+.2f}%")
                break

trail = TrailingStop(initial_stop_pct=3.0, trailing_pct=2.0)
trail.example_simulation()

# Output:
# === Trailing Stop Simulation ===
# Entry: $50000, Initial Stop: $48500 (-3%)
#
# Bar 1: Price $50000, Stop $48500, Profit +0.00%
# Bar 2: Price $52000, Stop $50960, Profit +4.00%  (стоп подтянулся!)
# Bar 3: Price $54000, Stop $52920, Profit +8.00%  (стоп подтянулся!)
# Bar 4: Price $53000, Stop $52920, Profit +6.00%  (стоп не меняется)
# Bar 5: Price $55000, Stop $53900, Profit +10.00% (стоп подтянулся!)
# Bar 6: Price $54500, Stop $53900, Profit +9.00%  (стоп не меняется)
# Bar 7: Price $52000, Stop $53900, Profit +4.00%  (стоп не меняется)
#
# ✓ STOP TRIGGERED at $51000
#   Final profit: +2.00%
#
# Без trailing stop: прибыль испарилась бы с +10% до +2%
# С trailing stop: зафиксировали +2% вместо потенциального -3%

(Продолжение в следующем сообщении из-за ограничения длины…)

Ошибка #7: Эмоциональное вмешательство в работу робота

Что это такое

Разработка автоматической стратегии, но ручное вмешательство в её работу на основе эмоций: страха, жадности, паники.

Реальный пример

# Робот генерирует сигнал SELL
# Трейдер думает: "Но рынок же растёт! Подожду ещё"
# Не выполняет сигнал

# Или наоборот:
# Робот генерирует сигнал BUY
# Трейдер думает: "Слишком страшно покупать на падении"
# Не выполняет сигнал

# Результат: берём все убыточные сделки, пропускаем прибыльные

Статистика:

  • Робот автоматически: Sharpe 1.5, +35% годовых
  • С ручным вмешательством: Sharpe 0.3, +5% годовых

Психологические ловушки

class EmotionalTrading:
    """Типичные эмоциональные ошибки"""

    def revenge_trading(self):
        """Месть рынку после убытка"""
        # После серии убытков трейдер:
        # 1. Удваивает размер позиции ("отыграюсь!")
        # 2. Игнорирует сигналы робота
        # 3. Открывает позиции против тренда
        #
        # Результат: ещё большие убытки
        pass

    def premature_exit(self):
        """Преждевременный выход из прибыльной позиции"""
        # Робот держит позицию с +5% прибыли
        # Трейдер: "Лучше зафиксирую прибыль, пока не поздно"
        # Закрывает позицию
        #
        # Позиция вырастает до +20%
        # Трейдер упустил +15% прибыли
        pass

    def moving_stop_loss(self):
        """Передвигание stop-loss дальше"""
        # Stop-loss: -3%
        # Цена подходит к -2.9%
        # Трейдер: "Ещё чуть-чуть и развернётся!"
        # Передвигает стоп на -5%
        #
        # Цена падает до -8%
        # Убыток в 2.5 раза больше запланированного
        pass

    def fear_of_missing_out(self):
        """FOMO - страх упустить возможность"""
        # Робот НЕ даёт сигнал (условия не выполнены)
        # Цена резко растёт
        # Трейдер: "Все покупают! Надо успеть!"
        # Покупает на пике
        #
        # Цена разворачивается
        # Убыток
        pass

# Реальная статистика одного трейдера:
#
# Месяц 1 (полностью автоматический робот):
# - 45 сделок, win rate 58%, +$3,200 прибыли
#
# Месяц 2 (с ручным вмешательством):
# - 52 сделки (7 ручных)
# - Автоматические: 45 сделок, +$3,100
# - Ручные: 7 сделок, -$2,800 (средний убыток -$400 на сделку!)
# - Итого: +$300 (вместо потенциальных +$3,100)
#
# Вмешательство уничтожило 90% прибыли!

Правильный подход

class DisciplinedTrading:
    def __init__(self):
        self.intervention_log = []

    def execute_signal(self, signal, reason=""):
        """Исполняем сигнал БЕЗ вопросов"""
        if signal == 'BUY':
            self.buy()
        elif signal == 'SELL':
            self.sell()

        # Логируем
        self.log_trade(signal, automated=True)

    def request_manual_intervention(self, reason):
        """Если ОЧЕНЬ хочется вмешаться - сначала логируем"""
        print(f"⚠️  Manual intervention requested: {reason}")
        print(f"   Are you SURE? This typically reduces performance.")

        # Логируем попытку вмешательства
        self.intervention_log.append({
            'timestamp': datetime.now(),
            'reason': reason,
            'executed': False  # по умолчанию НЕ исполняем
        })

        # Требуем подтверждение
        confirmation = input("Type 'OVERRIDE' to confirm: ")

        if confirmation == 'OVERRIDE':
            self.intervention_log[-1]['executed'] = True
            return True
        else:
            print("✓ Intervention cancelled - following the system")
            return False

    def analyze_interventions(self):
        """Анализируем все вмешательства"""
        if not self.intervention_log:
            print("✓ No manual interventions - good discipline!")
            return

        executed = [i for i in self.intervention_log if i['executed']]

        print(f"=== Intervention Analysis ===")
        print(f"Total intervention attempts: {len(self.intervention_log)}")
        print(f"Actually executed: {len(executed)}")
        print(f"Cancelled (good!): {len(self.intervention_log) - len(executed)}")

        # TODO: сравнить результаты вмешательств с автоматическими сделками

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

Ошибка #8: Игнорирование корреляции между инструментами

Что это такое

Открытие нескольких позиций по коррелированным инструментам, что увеличивает риск вместо его диверсификации.

Реальный пример

# Трейдер открывает 5 позиций:
positions = {
    'BTC/USDT': 0.5,   # $25,000
    'ETH/USDT': 10,    # $25,000
    'BNB/USDT': 100,   # $25,000
    'SOL/USDT': 500,   # $25,000
    'AVAX/USDT': 1000  # $25,000
}

# "Отлично, диверсифицировал на 5 инструментов!"

# Но все эти криптовалюты ВЫСОКО коррелированы:
correlations = {
    'BTC-ETH': 0.92,
    'BTC-BNB': 0.85,
    'BTC-SOL': 0.88,
    'BTC-AVAX': 0.83
}

# При падении BTC на -10%, ВСЕ позиции упадут примерно на -10%
# Это НЕ диверсификация, это 5x leverage на один актив!

Последствия:

  • BTC падает на -15%
  • Все 5 позиций теряют ~-15%
  • Общий убыток: $125,000 * 0.15 = -$18,750
  • Вместо диверсификации получили концентрированный риск

Правильный подход

import numpy as np
import pandas as pd

class CorrelationRiskManager:
    def __init__(self, max_correlation=0.7):
        self.max_correlation = max_correlation
        self.positions = {}
        self.price_history = {}

    def calculate_correlation(self, symbol1, symbol2, period=30):
        """Рассчитываем корреляцию между двумя инструментами"""
        if symbol1 not in self.price_history or symbol2 not in self.price_history:
            return 0

        prices1 = self.price_history[symbol1][-period:]
        prices2 = self.price_history[symbol2][-period:]

        if len(prices1) < period or len(prices2) < period:
            return 0

        # Корреляция Пирсона
        correlation = np.corrcoef(prices1, prices2)[0, 1]
        return correlation

    def can_open_position(self, new_symbol):
        """Проверяем, можно ли открыть позицию с учётом корреляции"""

        if not self.positions:
            return True, "First position - OK"

        # Проверяем корреляцию с существующими позициями
        for existing_symbol in self.positions.keys():
            corr = self.calculate_correlation(new_symbol, existing_symbol)

            if abs(corr) > self.max_correlation:
                return False, f"High correlation with {existing_symbol}: {corr:.2f}"

        return True, "Correlation check passed"

    def get_portfolio_correlation_matrix(self):
        """Матрица корреляций портфеля"""
        if len(self.positions) < 2:
            return None

        symbols = list(self.positions.keys())
        n = len(symbols)
        corr_matrix = np.zeros((n, n))

        for i, sym1 in enumerate(symbols):
            for j, sym2 in enumerate(symbols):
                if i == j:
                    corr_matrix[i][j] = 1.0
                else:
                    corr_matrix[i][j] = self.calculate_correlation(sym1, sym2)

        return pd.DataFrame(corr_matrix, index=symbols, columns=symbols)

    def calculate_portfolio_risk(self):
        """Рассчитываем совокупный риск с учётом корреляций"""
        if len(self.positions) < 2:
            return None

        # Упрощённый расчёт: средняя корреляция
        corr_matrix = self.get_portfolio_correlation_matrix()

        # Средняя корреляция (без диагонали)
        mask = np.ones(corr_matrix.shape, dtype=bool)
        np.fill_diagonal(mask, False)
        avg_correlation = corr_matrix.values[mask].mean()

        print(f"=== Portfolio Correlation Analysis ===")
        print(f"Positions: {len(self.positions)}")
        print(f"Average correlation: {avg_correlation:.2f}")

        if avg_correlation > 0.7:
            print("⚠️  WARNING: High correlation - portfolio is not well diversified")
        elif avg_correlation > 0.5:
            print("⚠️  MODERATE: Some correlation - consider adding uncorrelated assets")
        else:
            print("✓ GOOD: Low correlation - portfolio is well diversified")

        print("\nCorrelation Matrix:")
        print(corr_matrix.round(2))

        return avg_correlation

# Пример использования
mgr = CorrelationRiskManager(max_correlation=0.7)

# Загружаем исторические цены
mgr.price_history = {
    'BTC/USDT': [50000, 51000, 49500, 52000, 50500] * 10,  # симуляция
    'ETH/USDT': [3000, 3100, 2980, 3150, 3050] * 10,
    'GOLD/USD': [1800, 1805, 1795, 1810, 1800] * 10,
    'EUR/USD': [1.10, 1.105, 1.098, 1.112, 1.108] * 10
}

# Открываем BTC
mgr.positions['BTC/USDT'] = 0.5
print("Opened BTC/USDT")

# Пытаемся открыть ETH (коррелирует с BTC)
can_open, reason = mgr.can_open_position('ETH/USDT')
print(f"\nCan open ETH/USDT? {can_open} - {reason}")

# Пытаемся открыть GOLD (не коррелирует с BTC)
can_open, reason = mgr.can_open_position('GOLD/USD')
print(f"Can open GOLD/USD? {can_open} - {reason}")

if can_open:
    mgr.positions['GOLD/USD'] = 10

# Анализ портфеля
mgr.calculate_portfolio_risk()

Правильная диверсификация: открывать позиции в некоррелированных или отрицательно коррелированных активах:

  • Crypto + Commodities (золото)
  • Crypto + Forex
  • Tech stocks + Utilities
  • Long equity + Short equity (market neutral)

Ошибка #9-12: Краткий обзор оставшихся ошибок

Ошибка #9: Недостаточное логирование

Проблема: робот работает как “чёрный ящик”, при ошибке невозможно понять что пошло не так.

Решение:

import logging

logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('trading_bot.log'),
        logging.StreamHandler()
    ]
)

logger = logging.getLogger('TradingBot')

# Логируем ВСЁ
logger.info(f"Signal generated: {signal}")
logger.info(f"Order sent: {order_id}")
logger.error(f"Order failed: {error}")
logger.debug(f"Position updated: {position}")

Ошибка #10: Игнорирование проскальзывания при оптимизации

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

Решение: всегда включать слиппедж в процесс оптимизации (см. статью о проблемах).

Ошибка #11: Отсутствие version control для стратегий

Проблема: изменения в коде стратегии без истории, невозможно откатиться к предыдущей версии.

Решение: использовать Git для всего кода:

git init
git add strategy.py
git commit -m "Initial strategy version - Sharpe 1.2"

# После изменений
git add strategy.py
git commit -m "Added trailing stop - Sharpe 1.5"

# Откат к предыдущей версии
git checkout HEAD~1 strategy.py

Ошибка #12: Запуск на реальные деньги без paper trading

Проблема: сразу запуск на реальный счёт без тестирования на demo/paper trading.

Решение:

  1. Бэктест на исторических данных (минимум 1 год)
  2. Forward test на out-of-sample данных (минимум 3 месяца)
  3. Paper trading (минимум 1 месяц)
  4. Микро-депозит на реальном счёте (минимум 1 месяц)
  5. Полный депозит только после успешного прохождения всех этапов

Заключение: Checklist для проверки стратегии

Перед запуском робота на реальные деньги проверьте:

✓ Бэктестинг

  • Нет look-ahead bias (последовательная обработка данных)
  • Учтены комиссии, спреды, слиппедж
  • Тестирование на разных рыночных режимах (bull/bear/range)
  • Минимум 100+ сделок для статистической значимости
  • Минимум 1 год данных
  • Out-of-sample тестирование (20-30% данных отложено)
  • Walk-forward analysis
  • Robustness check (изменение параметров ±20%)

✓ Risk Management

  • Risk-based position sizing (1-2% риска на сделку)
  • Stop-loss на каждой позиции
  • Trailing stop для защиты прибыли
  • Максимум 20% капитала в одной позиции
  • Circuit breakers для аномалий
  • Корреляционный анализ портфеля

✓ Execution

  • Логирование всех сделок, сигналов, ошибок
  • Monitoring и alerts
  • Paper trading минимум 1 месяц
  • Version control (Git)
  • Documented rollback procedure

✓ Psychology

  • Полное доверие системе (иначе не запускать)
  • Никаких ручных вмешательств
  • Чёткий план действий при убытках
  • Realistic expectations (30-50% годовых это отлично, не 300%)

Ключевой урок: большинство ошибок начинающих — это не плохие стратегии, а отсутствие дисциплины и правильных процессов. Даже посредственная стратегия с правильным risk management, тестированием и дисциплиной превзойдёт гениальную стратегию без этих компонентов.

В следующих статьях мы обсудим, как собрать каталог open-source решений для алготрейдинга и как использовать OSA Engine для быстрого старта.