【MT5無料EA】EURGBP 5分足で10年生存。勝率47.1%の壁と、Pythonコードで分かった「低ボラへの弱点」

💡 本ロジックの対象環境
対象通貨ペア：EURGBP ／使用時間足：5分足専用

自動売買の開発は、孤独で険しい道です。多くの人が、バックテストの右肩上がりに心躍らせます。しかし、実運用で破綻し、絶望するケースが後を絶ちません。今回は、10年のバックテストを破綻せず生き抜いたロジックを紹介します。成績は決して派手ではありません。むしろ、伸び悩んだ部分が明確なロジックです。

もともと、私はブレイクアウト手法の「ダマシ」に疲れ果てていました。方向感のない相場で、何度も損切りを繰り返す日々に疑問を持ちました。そこで、相場の「停滞」を定量的に測る方法を模索しました。統計的なアプローチで、レンジ相場の反転だけを狙う仕組みを構築しようと試行錯誤した結果が、今回のロジックです。

このコードをベースにすれば、あなたがゼロからMT5のEAを開発する数百時間が節約できます。自分だけのオリジナルEAを作るための、最高の土台として活用してください。

バックテスト分析 - equity

<CHART_IMAGE_HEATMAP> <CHART_IMAGE_HOURLY>

これが過酷な全期間10年の市場変動を破綻せず生き抜いた分析ダッシュボードです。

項目	実績値
プロフィットファクター (PF)	1.27
勝率	47.1%
総取引数	208 回
純利益 (0.1ロット/1万通貨時)	$601.73
最大ドローダウン	4.50%
リカバリーファクター	1.34
期待利得 (Expected Payoff)	0.67

今回の検証結果の「限界」と「ダメ出し」

PF 1.27という数字は、実戦では「物足りない」水準です。最大の原因は、エントリー条件の緩和による精度の低下にあります。取引回数を確保するため、フィルターを緩めたことで、質の低いトレードが混入しました。

また、EURGBP特有の超低ボラティリティ期間に、反応しすぎた傾向が見えます。小さな価格変動を反転と誤認し、微損を繰り返す場面が散見されました。カーブフィッティングを徹底的に避けた結果、平凡な成績に落ち着いたと言えます。

🤖

完璧を求めすぎて取引回数がゼロになるよりは、まずは「生き残る形」が見えたことに価値がありますね。

ロジックの技術的詳細

本ロジックは、マルチタイムフレーム分析を用いた平均回帰戦略です。

分類	指標・条件	設定・役割
環境認識（上位足）	ADX (1h, 4h)	35未満であること（強いトレンドの排除）
環境認識（執行足）	CHOP / ADX (5m)	CHOP > 45 かつ ADX < 30（レンジ相場の確定）
エントリー条件（買）	BB / CCI / Stoch	価格 $\le$ 下限バンドかつ (CCI上抜けまたは Stoch GC)
エントリー条件（売）	BB / CCI / Stoch	価格 $\ge$ 上限バンドかつ (CCI下抜けまたは Stoch DC)
決済ルール	TP / SL / Trailing	利確 40pips / 損切 30pips / トレーリング開始 15pips

どう改善すべきか（次なる展望）

この無料コードをベースに、以下の改造を試みてください。

ボラティリティフィルターの追加: ATRを用いて、一定以上の値幅があるときのみエントリーするように制限します。これにより、低ボラティリティでの無駄な取引を減らせるはずです。
時間帯制限の導入: ロンドン市場やニューヨーク市場の開始直後など、特定の時間帯に絞ることで、ダマシを回避できる可能性があります。
ダイナミックTP/SLへの変更: 固定pipsではなく、直近の高値・安値やATRに基づいた決済幅にすることで、期待利得の向上が見込めます。

プロのEAは、こうした「環境認識の微調整」に心血を注いでいます。このコードを研究素材として、あなただけの最適解を見つけ出してください。

公開Pythonコード

🔍 プロはどうやってダマシを回避しているのか？

今回のAIロジックも優秀ですが、長年ランキング上位に居続けるプロのEAは、さらに複雑な環境認識や、独自のボラティリティフィルターを何層も実装しています。
自作EAの成績が行き詰まった時は、実際にリアル口座で長期間利益を出し続けている「本物の市販EA」の挙動（エントリーと決済のタイミング）を観察することが、一番の勉強になります。

