Most traders treat optimization like a slot machine—pull the lever, wait for the shiny result, and then promptly lose money in live trading. The problem isn't optimization itself; it's the cargo-cult mentality that surrounds it. I've spent the better part of five years elbow-deep in MQL4 backtesting, and I can tell you with absolute certainty: the default MT4 strategy tester is both a gift and a curse. It gives you power, but it also hands you enough rope to hang your equity curve.
This article isn't another generic "how to optimize" guide. We're going to dissect the adaptive walk-forward methodology, implement a custom genetic algorithm snippet that addresses a glaring flaw in MT4's built-in optimizer, and talk about why your optimization results are probably lying to you.
The Great Deception of the "Optimal" Set
Let’s address the 800-pound gorilla in the room: overfitting. The MT4 tester, by default, uses a brute-force or genetic algorithm to find parameters that maximize your chosen criterion (usually Profit Factor or Net Profit). The problem is that this process fits the noise of the historical period perfectly. Robert Pardo, in his seminal work The Evaluation and Optimization of Trading Strategies (Wiley, 2008), argues that the validation of a strategy is more important than its optimization. He posits that out-of-sample testing is the only true measure of robustness. Yet, how many of us actually run a proper walk-forward?
The typical workflow is:
The missing piece is stability. A parameter set that performs well over the entire dataset but has wild swings in performance across sub-periods is a ticking time bomb. The optimization should not just maximize profit; it should maximize consistency.
The Adaptive Walk-Forward Logic
The walk-forward analysis (WFA) is the gold standard. It works like this:
The "adaptive" part I propose is not just about rolling the window, but about weighting the optimization objective. In traditional WFA, the IS period is treated as a monolith. But markets change. A parameter that worked in the first half of the IS period might be detrimental in the second half.
Here is my 独家视角: Instead of optimizing for total net profit, optimize for the rolling Sharpe ratio of the IS period, but penalize the strategy if the performance in the second half of the IS period is significantly worse than the first half. This acts as a real-time "change-point" detector. It forces the optimization to find parameters that are not just profitable, but stable across the recent market regime.
The MQL4 Genetic Algorithm Snippet (and its fatal flaw)
MT4's built-in GA is decent, but it has a massive blind spot: it doesn't allow for custom seeding or diversity preservation. It tends to converge on a local optimum very quickly, especially when you have a large parameter space.
Let's build a custom GA that introduces adaptive mutation. The built-in GA uses a fixed mutation rate. Our version will increase the mutation rate if the population's average fitness stagnates for more than 5 generations. This is a technique borrowed from evolution strategies (ES) literature, specifically referencing the work of Schwefel and Bäck.
Here is a simplified, compilable MQL4 script that demonstrates this adaptive mutation logic for a parameter set of two variables:
MAPeriod and StopLoss.``
mql4
//+------------------------------------------------------------------+
//| AdaptiveGA_Example.mq4 |
//| (C) FXEAR.com - Proof of Concept |
//| |
//| This is a STANDALONE script to demonstrate adaptive mutation. |
//| In a real EA, you'd integrate this logic into the OnStart() |
//| or a custom optimization routine. |
//+------------------------------------------------------------------+
#property strict
// Population structure
struct SIndividual {
int MA_Period;
int SL_Points;
double Fitness; // e.g., Sharpe Ratio or Profit Factor
};
// Inputs for the GA
input int MaxGenerations = 50;
input int PopulationSize = 20;
input int MinMAPeriod = 5;
input int MaxMAPeriod = 100;
input int MinSL = 20;
input int MaxSL = 200;
// Global arrays
SIndividual Population[];
double FitnessHistory[];
int StagnationCounter = 0;
double PrevAvgFitness = 0.0;
//+------------------------------------------------------------------+
//| Script program start function |
//+------------------------------------------------------------------+
void OnStart() {
// 1. Initialize Population
ArrayResize(Population, PopulationSize);
for (int i = 0; i < PopulationSize; i++) {
Population[i].MA_Period = RandInt(MinMAPeriod, MaxMAPeriod);
Population[i].SL_Points = RandInt(MinSL, MaxSL);
Population[i].Fitness = CalculateFitness(Population[i].MA_Period, Population[i].SL_Points);
}
// 2. Main GA Loop
for (int gen = 0; gen < MaxGenerations; gen++) {
// Sort by fitness (descending)
SortPopulation();
// Calculate average fitness for stagnation detection
double avgFit = GetAverageFitness();
FitnessHistory[gen] = avgFit;
if (gen > 0) {
if (MathAbs(avgFit - PrevAvgFitness) < 0.0001) {
StagnationCounter++;
} else {
StagnationCounter = 0;
}
}
PrevAvgFitness = avgFit;
// Adaptive Mutation Logic
double MutationRate = 0.10; // Base 10%
if (StagnationCounter >= 5) {
MutationRate = 0.35; // Increase to 35% to escape local optimum
Print("Generation ", gen, ": Stagnation detected. Mutation rate increased to 35%.");
}
// Crossover and Mutation (Elitism: keep top 2)
int eliteCount = 2;
SIndividual NewPop[];
ArrayResize(NewPop, PopulationSize);
// Keep elites
for (int e = 0; e < eliteCount; e++) {
NewPop[e] = Population[e];
}
// Fill rest
for (int j = eliteCount; j < PopulationSize; j++) {
// Tournament selection
int parent1 = TournamentSelect();
int parent2 = TournamentSelect();
// Crossover (uniform crossover)
NewPop[j].MA_Period = (MathRand() % 2 == 0) ? Population[parent1].MA_Period : Population[parent2].MA_Period;
NewPop[j].SL_Points = (MathRand() % 2 == 0) ? Population[parent1].SL_Points : Population[parent2].SL_Points;
// Adaptive Mutation
if (MathRand() / 32767.0 < MutationRate) {
// Mutate MA Period
int delta = RandInt(-10, 10);
NewPop[j].MA_Period = MathMax(MinMAPeriod, MathMin(MaxMAPeriod, NewPop[j].MA_Period + delta));
}
if (MathRand() / 32767.0 < MutationRate) {
// Mutate SL
int delta = RandInt(-20, 20);
NewPop[j].SL_Points = MathMax(MinSL, MathMin(MaxSL, NewPop[j].SL_Points + delta));
}
// Evaluate
NewPop[j].Fitness = CalculateFitness(NewPop[j].MA_Period, NewPop[j].SL_Points);
}
// Replace population
ArrayCopy(Population, NewPop);
// Output best
Print("Gen ", gen, " Best Fitness: ", Population[0].Fitness, " MA: ", Population[0].MA_Period, " SL: ", Population[0].SL_Points);
}
}
//+------------------------------------------------------------------+
//| Helper: Random Integer |
//+------------------------------------------------------------------+
int RandInt(int minVal, int maxVal) {
return (minVal + (MathRand() % (maxVal - minVal + 1)));
}
//+------------------------------------------------------------------+
//| Dummy Fitness Function (Replace with your EA's logic) |
//| In reality, you'd run a backtest here for the specific params. |
//+------------------------------------------------------------------+
double CalculateFitness(int maPeriod, int slPoints) {
// This is a placeholder. In a real scenario, this would call a backtest.
// We create a fake "landscape" with a peak around maPeriod=50 and slPoints=80.
double fit = 10.0 - MathAbs(maPeriod - 50) 0.1 - MathAbs(slPoints - 80) 0.05;
// Add some noise
fit += (MathRand() / 32767.0) * 2.0;
return MathMax(0.1, fit);
}
//+------------------------------------------------------------------+
//| Sort Population (Bubble sort for simplicity) |
//+------------------------------------------------------------------+
void SortPopulation() {
for (int i = 0; i < PopulationSize - 1; i++) {
for (int j = 0; j < PopulationSize - i - 1; j++) {
if (Population[j].Fitness < Population[j+1].Fitness) {
SIndividual temp = Population[j];
Population[j] = Population[j+1];
Population[j+1] = temp;
}
}
}
}
//+------------------------------------------------------------------+
//| Tournament Selection |
//+------------------------------------------------------------------+
int TournamentSelect() {
int idx1 = RandInt(0, PopulationSize - 1);
int idx2 = RandInt(0, PopulationSize - 1);
return (Population[idx1].Fitness > Population[idx2].Fitness) ? idx1 : idx2;
}
//+------------------------------------------------------------------+
//| Average Fitness |
//+------------------------------------------------------------------+
double GetAverageFitness() {
double sum = 0.0;
for (int i = 0; i < PopulationSize; i++) {
sum += Population[i].Fitness;
}
return sum / PopulationSize;
}
//+------------------------------------------------------------------+
`
The Nuance: Notice the function. In a real EA, this would execute a full backtest on the IS data. This is computationally expensive. The "trick" to making this work efficiently is to use discrete event simulation rather than tick-by-tick. Most people just use the built-in tester, but that's slow. I recommend writing a custom backtesting engine within the EA that reads OHLCV data from an array. It's faster and gives you more control over the execution logic.
A Common Trap with
OrderSend and Optimization
Here is a classic "gotcha" that will ruin your optimization: OrderSend errors. During optimization, the tester runs thousands of iterations. If your code returns -1 (failure) for a set of parameters, the tester usually returns a zero profit for that run. But what if it fails sometimes? The MT4 OrderSend function is notorious for returning -1 due to "common errors" like 130 (Invalid stops) or 138 (Requote). The tester might pass the OrderSend on the first few bars but fail on the last bar, skewing your results.
My Rule: Always wrap your OrderSend in a loop with a retry mechanism. But for optimization purposes, you need a pre-check. Before sending the order, calculate the Stop Loss and Take Profit levels and verify they are within the current MarketInfo(Symbol(), MODE_STOPLEVEL). If they aren't, skip the trade or adjust them. Don't rely on the error handler to save you, because the tester will just mark it as a loss, and you won't know why.
`mql4
// Safe OrderSend wrapper with pre-validation
bool SafeOrderSend(int cmd, double price, double sl, double tp) {
int stopLevel = (int)MarketInfo(Symbol(), MODE_STOPLEVEL);
if (cmd == OP_BUY) {
if (sl != 0 && price - sl < stopLevel Point) return false;
if (tp != 0 && tp - price < stopLevel Point) return false;
} else if (cmd == OP_SELL) {
if (sl != 0 && sl - price < stopLevel Point) return false;
if (tp != 0 && price - tp < stopLevel Point) return false;
}
// If valid, proceed with OrderSend and retry loop (3 attempts)
for(int attempt = 0; attempt < 3; attempt++) {
int ticket = OrderSend(Symbol(), cmd, Lots, price, 3, sl, tp, "EA_Opt", Magic, 0, clrNONE);
if(ticket > 0) return true;
Sleep(100); // Wait for market update
RefreshRates();
}
return false;
}
``Debugging the Optimization Run
The built-in optimizer gives you a nice chart, but it doesn't give you consistency metrics. I always add a custom metric called "Efficiency Ratio" (ER), borrowed from Kaufman's Adaptive Moving Average. In the context of optimization, I calculate the Return-to-Risk ratio of the equity curve's slope. A strategy with a high net profit but a choppy equity curve is dangerous.
$$
\text{Optimization Score} = \text{Sharpe Ratio} \times \left(1 - \frac{\text{Max Drawdown}}{\text{Net Profit}}\right)
$$
This penalizes drawdowns effectively.
Reference
This approach won't guarantee a winning strategy, but it will guarantee that you aren't fooling yourself. Optimization is a mirror; it reflects your assumptions. Make sure you're looking at a clear reflection, not a funhouse mirror.
本文首发于FXEAR.com，原创内容，未经授权禁止转载。