310 lines
22 KiB
MQL5
310 lines
22 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| crossentropy.mq5 |
|
|
//| Copyright 2022, DNG |
|
|
//| https://www.mql5.com/ru/users/dng |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "Copyright 2022, DNG"
|
|
#property link "https://www.mql5.com/ru/users/dng"
|
|
#property version "1.00"
|
|
//+------------------------------------------------------------------+
|
|
//| Includes |
|
|
//+------------------------------------------------------------------+
|
|
#include "..\Unsupervised\K-means\kmeans.mqh"
|
|
#include <Trade\SymbolInfo.mqh>
|
|
#include <Indicators\Oscilators.mqh>
|
|
//+------------------------------------------------------------------+
|
|
//| Input parameters |
|
|
//+------------------------------------------------------------------+
|
|
input int StudyPeriod = 15; //Study period, years
|
|
input uint HistoryBars = 20; //Depth of history
|
|
input int Clusters = 500; //Clusters
|
|
ENUM_TIMEFRAMES TimeFrame = PERIOD_CURRENT;
|
|
input int Samples = 100;
|
|
input int Percentile = 70;
|
|
int Actions = 3;
|
|
//---
|
|
input group "---- RSI ----"
|
|
input int RSIPeriod = 14; //Period
|
|
input ENUM_APPLIED_PRICE RSIPrice = PRICE_CLOSE; //Applied price
|
|
//---
|
|
input group "---- CCI ----"
|
|
input int CCIPeriod = 14; //Period
|
|
input ENUM_APPLIED_PRICE CCIPrice = PRICE_TYPICAL; //Applied price
|
|
//---
|
|
input group "---- ATR ----"
|
|
input int ATRPeriod = 14; //Period
|
|
//---
|
|
input group "---- MACD ----"
|
|
input int FastPeriod = 12; //Fast
|
|
input int SlowPeriod = 26; //Slow
|
|
input int SignalPeriod = 9; //Signal
|
|
input ENUM_APPLIED_PRICE MACDPrice = PRICE_CLOSE; //Applied price
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
CSymbolInfo *Symb;
|
|
MqlRates Rates[];
|
|
CKmeans *Kmeans;
|
|
CArrayDouble *TempData;
|
|
CiRSI *RSI;
|
|
CiCCI *CCI;
|
|
CiATR *ATR;
|
|
CiMACD *MACD;
|
|
//+------------------------------------------------------------------+
|
|
//| Expert initialization function |
|
|
//+------------------------------------------------------------------+
|
|
int OnInit()
|
|
{
|
|
//---
|
|
Symb = new CSymbolInfo();
|
|
if(CheckPointer(Symb) == POINTER_INVALID || !Symb.Name(_Symbol))
|
|
return INIT_FAILED;
|
|
Symb.Refresh();
|
|
//---
|
|
RSI = new CiRSI();
|
|
if(CheckPointer(RSI) == POINTER_INVALID || !RSI.Create(Symb.Name(), TimeFrame, RSIPeriod, RSIPrice))
|
|
return INIT_FAILED;
|
|
//---
|
|
CCI = new CiCCI();
|
|
if(CheckPointer(CCI) == POINTER_INVALID || !CCI.Create(Symb.Name(), TimeFrame, CCIPeriod, CCIPrice))
|
|
return INIT_FAILED;
|
|
//---
|
|
ATR = new CiATR();
|
|
if(CheckPointer(ATR) == POINTER_INVALID || !ATR.Create(Symb.Name(), TimeFrame, ATRPeriod))
|
|
return INIT_FAILED;
|
|
//---
|
|
MACD = new CiMACD();
|
|
if(CheckPointer(MACD) == POINTER_INVALID || !MACD.Create(Symb.Name(), TimeFrame, FastPeriod, SlowPeriod, SignalPeriod, MACDPrice))
|
|
return INIT_FAILED;
|
|
//---
|
|
Kmeans = new CKmeans();
|
|
if(CheckPointer(Kmeans) == POINTER_INVALID)
|
|
return INIT_FAILED;
|
|
//---
|
|
bool bEventStudy = EventChartCustom(ChartID(), 1, 0, 0, "Init");
|
|
//---
|
|
return(INIT_SUCCEEDED);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Expert deinitialization function |
|
|
//+------------------------------------------------------------------+
|
|
void OnDeinit(const int reason)
|
|
{
|
|
//---
|
|
if(CheckPointer(Symb) != POINTER_INVALID)
|
|
delete Symb;
|
|
//---
|
|
if(CheckPointer(RSI) != POINTER_INVALID)
|
|
delete RSI;
|
|
//---
|
|
if(CheckPointer(CCI) != POINTER_INVALID)
|
|
delete CCI;
|
|
//---
|
|
if(CheckPointer(ATR) != POINTER_INVALID)
|
|
delete ATR;
|
|
//---
|
|
if(CheckPointer(MACD) != POINTER_INVALID)
|
|
delete MACD;
|
|
//---
|
|
if(CheckPointer(Kmeans) != POINTER_INVALID)
|
|
delete Kmeans;
|
|
//---
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Expert tick function |
|
|
//+------------------------------------------------------------------+
|
|
void OnTick()
|
|
{
|
|
//---
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| ChartEvent function |
|
|
//+------------------------------------------------------------------+
|
|
void OnChartEvent(const int id,
|
|
const long &lparam,
|
|
const double &dparam,
|
|
const string &sparam)
|
|
{
|
|
//---
|
|
if(id == 1001)
|
|
Train();
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void Train(void)
|
|
{
|
|
COpenCLMy *opencl = OpenCLCreate(cl_unsupervised);
|
|
if(CheckPointer(opencl) == POINTER_INVALID)
|
|
{
|
|
ExpertRemove();
|
|
return;
|
|
}
|
|
if(!Kmeans.SetOpenCL(opencl))
|
|
{
|
|
delete opencl;
|
|
ExpertRemove();
|
|
return;
|
|
}
|
|
//---
|
|
MqlDateTime start_time;
|
|
TimeCurrent(start_time);
|
|
start_time.year -= StudyPeriod;
|
|
if(start_time.year <= 0)
|
|
start_time.year = 1900;
|
|
datetime st_time = StructToTime(start_time);
|
|
//---
|
|
int bars = CopyRates(Symb.Name(), TimeFrame, st_time, TimeCurrent(), Rates);
|
|
if(!RSI.BufferResize(bars) || !CCI.BufferResize(bars) || !ATR.BufferResize(bars) || !MACD.BufferResize(bars))
|
|
{
|
|
ExpertRemove();
|
|
return;
|
|
}
|
|
if(!ArraySetAsSeries(Rates, true))
|
|
{
|
|
ExpertRemove();
|
|
return;
|
|
}
|
|
//---
|
|
RSI.Refresh();
|
|
CCI.Refresh();
|
|
ATR.Refresh();
|
|
MACD.Refresh();
|
|
//---
|
|
int handl = FileOpen(StringFormat("kmeans_%d.net", Clusters), FILE_READ | FILE_BIN);
|
|
if(handl == INVALID_HANDLE)
|
|
{
|
|
ExpertRemove();
|
|
return;
|
|
}
|
|
if(FileReadInteger(handl) != Kmeans.Type())
|
|
{
|
|
ExpertRemove();
|
|
return;
|
|
}
|
|
bool result = Kmeans.Load(handl);
|
|
FileClose(handl);
|
|
if(!result)
|
|
{
|
|
ExpertRemove();
|
|
return;
|
|
}
|
|
//---
|
|
int total = bars - (int)HistoryBars - 480;
|
|
double data[], fractals[];
|
|
if(ArrayResize(data, total * 8 * HistoryBars) <= 0 ||
|
|
ArrayResize(fractals, total * 3) <= 0)
|
|
{
|
|
ExpertRemove();
|
|
return;
|
|
}
|
|
//---
|
|
for(int i = 0; (i < total && !IsStopped()); i++)
|
|
{
|
|
Comment(StringFormat("Create data: %d of %d", i, total));
|
|
for(int b = 0; b < (int)HistoryBars; b++)
|
|
{
|
|
int bar = i + b + 480;
|
|
int shift = (i * (int)HistoryBars + b) * 8;
|
|
double open = Rates[bar]
|
|
.open;
|
|
data[shift] = open - Rates[bar].low;
|
|
data[shift + 1] = Rates[bar].high - open;
|
|
data[shift + 2] = Rates[bar].close - open;
|
|
data[shift + 3] = RSI.GetData(MAIN_LINE, bar);
|
|
data[shift + 4] = CCI.GetData(MAIN_LINE, bar);
|
|
data[shift + 5] = ATR.GetData(MAIN_LINE, bar);
|
|
data[shift + 6] = MACD.GetData(MAIN_LINE, bar);
|
|
data[shift + 7] = MACD.GetData(SIGNAL_LINE, bar);
|
|
}
|
|
int shift = i * 3;
|
|
int bar = i + 480;
|
|
fractals[shift] = (int)(Rates[bar - 1].high <= Rates[bar].high && Rates[bar + 1].high < Rates[bar].high);
|
|
fractals[shift + 1] = (int)(Rates[bar - 1].low >= Rates[bar].low && Rates[bar + 1].low > Rates[bar].low);
|
|
fractals[shift + 2] = (int)((fractals[shift] + fractals[shift]) == 0);
|
|
}
|
|
if(IsStopped())
|
|
{
|
|
ExpertRemove();
|
|
return;
|
|
}
|
|
CBufferFloat *Data = new CBufferFloat();
|
|
if(CheckPointer(Data) == POINTER_INVALID ||
|
|
!Data.AssignArray(data))
|
|
return;
|
|
CBufferFloat *Fractals = new CBufferFloat();
|
|
if(CheckPointer(Fractals) == POINTER_INVALID ||
|
|
!Fractals.AssignArray(fractals))
|
|
return;
|
|
//---
|
|
ResetLastError();
|
|
Data = Kmeans.SoftMax(Data);
|
|
//---
|
|
vector env = vector::Zeros(Data.Total() / Clusters);
|
|
vector target = vector::Zeros(env.Size());
|
|
matrix states = matrix::Zeros(Samples, env.Size());
|
|
matrix actions = matrix::Zeros(Samples, env.Size());
|
|
vector CumRewards = vector::Zeros(Samples);
|
|
double average = 1.0 / Actions;
|
|
matrix policy = matrix::Full(Clusters, Actions, average);
|
|
for(ulong state = 0; state < env.Size(); state++)
|
|
{
|
|
ulong shift = state * Clusters;
|
|
env[state] = (double)(Data.Maximum((int)shift, Clusters) - shift);
|
|
shift = state * Actions;
|
|
target[state] = (double)(Fractals.Maximum((int)shift, Actions) - shift);
|
|
}
|
|
//---
|
|
for(int iter = 0; iter < 200; iter++)
|
|
{
|
|
CumRewards.Fill(0);
|
|
//--- Samples
|
|
for(int sampl = 0; sampl < Samples; sampl++)
|
|
{
|
|
for(ulong state = 0; state < env.Size(); state++)
|
|
{
|
|
ulong a = policy.Row((int)env[state]).ArgMax();
|
|
if(policy[(int)env[state], a] <= average)
|
|
a = (int)(MathRand() / 32768.0 * Actions);
|
|
if(a == target[state])
|
|
CumRewards[sampl] += 1;
|
|
else
|
|
CumRewards[sampl] -= 1;
|
|
actions[sampl, state] = (double)a;
|
|
states[sampl,state]=env[state];
|
|
}
|
|
}
|
|
//--- update policy
|
|
double percentile = CumRewards.Percentile(Percentile);
|
|
policy.Fill(0);
|
|
for(int sampl = 0; sampl < Samples; sampl++)
|
|
{
|
|
if(CumRewards[sampl] < percentile)
|
|
continue;
|
|
for(int state = 0; state < (int)env.Size(); state++)
|
|
policy[(int)states[sampl, state], (int)actions[sampl, state]] += 1;
|
|
}
|
|
for(int row = 0; row < Clusters; row++)
|
|
{
|
|
vector temp = policy.Row(row);
|
|
double sum = temp.Sum();
|
|
if(sum > 0)
|
|
temp = temp / sum;
|
|
else
|
|
temp.Fill(average);
|
|
if(!policy.Row(temp, row))
|
|
break;
|
|
}
|
|
PrintFormat("Iteration %d, Max reward %.0f", iter, CumRewards.Max());
|
|
}
|
|
if(CheckPointer(Data) == POINTER_DYNAMIC)
|
|
delete Data;
|
|
if(CheckPointer(Fractals) == POINTER_DYNAMIC)
|
|
delete Fractals;
|
|
if(CheckPointer(opencl) == POINTER_DYNAMIC)
|
|
delete opencl;
|
|
Comment("");
|
|
//---
|
|
ExpertRemove();
|
|
}
|
|
//+------------------------------------------------------------------+
|