420 lines
16 KiB
MQL5
420 lines
16 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| TrainPriceActionNN.mq5 |
|
|
//| Copyright 2025, Google Gemini |
|
|
//| https://www.mql5.com |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "Copyright 2025, Google Gemini"
|
|
#property link "https://www.google.com"
|
|
#property version "3.00"
|
|
#property script_show_inputs
|
|
|
|
#include <NeuralNet.mqh>
|
|
|
|
input int InpEpochs = 500;
|
|
input int InpLookback = 144;
|
|
input string InpHiddenLayerConfig = "256,128,64";
|
|
input double InpTrainingRate = 0.001;
|
|
input double InpTrainingDecay = 0.98;
|
|
input double InpLambda = 0.0001; // L2 Regularization (Weight Decay)
|
|
input double InpJitter = 0.05; // Nudge magnitude when stuck
|
|
input int InpMaxBars = 5000000;
|
|
input int InpPredictionHorizon = 144;
|
|
// Session Times (Broker Server Hour)
|
|
input int InpAsianStart = 0;
|
|
input int InpAsianEnd = 8;
|
|
input int InpLondonStart = 8;
|
|
input int InpLondonEnd = 16;
|
|
input int InpNYStart = 13;
|
|
input int InpNYEnd = 22;
|
|
|
|
CNeuralNet *Net;
|
|
int GlobalTopology[];
|
|
int handleATR_D1, handleEMA50, handleEMA200;
|
|
|
|
struct Sample {
|
|
double inputs[];
|
|
double target;
|
|
};
|
|
|
|
struct DaySession {
|
|
double aH, aL;
|
|
double lH, lL;
|
|
double nH, nL;
|
|
bool aValid, lValid, nValid;
|
|
};
|
|
|
|
// Map: DayIndex (Time/86400) -> Stats
|
|
// Since time is large, we map [0..NumDays].
|
|
// We need 'StartDayTime' for index 0.
|
|
DaySession sessions[];
|
|
datetime baseTime;
|
|
|
|
void ComputeSessions(const MqlRates &rates[], int total)
|
|
{
|
|
// 1. Find Date Range
|
|
datetime first = rates[total-1].time; // Oldest
|
|
datetime last = rates[0].time; // Newest
|
|
|
|
// Align to Day Start
|
|
first = first - (first % 86400);
|
|
baseTime = first;
|
|
|
|
int numDays = (int)((last - first) / 86400) + 2; // +buffer
|
|
ArrayResize(sessions, numDays);
|
|
|
|
// Initialize
|
|
for(int k=0; k<numDays; k++) {
|
|
sessions[k].aH = -1; sessions[k].aL = 999999;
|
|
sessions[k].lH = -1; sessions[k].lL = 999999;
|
|
sessions[k].nH = -1; sessions[k].nL = 999999;
|
|
sessions[k].aValid=false; sessions[k].lValid=false; sessions[k].nValid=false;
|
|
}
|
|
|
|
Print("Pre-calculating sessions for ", numDays, " days...");
|
|
|
|
// Scan all bars
|
|
for(int i=0; i<total; i++) {
|
|
datetime t = rates[i].time;
|
|
int dayIdx = (int)((t - baseTime) / 86400);
|
|
if(dayIdx < 0 || dayIdx >= numDays) continue;
|
|
|
|
MqlDateTime dt; TimeToStruct(t, dt);
|
|
int h = dt.hour;
|
|
double H = rates[i].high;
|
|
double L = rates[i].low;
|
|
|
|
// Update stats for that day
|
|
// Asian
|
|
if(h >= InpAsianStart && h < InpAsianEnd) {
|
|
if(H > sessions[dayIdx].aH || sessions[dayIdx].aH == -1) sessions[dayIdx].aH = H;
|
|
if(L < sessions[dayIdx].aL) sessions[dayIdx].aL = L;
|
|
sessions[dayIdx].aValid = true;
|
|
}
|
|
// London
|
|
if(h >= InpLondonStart && h < InpLondonEnd) {
|
|
if(H > sessions[dayIdx].lH || sessions[dayIdx].lH == -1) sessions[dayIdx].lH = H;
|
|
if(L < sessions[dayIdx].lL) sessions[dayIdx].lL = L;
|
|
sessions[dayIdx].lValid = true;
|
|
}
|
|
// NY
|
|
if(h >= InpNYStart && h < InpNYEnd) {
|
|
if(H > sessions[dayIdx].nH || sessions[dayIdx].nH == -1) sessions[dayIdx].nH = H;
|
|
if(L < sessions[dayIdx].nL) sessions[dayIdx].nL = L;
|
|
sessions[dayIdx].nValid = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void OnStart()
|
|
{
|
|
Print("--- Advanced Training: v3.0 Optimized ---");
|
|
Print( "InpEpochs: ", InpEpochs,
|
|
"\nInpHiddenLayerConfig: ", InpHiddenLayerConfig,
|
|
"\nInpTrainingRate: ", InpTrainingRate,
|
|
"\nInpTrainingDecay: ", InpTrainingDecay,
|
|
"\nInpLookback: " ,InpLookback,
|
|
"\nInpMaxBars: " , InpMaxBars,
|
|
"\nInpPredictionHorizon: " , InpPredictionHorizon);
|
|
|
|
|
|
handleATR_D1 = iATR(_Symbol, PERIOD_D1, 14);
|
|
handleEMA50 = iMA(_Symbol, PERIOD_H1, 50, 0, MODE_EMA, PRICE_CLOSE);
|
|
handleEMA200 = iMA(_Symbol, PERIOD_H1, 200, 0, MODE_EMA, PRICE_CLOSE);
|
|
|
|
MqlRates rates[];
|
|
ArraySetAsSeries(rates, true);
|
|
int needed = InpMaxBars + InpPredictionHorizon + InpLookback + 5000;
|
|
int copied = CopyRates(_Symbol, PERIOD_H1, 0, needed, rates);
|
|
if(copied < 5000) return;
|
|
|
|
double ema50[], ema200[];
|
|
ArraySetAsSeries(ema50, true);
|
|
ArraySetAsSeries(ema200, true);
|
|
CopyBuffer(handleEMA50, 0,0,copied, ema50);
|
|
CopyBuffer(handleEMA200, 0,0,copied, ema200);
|
|
|
|
// --- Log Training Data Info ---
|
|
datetime startT = rates[copied-1].time;
|
|
datetime endT = rates[0].time;
|
|
double totalDays = (double)(endT - startT) / 86400.0;
|
|
|
|
Print("--------------------------------------------------");
|
|
PrintFormat("Training Data Loaded: %d Bars", copied);
|
|
Print("Date Range: " + TimeToString(startT) + " to " + TimeToString(endT));
|
|
PrintFormat("Total Duration: %.2f Days", totalDays);
|
|
Print("--------------------------------------------------");
|
|
Print("Inputs Reference:");
|
|
PrintFormat("MaxBars: %d", InpMaxBars);
|
|
PrintFormat("Prediction Horizon: %d bars", InpPredictionHorizon);
|
|
PrintFormat("Lookback: %d bars", InpLookback);
|
|
PrintFormat("Hidden Layers: %s", InpHiddenLayerConfig);
|
|
PrintFormat("Training Rate: %.4f (Decay: %.3f)", InpTrainingRate, InpTrainingDecay);
|
|
Print("--------------------------------------------------");
|
|
|
|
// Precalc Sessions
|
|
ComputeSessions(rates, copied);
|
|
|
|
int featuresPerBar = 17;
|
|
int inputSize = InpLookback * featuresPerBar;
|
|
|
|
string result[];
|
|
int hiddenLayerCount = StringSplit(InpHiddenLayerConfig, ',', result);
|
|
ArrayResize(GlobalTopology, 1 + hiddenLayerCount + 1);
|
|
GlobalTopology[0] = inputSize;
|
|
for(int i=0; i<hiddenLayerCount; i++) GlobalTopology[i+1] = (int)StringToInteger(result[i]);
|
|
GlobalTopology[ArraySize(GlobalTopology)-1] = 1;
|
|
|
|
Net = new CNeuralNet(GlobalTopology, ACT_LEAKY_RELU);
|
|
Net.SetLearningRate(InpTrainingRate);
|
|
Net.SetLambda(InpLambda);
|
|
|
|
Sample samples[];
|
|
int pos=0, neg=0, flat=0;
|
|
|
|
int startIdx = InpPredictionHorizon;
|
|
int endIdx = copied - InpLookback - 1;
|
|
if(endIdx - startIdx > InpMaxBars) endIdx = startIdx + InpMaxBars;
|
|
|
|
for(int i = startIdx; i <= endIdx; i++)
|
|
{
|
|
// Stride: Train every 20 minutes (Minute 0, 20, 40)
|
|
MqlDateTime dt; TimeToStruct(rates[i].time, dt);
|
|
//if(dt.min % 20 != 0) continue;
|
|
|
|
// -- D1 ATR --
|
|
double d1ATR_Arr[1];
|
|
if(CopyBuffer(handleATR_D1, 0, rates[i].time, 1, d1ATR_Arr)<=0) continue;
|
|
double dailyATR = d1ATR_Arr[0];
|
|
|
|
double targetTP = 1.0 * dailyATR;
|
|
double targetSL = 0.5 * dailyATR;
|
|
double entryPrice = rates[i].close;
|
|
double label = 0;
|
|
|
|
int firstBuyTP = 99999, firstBuySL = 99999;
|
|
int firstSellTP = 99999, firstSellSL = 99999;
|
|
|
|
for(int k=1; k<=InpPredictionHorizon; k++) {
|
|
int f = i-k; if(f<0) break;
|
|
double h = rates[f].high;
|
|
double l = rates[f].low;
|
|
|
|
if(firstBuyTP==99999 && h >= entryPrice + targetTP) firstBuyTP = k;
|
|
if(firstBuySL==99999 && l <= entryPrice - targetSL) firstBuySL = k;
|
|
|
|
if(firstSellTP==99999 && l <= entryPrice - targetTP) firstSellTP = k;
|
|
if(firstSellSL==99999 && h >= entryPrice + targetSL) firstSellSL = k;
|
|
}
|
|
|
|
if(firstBuyTP < firstBuySL) label = 1.0; // Buy Win
|
|
else if(firstSellTP < firstSellSL) label = -1.0; // Sell Win
|
|
else label = 0.0;
|
|
|
|
// -- Features --
|
|
double inputs[];
|
|
ArrayResize(inputs, inputSize);
|
|
|
|
for(int k=0; k<InpLookback; k++) {
|
|
int p = i + k;
|
|
if(p >= copied) break;
|
|
int off = k * featuresPerBar;
|
|
|
|
double o = rates[p].open;
|
|
double c = rates[p].close;
|
|
double h = rates[p].high;
|
|
double l = rates[p].low;
|
|
double pH = rates[p+1].high;
|
|
double pL = rates[p+1].low;
|
|
|
|
inputs[off+0] = (c - o)/o * 100.0;
|
|
inputs[off+1] = (h - o)/o * 100.0;
|
|
inputs[off+2] = (l - o)/o * 100.0;
|
|
inputs[off+3] = ((h - pH)/pH) * 100.0;
|
|
inputs[off+4] = ((l - pL)/pL) * 100.0;
|
|
inputs[off+5] = (rates[p].tick_volume - rates[p+1].tick_volume) / (rates[p+1].tick_volume + 1.0) * 10.0; // Completed Bar Volume difference normalized
|
|
inputs[off+6] = ((c - ema50[p])/ema50[p]) * 100.0;
|
|
inputs[off+7] = ((c - ema200[p])/ema200[p]) * 100.0;
|
|
|
|
// -- Optimized Session Lookup --
|
|
datetime pTime = rates[p].time;
|
|
int dayIdx = (int)((pTime - baseTime) / 86400);
|
|
MqlDateTime pDt; TimeToStruct(pTime, pDt);
|
|
int pHour = pDt.hour;
|
|
|
|
// Asian: If pTime >= AsianEnd, use Today. Else Yesterday.
|
|
double aH, aL;
|
|
int aIdx = (pHour >= InpAsianEnd) ? dayIdx : dayIdx - 1;
|
|
if(aIdx>=0 && sessions[aIdx].aValid) { aH=sessions[aIdx].aH; aL=sessions[aIdx].aL; }
|
|
else { aH=rates[p].high; aL=rates[p].low; } // Fallback
|
|
|
|
// London
|
|
double lH, lL;
|
|
int lIdx = (pHour >= InpLondonEnd) ? dayIdx : dayIdx - 1;
|
|
if(lIdx>=0 && sessions[lIdx].lValid) { lH=sessions[lIdx].lH; lL=sessions[lIdx].lL; }
|
|
else { lH=rates[p].high; lL=rates[p].low; }
|
|
|
|
// NY
|
|
double nH, nL;
|
|
int nIdx = (pHour >= InpNYEnd) ? dayIdx : dayIdx - 1;
|
|
if(nIdx>=0 && sessions[nIdx].nValid) { nH=sessions[nIdx].nH; nL=sessions[nIdx].nL; }
|
|
else { nH=rates[p].high; nL=rates[p].low; }
|
|
|
|
inputs[off+8] = ((c - aH)/aH) * 100.0;
|
|
inputs[off+9] = ((c - aL)/aH) * 100.0;
|
|
inputs[off+10] = ((c - lH)/lH) * 100.0;
|
|
inputs[off+11] = ((c - lL)/lH) * 100.0;
|
|
inputs[off+12] = ((c - nH)/nH) * 100.0;
|
|
inputs[off+13] = ((c - nL)/nH) * 100.0;
|
|
|
|
inputs[off+14] = (double)pDt.day_of_week / 7.0;
|
|
inputs[off+15] = (double)pDt.hour / 24.0;
|
|
inputs[off+16] = (double)pDt.min / 60.0;
|
|
}
|
|
|
|
Sample s;
|
|
s.target = label;
|
|
ArrayResize(s.inputs, inputSize);
|
|
ArrayCopy(s.inputs, inputs);
|
|
|
|
int n=ArraySize(samples);
|
|
ArrayResize(samples, n+1);
|
|
samples[n] = s;
|
|
|
|
if(label > 0.1) pos++; else if(label < -0.1) neg++; else flat++;
|
|
}
|
|
|
|
PrintFormat("Collected: Pos=%d Neg=%d Flat=%d", pos, neg, flat);
|
|
|
|
// Balance
|
|
int targetCount = (pos + neg) / 2;
|
|
Sample balanced[];
|
|
for(int k=0; k<ArraySize(samples); k++) {
|
|
if(samples[k].target == 0) {
|
|
if(MathRand()%100 < 100.0 * targetCount/flat) {
|
|
int b=ArraySize(balanced); ArrayResize(balanced, b+1);
|
|
balanced[b]=samples[k];
|
|
}
|
|
} else {
|
|
int b=ArraySize(balanced); ArrayResize(balanced, b+1);
|
|
balanced[b]=samples[k];
|
|
}
|
|
}
|
|
PrintFormat("Balanced to %d", ArraySize(balanced));
|
|
|
|
// Train
|
|
int total = ArraySize(balanced);
|
|
int nTrain = (int)(total * 0.8);
|
|
int indices[]; ArrayResize(indices, nTrain);
|
|
for(int k=0; k<nTrain; k++) indices[k]=k;
|
|
|
|
double bestValAcc = 0;
|
|
double lastValAcc = 0;
|
|
int stuckCount = 0;
|
|
|
|
for(int e=0; e<InpEpochs; e++) {
|
|
// Shuffle training indices
|
|
for(int k=nTrain-1; k>0; k--) { int r=MathRand()%(k+1); int t=indices[k]; indices[k]=indices[r]; indices[r]=t; }
|
|
|
|
for(int k=0; k<nTrain; k++) {
|
|
double t[1]; t[0]=balanced[indices[k]].target;
|
|
Net.FeedForward(balanced[indices[k]].inputs);
|
|
Net.BackProp(t);
|
|
}
|
|
|
|
// Calculate Validation Accuracy
|
|
int corr=0, tot=0;
|
|
for(int v=nTrain; v<total; v++) {
|
|
Net.FeedForward(balanced[v].inputs);
|
|
double res[]; Net.GetResults(res);
|
|
if(MathAbs(balanced[v].target)>0.1) {
|
|
tot++;
|
|
if(balanced[v].target * res[0] > 0) corr++;
|
|
}
|
|
}
|
|
double valAcc = (tot>0)?(double)corr/tot*100:0;
|
|
|
|
if(e%10==0 || e==InpEpochs-1) {
|
|
PrintFormat("Epoch %d Val: %.1f%% (Best: %.1f%%) - LR: %.6f", e, valAcc, bestValAcc, Net.eta);
|
|
}
|
|
|
|
// Handle "Best Model" Persistence
|
|
if(valAcc > bestValAcc + 0.05) {
|
|
bestValAcc = valAcc;
|
|
SaveModelWithHeader("PriceActionNN_v3.bin");
|
|
PrintFormat("--- NEW BEST MODEL SAVED! Accuracy: %.2f%%", bestValAcc);
|
|
stuckCount = 0;
|
|
} else {
|
|
stuckCount++;
|
|
}
|
|
|
|
// If no improvement for 30 epochs relative to current state, NUDGE
|
|
if(stuckCount >= 30 && InpJitter > 0) {
|
|
PrintFormat("STUCK DETECTED! (Current: %.2f%% stayed flat). Nudging weights...", valAcc);
|
|
Net.Jitter(InpJitter);
|
|
stuckCount = 0;
|
|
Net.SetLearningRate(Net.eta * 1.5);
|
|
}
|
|
|
|
Net.SetLearningRate(Net.eta * InpTrainingDecay);
|
|
}
|
|
|
|
string fullPath = TerminalInfoString(TERMINAL_COMMONDATA_PATH) + "\\Files\\PriceActionNN_v3.bin";
|
|
Print("--------------------------------------------------");
|
|
Print("TRAINING FINISHED.");
|
|
PrintFormat("Peak Validation Accuracy Achieved: %.2f%%", bestValAcc);
|
|
PrintFormat("Topology Used: %d inputs, %s hidden, 1 output", GlobalTopology[0], InpHiddenLayerConfig);
|
|
Print("Final Best Model at: " + fullPath);
|
|
Print("--------------------------------------------------");
|
|
|
|
SaveModelWithHeader("PriceActionNN_v3.bin");
|
|
|
|
delete Net; Net = NULL;
|
|
IndicatorRelease(handleATR_D1);
|
|
IndicatorRelease(handleEMA50);
|
|
IndicatorRelease(handleEMA200);
|
|
}
|
|
|
|
void OnDeinit(const int reason)
|
|
{
|
|
if(CheckPointer(Net) == POINTER_DYNAMIC) {
|
|
Print("Script stopped/interrupted. Saving current weights...");
|
|
SaveModelWithHeader("PriceActionNN_v3.bin");
|
|
delete Net;
|
|
Net = NULL;
|
|
}
|
|
IndicatorRelease(handleATR_D1);
|
|
IndicatorRelease(handleEMA50);
|
|
IndicatorRelease(handleEMA200);
|
|
}
|
|
|
|
void SaveModelWithHeader(string filename)
|
|
{
|
|
int handle = FileOpen(filename, FILE_WRITE|FILE_BIN|FILE_COMMON);
|
|
if(handle == INVALID_HANDLE) { Print("Error opening file for write: ", filename); return; }
|
|
|
|
// Header Data
|
|
int version = 2; // Version 2 supports Metadata
|
|
FileWriteInteger(handle, version);
|
|
FileWriteInteger(handle, InpLookback);
|
|
FileWriteInteger(handle, ArraySize(GlobalTopology));
|
|
for(int i=0; i<ArraySize(GlobalTopology); i++) FileWriteInteger(handle, GlobalTopology[i]);
|
|
|
|
// Risk Settings
|
|
FileWriteDouble(handle, 1.0); // Target Multiplier
|
|
FileWriteDouble(handle, 0.5); // Stop Multiplier
|
|
|
|
// Session Times (Only used in Advanced, but kept for consistent header structure or omitted?
|
|
// PriceActionNN simple version doesn't use Session Inputs as strictly.
|
|
// Actually, `TrainPriceActionNN` DOES use sessions (Lines 23-28).
|
|
FileWriteInteger(handle, InpAsianStart);
|
|
FileWriteInteger(handle, InpAsianEnd);
|
|
FileWriteInteger(handle, InpLondonStart);
|
|
FileWriteInteger(handle, InpLondonEnd);
|
|
FileWriteInteger(handle, InpNYStart);
|
|
FileWriteInteger(handle, InpNYEnd);
|
|
|
|
if(Net.Save(handle)) Print("Saved Model + Metadata to ", filename);
|
|
else Print("Error saving weights!");
|
|
|
|
FileClose(handle);
|
|
}
|