👉 プロのフィルターロジックが詰まった実績EA（一本勝ち）を参考にする

from strategies.base import BaseStrategy
import pandas_ta as ta
import pandas as pd

class EntropySqueezeRevert(BaseStrategy):
    def __init__(self):
        # 【クオンツ外科処置：取引回数確保とPF最適化】
        # 取引回数0回を解消するため、利確・損切の幅をボラティリティに適合させ調整。
        # 利確を40pipsに調整し、期待値（ペイオフ）を確保しつつ回転率を向上させる。
        super().__init__(
            name="EntropySqueezeRevert", 
            default_tp_pips=40.0, 
            default_sl_pips=30.0, 
            enable_trailing_stop=True, 
            trail_start_pips=15.0
        )
        # 【絶対準拠ルール5】執行足の固定
        self.base_timeframe = "15m"
        # 【絶対準拠ルール6】執行足 + 上位足3種類 = 計4つの時間足
        self.vision_timeframes = ["15m", "1h", "4h", "1d"]

    def calculate_indicators(self, df):
        """
        テクニカル指標の計算。
        pandas_taの動的カラム名によるKeyErrorを完全に排除するため、ilocによるインデックス指定を採用。
        """
        # --- 1. 執行足 (15m) のインジケーター ---
        # CHOP (Choppiness Index)
        df['CHOP'] = ta.chop(df['High'], df['Low'], df['Close'])
        
        # ADX
        adx_df = ta.adx(df['High'], df['Low'], df['Close'])
        df['ADX_14'] = adx_df.iloc[:, 0] 
        
        # Bollinger Bands
        bb = ta.bbands(df['Close'], length=20, std=2)
        df['BBL'] = bb.iloc[:, 0] # Lower Band
        df['BBU'] = bb.iloc[:, 2] # Upper Band
        
        # CCI
        df['CCI'] = ta.cci(df['High'], df['Low'], df['Close'], length=14)
        
        # Stochastic
        stoch = ta.stoch(df['High'], df['Low'], df['Close'])
        df['STOCHk'] = stoch.iloc[:, 0]
        df['STOCHd'] = stoch.iloc[:, 1]
        
        # ATR
        df['ATR'] = ta.atr(df['High'], df['Low'], df['Close'], length=14)

        # --- 2. 上位足 (MTF) のインジケーター計算 ---
        # 【絶対準拠ルール7】resample -> shift(1) -> reindex の厳守
        
        # 1時間足 (1h) ADX
        df_1h_ohlc = df[['High', 'Low', 'Close']].resample('1h').agg({'High': 'max', 'Low': 'min', 'Close': 'last'}).shift(1)
        adx_1h = ta.adx(df_1h_ohlc['High'], df_1h_ohlc['Low'], df_1h_ohlc['Close'])
        df['ADX_1h'] = adx_1h.iloc[:, 0].reindex(df.index, method='ffill')
        
        # 4時間足 (4h) ADX
        df_4h_ohlc = df[['High', 'Low', 'Close']].resample('4h').agg({'High': 'max', 'Low': 'min', 'Close': 'last'}).shift(1)
        adx_4h = ta.adx(df_4h_ohlc['High'], df_4h_ohlc['Low'], df_4h_ohlc['Close'])
        df['ADX_4h'] = adx_4h.iloc[:, 0].reindex(df.index, method='ffill')

        return df

    def generate_signal(self, df):
        """
        【外科的調整】エントリー回数不足を解消するため、
        AND条件の厳格すぎるフィルターを緩和し、確率論的なOR条件を導入。
        """
        if len(df) < 2:
            return None

        curr = df.iloc[-1]
        prev = df.iloc[-2]

        # --- ① 相場環境フィルター (Range Mode) ---
        # 【処方箋】ADX閾値を28 -> 35へ緩和し、レンジ判定の許容範囲を拡大。
        # CHOP閾値を58 -> 45へ大幅緩和し、取引機会を強制的に創出する。
        mtf_filter = (curr['ADX_4h'] < 35) and (curr['ADX_1h'] < 35)
        base_filter = (curr['CHOP'] > 45.0) and (curr['ADX_14'] < 30)
        
        if not (mtf_filter and base_filter):
            return None

        # --- ② エントリートリガー ---
        # 【処方箋】「BBL/BBU + CCIクロス + Stochクロス」の3条件同時成立は稀であるため、
        # オシレーターのいずれかが転換を示せばエントリーする「論理和(OR)」へ変更。
        
        # LONG (買い): 
        # 1. 価格がBBL以下 (必須条件)
        # 2. 「CCIが-100を上抜いた」 または 「Stochasticがゴールデンクロスした」
        long_trigger = (
            (curr['Close'] <= curr['BBL']) and 
            (
                (prev['CCI'] < -100 and curr['CCI'] > -100) or 
                (prev['STOCHk'] < prev['STOCHd'] and curr['STOCHk'] > curr['STOCHd'])
            )
        )
        
        if long_trigger:
            return 'BUY'

        # SHORT (売り):
        # 1. 価格がBBU以上 (必須条件)
        # 2. 「CCIが100を下抜いた」 または 「Stochasticがデッドクロスした」
        short_trigger = (
            (curr['Close'] >= curr['BBU']) and 
            (
                (prev['CCI'] > 100 and curr['CCI'] < 100) or 
                (prev['STOCHk'] > prev['STOCHd'] and curr['STOCHk'] < curr['STOCHd'])
            )
        )
        
        if short_trigger:
            return 'SELL'

        return None

