Генетические алгоритмы

При создании самооптимизирующегося советника, на определенном этапе его работы, требуется автоматический вызов кода, который заново оптимизирует параметры советника на истории финансового инструмента, и далее советник продолжит свою работу уже с новыми параметрами.

Так как сам советник работает на текущем баре и не использует историю символа, код оптимизации параметров советника должен опираться на код индикатора, который в свою очередь создан на основе кода советника.

Для оптимизации параметров советника, или теперь уже параметров индикатора, совпадающих с параметрами советника, можно использовать полный перебор, однако для сокращения времени оптимизации можно применить генетический алгоритм.

Обратимся к терминологии.

Хромосома состоит из набора генов – набора случайно выбранных параметров советника в допустимых диапазонах.

Поколение это набор хромосом.

Фитнес функция FF это код, возвращающий значение советника, по которому производится оптимизация, например прибыль.

Значение функции фитнеса VFF () используется для вычисления вероятности воспроизведения хромосомы – члена популяции.

Начальная популяция формируется случайным образом и размер популяции (количество особей) фиксируется и не изменяется в течение работы всего алгоритма.

На основе вероятностей воспроизведения хромосом начальной популяции формируется новая популяция, и так далее пока не сработает условие завершения работы алгоритма.

Каждая следующая популяция формируется из предыдущей с помощью отбора, скрещивания и мутации.

Для отбора могут использоваться такие алгоритмы как рулетка, турнирный отбор и элитный отбор.

При применении рулетки, колесо рулетки делится на сектора, число которых совпадает с числом особей популяции. Площадь каждого сектора пропорциональна вероятности воспроизведения особи популяции. Отбор производится с помощью вращения колеса рулетки. Таким образом, особь с наибольшим значением вероятности воспроизведения попадает в следующую популяцию наибольшее число раз. Количество копий особи в следующей популяции определяется по формуле:

Где N – число особей в популяции.

При турнирном отборе из популяции случайно выбираются две особи, из которых остается особь с наибольшим значением вероятности воспроизведения.

При элитном отборе несколько лучших особей переходят в следующую популяцию без изменений, не участвуя в отборе и скрещивании.

После отбора идет скрещивание особей, при котором сначала выбираются две особи, затем случайно определяется точка разрыва в диапазоне числа параметров фитнес функции, после чего особи обмениваются сегментами хромосомы. Само скрещивание производится с вероятностью ½.

При применении мутации, сначала случайно выбирается параметр фитнес функции, затем он модифицируется. Сама мутация производится с вероятностью 0,001.

Библиотека UGAlib MQL5 Community реализации генетического алгоритма использует представление хромосомы в виде массива double Chromosome [], где 0 индекс это значение фитнес функции, а остальные индексы это параметры фитнес функции или гены хромосомы.

Оптимизация параметров фитнес функции ведется в одном диапазоне от RangeMinimum до RangeMaximum. Поэтому если оптимизируемые параметры имеют разные диапазоны, их нужно привести к одному диапазону, как правило, от 0.0 до 1.0.

Популяция особей представлена двумерным массивом double Population [] [1000], где строки это хромосомы.

Популяция ранжируется по значению фитнес функции таким образом, что первый ее член имеет наилучшее значение фитнес функции по критерию оптимизации.

Популяция делится на две части. Вначале вся популяция заселяется особями со случайно выбранными генами в диапазоне. Затем для этих особей вычисляется значение фитнес функции, которое помещается в 0 индекс хромосомы. При этом функция GetFitness расчета значения фитнес функции оперирует колонией потомков, представленной массивом double Colony [] [500], имеющим размер в два раза меньший, чем размер популяции. Таким образом, популяция заселяется двумя колониями потомков.

Колония потомков имеет размер меньший, чем размер популяции, для того, чтобы после мутаций и скрещиваний заселить ту часть популяции, которая имеет худшие значения фитнес функции. При этом особи, полученные в результате мутаций и скрещиваний, заселяют именно колонию потомков.

После начального заселения популяции производится удаление дубликатов с помощью функции RemovalDuplicates, в которой также производится ранжирование популяции по значению фитнес функции.

После подготовки начальной популяции вызывается цикл эпох – цикл рождения новых популяций, который продолжается до тех пор, пока количество эпох без улучшения не превысит порог Epoch.

Критерием улучшения служит эталонная хромосома – первая особь популяции.

В цикле эпох популяция модифицируется с помощью репликации, естественной мутации, искусственной мутации, заимствования генов и скрещивания, применяемых для заселения новой колонии потомков, которая затем замещает часть популяции, имеющей худшие значения фитнес функции.

В цикле заселения новой колонии потомков функции CycleOfOperators, операторы репликации, естественной мутации, искусственной мутации, заимствования генов и скрещивания выбираются случайно, в зависимости от их доли от 0 до 100.

После создания новой популяции, в ней также удаляются дубликаты, и она ранжируется по значению фитнес функции.

Здесь репликация заключается в выборе двух хромосом популяции и создании на их основе новой хромосомы, для которой гены случайно выбираются в расширенном диапазоне с помощью сдвига от гена первой особи влево и от гена второй особи вправо.

Выбор двух родителей из популяции осуществляется с помощью алгоритма рулетки, упомянутого выше.

Естественная мутация производится с помощью выбора одного родителя из популяции, используя алгоритм рулетки, и замены его генов генами, случайно выбранными в диапазоне от RangeMinimum до RangeMaximum. Замена генов производится с вероятностью NMutationProbability от 0.0 до 100.0.

При искусственной мутации выбираются два родителя из популяции, используя алгоритм рулетки, и гены потомка случайно выбираются из незанятого генами родителей пространства на числовой прямой в диапазонах от RangeMinimum до сдвига от гена первой особи вправо и от сдвига от гена второй особи влево до RangeMaximum.

При заимствовании генов для первого гена потомка выбирается родитель из популяции, используя алгоритм рулетки, и берется у него первый ген, далее, для второго гена отбирается второй родитель и берется второй ген и т. д.

При скрещивании выбираются два родителя из популяции, используя алгоритм рулетки, и гены потомка формируются за счет обмена отрезками хромосом мамы и папы.

Полный код реализации генетического алгоритма.

//+ – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – +

//| JQS UGA v1.3.1 |

//| http://www.mql4.com/ru/users/joo |

//| https://login.mql5.com/ru/users/joo |

//+ – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – +

//Библиотека «Универсального Генетического Алгоритма UGAlib» |

//использующего представление хромосомы вещественными числами. |

//+ – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – +

// – — – — – — – — – — – Глобальные переменные – — – — – — – — – — – — – — —

double Chromosome []; //Набор оптимизируемых аргументов функции – генов

// (например: веса нейронной сети и т.д.) -хромосома

int ChromosomeCount =0; //Максимально возможное количество хромосом в колонии

