🔬【読者の鋭い指摘】ATRフィルターのシフト問題を徹底検証！銘柄で真逆の結果に

時刻   00:00  00:05  00:10  00:15  ← ブレイク発生！
ATR    0.05   0.05   0.05   0.15  ← ATR急上昇！

「ブレイク足（00:15）のATRが0.15だから高ボラ！」
↑これ、当たり前じゃね？🤔

時刻   00:00  00:05  00:10  00:15  ← ブレイク発生！
ATR    0.05   0.05   0.05   0.15
                      ↑
               この足のATRで判定（0.05）

「ブレイク前のATRで判断しよう」

時間足: 5分足
データ数: 各10,000本
ブレイク判定: 直近20本の高値/安値を突破
決済: 120分後（時間決済）

❌ 高ボラ時にエントリー → 逆効果！
✅ 低ボラ時にエントリー → まだマシ（52-53%）
✅ そもそもブレイクアウトより他の手法を検討

✅ 高ボラ時に買いエントリー → 勝率59%、+218$
❌ 低ボラ時に買いエントリー → 負ける（-80$）
✅ ATR(3) × 2.7以上で絞ると最強

"""
ATRフィルター検証 - シフト0 vs シフト1
銘柄: USDJPYm, BTCUSDm
"""

import MetaTrader5 as mt5
import pandas as pd
import numpy as np
from scipy import stats
import warnings
warnings.filterwarnings('ignore')

# ===== 設定 =====
SYMBOL = "BTCUSDm"  # または "USDJPYm"
TIMEFRAME = mt5.TIMEFRAME_M5
NUM_BARS = 10000
BREAKOUT_PERIOD = 20
ATR_PERIOD = 3  # BTCは3、USDJPYは14
ATR_MULTIPLIER = 2.7  # フィルター倍率

TIME_HORIZONS = [5, 15, 30, 60, 120]


def initialize_mt5():
    if not mt5.initialize():
        return False
    print(f"MT5 version: {mt5.version()}")
    return True


def get_ohlc_data(symbol, timeframe, num_bars):
    symbol_info = mt5.symbol_info(symbol)
    if symbol_info is None:
        # シンボル名のバリエーションを試す
        for suffix in ['', 'm', '.i', '-m', '_SB']:
            test_symbol = symbol.replace('m', '') + suffix
            symbol_info = mt5.symbol_info(test_symbol)
            if symbol_info is not None:
                symbol = test_symbol
                break
    if symbol_info is None:
        return None
    if not symbol_info.visible:
        mt5.symbol_select(symbol, True)
    rates = mt5.copy_rates_from_pos(symbol, timeframe, 0, num_bars)
    if rates is None:
        return None
    df = pd.DataFrame(rates)
    df['time'] = pd.to_datetime(df['time'], unit='s')
    df.set_index('time', inplace=True)
    print(f"Data: {len(df)} bars ({df.index[0]} to {df.index[-1]})")
    return df


def calculate_atr(df, period):
    """ATR (Average True Range) を計算"""
    high = df['high']
    low = df['low']
    close = df['close'].shift(1)
    tr1 = high - low
    tr2 = abs(high - close)
    tr3 = abs(low - close)
    tr = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
    return tr.rolling(window=period).mean()


def detect_breakouts(df, period):
    """ブレイクアウトを検出"""
    # 直近N本の高値・安値（1本前までで計算）
    df['highest'] = df['high'].rolling(window=period).max().shift(1)
    df['lowest'] = df['low'].rolling(window=period).min().shift(1)

    # ブレイク判定
    df['breakout_up'] = df['close'] > df['highest']
    df['breakout_down'] = df['close'] < df['lowest']

    # 連続ブレイクを除外（最初の1本だけ）
    df['breakout_up_signal'] = df['breakout_up'] & ~df['breakout_up'].shift(1).fillna(False)
    df['breakout_down_signal'] = df['breakout_down'] & ~df['breakout_down'].shift(1).fillna(False)

    print(f"Breakout UP: {df['breakout_up_signal'].sum()}")
    print(f"Breakout DOWN: {df['breakout_down_signal'].sum()}")
    return df


def calculate_future_returns(df, horizons_minutes, timeframe_minutes=5):
    """将来リターンを計算"""
    for minutes in horizons_minutes:
        bars_ahead = minutes // timeframe_minutes
        future_close = df['close'].shift(-bars_ahead)
        df[f'return_{minutes}m'] = (future_close - df['close']) * 100
    return df


def analyze_with_filter(df, signal_col, horizons, atr_filter, atr_shift, multiplier=1.0):
    """
    ATRフィルター付きでブレイクアウトを分析

    atr_filter: 'high', 'low', None
    atr_shift: 0（当該足）or 1（1本前の足）
    multiplier: 閾値の倍率（例: 2.7）
    """
    signal_df = df[df[signal_col] == True].copy()

    if len(signal_df) == 0:
        return None

    if atr_filter is not None:
        atr_median = df['atr'].median()
        threshold = atr_median * multiplier

        if atr_shift == 0:
            atr_values = signal_df['atr']
        else:
            atr_values = df['atr'].shift(atr_shift).loc[signal_df.index]

        if atr_filter == 'high':
            signal_df = signal_df[atr_values > threshold]
        else:
            signal_df = signal_df[atr_values <= threshold]

    if len(signal_df) < 10:
        return None

    results = {}
    for minutes in horizons:
        returns = signal_df[f'return_{minutes}m'].dropna()
        if len(returns) >= 10:
            results[minutes] = {
                'count': len(returns),
                'mean': returns.mean(),
                'win_rate': (returns > 0).mean() * 100,
            }
    return results


def main():
    if not initialize_mt5():
        return

    try:
        df = get_ohlc_data(SYMBOL, TIMEFRAME, NUM_BARS)
        if df is None:
            return

        df['atr'] = calculate_atr(df, ATR_PERIOD)
        df = detect_breakouts(df, BREAKOUT_PERIOD)
        df = calculate_future_returns(df, TIME_HORIZONS)

        atr_median = df['atr'].median()
        print(f"\nATR({ATR_PERIOD}) median: {atr_median:.5f}")
        print(f"High vol threshold (x{ATR_MULTIPLIER}): {atr_median * ATR_MULTIPLIER:.5f}")

        # 各条件で検証
        multipliers = [1.0, 1.5, 2.0, 2.7]

        for shift in [0, 1]:
            print(f"\n{'='*60}")
            print(f"ATR SHIFT = {shift}")
            print(f"{'='*60}")

            # 上方ブレイク（買い）
            print("\n[UP (Buy)]")
            for mult in multipliers:
                result = analyze_with_filter(
                    df, 'breakout_up_signal', TIME_HORIZONS, 'high', shift, mult
                )
                if result and 120 in result:
                    print(f"  High Vol (x{mult}): {result[120]['win_rate']:.1f}%, "
                          f"Mean={result[120]['mean']:+.2f}, N={result[120]['count']}")

            result_low = analyze_with_filter(
                df, 'breakout_up_signal', TIME_HORIZONS, 'low', shift, 1.0
            )
            if result_low and 120 in result_low:
                print(f"  Low Vol:          {result_low[120]['win_rate']:.1f}%, "
                      f"Mean={result_low[120]['mean']:+.2f}, N={result_low[120]['count']}")

    finally:
        mt5.shutdown()


if __name__ == "__main__":
    main()