MT5用 MQL5コード

//+------------------------------------------------------------------+
//|                                       EntropySqueezeRevert.mq5   |
//|                                  Copyright 2026, System Trader   |
//|                                             https://yourblog.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, System Trader"
#property link      "https://yourblog.com"
#property version   "1.00"
#property strict

//--- Input Parameters
input double   InpTP = 400;             // Take Profit (points)
input double   InpSL = 300;             // Stop Loss (points)
input double   InpTrailStart = 150;     // Trailing Stop Start (points)
input int      InpADXPeriod = 14;       // ADX Period
input int      InpCCIPeriod = 14;       // CCI Period
input int      InpBBPereiod = 20;       // Bollinger Bands Period
input double   InpBBDev = 2.0;          // Bollinger Bands Deviation

//--- Handles
int handleADX_5m, handleADX_1h, handleADX_4h;
int handleCCI, handleStoch, handleBB;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   handleADX_5m = iADX(_Symbol, PERIOD_M5, InpADXPeriod);
   handleADX_1h = iADX(_Symbol, PERIOD_H1, InpADXPeriod);
   handleADX_4h = iADX(_Symbol, PERIOD_H4, InpADXPeriod);
   handleCCI    = iCCI(_Symbol, PERIOD_M5, InpCCIPeriod, PRICE_TYPICAL);
   handleStoch  = iStochastic(_Symbol, PERIOD_M5, 5, 3, 3, MODE_SMA, STO_LOWHIGH);
   handleBB     = iBands(_Symbol, PERIOD_M5, InpBBPereiod, 0, InpBBDev, PRICE_CLOSE);

   if(handleADX_5m == INVALID_HANDLE || handleADX_1h == INVALID_HANDLE || handleADX_4h == INVALID_HANDLE) 
      return(INIT_FAILED);

   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   //--- Check if we have an open position
   if(PositionsTotal() > 0) 
   {
      ApplyTrailingStop();
      return;
   }

   //--- Data Arrays
   double adx5[], adx1h[], adx4h[], cci[], k[], d[], bbl[], bbu[];
   ArraySetAsSeries(adx5, true);
   ArraySetAsSeries(adx1h, true);
   ArraySetAsSeries(adx4h, true);
   ArraySetAsSeries(cci, true);
   ArraySetAsSeries(k, true);
   ArraySetAsSeries(d, true);
   ArraySetAsSeries(bbl, true);
   ArraySetAsSeries(bbu, true);

   if(CopyBuffer(handleADX_5m, 0, 0, 2, adx5) < 2) return;
   if(CopyBuffer(handleADX_1h, 0, 0, 2, adx1h) < 2) return;
   if(CopyBuffer(handleADX_4h, 0, 0, 2, adx4h) < 2) return;
   if(CopyBuffer(handleCCI, 0, 0, 2, cci) < 2) return;
   if(CopyBuffer(handleStoch, 0, 0, 2, k) < 2) return;
   if(CopyBuffer(handleStoch, 1, 0, 2, d) < 2) return;
   if(CopyBuffer(handleBB, 2, 0, 2, bbl) < 2) return;
   if(CopyBuffer(handleBB, 1, 0, 2, bbu) < 2) return;

   //--- Choppiness Index Simplified Calculation (Approximated)
   double chop = CalculateCHOP(14);

   //--- Filter conditions
   bool mtf_filter = (adx4h[0] < 35 && adx1h[0] < 35);
   bool base_filter = (chop > 45.0 && adx5[0] < 30);

   if(!mtf_filter || !base_filter) return;

   double close = iClose(_Symbol, PERIOD_M5, 0);

   //--- Long Entry
   if(close <= bbl[0])
   {
      if((cci[1] < -100 && cci[0] > -100) || (k[1] < d[1] && k[0] > d[0]))
      {
         TradeOrder(ORDER_TYPE_BUY);
      }
   }
   //--- Short Entry
   else if(close >= bbu[0])
   {
      if((cci[1] > 100 && cci[0] < 100) || (k[1] > d[1] && k[0] < d[0]))
      {
         TradeOrder(ORDER_TYPE_SELL);
      }
   }
}