int TotalOfChromosomesInHistory=0;//Общее количество хромосом в истории

int ChrCountInHistory =0; //Количество уникальных хромосом в базе хромосом

int GeneCount =0; //Количество генов в хромосоме

double RangeMinimum =0.0;//Минимум диапазона поиска

double RangeMaximum =0.0;//Максимум диапазона поиска

double Precision =0.0;//Шаг поиска

int OptimizeMethod =0; //1-минимум, любое другое – максимум

double Population [] [1000]; //Популяция

double Colony [] [500]; //Колония потомков

int PopulChromosCount =0; //Текущее количество хромосом в популяции

int Epoch =0; //Кол-во эпох без улучшения

int AmountStartsFF=0; //Количество запусков функции приспособленности

// – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – –

//Основная функция UGA

void UGA

(

double ReplicationPortion, //Доля Репликации.

double NMutationPortion, //Доля Естественной мутации.

double ArtificialMutation, //Доля Искусственной мутации.

double GenoMergingPortion, //Доля Заимствования генов.

double CrossingOverPortion,//Доля Кроссинговера.

// – —

double ReplicationOffset, //Коэффициент смещения границ интервала

double NMutationProbability//Вероятность мутации каждого гена в %

)

{

//сброс генератора, производится только один раз

MathSrand ((int) TimeLocal ());

// – — – — – — – — – — – -Переменные – — – — – — – — – — – — – — – — – — —

int chromos=0, gene =0;//индексы хромосом и генов

int resetCounterFF =0;//счетчик сбросов «Эпох без улучшений»

int currentEpoch =1;//номер текущей эпохи

int SumOfCurrentEpoch=0;//сумма «Эпох без улучшений»

int MinOfCurrentEpoch=Epoch;//минимальное «Эпох без улучшений»

int MaxOfCurrentEpoch=0;//максимальное «Эпох без улучшений»

int epochGlob =0;//общее количество эпох

// Колония [количество признаков (генов)] [количество особей в колонии]

ArrayResize (Population, GeneCount+1);

ArrayInitialize (Population,0.0);

// Колония потомков [количество признаков (генов)] [количество особей в колонии]

ArrayResize (Colony, GeneCount+1);

ArrayInitialize (Colony,0.0);

// Банк хромосом

// [количество признаков (генов)] [количество хромосом в банке]

double historyHromosomes [] [100000];

ArrayResize (historyHromosomes, GeneCount+1);

ArrayInitialize (historyHromosomes,0.0);

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — —

// – — – — – — – Проверка корректности входных параметров – — – — – — – —

//…количество хромосом должно быть не меньше 2

if (ChromosomeCount <=1) ChromosomeCount=2;

if (ChromosomeCount> 500) ChromosomeCount=500;

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — —

//======================================================================

// 1) Создать протопопуляцию – – – —1)

ProtopopulationBuilding ();

//======================================================================

// 2) Определить приспособленность каждой особи – – – —2)

//Для 1-ой колонии

for (chromos=0;chromos <ChromosomeCount; chromos++)

for (gene=1;gene <=GeneCount; gene++)

Colony [gene] [chromos] =Population [gene] [chromos];

GetFitness (historyHromosomes);

for (chromos=0;chromos <ChromosomeCount; chromos++)

Population [0] [chromos] =Colony [0] [chromos];

//Для 2-ой колонии

for (chromos=ChromosomeCount; chromos <ChromosomeCount*2;chromos++)

for (gene=1;gene <=GeneCount; gene++)

Colony [gene] [chromos-ChromosomeCount] =Population [gene] [chromos];

GetFitness (historyHromosomes);

for (chromos=ChromosomeCount; chromos <ChromosomeCount*2;chromos++)

Population [0] [chromos] =Colony [0] [chromos-ChromosomeCount];

//======================================================================

// 3) Подготовить популяцию к размножению – –3)

RemovalDuplicates ();

//======================================================================

// 4) Выделить эталонную хромосому – – – —4)

for (gene=0;gene <=GeneCount; gene++)

Chromosome [gene] =Population [gene] [0];

//======================================================================

ServiceFunction ();

//Основной цикл генетического алгоритма с 5 по 6

while (currentEpoch <=Epoch)

{

//====================================================================

// 5) Операторы UGA – – – —5)

CycleOfOperators

(

historyHromosomes,

// – —

ReplicationPortion, //Доля Репликации.

NMutationPortion, //Доля Естественной мутации.

ArtificialMutation, //Доля Искусственной мутации.

GenoMergingPortion, //Доля Заимствования генов.

CrossingOverPortion,//Доля Кроссинговера.

// – —

ReplicationOffset, //Коэффициент смещения границ интервала

NMutationProbability//Вероятность мутации каждого гена в %

);

//====================================================================

// 6) Сравнить гены лучшего потомка с генами эталонной хромосомы.

// Если хромосома лучшего потомка лучше эталонной,

// заменить эталонную. – – – —6)

//Если режим оптимизации – минимизация

if (OptimizeMethod==1)

{

//Если лучшая хромосома популяции лучше эталонной

if (Population [0] [0] <Chromosome [0])

{

//Заменим эталонную хромосому

for (gene=0;gene <=GeneCount; gene++)

Chromosome [gene] =Population [gene] [0];

ServiceFunction ();

//Сбросим счетчик «эпох без улучшений»

if (currentEpoch <MinOfCurrentEpoch)

MinOfCurrentEpoch=currentEpoch;

if (currentEpoch> MaxOfCurrentEpoch)

MaxOfCurrentEpoch=currentEpoch;

SumOfCurrentEpoch+=currentEpoch; currentEpoch=1; resetCounterFF++;

}

else

currentEpoch++;

}

//Если режим оптимизации – максимизация

else

{

//Если лучшая хромосома популяции лучше эталонной

if (Population [0] [0]> Chromosome [0])

{

//Заменим эталонную хромосому

for (gene=0;gene <=GeneCount; gene++)

Chromosome [gene] =Population [gene] [0];

ServiceFunction ();

//Сбросим счетчик «эпох без улучшений»

if (currentEpoch <MinOfCurrentEpoch)

MinOfCurrentEpoch=currentEpoch;

if (currentEpoch> MaxOfCurrentEpoch)

MaxOfCurrentEpoch=currentEpoch;

SumOfCurrentEpoch+=currentEpoch; currentEpoch=1; resetCounterFF++;

}

else

currentEpoch++;

}

//====================================================================

//Прошла ещё одна эпоха…

epochGlob++;

}

Print («Прошло всего эпох=», epochGlob,» Всего сбросов=», resetCounterFF);

Print («Мин. эпох без улучш.=», MinOfCurrentEpoch,

«Средн. эпох без улучш.=»,

NormalizeDouble ((double) SumOfCurrentEpoch/ (double) resetCounterFF,2),

«Макс. эпох без улучш.=», MaxOfCurrentEpoch);

Print (ChrCountInHistory,» – Уникальных хромосом»);

Print (AmountStartsFF,» – Общее кол-во запусков FF»);

Print (TotalOfChromosomesInHistory,» – Общее кол-во хромосом в истории»);

Print (NormalizeDouble (100.0- ((double) ChrCountInHistory*100.0/

(double) TotalOfChromosomesInHistory),2),»% дубликатов»);

Print (Chromosome [0],» – Лучший результат»);

}

// – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – –

//Создание протопопуляции

void ProtopopulationBuilding ()

{

PopulChromosCount=ChromosomeCount*2;

//Заполнить популяцию хромосомами со случайными

//…генами в диапазоне RangeMinimum… RangeMaximum

for (int chromos=0;chromos <PopulChromosCount; chromos++)

{

//начиная с 1-го индекса (0-ой -зарезервирован для VFF)

for (int gene=1;gene <=GeneCount; gene++)

Population [gene] [chromos] =

SelectInDiscreteSpace (RNDfromCI (RangeMinimum, RangeMaximum),RangeMinimum, RangeMaximum, Precision,3);

TotalOfChromosomesInHistory++;

}

// – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – –

//Получение приспособленности для каждой особи.

void GetFitness

(

double &historyHromosomes [] [100000]

)

{

for (int chromos=0;chromos <ChromosomeCount; chromos++)

CheckHistoryChromosomes (chromos, historyHromosomes);

}

// – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – –

//Проверка хромосомы по базе хромосом.

void CheckHistoryChromosomes

(

int chromos,

double &historyHromosomes [] [100000]

)

{

// – — – — – — – — – — – -Переменные – — – — – — – — – — – — – — – — – — —

int Ch1=0; //Индекс хромосомы из базы

int Ge =0; //Индекс гена

int cnt=0; //Счетчик уникальных генов. Если хоть один ген отличается

//– хромосома признается уникальной

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — —

//Если в базе хранится хоть одна хромосома

if (ChrCountInHistory> 0)

{

//Переберем хромосомы в базе, чтобы найти такую же

for (Ch1=0;Ch1 <ChrCountInHistory && cnt <GeneCount; Ch1++)

{

cnt=0;

//Сверяем гены, пока индекс гена меньше кол-ва генов и пока попадаются одинаковые гены

for (Ge=1;Ge <=GeneCount; Ge++)

{

if (Colony [Ge] [chromos]!=historyHromosomes [Ge] [Ch1])

break;

cnt++;

}

//Если набралось одинаковых генов столько же, можно взять готовое решение из базы

if (cnt==GeneCount)

Colony [0] [chromos] =historyHromosomes [0] [Ch1—1];

//Если нет такой же хромосомы в базе, то рассчитаем для неё FF…

else

{

FitnessFunction (chromos);

//.. и если есть место в базе сохраним

if (ChrCountInHistory <100000)

{

for (Ge=0;Ge <=GeneCount; Ge++)

historyHromosomes [Ge] [ChrCountInHistory] =Colony [Ge] [chromos];

ChrCountInHistory++;

}

//Если база пустая, рассчитаем для неё FF и сохраним её в базе

else

{

FitnessFunction (chromos);

for (Ge=0;Ge <=GeneCount; Ge++)

historyHromosomes [Ge] [ChrCountInHistory] =Colony [Ge] [chromos];

ChrCountInHistory++;

}

// – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – –

//Цикл операторов UGA

void CycleOfOperators

(

double &historyHromosomes [] [100000],

// – —

double ReplicationPortion, //Доля Репликации.

double NMutationPortion, //Доля Естественной мутации.

double ArtificialMutation, //Доля Искусственной мутации.

double GenoMergingPortion, //Доля Заимствования генов.

double CrossingOverPortion,//Доля Кроссинговера.

// – —

double ReplicationOffset, //Коэффициент смещения границ интервала

double NMutationProbability//Вероятность мутации каждого гена в %

)

{

// – — – — – — – — – — – -Переменные – — – — – — – — – — – — – — – — – — —

double child [];

ArrayResize (child, GeneCount+1);

ArrayInitialize (child,0.0);

int gene=0,chromos=0, border=0;

int i=0,u=0;

double p=0.0,start=0.0;

double fit [] [2];

ArrayResize (fit,6);

ArrayInitialize (fit,0.0);

//Счетчик посадочных мест в новой популяции.

int T=0;

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — —

//Зададим долю операторов UGA

double portion [6];

portion [0] =ReplicationPortion; //Доля Репликации.

portion [1] =NMutationPortion; //Доля Естественной мутации.

portion [2] =ArtificialMutation; //Доля Искусственной мутации.

portion [3] =GenoMergingPortion; //Доля Заимствования генов.

portion [4] =CrossingOverPortion;//Доля Кроссинговера.

portion [5] =0.0;

// – — – — – — – — – — – — – —

if (NMutationProbability <0.0)

NMutationProbability=0.0;

if (NMutationProbability> 100.0)

NMutationProbability=100.0;

// – — – — – — – — – — – — – —

// – — – — – — – — – — – — Цикл операторов UGA – — – — —

//Заполняем новую колонию потомками

while (T <ChromosomeCount)

{

//============================

for (i=0;i <6;i++)

{

fit [i] [0] =start;

fit [i] [1] =start+MathAbs (portion [i] -portion [5]);

start=fit [i] [1];

}

p=RNDfromCI (fit [0] [0],fit [4] [1]);

for (u=0;u <5;u++)

{

if ((fit [u] [0] <=p && p <fit [u] [1]) || p==fit [u] [1])

break;

}

Print (u);

//============================

switch (u)

{

// – — – — – — – — – — —

case 0:

// – — – — – — – — – — – — Репликация – — – — – — – — – — – — – — – —

//Если есть место в новой колонии, создадим новую особь

if (T <ChromosomeCount)

{

Replication (child, ReplicationOffset);

//Поселим новую особь в новую колонию

for (gene=1;gene <=GeneCount; gene++) Colony [gene] [T] =child [gene];

//Одно место заняли, счетчик перемотаем вперед

T++;

TotalOfChromosomesInHistory++;

}

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – —

break;

// – — – — – — – — – — —

case 1:

// – — – — – — – — – — -Естественная мутация – — – — – — – — – — – — —

//Если есть место в новой колонии, создадим новую особь

if (T <ChromosomeCount)

{

NaturalMutation (child, NMutationProbability);

//Поселим новую особь в новую колонию

for (gene=1;gene <=GeneCount; gene++) Colony [gene] [T] =child [gene];

//Одно место заняли, счетчик перемотаем вперед

T++;

TotalOfChromosomesInHistory++;

}

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – —

break;

// – — – — – — – — – — —

case 2:

// – — – — – — – — – — – Искусственная мутация – — – — – — – — – — – —

//Если есть место в новой колонии, создадим новую особь

if (T <ChromosomeCount)

{

ArtificialMutation (child, ReplicationOffset);

//Поселим новую особь в новую колонию

for (gene=1;gene <=GeneCount; gene++) Colony [gene] [T] =child [gene];

//Одно место заняли, счетчик перемотаем вперед

T++;

TotalOfChromosomesInHistory++;

}

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – —

break;

// – — – — – — – — – — —

case 3:

// – — – — – — -Образование особи с заимствованными генами – — – — – —

//Если есть место в новой колонии, создадим новую особь

if (T <ChromosomeCount)

{

GenoMerging (child);

//Поселим новую особь в новую колонию

for (gene=1;gene <=GeneCount; gene++) Colony [gene] [T] =child [gene];

//Одно место заняли, счетчик перемотаем вперед

T++;

TotalOfChromosomesInHistory++;

}

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – —

break;

// – — – — – — – — – — —

default:

// – — – — – — – — – — – — – -Кроссинговер – — – — – — – — – — – — – —

//Если есть место в новой колонии, создадим новую особь

if (T <ChromosomeCount)

{

CrossingOver (child);

//Поселим новую особь в новую колонию

for (gene=1;gene <=GeneCount; gene++) Colony [gene] [T] =child [gene];

//Одно место заняли, счетчик перемотаем вперед

T++;

TotalOfChromosomesInHistory++;

}

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – —

break;

// – — – — – — – — – — —

}

} //Конец цикла операторов UGA —

//Определим приспособленность каждой особи в колонии потомков

GetFitness (historyHromosomes);

//Поселим потомков в основную популяцию

if (PopulChromosCount> =ChromosomeCount)

{

border=ChromosomeCount;

PopulChromosCount=ChromosomeCount*2;

}

else

{

border=PopulChromosCount;

PopulChromosCount+=ChromosomeCount;

}

for (chromos=0;chromos <ChromosomeCount; chromos++)

for (gene=0;gene <=GeneCount; gene++)

Population [gene] [chromos+border] =Colony [gene] [chromos];

//Подготовим популяцию к следующему размножению

RemovalDuplicates ();

} //конец ф-ии

// – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – –

//Репликация

void Replication

(

double &child [],

double ReplicationOffset

)

{

// – — – — – — – — – — – -Переменные – — – — – — – — – — – — – — – — – — —

double C1=0.0,C2=0.0,temp=0.0,Maximum=0.0,Minimum=0.0;

int address_mama=0,address_papa=0;

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — —

SelectTwoParents (address_mama, address_papa);

// – — – — – — – — – -Цикл перебора генов – — – — – — – — – — – — – — – —

for (int i=1;i <=GeneCount; i++)

{

// – — определим откуда мать и отец – — – —

C1 = Population [i] [address_mama];

C2 = Population [i] [address_papa];

// – — – — – — – — – — – — – — – — – — – — —

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — —

//…определим наибольший и наименьший из них,

//если С1> C2, поменяем их местами

if (C1> C2)

{

temp = C1; C1=C2; C2 = temp;

}

// – — – — – — – — – — – — – — – — – — – — – —

if (C2-C1 <Precision)

{

child [i] =C1; continue;

}

// – — – — – — – — – — – — – — – — – — – — – —

//Назначим границы создания нового гена

Minimum = C1- ((C2-C1) *ReplicationOffset);

Maximum = C2+ ((C2-C1) *ReplicationOffset);

// – — – — – — – — – — – — – — – — – — – — – —

//Обязательная проверка, что бы поиск не вышел из заданного диапазона

if (Minimum <RangeMinimum) Minimum = RangeMinimum;

if (Maximum> RangeMaximum) Maximum = RangeMaximum;

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – —

temp=RNDfromCI (Minimum, Maximum);

child [i] =

SelectInDiscreteSpace (temp, RangeMinimum, RangeMaximum, Precision,3);

}

// – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – –

//Естественная мутация.

void NaturalMutation

(

double &child [],

double NMutationProbability

)

{

// – — – — – — – — – — – -Переменные – — – — – — – — – — – — – — – — – — —

int address=0;

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — —

// – — – — – — – — -Отбор родителя – — – — – — – — – — – —

SelectOneParent (address);

// – — – — – — – — – — – — – — – — – — – —

for (int i=1;i <=GeneCount; i++)

if (RNDfromCI (0.0,100.0) <=NMutationProbability)

child [i] =

SelectInDiscreteSpace (RNDfromCI (RangeMinimum, RangeMaximum),RangeMinimum, RangeMaximum, Precision,3);

else

child [i] =Population [i] [address];

}

// – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – –

//Искусственная мутация.

void ArtificialMutation

(

double &child [],

double ReplicationOffset

)

{

// – — – — – — – — – — – -Переменные – — – — – — – — – — – — – — – — – — —

double C1=0.0,C2=0.0,temp=0.0,Maximum=0.0,Minimum=0.0,p=0.0;

int address_mama=0,address_papa=0;

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — —

// – — – — – — – — -Отбор родителей – — – — – — – — – — – —

SelectTwoParents (address_mama, address_papa);

// – — – — – — – — – — – — – — – — – — – — – — – — – — – —

// – — – — – — – — – -Цикл перебора генов – — – — – — – — – — – — – — —

for (int i=1;i <=GeneCount; i++)

{

// – — определим откуда мать и отец – — – —

C1 = Population [i] [address_mama];

C2 = Population [i] [address_papa];

// – — – — – — – — – — – — – — – — – — – — —

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — —

//…определим наибольший и наименьший из них,

//если С1> C2, поменяем их местами

if (C1> C2)

{

temp=C1; C1=C2; C2=temp;

}

// – — – — – — – — – — – — – — – — – — – — – —

//Назначим границы создания нового гена

Minimum=C1- ((C2-C1) *ReplicationOffset);

Maximum=C2+ ((C2-C1) *ReplicationOffset);

// – — – — – — – — – — – — – — – — – — – — – —

//Обязательная проверка, что бы поиск не вышел из заданного диапазона

if (Minimum <RangeMinimum) Minimum = RangeMinimum;

if (Maximum> RangeMaximum) Maximum = RangeMaximum;

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – —

p=MathRand ();

if (p <16383.5)

{

temp=RNDfromCI (RangeMinimum, Minimum);

child [i] =

SelectInDiscreteSpace (temp, RangeMinimum, RangeMaximum, Precision,3);

}

else

{

temp=RNDfromCI (Maximum, RangeMaximum);

child [i] =

SelectInDiscreteSpace (temp, RangeMinimum, RangeMaximum, Precision,3);

}

// – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – –

//Заимствование генов.

void GenoMerging

(

double &child []

)

{

// – — – — – — – — – — – -Переменные – — – — – — – — – — – — – — – — – — —

int address=0;

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — —

for (int i=1;i <=GeneCount; i++)

{

// – — – — – — – — -Отбор родителя – — – — – — – — – — – —

SelectOneParent (address);

// – — – — – — – — – — – — – — – — – — – — – — – — – — – —

child [i] =Population [i] [address];

}

// – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – –

//Кроссинговер.

void CrossingOver

(

double &child []

)

{

// – — – — – — – — – — – -Переменные – — – — – — – — – — – — – — – — – — —

int address_mama=0,address_papa=0;

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — —

// – — – — – — – — -Отбор родителей – — – — – — – — – — – —

SelectTwoParents (address_mama, address_papa);

// – — – — – — – — – — – — – — – — – — – — – — – — – — – —

//Определим точку разрыва

int address_of_gene= (int) MathFloor ((GeneCount-1) * (MathRand () /32767.5));

for (int i=1;i <=GeneCount; i++)

{

// – — копируем гены матери – — – —

if (i <=address_of_gene+1)

child [i] =Population [i] [address_mama];

// – — копируем гены отца – — – —

else

child [i] =Population [i] [address_papa];

}

// – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – –

//Отбор двух родителей.

void SelectTwoParents

(

int &address_mama,

int &address_papa

)

{

// – — – — – — – — – — – -Переменные – — – — – — – — – — – — – — – — – — —

int cnt=1;

address_mama=0;//адрес материнской особи в популяции

address_papa=0;//адрес отцовской особи в популяции

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — —

// – — – — – — – — – — – — – — Отбор родителей – — – — – — – — – — – — —

//Десять попыток выбрать разных родителей.

while (cnt <=10)

{

//Для материнской особи

address_mama=NaturalSelection ();

//Для отцовской особи

address_papa=NaturalSelection ();

if (address_mama!=address_papa)

break;

cnt++;

}

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — —

}

// – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – –

//Отбор одного родителя.

void SelectOneParent

(

int &address//адрес родительской особи в популяции

)

{

// – — – — – — – — – — – -Переменные – — – — – — – — – — – — – — – — – — —

address=0;

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — —

// – — – — – — – — – — – — – — Отбор родителя – — – — – — – — – — – — —

address=NaturalSelection ();

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — —

}

// – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – –

//Естественный отбор.

int NaturalSelection ()

{

// – — – — – — – — – — – -Переменные – — – — – — – — – — – — – — – — – — —

int i=0,u=0;

double p=0.0,start=0.0;

double fit [] [2];

ArrayResize (fit, PopulChromosCount);

ArrayInitialize (fit,0.0);

double delta= (Population [0] [0] -Population [0] [PopulChromosCount-1]) *0.01-Population [0] [PopulChromosCount-1];

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — —

for (i=0;i <PopulChromosCount; i++)

{

fit [i] [0] =start;

fit [i] [1] =start+MathAbs (Population [0] [i] +delta);

start=fit [i] [1];

}

p=RNDfromCI (fit [0] [0],fit [PopulChromosCount-1] [1]);

for (u=0;u <PopulChromosCount; u++)

if ((fit [u] [0] <=p && p <fit [u] [1]) || p==fit [u] [1])

break;

return (u);

}

// – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – –

//Удаление дубликатов с сортировкой по VFF

void RemovalDuplicates ()

{

// – — – — – — – — – — – -Переменные – — – — – — – — – — – — – — – — – — —

int chromosomeUnique [1000];//Массив хранит признак уникальности

//каждой хромосомы: 0-дубликат, 1-уникальная

ArrayInitialize (chromosomeUnique,1); //Предположим, что дубликатов нет

double PopulationTemp [] [1000];

ArrayResize (PopulationTemp, GeneCount+1);

ArrayInitialize (PopulationTemp,0.0);

int Ge =0; //Индекс гена

int Ch =0; //Индекс хромосомы

int Ch2=0; //Индекс второй хромосомы

int cnt=0; //Счетчик

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — —

// – — – — – — – — – — – Удалим дубликаты – — – — – — – — – — – — – -1

//Выбираем первый из пары для сравнения…

for (Ch=0;Ch <PopulChromosCount-1;Ch++)

{

//Если не дубликат…

if (chromosomeUnique [Ch]!=0)

{

//Выбираем второй из пары…

for (Ch2=Ch+1;Ch2 <PopulChromosCount; Ch2++)

{

if (chromosomeUnique [Ch2]!=0)

{

//Обнулим счетчик количества идентичных генов

cnt=0;

//Сверяем гены, пока попадаются одинаковые гены

for (Ge=1;Ge <=GeneCount; Ge++)

{

if (Population [Ge] [Ch]!=Population [Ge] [Ch2])

break;

else

cnt++;

}

//Если набралось одинаковых генов столько же, сколько всего генов

//..хромосома признается дубликатом

if (cnt==GeneCount)

chromosomeUnique [Ch2] =0;

}

//Счетчик посчитает количество уникальных хромосом

cnt=0;

//Скопируем уникальные хромосомы во временный масив

for (Ch=0;Ch <PopulChromosCount; Ch++)

{

//Если хромосома уникальна, скопируем её, если нет, перейдем к следующей

if (chromosomeUnique [Ch] ==1)

{

for (Ge=0;Ge <=GeneCount; Ge++)

PopulationTemp [Ge] [cnt] =Population [Ge] [Ch];

cnt++;

}

//Назначим переменной «Всего хромосом» значение счетчика уникальных хромосом

PopulChromosCount=cnt;

//Вернем уникальные хромосомы обратно в массив для временного хранения

//..обьединяемых популяций

for (Ch=0;Ch <PopulChromosCount; Ch++)

for (Ge=0;Ge <=GeneCount; Ge++)

Population [Ge] [Ch] =PopulationTemp [Ge] [Ch];

//=================================================================1

// – — – — – — – — Ранжирование популяции – — – — – — – — – — – — – -2

PopulationRanking ();

//=================================================================2

}

// – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – –

//Ранжирование популяции.

void PopulationRanking ()

{

// – — – — – — – — – — – -Переменные – — – — – — – — – — – — – — – — – — —

int cnt=1, i = 0, u = 0;

double PopulationTemp [] [1000]; //Временная популяция

ArrayResize (PopulationTemp, GeneCount+1);

ArrayInitialize (PopulationTemp,0.0);

int Indexes []; //Индексы хромосом

ArrayResize (Indexes, PopulChromosCount);

ArrayInitialize (Indexes,0);

int t0=0;

double ValueOnIndexes []; //VFF соответствующих

//..индексов хромосом

ArrayResize (ValueOnIndexes, PopulChromosCount);

ArrayInitialize (ValueOnIndexes,0.0); double t1=0.0;

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — —

//Проставим индексы во временном массиве temp2 и

//…скопируем первую строку из сортируемого массива

for (i=0;i <PopulChromosCount; i++)

{

Indexes [i] = i;

ValueOnIndexes [i] = Population [0] [i];

}

if (OptimizeMethod==1)

{

while (cnt> 0)

{

cnt=0;

for (i=0;i <PopulChromosCount-1;i++)

{

if (ValueOnIndexes [i]> ValueOnIndexes [i+1])

{

// – — – — – — – — – — – —

t0 = Indexes [i+1];

t1 = ValueOnIndexes [i+1];

Indexes [i+1] = Indexes [i];

ValueOnIndexes [i+1] = ValueOnIndexes [i];

Indexes [i] = t0;

ValueOnIndexes [i] = t1;

// – — – — – — – — – — – —

cnt++;

}

else

{

while (cnt> 0)

{

cnt=0;

for (i=0;i <PopulChromosCount-1;i++)

{

if (ValueOnIndexes [i] <ValueOnIndexes [i+1])

{

// – — – — – — – — – — – —

t0 = Indexes [i+1];

t1 = ValueOnIndexes [i+1];

Indexes [i+1] = Indexes [i];

ValueOnIndexes [i+1] = ValueOnIndexes [i];

Indexes [i] = t0;

ValueOnIndexes [i] = t1;

// – — – — – — – — – — – —

cnt++;

}

//Создадим отсортированный массив по полученным индексам

for (i=0;i <GeneCount+1;i++)

for (u=0;u <PopulChromosCount; u++)

PopulationTemp [i] [u] =Population [i] [Indexes [u]];

//Скопируем отсортированный массив обратно

for (i=0;i <GeneCount+1;i++)

for (u=0;u <PopulChromosCount; u++)

Population [i] [u] =PopulationTemp [i] [u];

}

// – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – –

//Генератор случайных чисел из заданного интервала.

double RNDfromCI (double Minimum, double Maximum)

{return (Minimum+ ((Maximum-Minimum) *MathRand () /32767.5));}

// – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – –

//Выбор в дискретном пространстве.

//Режимы:

//1-ближайшее снизу

//2-ближайшее сверху

//любое-до ближайшего

double SelectInDiscreteSpace

(

double In,

double InMin,

double InMax,

double step,

int RoundMode

)

{

if (step==0.0)

return (In);

// обеспечим правильность границ

if (InMax <InMin)

{

double temp = InMax; InMax = InMin; InMin = temp;

}

// при нарушении – вернем нарушенную границу

if (In <InMin) return (InMin);

if (In> InMax) return (InMax);

if (InMax == InMin || step <= 0.0) return (InMin);

// приведем к заданному масштабу

step = (InMax – InMin) / MathCeil ((InMax – InMin) / step);

switch (RoundMode)

{

case 1: return (InMin + step * MathFloor ((In – InMin) / step));

case 2: return (InMin + step * MathCeil ((In – InMin) / step));

default: return (InMin + step * MathRound ((In – InMin) / step));

}

// – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – —

Для использования библиотеки UGAlib необходимо написать две функции FitnessFunction и ServiceFunction.

Функция FitnessFunction получает на вход индекс хромосомы и рассчитывает для нее значение, по которому ведется оптимизация генов хромосомы.

Функция ServiceFunction может выводить значение фитнес функции и остальные гены эталонной хромосомы при каждом проходе оптимизации.

В качестве примера рассмотрим оптимизацию параметров индикатора, созданного в главе «Создание индикатора на основе модулей торговых сигналов эксперта».

Модифицируем код индикатора таким образом, чтобы рассчитывать виртуальные сделки на покупку и продажу финансового инструмента по сигналам индикатора.

#property indicator_chart_window

#include <Expert\ExpertInd.mqh>

#include <Expert\Signal\MySignal\SignalMACDExInd.mqh>

#include <Expert\Signal\MySignal\SignalMAExInd.mqh>

#property indicator_buffers 2

#property indicator_plots 1

#property indicator_type1 DRAW_COLOR_LINE

#property indicator_color1 clrBlack, clrRed, clrLawnGreen

#property indicator_style1 STYLE_SOLID

#property indicator_width1 2

double InBuffer [];

double ColorBuffer [];

int bars_calculated=0;

input int Signal_ThresholdOpen =20; // Signal threshold value to open [0…100]

input int Signal_ThresholdClose =20; // Signal threshold value to close [0…100]

input int Signal_MACD_PeriodFast =12; // MACD (12,24,9,PRICE_CLOSE) Period of fast EMA

input int Signal_MACD_PeriodSlow =24; // MACD (12,24,9,PRICE_CLOSE) Period of slow EMA

input int Signal_MACD_PeriodSignal =9; // MACD (12,24,9,PRICE_CLOSE) Period of averaging of difference

input ENUM_APPLIED_PRICE Signal_MACD_Applied =PRICE_CLOSE; // MACD (12,24,9,PRICE_CLOSE) Prices series

input double Signal_MACD_Weight =1.0; // MACD (12,24,9,PRICE_CLOSE) Weight [0…1.0]

input int Signal_MA_PeriodMA =12; // Moving Average (12,0,…) Period of averaging

input int Signal_MA_Shift =0; // Moving Average (12,0,…) Time shift

input ENUM_MA_METHOD Signal_MA_Method =MODE_SMA; // Moving Average (12,0,…) Method of averaging

input ENUM_APPLIED_PRICE Signal_MA_Applied =PRICE_CLOSE; // Moving Average (12,0,…) Prices series

input double Signal_MA_Weight =1.0; // Moving Average (12,0,…) Weight [0…1.0]

CExpertInd ExtExpert;

CSignalMAInd *filter0 = new CSignalMAInd;

CSignalMACDInd *filter1 = new CSignalMACDInd;

//+ – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – +

//| Custom indicator initialization function |

//+ – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – +

int OnInit ()

{

// – - Initializing expert

if(!ExtExpert.Init (Symbol (),Period (),true,100))

{

// – - failed

printf (__FUNCTION__+": error initializing expert»);

ExtExpert.Deinit ();

return (INIT_FAILED);

}

// – - Creating signal

CExpertSignal *signal=new CExpertSignal;

if (signal==NULL)

{

// – - failed

printf (__FUNCTION__+": error creating signal»);

ExtExpert.Deinit ();

return (INIT_FAILED);

}

// – —

ExtExpert.InitSignal (signal);

filter0.PeriodMA (Signal_MA_PeriodMA);

filter0.Shift (Signal_MA_Shift);

filter0.Method (Signal_MA_Method);

filter0.Applied (Signal_MA_Applied);

filter1.PeriodFast (Signal_MACD_PeriodFast);

filter1.PeriodSlow (Signal_MACD_PeriodSlow);

filter1.PeriodSignal (Signal_MACD_PeriodSignal);

filter1.Applied (Signal_MACD_Applied);

signal.AddFilter (filter0);

signal.AddFilter (filter1);

if(!ExtExpert.ValidationSettings ())

{

// – - failed

ExtExpert.Deinit ();

return (INIT_FAILED);

}

// – - Tuning of all necessary indicators

if(!ExtExpert.InitIndicators ())

{

// – - failed

printf (__FUNCTION__+": error initializing indicators»);

ExtExpert.Deinit ();

return (INIT_FAILED);

}

// – - ok

// – - indicator buffers mapping

SetIndexBuffer (0,InBuffer, INDICATOR_DATA);

SetIndexBuffer (1,ColorBuffer, INDICATOR_COLOR_INDEX);

ArraySetAsSeries (InBuffer, true);

ArraySetAsSeries (ColorBuffer, true);

// – —

return (INIT_SUCCEEDED);

}

//+ – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – +

//| Custom indicator iteration function |

//+ – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – +

int OnCalculate (const int rates_total,

const int prev_calculated,

const datetime &time [],

const double &open [],

const double &high [],

const double &low [],

const double &close [],

const long &tick_volume [],

const long &volume [],

const int &spread [])

{

// – - количество копируемых значений из индикатора

int values_to_copy;

// – - узнаем количество рассчитанных значений в индикаторе

int calculated=MathMin(filter0.BarsCalculatedInd (), filter1.BarsCalculatedInd ());

if (calculated <=0)

{

PrintFormat («BarsCalculated () вернул %d, код ошибки %d», calculated, GetLastError ());

return (0);

}

// – - если это первый запуск вычислений нашего индикатора или изменилось количество значений в индикаторе

// – - или если необходимо рассчитать индикатор для двух или более баров (значит что-то изменилось в истории)

if (prev_calculated==0 || calculated!=bars_calculated || rates_total> prev_calculated+1)

{

// – - если массив больше, чем значений в индикаторе на паре symbol/period, то копируем не все

// – - в противном случае копировать будем меньше, чем размер индикаторных буферов

if (calculated> rates_total) values_to_copy=rates_total;

else values_to_copy=calculated;

}

else

{

// – - значит наш индикатор рассчитывается не в первый раз и с момента последнего вызова OnCalculate ())

// – - для расчета добавилось не более одного бара

values_to_copy= (rates_total-prev_calculated) +1;

}

bars_calculated=calculated;

ArraySetAsSeries (open, true);

if (values_to_copy> 1)

{

ExtExpert.RefreshInd ();

// – - флаг покупки

bool flagBuy=false;

// – флаг продажи

bool flagSell=false;

// – покупка

double priceBuy=0;

double priceStopBuy=0;

double profitBuy=0;

double profitTotalBuy=0;

int countProfitBuyPlus=0;

int countProfitBuyMinus=0;

// – продажа

double priceSell=0;

double priceStopSell=0;

double profitSell=0;

double profitTotalSell=0;

int countProfitSellPlus=0;

int countProfitSellMinus=0;

// – спред

double sp=0.0002;

for (int i=0; i <values_to_copy; i++) {

ColorBuffer [i] =0;

InBuffer [i] =open [i];

double result0=Signal_MA_Weight*(filter0.LongConditionInd(i)-filter0.ShortConditionInd (i));

double result1=Signal_MACD_Weight*(filter1.LongConditionInd(i)-filter1.ShortConditionInd (i));

double result= (result0+result1) /2;

if (result> =Signal_ThresholdOpen)

{

ColorBuffer [i] =2;

if (flagSell==true) {

flagSell=false;

priceStopSell=InBuffer [i];

profitSell= (priceStopSell-priceSell-sp) *10000;

if (profitSell> 0) {countProfitSellPlus++;} else {countProfitSellMinus++;}

profitTotalSell=profitTotalSell+profitSell;

}

if (flagBuy==false) {

flagBuy=true;

priceBuy=InBuffer [i];

}

if (-result> =Signal_ThresholdOpen) {

ColorBuffer [i] =1;

if (flagBuy==true) {

flagBuy=false;

priceStopBuy=InBuffer [i];

profitBuy= (priceStopBuy-priceBuy-sp) *10000;

if (profitBuy> 0) {countProfitBuyPlus++;} else {countProfitBuyMinus++;}

profitTotalBuy=profitTotalBuy+profitBuy;

}

if (flagSell==false) {

priceSell=InBuffer [i];

flagSell=true;

}

//Print (» ProfitBuy», profitTotalBuy,» countProfitBuyPlus», countProfitBuyPlus,» countProfitBuyMinus», countProfitBuyMinus);

//Print (» ProfitSell», profitTotalSell,» countProfitSellPlus», countProfitSellPlus,» countProfitSellMinus», countProfitSellMinus);

}

// – - return value of prev_calculated for next call

return (rates_total);

}

//+ – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – +

Напишем фитнес функцию на основе этого индикатора. Оптимизировать будем весы сигналов MA и MACD для получения максимального профита.

void FitnessFunction (int chromos)

{

double _MACD_Weight=0.0;

double _MA_Weight=0.0;

double sum=0.0;

int cnt=1;

while (cnt <=GeneCount)

{

_MACD_Weight=Colony [cnt] [chromos];

cnt++;

_MA_Weight=Colony [cnt] [chromos];

cnt++;

int handleInd;

double BufferInd [];

double BufferColorInd [];

handleInd=iCustom (NULL,0,«MAMACDExInd»,

Signal_ThresholdOpen,

Signal_ThresholdClose,

Signal_MACD_PeriodFast,

Signal_MACD_PeriodSlow,

Signal_MACD_PeriodSignal,

Signal_MACD_Applied,

_MACD_Weight,

Signal_MA_PeriodMA,

Signal_MA_Shift,

Signal_MA_Method,

Signal_MA_Applied,

_MA_Weight

);

ResetLastError ();

int size=5000;

if (CopyBuffer (handleInd,0,0,size, BufferInd) <0)

{

// – - если копирование не удалось, сообщим код ошибки

PrintFormat («Не удалось скопировать данные из индикатора 0, код ошибки %d», GetLastError ());

}

if (CopyBuffer (handleInd,1,0,size, BufferColorInd) <0)

{

// – - если копирование не удалось, сообщим код ошибки

PrintFormat («Не удалось скопировать данные из индикатора 1, код ошибки %d», GetLastError ());

}

ArraySetAsSeries (BufferInd, true);

ArraySetAsSeries (BufferColorInd, true);

// – - флаг покупки

bool flagBuy=false;

// – флаг продажи

bool flagSell=false;

// – покупка

double priceBuy=0;

double priceStopBuy=0;

double profitBuy=0;

double profitTotalBuy=0;

int countProfitBuyPlus=0;

int countProfitBuyMinus=0;

// – продажа

double priceSell=0;

double priceStopSell=0;

double profitSell=0;

double profitTotalSell=0;

int countProfitSellPlus=0;

int countProfitSellMinus=0;

// – спред

double sp=0.0002;

for (int i=0; i <size; i++) {

if (BufferColorInd [i] ==2)

{

if (flagSell==true) {

flagSell=false;

priceStopSell=BufferInd [i];

profitSell= (priceStopSell-priceSell-sp) *10000;

if (profitSell> 0) {countProfitSellPlus++;} else {countProfitSellMinus++;}

profitTotalSell=profitTotalSell+profitSell;

}

if (flagBuy==false) {

flagBuy=true;

priceBuy=BufferInd [i];

}

if (BufferColorInd [i] ==1) {

if (flagBuy==true) {

flagBuy=false;

priceStopBuy=BufferInd [i];

profitBuy= (priceStopBuy-priceBuy-sp) *10000;

if (profitBuy> 0) {countProfitBuyPlus++;} else {countProfitBuyMinus++;}

profitTotalBuy=profitTotalBuy+profitBuy;

}

if (flagSell==false) {

priceSell=BufferInd [i];

flagSell=true;

}

//Print (» ProfitBuy», profitTotalBuy,» countProfitBuyPlus», countProfitBuyPlus,» countProfitBuyMinus», countProfitBuyMinus);

//Print (» ProfitSell», profitTotalSell,» countProfitSellPlus», countProfitSellPlus,» countProfitSellMinus», countProfitSellMinus);

sum = profitTotalBuy + profitTotalSell;

}

AmountStartsFF++;

Colony [0] [chromos] =sum;

}

void ServiceFunction ()

{

double _MACD_Weight=0.0;

double _MA_Weight=0.0;

int cnt=1;

while (cnt <=GeneCount)

{

_MACD_Weight=Chromosome [cnt];

cnt++;

_MA_Weight=Chromosome [cnt];

cnt++;

}

Print («Fitness func =», Chromosome [0],»\n»,

«Полученные значения аргументов:»,»\n»,

«_MACD_Weight =», Chromosome [1],»\n»,

«_MA_Weight =», Chromosome [2],»\n»

);

}

// – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – –

Напишем скрипт, который будет оптимизировать параметры индикатора с помощью генетического алгоритма.

#include <Fitness\MAMACDFitness.mqh>

#include <Fitness\UGAlib.mqh>

double ReplicationPortion_E = 100.0; //Доля Репликации.

double NMutationPortion_E = 10.0; //Доля Естественной мутации.

double ArtificialMutation_E = 10.0; //Доля Искусственной мутации.

double GenoMergingPortion_E = 20.0; //Доля Заимствования генов.

double CrossingOverPortion_E = 20.0; //Доля Кроссинговера.

// – —

double ReplicationOffset_E = 0.5; //Коэффициент смещения границ интервала

double NMutationProbability_E= 5.0; //Вероятность мутации каждого гена в %

// – - inputs for main signal

input int Signal_ThresholdOpen =20; // Signal threshold value to open [0…100]

input int Signal_ThresholdClose =20; // Signal threshold value to close [0…100]

input double Signal_PriceLevel =0.0; // Price level to execute a deal

input double Signal_StopLevel =50.0; // Stop Loss level (in points)

input double Signal_TakeLevel =50.0; // Take Profit level (in points)

input int Signal_Expiration =4; // Expiration of pending orders (in bars)

input int Signal_MA_PeriodMA =12; // Moving Average (12,0,…) Period of averaging

input int Signal_MA_Shift =0; // Moving Average (12,0,…) Time shift

input ENUM_MA_METHOD Signal_MA_Method =MODE_SMA; // Moving Average (12,0,…) Method of averaging

input ENUM_APPLIED_PRICE Signal_MA_Applied =PRICE_CLOSE; // Moving Average (12,0,…) Prices series

input double Signal_MA_Weight =1.0; // Moving Average (12,0,…) Weight [0…1.0]

input int Signal_MACD_PeriodFast =12; // MACD (12,24,9,PRICE_CLOSE) Period of fast EMA

input int Signal_MACD_PeriodSlow =24; // MACD (12,24,9,PRICE_CLOSE) Period of slow EMA

input int Signal_MACD_PeriodSignal=9; // MACD (12,24,9,PRICE_CLOSE) Period of averaging of difference

input ENUM_APPLIED_PRICE Signal_MACD_Applied =PRICE_CLOSE; // MACD (12,24,9,PRICE_CLOSE) Prices series

input double Signal_MACD_Weight =1.0; // MACD (12,24,9,PRICE_CLOSE) Weight [0…1.0]

//+ – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – +

//| Script program start function |

//+ – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – +

void OnStart ()

{

// – —

ChromosomeCount = 10; //Кол-во хромосом в колонии

GeneCount = 2; //Кол-во генов

Epoch = 50; //Кол-во эпох без улучшения

// – —

RangeMinimum = 0.0; //Минимум диапазона поиска

RangeMaximum = 1.0; //Максимум диапазона поиска

Precision = 0.1;//Требуемая точность

OptimizeMethod = 2; //Оптим.:1-Min, другое-Max

ArrayResize (Chromosome, GeneCount+1);

ArrayInitialize (Chromosome,0);

//Локальные переменные

int time_start= (int) GetTickCount (),time_end=0;

// – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — —

//Запуск главной ф-ии UGA

UGA

(

ReplicationPortion_E, //Доля Репликации.

NMutationPortion_E, //Доля Естественной мутации.

ArtificialMutation_E, //Доля Искусственной мутации.

GenoMergingPortion_E, //Доля Заимствования генов.

CrossingOverPortion_E,//Доля Кроссинговера.

// – —

ReplicationOffset_E, //Коэффициент смещения границ интервала

NMutationProbability_E//Вероятность мутации каждого гена в %

);

// – — – — – — – — – — – — – — – — —

time_end= (int) GetTickCount ();

// – — – — – — – — – — – — – — – — —

Print (time_end-time_start,» мс – Время исполнения»);

// – — – — – — – — – — – — – — – — —

}

//+ – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – — – +

Запустив скрипт, получим следующий результат:

Fitness func =402.2999999999981

Полученные значения аргументов:

_MACD_Weight =0.1

_MA_Weight =0.4

11498 мс – Время исполнения

Используемый индикатор основан на применении классов CiMA и CiMACD, имеющих проблемы с глубиной истории, потому параметр size в фитнес функции не может быть большим.

Перепишем индикатор, используя более низкоуровневый интерфейс.

#property indicator_chart_window

#include <Expert\ExpertInd.mqh>

#include <Expert\Signal\MySignal\SignalMACDInd.mqh>

#include <Expert\Signal\MySignal\SignalMAInd.mqh>