forked from mnbvc188199/Warrior_EA
47a5ef338b
- Replaced standard library signal modules with custom implementations to allow for named patterns and improved voting. - Added new input parameters for module weights, allowing for optimization of individual signal contributions. - Enhanced the management of trades with new options for breakeven and management cut. - Introduced a mechanism for dynamic ranking of signal weights based on historical performance. - Improved initialization logic to ensure proper registration of filters and handling of trading conditions. - Added detailed logging for trading permissions and account status during initialization.
315 lines
15 KiB
MQL5
315 lines
15 KiB
MQL5
//+------------------------------------------------------------------+
| |
//| WarriorNet.mqh |
| |
//| AnimateDread |
| |
//| |
| |
//| A NEURAL NETWORK THAT TRAINS IN THE TERMINAL, using the ALGLIB |
| |
//| that ships with MT5. No DLL, no OpenCL, no Python, no export step.|
| |
//| |
| |
//| The deleted stack was ~15,000 lines to do this: a hand-rolled |
| |
//| CNet, three compute backends, an era/epoch scheduler, a deploy |
| |
//| gate and a .nnw format. MLPCreateC1 + MLPTrainES + MLPSerialize |
| |
//| are the same four operations, already written and already tested. |
| |
//| |
| |
//| THE FEATURE NAMES ARE THE CONTRACT, and this is the one idea from |
| |
//| the old stack worth keeping verbatim (System\NNFilter.mqh): the |
| |
//| file records the name of every input column in the order it was |
| |
//| trained on, and Load() REFUSES a model whose names do not match |
| |
//| what the caller is about to feed it. A network handed a different |
| |
//| column is not degraded, it is reading noise under a familiar name |
| |
//| - and it will keep producing confident numbers while it does. |
| |
//| |
| |
//| EARLY STOPPING BY CONSTRUCTION. MLPTrainES takes a TRAINING and a |
| |
//| VALIDATION matrix as separate arguments, so a holdout is not |
| |
//| something the caller may forget - the API will not run without |
| |
//| one. The split here is CHRONOLOGICAL: the validation rows are the |
| |
//| LAST rows, never a random sample, because a random split of |
| |
//| overlapping market windows leaks the answer across the boundary. |
| |
//+------------------------------------------------------------------+
| |
#ifndef WARRIOR_SIMPLE_NET_MQH
| |
#define WARRIOR_SIMPLE_NET_MQH
| |
| |
#include <Math\Alglib\alglib.mqh>
| |
| |
#define WARRIOR_NET_MAGIC "WARRIOR_NET 1"
| |
#define WARRIOR_NET_HIDDEN 24 // CAP on the hidden layer - the actual width is derived
| |
// from the sample size in Train(); see the note there.
| |
#define WARRIOR_NET_DECAY 0.001 // weight decay - ALGLIB's regularisation term
| |
#define WARRIOR_NET_RESTART 3 // random restarts, best kept
| |
#define WARRIOR_NET_VAL_FRAC 0.30 // last 30% of rows are the validation set
| |
//--- HOW DEEP A TRAINING SWEEP MAY REACH, in bars. A caller passes min(this, Bars()) to
| |
//--- CWarriorSignal::DeepenPrices(), so it is a ceiling on ambition, never a promise of history.
| |
//--- It exists because the standard library's own ceiling is 1024 (Series.mqh:11) and that number
| |
//--- was silently sizing both the training set and, through it, the hidden layer derived below.
| |
//--- 8192 covers ~32 years of D1 and ~5 of H1 - past which the oldest rows describe a market
| |
//--- structure the newest ones no longer share, and the walk-forward retrain is the better answer.
| |
#define WARRIOR_NET_HISTORY 8192
| |
| |
class CWarriorNet
| |
{
| |
private:
| |
CMultilayerPerceptronShell m_net;
| |
bool m_loaded;
| |
double m_auc; // held-out AUC of the last fit; <0 when never trained
| |
int m_nIn;
| |
string m_names[]; // the column contract, in order
| |
string m_why;
| |
| |
//--- Names joined with single spaces - the form written to and compared from the file.
| |
string JoinNames(const string &names[]) const
| |
{
| |
string s = "";
| |
for(int i = 0; i < ArraySize(names); i++)
| |
s += (i ? " " : "") + names[i];
| |
return s;
| |
}
| |
| |
public:
| |
CWarriorNet(void) : m_loaded(false), m_auc(-1.0), m_nIn(0), m_why("not loaded") {}
| |
~CWarriorNet(void) {}
| |
| |
bool Loaded(void) const { return m_loaded; }
| |
string Why(void) const { return m_why; }
| |
int Inputs(void) const { return m_nIn; }
| |
double AUC(void) const { return m_auc; }
| |
| |
//--- TRAIN on `rows` samples of `nIn` features plus a 0/1 label in the last column.
| |
//--- `xy` must already be in CHRONOLOGICAL order: the split below takes the tail as validation.
| |
//--- `embargo` = rows dropped from the END of the training half, so that no training sample
| |
//--- overlaps in time with the first validation sample. Zero means the split is a bare cut.
| |
bool Train(CMatrixDouble &xy, const int rows, const int nIn, const string &names[],
| |
const int embargo = 0);
| |
bool Save(const string path, const string &names[], const string note);
| |
bool Load(const string path, const string &names[]);
| |
//--- P(label == 1) for one raw feature vector, or -1.0 when no model is loaded.
| |
double Score(double &x[]);
| |
};
| |
//+------------------------------------------------------------------+
| |
bool CWarriorNet::Train(CMatrixDouble &xy, const int rows, const int nIn, const string &names[],
| |
const int embargo)
| |
{
| |
m_loaded = false;
| |
if(nIn <= 0 || ArraySize(names) != nIn)
| |
{
| |
m_why = StringFormat("feature count %d does not match %d name(s)", nIn, ArraySize(names));
| |
return false;
| |
}
| |
//--- THE NET SIZES ITSELF TO THE DATA, rather than the data being required to fit the net.
| |
//---
| |
//--- Ten samples per weight is the usual rule of thumb, and a net fitted below it memorises its
| |
//--- training set - the in-sample error then looks excellent and means nothing. A FIXED width
| |
//--- turns that rule into a wall: 18 inputs x 24 hidden is 480 weights, needing 4,800 rows, and
| |
//--- eleven years of DAILY bars yields about 900. The honest response to a small sample is a
| |
//--- small model, not a lower standard, so the width is derived from the row count and the rule
| |
//--- is preserved instead of relaxed.
| |
//---
| |
//--- weights = nIn*hidden + hidden*2 <= rows/10 -> hidden <= rows / (10*(nIn+2))
| |
int hidden = (int)MathFloor((double)rows / (10.0 * (nIn + 2)));
| |
if(hidden > WARRIOR_NET_HIDDEN)
| |
hidden = WARRIOR_NET_HIDDEN; // never wider than the cap, however much data exists
| |
if(hidden < 2)
| |
{
| |
//--- Even two hidden units would be over-fitted. Refusing is the answer: a model trained here
| |
//--- would vote confidently on noise, and a module that abstains is visibly doing nothing
| |
//--- whereas one that has memorised its sample looks like it is working.
| |
m_why = StringFormat("%d row(s) cannot support even a 2-unit hidden layer at 10 rows/weight"
| |
" (%d inputs needs >= %d rows) - not trained",
| |
rows, nIn, 20 * (nIn + 2));
| |
return false;
| |
}
| |
const int weights = nIn * hidden + hidden * 2;
| |
//--- CHRONOLOGICAL SPLIT. The tail is the validation set. A random split would put a row's
| |
//--- neighbours on both sides of the boundary, and overlapping windows make those near-copies.
| |
const int valRows = (int)MathMax(1, MathRound(rows * WARRIOR_NET_VAL_FRAC));
| |
//--- THE EMBARGO. A chronological cut is not enough when each row is built from a WINDOW: two
| |
//--- rows from adjacent bars share almost their whole path, so the last training rows and the
| |
//--- first validation rows are the same trades one bar apart, and the "held-out" tail has seen
| |
//--- its own answers. Measured 2026-09-11 on the management net: every first fit reported AUC
| |
//--- 0.66-0.77 on 4 months of overlapping virtual trades, and every deeper refit converged to
| |
//--- ~0.51 on three symbols. Dropping `embargo` rows before the boundary - one horizon's worth -
| |
//--- removes the overlap, at the cost of a slightly smaller training half.
| |
const int gap = (embargo > 0 && embargo < rows / 4) ? embargo : 0;
| |
const int trnRows = rows - valRows - gap;
| |
if(trnRows <= nIn + 1)
| |
{
| |
m_why = "training half too small after the split";
| |
return false;
| |
}
| |
CMatrixDouble trn(trnRows, nIn + 1), val(valRows, nIn + 1);
| |
for(int r = 0; r < trnRows; r++)
| |
for(int c = 0; c <= nIn; c++)
| |
trn.Set(r, c, xy.Get(r, c));
| |
for(int r = 0; r < valRows; r++)
| |
for(int c = 0; c <= nIn; c++)
| |
val.Set(r, c, xy.Get(trnRows + gap + r, c)); // validation starts AFTER the gap
| |
| |
//--- Classifier: two outputs, softmax, so Score() reads a calibrated-ish probability rather than
| |
//--- a regression value that has to be squashed by hand.
| |
CAlglib::MLPCreateC1(nIn, hidden, 2, m_net);
| |
int info = 0;
| |
CMLPReportShell rep;
| |
CAlglib::MLPTrainES(m_net, trn, trnRows, val, valRows, WARRIOR_NET_DECAY,
| |
WARRIOR_NET_RESTART, info, rep);
| |
if(info <= 0)
| |
{
| |
m_why = StringFormat("MLPTrainES refused the dataset (info %d)", info);
| |
return false;
| |
}
| |
m_nIn = nIn;
| |
ArrayResize(m_names, nIn);
| |
for(int i = 0; i < nIn; i++)
| |
m_names[i] = names[i];
| |
m_loaded = true;
| |
m_why = "trained";
| |
//--- DID IT LEARN ANYTHING? Reported separately from whether it MADE MONEY, because those are
| |
//--- different questions and this project has only ever answered the second. A net can be
| |
//--- worthless and still sit inside a profitable run, or genuinely informative and lose money
| |
//--- because the exits are wrong - and P&L cannot tell those apart. AUC on the held-out tail
| |
//--- can, and it costs one pass over rows the fit never saw.
| |
//---
| |
//--- AUC, not accuracy alone: with an unbalanced label, "always say no" scores well on accuracy
| |
//--- and learns nothing. The base rate is printed beside it so that trap is visible rather than
| |
//--- inferred. AUC 0.50 is a coin flip; below 0.50 means the model is reliably WRONG, which is
| |
//--- information too and usually a sign the label is inverted somewhere.
| |
double pv[];
| |
int lv[];
| |
ArrayResize(pv, valRows);
| |
ArrayResize(lv, valRows);
| |
double xrow[], yrow[];
| |
ArrayResize(xrow, nIn);
| |
int pos = 0, hit = 0;
| |
for(int r = 0; r < valRows; r++)
| |
{
| |
for(int c = 0; c < nIn; c++)
| |
xrow[c] = val.Get(r, c);
| |
CAlglib::MLPProcess(m_net, xrow, yrow);
| |
pv[r] = (ArraySize(yrow) > 1) ? yrow[1] : 0.0;
| |
lv[r] = (int)MathRound(val.Get(r, nIn));
| |
if(lv[r] == 1)
| |
pos++;
| |
if((pv[r] >= 0.5 ? 1 : 0) == lv[r])
| |
hit++;
| |
}
| |
double auc = 0.5;
| |
const int neg = valRows - pos;
| |
if(pos > 0 && neg > 0)
| |
{
| |
//--- Rank-sum (Mann-Whitney) form: no sorting of pairs, no O(n^2) sweep over 1,000+ rows.
| |
int idx[];
| |
ArrayResize(idx, valRows);
| |
for(int i = 0; i < valRows; i++)
| |
idx[i] = i;
| |
for(int i = 1; i < valRows; i++) // insertion sort by score, ascending
| |
{
| |
const int k = idx[i];
| |
int j = i - 1;
| |
while(j >= 0 && pv[idx[j]] > pv[k])
| |
{ idx[j + 1] = idx[j]; j--; }
| |
idx[j + 1] = k;
| |
}
| |
double rankSum = 0.0;
| |
int i2 = 0;
| |
while(i2 < valRows) // average ranks inside a tie group
| |
{
| |
int j2 = i2;
| |
while(j2 + 1 < valRows && pv[idx[j2 + 1]] == pv[idx[i2]])
| |
j2++;
| |
const double avgRank = 0.5 * ((i2 + 1) + (j2 + 1));
| |
for(int k2 = i2; k2 <= j2; k2++)
| |
if(lv[idx[k2]] == 1)
| |
rankSum += avgRank;
| |
i2 = j2 + 1;
| |
}
| |
auc = (rankSum - 0.5 * pos * (pos + 1.0)) / ((double)pos * neg);
| |
}
| |
PrintFormat("CWarriorNet: trained on %d row(s) (%d train / %d embargo / %d validation, chronological),"
| |
" %d input(s), %d hidden, %d weight(s). ALGLIB info %d.",
| |
rows, trnRows, gap, valRows, nIn, hidden, weights, info);
| |
PrintFormat("CWarriorNet: OUT-OF-SAMPLE AUC %.3f, accuracy %.1f%% against a %.1f%% base rate"
| |
" (%d positive of %d validation rows).",
| |
auc, 100.0 * hit / valRows, 100.0 * pos / valRows, pos, valRows);
| |
m_auc = auc;
| |
return true;
| |
}
| |
//+------------------------------------------------------------------+
| |
bool CWarriorNet::Save(const string path, const string &names[], const string note)
| |
{
| |
if(!m_loaded)
| |
return false;
| |
string model = "";
| |
CAlglib::MLPSerialize(m_net, model);
| |
//--- FILE_COMMON so the tester and the live terminal read the same file.
| |
const int h = FileOpen(path, FILE_WRITE | FILE_TXT | FILE_ANSI | FILE_COMMON);
| |
if(h == INVALID_HANDLE)
| |
{
| |
m_why = StringFormat("cannot write %s (error %d)", path, GetLastError());
| |
return false;
| |
}
| |
FileWriteString(h, WARRIOR_NET_MAGIC + "\n");
| |
FileWriteString(h, StringFormat("inputs %d\n", m_nIn));
| |
FileWriteString(h, "features " + JoinNames(names) + "\n");
| |
FileWriteString(h, "note " + note + "\n");
| |
FileWriteString(h, model);
| |
FileClose(h);
| |
PrintFormat("CWarriorNet: wrote %s (%d input(s)).", path, m_nIn);
| |
return true;
| |
}
| |
//+------------------------------------------------------------------+
| |
bool CWarriorNet::Load(const string path, const string &names[])
| |
{
| |
m_loaded = false;
| |
const int h = FileOpen(path, FILE_READ | FILE_TXT | FILE_ANSI | FILE_COMMON);
| |
if(h == INVALID_HANDLE)
| |
{
| |
m_why = "no model file at " + path;
| |
return false;
| |
}
| |
const string magic = FileReadString(h);
| |
const string inputs = FileReadString(h);
| |
const string feats = FileReadString(h);
| |
const string note = FileReadString(h);
| |
string model = "";
| |
while(!FileIsEnding(h))
| |
model += FileReadString(h) + "\n";
| |
FileClose(h);
| |
| |
if(StringFind(magic, WARRIOR_NET_MAGIC) != 0)
| |
{
| |
m_why = "bad magic in " + path;
| |
return false;
| |
}
| |
//--- 🛑 THE REFUSAL THAT MATTERS. A model whose columns differ from what the caller builds is not
| |
//--- slightly wrong, it is reading a different quantity under the same name - and it will keep
| |
//--- returning confident probabilities while doing so. Refusing is the only safe answer, and it
| |
//--- must be LOUD, because the alternative failure is completely silent.
| |
const string want = "features " + JoinNames(names);
| |
if(feats != want)
| |
{
| |
m_why = "feature contract mismatch";
| |
PrintFormat("CWarriorNet: REFUSED %s - the model was trained on different columns.\n"
| |
" file : %s\n build: %s\n"
| |
" Retrain, or fix the feature builder; do NOT run this model.",
| |
path, feats, want);
| |
return false;
| |
}
| |
CAlglib::MLPUnserialize(model, m_net);
| |
m_nIn = (int)StringToInteger(StringSubstr(inputs, StringLen("inputs ")));
| |
ArrayResize(m_names, ArraySize(names));
| |
for(int i = 0; i < ArraySize(names); i++)
| |
m_names[i] = names[i];
| |
m_loaded = true;
| |
m_why = "loaded";
| |
PrintFormat("CWarriorNet: loaded %s - %d input(s). %s", path, m_nIn, note);
| |
return true;
| |
}
| |
//+------------------------------------------------------------------+
| |
double CWarriorNet::Score(double &x[])
| |
{
| |
if(!m_loaded || ArraySize(x) != m_nIn)
| |
return -1.0;
| |
double y[];
| |
CAlglib::MLPProcess(m_net, x, y);
| |
if(ArraySize(y) < 2)
| |
return -1.0;
| |
return y[1]; // softmax P(class 1) = "this one pays"
| |
}
| |
#endif // WARRIOR_SIMPLE_NET_MQH
|