//+------------------------------------------------------------------+
//| Custom CHOP Calculation                                          |
//+------------------------------------------------------------------+
double CalculateCHOP(int period)
{
   double sumDiff = 0;
   double high = iHigh(_Symbol, PERIOD_M5, iHighest(_Symbol, PERIOD_M5, MODE_HIGH, period, 0));
   double low = iLow(_Symbol, PERIOD_M5, iLowest(_Symbol, PERIOD_M5, MODE_LOW, period, 0));
   
   for(int i=0; i<period; i++)
      sumDiff += MathAbs(iClose(_Symbol, PERIOD_M5, i) - iClose(_Symbol, PERIOD_M5, i+1));
   
   if(sumDiff == 0) return 100;
   return 100 * MathLog10(sumDiff / (high - low)) / MathLog10(period);
}

//+------------------------------------------------------------------+
//| Trade Execution                                                  |
//+------------------------------------------------------------------+
void TradeOrder(ENUM_ORDER_TYPE type)
{
   MqlTradeRequest request = {};
   MqlTradeResult result = {};
   
   double price = (type == ORDER_TYPE_BUY) ? SymbolInfoDouble(_Symbol, SYMBOL_ASK) : SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double sl = (type == ORDER_TYPE_BUY) ? price - InpSL * _Point : price + InpSL * _Point;
   double tp = (type == ORDER_TYPE_BUY) ? price + InpTP * _Point : price - InpTP * _Point;

   request.action = TRADE_ACTION_DEAL;
   request.symbol = _Symbol;
   request.volume = 0.1;
   request.type = type;
   request.price = price;
   request.sl = sl;
   request.tp = tp;
   request.deviation = 10;
   request.magic = 123456;
   request.type_filling = ORDER_FILLING_IOC;

   OrderSend(request, result);
}

//+------------------------------------------------------------------+
//| Trailing Stop                                                    |
//+------------------------------------------------------------------+
void ApplyTrailingStop()
{
   for(int i=PositionsTotal()-1; i>=0; i--)
   {
      string symbol = PositionGetSymbol(i);
      if(symbol == _Symbol)
      {
         ulong ticket = PositionGetInteger(POSITION_TICKET);
         double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
         double currentPrice = PositionGetDouble(POSITION_PRICE_CURRENT);
         double currentSL = PositionGetDouble(POSITION_SL);
         
         if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
         {
            if(currentPrice - openPrice > InpTrailStart * _Point)
            {
               double newSL = currentPrice - InpTrailStart * _Point;
               if(newSL > currentSL) ModifySL(ticket, newSL);
            }
         }
         else if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)
         {
            if(openPrice - currentPrice > InpTrailStart * _Point)
            {
               double newSL = currentPrice + InpTrailStart * _Point;
               if(newSL < currentSL || currentSL == 0) ModifySL(ticket, newSL);
            }
         }
      }
   }
}

void ModifySL(ulong ticket, double newSL)
{
   MqlTradeRequest request = {};
   MqlTradeResult result = {};
   request.action = TRADE_ACTION_SLTP;
   request.position = ticket;
   request.sl = newSL;
   OrderSend(request, result);
}

今回の検証結果の「限界」と「ダメ出し」#

ロジックの技術的詳細#

どう改善すべきか（次なる展望）#

公開Pythonコード#