Доктор Трейдлав, или Как я перестал беспокоиться и написал самообучающийся эксперт

Замысел

Все мы после написания эксперта прибегаем к помощи встроенного Тестера стратегий для подбора оптимальных параметров. Найдя их, запускаем эксперт и при наступлении каких-либо, значимых для нас изменений в работе эксперта, останавливаем его, оптимизируем в Тестере еще раз, и еще раз - и так все время.

Можно ли возложить на сам эксперт принятие решения о переоптимизации и непосредственно саму переоптимизацию, не прерывая при этом, естественно, работы самого эксперта?

Один из вариантов решения этой проблемы предложил нам Quantum в своей статье "Адаптивные торговые системы и их использование в терминале MetaTrader 5", в которой рассмотрел использование наряду с реальной торговой системой нескольких (неограниченное количество) виртуальных торговых стратегий, из которых и происходил выбор стратегии, принесшей к текущему моменту наибольшую прибыль. Решение о смене торговой стратегии принимается по прошествии какого-то фиксированного значения баров.

Я же предлагаю воспользоваться кодом генетического алгоритма (ГА), описанным joo в статье "Генетические алгоритмы - это просто!". Рассмотрим реализацию такого эксперта (в качестве одного из примеров - эксперт, выставленный на чемпионат Automated Trading Championship 2011).

Трудимся

Итак, определимся, что должен уметь делать эксперт. Во-первых, само собой разумеется, торговать по выбранной стратегии. Во-вторых, принимать решение: пришло ли время переоптимизироваться (провести новую оптимизацию входных параметров). И в-третьих, используя ГА - переоптимизироваться. На первых порах рассмотрим простейшую переоптимизацию - есть стратегия и мы просто подбираем новые параметры. В дальнейшем задумаемся над тем, можно ли, и если можно - то как, с помощью ГА выбрать другую стратегию для изменившихся рыночных условий.

Также, для облегчения моделирования в fitness-функции, примем решение о торговле только на сформированных барах по одному инструменту. Доливок и частичных закрытий также не будет. Тех, кто предпочитает использовать жесткие стопы и тейки, а также тралить стопы, отсылаю к статье "Алгоритм генерации тиков в тестере стратегий терминала MetaTrader 5" для реализации в fitness-функции проверок на срабатывание ордеров Stop Loss и Take Profit. Остановлюсь подробнее на этой хитрой фразе:

Я для себя моделирую в фитнесс-функции режим тестирования, называемый в тестере "Только цены открытия". НО! Это не означает, что это единственно возможное моделирование процесса тестирования в фитнесс-функции. Более дотошные люди, возможно, захотят реализовать в фитнесс-функции тестирование в режиме "Все тики". И вот для того, чтобы они не изобретали велосипед, не выдумывали сами эти "все тики", я рекомендую обратить их внимание на уже готовый алгоритм - компании MetaQuotes. Т.е., прочитав эту статью, человек в фитнесс-функции может смоделировать режим "Все тики", что является необходимым условием для корректного моделирования в ФФ и стопов с тейками.

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

//+------------------------------------------------------------------+
//| Определяем, не наступил ли новый бар                             |
//+------------------------------------------------------------------+
bool isNewBars()
  {
   CopyTime(s,tf,0,1,curBT);
   TimeToStruct(curBT[0],curT);
   if(tf==PERIOD_M1||
      tf==PERIOD_M2||
      tf==PERIOD_M3||
      tf==PERIOD_M4||
      tf==PERIOD_M5||
      tf==PERIOD_M6||
      tf==PERIOD_M10||
      tf==PERIOD_M12||
      tf==PERIOD_M15||
      tf==PERIOD_M20||
      tf==PERIOD_M30)
      if(curT.min!=prevT.min)
        {
         prevBT[0]=curBT[0];
         TimeToStruct(prevBT[0],prevT);
         return(true);
        };
   if(tf==PERIOD_H1||
      tf==PERIOD_H2||
      tf==PERIOD_H3||
      tf==PERIOD_H4||
      tf==PERIOD_H6||
      tf==PERIOD_H8||
      tf==PERIOD_M12)
      if(curT.hour!=prevT.hour)
        {
         prevBT[0]=curBT[0];
         TimeToStruct(prevBT[0],prevT);
         return(true);
        };
   if(tf==PERIOD_D1||
      tf==PERIOD_W1)
      if(curT.day!=prevT.day)
        {
         prevBT[0]=curBT[0];
         TimeToStruct(prevBT[0],prevT);
         return(true);
        };
   if(tf==PERIOD_MN1)
      if(curT.mon!=prevT.mon)
        {
         prevBT[0]=curBT[0];
         TimeToStruct(prevBT[0],prevT);
         return(true);
        };
   return(false);
  }
//+------------------------------------------------------------------+
//|  ClosePosition                                                   |
//+------------------------------------------------------------------+
void ClosePosition()
  {
   request.action=TRADE_ACTION_DEAL;
   request.symbol=PositionGetSymbol(0);
   if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY) request.type=ORDER_TYPE_SELL; 
   else request.type=ORDER_TYPE_BUY;
   request.type_filling=ORDER_FILLING_FOK;
   if(SymbolInfoInteger(PositionGetSymbol(0),SYMBOL_TRADE_EXEMODE)==SYMBOL_TRADE_EXECUTION_REQUEST||
      SymbolInfoInteger(PositionGetSymbol(0),SYMBOL_TRADE_EXEMODE)==SYMBOL_TRADE_EXECUTION_INSTANT)
     {
      request.sl=NULL;
      request.tp=NULL;
      request.deviation=100;
     }
   while(PositionsTotal()>0)
     {
      request.volume=NormalizeDouble(MathMin(PositionGetDouble(POSITION_VOLUME),SymbolInfoDouble(PositionGetSymbol(0),SYMBOL_VOLUME_MAX)),2);
      if(SymbolInfoInteger(PositionGetSymbol(0),SYMBOL_TRADE_EXEMODE)==SYMBOL_TRADE_EXECUTION_REQUEST||
         SymbolInfoInteger(PositionGetSymbol(0),SYMBOL_TRADE_EXEMODE)==SYMBOL_TRADE_EXECUTION_INSTANT)
        {
         if(request.type==ORDER_TYPE_SELL) request.price=SymbolInfoDouble(s,SYMBOL_BID);
         else request.price=SymbolInfoDouble(s,SYMBOL_ASK);
        }
      OrderSend(request,result);
      Sleep(10000);
     }
  }
//+------------------------------------------------------------------+
//|  OpenPosition                                                    |
//+------------------------------------------------------------------+
void OpenPosition()
  {
   double vol;
   request.action=TRADE_ACTION_DEAL;
   request.symbol=s;
   request.type_filling=ORDER_FILLING_FOK;
   if(SymbolInfoInteger(s,SYMBOL_TRADE_EXEMODE)==SYMBOL_TRADE_EXECUTION_REQUEST||
      SymbolInfoInteger(s,SYMBOL_TRADE_EXEMODE)==SYMBOL_TRADE_EXECUTION_INSTANT)
     {
      request.sl=NULL;
      request.tp=NULL;
      request.deviation=100;
     }
   vol=MathFloor(AccountInfoDouble(ACCOUNT_FREEMARGIN)*optF*AccountInfoInteger(ACCOUNT_LEVERAGE)
       /(SymbolInfoDouble(s,SYMBOL_TRADE_CONTRACT_SIZE)*SymbolInfoDouble(s,SYMBOL_VOLUME_STEP)))*SymbolInfoDouble(s,SYMBOL_VOLUME_STEP);
   vol=MathMax(vol,SymbolInfoDouble(s,SYMBOL_VOLUME_MIN));
   vol=MathMin(vol,GetPossibleLots()*0.95);
   if(SymbolInfoDouble(s,SYMBOL_VOLUME_LIMIT)!=0) vol=NormalizeDouble(MathMin(vol,SymbolInfoDouble(s,SYMBOL_VOLUME_LIMIT)),2);
   request.volume=NormalizeDouble(MathMin(vol,SymbolInfoDouble(s,SYMBOL_VOLUME_MAX)),2);
   while(PositionSelect(s)==false)
     {
      if(SymbolInfoInteger(s,SYMBOL_TRADE_EXEMODE)==SYMBOL_TRADE_EXECUTION_REQUEST||
         SymbolInfoInteger(s,SYMBOL_TRADE_EXEMODE)==SYMBOL_TRADE_EXECUTION_INSTANT)
        {
         if(request.type==ORDER_TYPE_SELL) request.price=SymbolInfoDouble(s,SYMBOL_BID); 
         else request.price=SymbolInfoDouble(s,SYMBOL_ASK);
        }
      OrderSend(request,result);
      Sleep(10000);
      PositionSelect(s);
     }
   while(PositionGetDouble(POSITION_VOLUME)<vol)
     {
      request.volume=NormalizeDouble(MathMin(vol-PositionGetDouble(POSITION_VOLUME),SymbolInfoDouble(s,SYMBOL_VOLUME_MAX)),2);
      if(SymbolInfoInteger(PositionGetSymbol(0),SYMBOL_TRADE_EXEMODE)==SYMBOL_TRADE_EXECUTION_REQUEST||
         SymbolInfoInteger(PositionGetSymbol(0),SYMBOL_TRADE_EXEMODE)==SYMBOL_TRADE_EXECUTION_INSTANT)
        {
         if(request.type==ORDER_TYPE_SELL) request.price=SymbolInfoDouble(s,SYMBOL_BID);
         else request.price=SymbolInfoDouble(s,SYMBOL_ASK);
        }
      OrderSend(request,result);
      Sleep(10000);
      PositionSelect(s);
     }
  }
//+------------------------------------------------------------------+

При внимательном изучении в функции открытия позиции можно заметить три существенные вещи: переменные s, optF и вызов функции GetPossibleLots():

• s - инструмент, которым будем торговать, является одной из оптимизируемых ГА переменных,
  
• optF - часть депозита, которой хотелось бы торговать (еще одна из оптимизируемых ГА переменных), 
• функция GetPossibleLots() - возвращает часть депозита, которой можно торговать:

//+------------------------------------------------------------------+
//|  GetPossibleLots                                                 |
//+------------------------------------------------------------------+
double GetPossibleLots()
  {
   request.volume=1.0;
   if(request.type==ORDER_TYPE_SELL) request.price=SymbolInfoDouble(s,SYMBOL_BID);
   else request.price=SymbolInfoDouble(s,SYMBOL_ASK);
   OrderCheck(request,check);
   return(NormalizeDouble(AccountInfoDouble(ACCOUNT_FREEMARGIN)/check.margin,2));
  }

Нарушая немного очередность повествования, введем еще две функции, общие для всех наших экспертов и необходимые на шаге номер Два:

//+------------------------------------------------------------------+
//|  InitRelDD                                                       |
//+------------------------------------------------------------------+
void InitRelDD()
  {
   ulong DealTicket;
   double curBalance;
   prevBT[0]=D'2000.01.01 00:00:00';
   TimeToStruct(prevBT[0],prevT);
   curBalance=AccountInfoDouble(ACCOUNT_BALANCE);
   maxBalance=curBalance;
   HistorySelect(D'2000.01.01 00:00:00',TimeCurrent());
   for(int i=HistoryDealsTotal();i>0;i--)
     {
      DealTicket=HistoryDealGetTicket(i);
      curBalance=curBalance+HistoryDealGetDouble(DealTicket,DEAL_PROFIT);
      if(curBalance>maxBalance) maxBalance=curBalance;
     }
  }
//+------------------------------------------------------------------+
//|  GetRelDD                                                        |
//+------------------------------------------------------------------+
double GetRelDD()
  {
   if(AccountInfoDouble(ACCOUNT_BALANCE)>maxBalance) maxBalance=AccountInfoDouble(ACCOUNT_BALANCE);
   return((maxBalance-AccountInfoDouble(ACCOUNT_BALANCE))/maxBalance);
  }

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

• один торгует по пересечениям скользящих средних (золотой крест - покупаем инструмент, мертвый - продаем);
  
• второй - простейшая нейросеть, которая получает на вход приведенные к диапазону [0..1] изменения цен за пять предыдущих торговых сессий.

Алгоритмически работа самооптимизирующегося эксперта выглядит следующим образом:

1. Инициализируем переменные, используемые экспертом: определяем и инициализируем индикаторные буферы, либо задаем топологию нейросети (число слоев/нейронов в слое, в примере простейшая сеть с числом нейронов, одинаковым во всех слоях), указываем рабочий таймфрейм. Далее, наверное, самый ответственный шаг - вызываем функцию Генетической оптимизации, которая, в свою очередь, обращается к самой главной функции - fitness-функции (далее по тексту - ФФ).

   ВАЖНО! Для каждой новой торговой стратегии ФФ новая, т.е. переписывается, для одной средней ФФ совершенно не такая, как ФФ для двух средних, и существенно отличается от ФФ нейросети.

   Результатом работы ФФ в моих экспертах является максимум баланса при условии непревышения относительной просадкой критического значения, задаваемого внешней переменной (в наших примерах - 0,5). То есть если очередной прогон ГА дал баланс 100 000, но относительная просадка по балансу - 0,6, то ФФ=0,0. Для вас, уважаемый читатель, результатом в ФФ могут быть совершенно иные критерии.

   Забираем результаты работы Генетического алгоритма: для пересечения скользящих это будут, естественно, периоды скользящих, для нейросети - веса синапсов, для них обоих (и для других моих экспертов) - инструмент, на котором будем торговать до следующей переоптимизации, затем уже знакомое нам optF - часть депозита, которой бы хотелось торговать. Вы вольны добавлять в свои ФФ оптимизируемые параметры по желанию, например, выбирать еще и таймфрейм, да мало-ли...

   Последний пункт в инициализации - узнать максимальное значения баланса счета. В чем важность этого пункта? В том, что это - отправная точка для принятия решения о проведении переоптимизации.

   ВАЖНО! Как принимается решение о переоптимизации: при достижении относительной просадкой по БАЛАНСУ определенной критической величины, задаваемой в качестве внешней переменной (в наших примерах - 0,2) - переоптимизируемся. Для того чтобы не принуждать эксперт проводить переоптимизацию на каждом баре после достижения критической просадки, подменяем после каждой переоптимизации максимальное значение баланса текущим значением.

   У вас, уважаемый читатель, критерий наступления момента переоптимизации может быть совершенно иной.
   
   
2. Проводим торговые операции.
   
   
3. После каждой закрытой позиции проверяем, не достигла ли просадка по балансу критической величины. Если достигла, то вызываем ГА, забираем результаты его работы (вот она, переоптимизация!).
   
   

4. Ждем или звонка от директора форекса с просьбой не банкротить мир, или (что чаще) - Stop Out, Margin Call, карета скорой помощи...

Приведем программную реализацию вышесказанного для эксперта на средних (исходники также прилагаются), для нейросети - все в исходниках.

Код распространяется на условиях лицензии GPL.

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   tf=Period();
//--- для побарного тестирования...
   prevBT[0]=D'2001.01.01';
//---... очень давно
   TimeToStruct(prevBT[0],prevT);
//--- глубина истории (задаем, так как оптимизируем на исторических данных)
   depth=10000;
//--- сколько за раз копируем (задаем, так как оптимизируем на исторических данных)
   count=2;
   ArrayResize(LongBuffer,count);
   ArrayResize(ShortBuffer,count);
   ArrayInitialize(LongBuffer,0);
   ArrayInitialize(ShortBuffer,0);
//--- вызываем функцию генетической оптимизации нейросети
   GA();
//--- получаем оптимизированные параметры нейросети и других переменных
   GetTrainResults();
//--- получаем просадку по балансу
   InitRelDD();
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   if(isNewBars()==true)
     {
      bool trig=false;
      CopyBuffer(MAshort,0,0,count,ShortBuffer);
      CopyBuffer(MAlong,0,0,count,LongBuffer);
      if(LongBuffer[0]>LongBuffer[1] && ShortBuffer[0]>LongBuffer[0] && ShortBuffer[1]<LongBuffer[1])
        {
         if(PositionsTotal()>0)
           {
            if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY)
              {
               ClosePosition();
               trig=true;
              }
           }
        }
      if(LongBuffer[0]<LongBuffer[1] && ShortBuffer[0]<LongBuffer[0] && ShortBuffer[1]>LongBuffer[1])
        {
         if(PositionsTotal()>0)
           {
            if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL)
              {
               ClosePosition();
               trig=true;
              }
           }
        }
      if(trig==true)
        {
         //--- если просадка баланса превысила допустимую:
         if(GetRelDD()>maxDD)
           {
            //--- вызываем функцию генетической оптимизации нейросети
            GA();
            //--- получаем оптимизированные параметры нейросети и других переменных
            GetTrainResults();
            //--- отсчет просадки будем теперь вести не от максимума баланса, а от текущего баланса
            maxBalance=AccountInfoDouble(ACCOUNT_BALANCE);
           }
        }
      CopyBuffer(MAshort,0,0,count,ShortBuffer);
      CopyBuffer(MAlong,0,0,count,LongBuffer);
      if(LongBuffer[0]>LongBuffer[1] && ShortBuffer[0]>LongBuffer[0] && ShortBuffer[1]<LongBuffer[1])
        {
         request.type=ORDER_TYPE_SELL;
         OpenPosition();
        }
      if(LongBuffer[0]<LongBuffer[1] && ShortBuffer[0]<LongBuffer[0] && ShortBuffer[1]>LongBuffer[1])
        {
         request.type=ORDER_TYPE_BUY;
         OpenPosition();
        }
     };
  }
//+------------------------------------------------------------------+
//| Подготовка и вызов генетического оптимизатора                    |
//+------------------------------------------------------------------+
void GA()
  {
//--- кол-во генов (равно кол-ву оптимизируемых переменных, 
//--- всех их необходимо не забывать упомянуть в FitnessFunction())
   GeneCount      =OptParamCount+2;    
//--- кол-во хромосом в колонии
   ChromosomeCount=GeneCount*11;
//--- минимум диапазона поиска
   RangeMinimum   =0.0;
//--- максимум диапазона поиска
   RangeMaximum   =1.0;
//--- шаг поиска
   Precision      =0.0001;
//--- 1-минимум, любое другое-максимум
   OptimizeMethod =2;                                                 
   ArrayResize(Chromosome,GeneCount+1);
   ArrayInitialize(Chromosome,0);
//--- кол-во эпох без улучшения
   Epoch          =100;                                               
//--- доля репликации, естественной мутации, искусственной мутации, заимствования генов, 
//--- кроссинговера, коэффициент смещения границ интервала, вероятность мутации каждого гена в %
   UGA(100.0,1.0,1.0,1.0,1.0,0.5,1.0);                                
  }
//+------------------------------------------------------------------+
//| Fitness-функция для генетического оптимизатора нейросети:        | 
//| выбирает пару, optF, веса синапсов;                              |
//| можно оптимизировать что-угодно, но необходимо                   |
//| внимательно следить за количествами генов                        |
//+------------------------------------------------------------------+
void FitnessFunction(int chromos)
  {
   int    b;
//--- есть открытая позиция?
   bool   trig=false;
//--- направление открытой позиции
   string dir="";
//--- цена открытия позиции
   double OpenPrice=0;
//--- промежуточное звено между колонией генов и оптимизируемыми параметрами
   int    z;
//--- текущий баланс
   double t=cap;
//--- максимальный баланс
   double maxt=t;
//--- абсолютная просадка
   double aDD=0;
//--- относительная просадка
   double rDD=0.000001;
//--- непосредственно fitness-функция
   double ff=0;
//--- ГА выбирает пару
   z=(int)MathRound(Colony[GeneCount-1][chromos]*12);
   switch(z)
     {
      case  0: {s="AUDUSD"; break;};
      case  1: {s="AUDUSD"; break;};
      case  2: {s="EURAUD"; break;};
      case  3: {s="EURCHF"; break;};
      case  4: {s="EURGBP"; break;};
      case  5: {s="EURJPY"; break;};
      case  6: {s="EURUSD"; break;};
      case  7: {s="GBPCHF"; break;};
      case  8: {s="GBPJPY"; break;};
      case  9: {s="GBPUSD"; break;};
      case 10: {s="USDCAD"; break;};
      case 11: {s="USDCHF"; break;};
      case 12: {s="USDJPY"; break;};
      default: {s="EURUSD"; break;};
     }
   MAshort=iMA(s,tf,(int)MathRound(Colony[1][chromos]*MaxMAPeriod)+1,0,MODE_SMA,PRICE_OPEN);
   MAlong =iMA(s,tf,(int)MathRound(Colony[2][chromos]*MaxMAPeriod)+1,0,MODE_SMA,PRICE_OPEN);
   dig=MathPow(10.0,(double)SymbolInfoInteger(s,SYMBOL_DIGITS));
   
//--- ГА выбирает оптимальное F
   optF=Colony[GeneCount][chromos];                                   
   
   leverage=AccountInfoInteger(ACCOUNT_LEVERAGE);
   contractSize=SymbolInfoDouble(s,SYMBOL_TRADE_CONTRACT_SIZE);
   b=MathMin(Bars(s,tf)-1-count-MaxMAPeriod,depth);
   
//--- для нейросети, использующей исторические данные - откуда начинаем их копировать
   for(from=b;from>=1;from--) 
     {
      CopyBuffer(MAshort,0,from,count,ShortBuffer);
      CopyBuffer(MAlong,0,from,count,LongBuffer);
      if(LongBuffer[0]>LongBuffer[1] && ShortBuffer[0]>LongBuffer[0] && ShortBuffer[1]<LongBuffer[1])
        {
         if(trig==false)
           {
            CopyOpen(s,tf,from,count,o);
            OpenPrice=o[1];
            dir="SELL";
            trig=true;
           }
         else
           {
            if(dir=="BUY")
              {
               CopyOpen(s,tf,from,count,o);
               if(t>0) t=t+t*optF*leverage*(o[1]-OpenPrice)*dig/contractSize; else t=0;
               if(t>maxt) {maxt=t; aDD=0;} else if((maxt-t)>aDD) aDD=maxt-t;
               if((maxt>0) && (aDD/maxt>rDD)) rDD=aDD/maxt;
               OpenPrice=o[1];
               dir="SELL";
               trig=true;
              }
           }
        }
      if(LongBuffer[0]<LongBuffer[1] && ShortBuffer[0]<LongBuffer[0] && ShortBuffer[1]>LongBuffer[1])
        {
         if(trig==false)
           {
            CopyOpen(s,tf,from,count,o);
            OpenPrice=o[1];
            dir="BUY";
            trig=true;
           }
         else
           {
            if(dir=="SELL")
              {
               CopyOpen(s,tf,from,count,o);
               if(t>0) t=t+t*optF*leverage*(OpenPrice-o[1])*dig/contractSize; else t=0;
               if(t>maxt) {maxt=t; aDD=0;} else if((maxt-t)>aDD) aDD=maxt-t;
               if((maxt>0) && (aDD/maxt>rDD)) rDD=aDD/maxt;
               OpenPrice=o[1];
               dir="BUY";
               trig=true;
              }
           }
        }
     }
   if(rDD<=trainDD) ff=t; else ff=0.0;
   AmountStartsFF++;
   Colony[0][chromos]=ff;
  }

//+-------------------------------------------------------------------+
//| Получаем оптимизированные параметры нейросети и других переменных |
//| всегда должно быть равно кол-ву генов                             |
//+-------------------------------------------------------------------+
void GetTrainResults()
  {
//--- промежуточное звено между колонией генов и оптимизируемыми параметрами
   int z;                                                             
   MAshort=iMA(s,tf,(int)MathRound(Chromosome[1]*MaxMAPeriod)+1,0,MODE_SMA,PRICE_OPEN);
   MAlong =iMA(s,tf,(int)MathRound(Chromosome[2]*MaxMAPeriod)+1,0,MODE_SMA,PRICE_OPEN);
   CopyBuffer(MAshort,0,from,count,ShortBuffer);
   CopyBuffer(MAlong,0,from,count,LongBuffer);
//--- запоминаем лучшую пару
   z=(int)MathRound(Chromosome[GeneCount-1]*12);                      
   switch(z)
     {
      case  0: {s="AUDUSD"; break;};
      case  1: {s="AUDUSD"; break;};
      case  2: {s="EURAUD"; break;};
      case  3: {s="EURCHF"; break;};
      case  4: {s="EURGBP"; break;};
      case  5: {s="EURJPY"; break;};
      case  6: {s="EURUSD"; break;};
      case  7: {s="GBPCHF"; break;};
      case  8: {s="GBPJPY"; break;};
      case  9: {s="GBPUSD"; break;};
      case 10: {s="USDCAD"; break;};
      case 11: {s="USDCHF"; break;};
      case 12: {s="USDJPY"; break;};
      default: {s="EURUSD"; break;};
     }
//--- запоминаем лучший оптимальное F
   optF=Chromosome[GeneCount];                                        
  }
//+------------------------------------------------------------------+

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

Вся затея самооптимизирующегося эксперта основана на моделировании процесса торговли (как в стандартном тестере от MetaQuotes) во времени (допустим, на истории в 10000 баров) в фитнес-функции, на вход которой генетический алгоритм (функция GA()) подает оптимизируемые переменные. В случае с алгоритмом, основанном на пересечениях скользящих средних, к оптимизируемым переменным относятся:

• инструмент (для форекса - валютная пара); да-да, это типичный мультивалютник, и генетический алгоритм выбирает инструмент (так как код взят из эксперта, выставленного на Чемпионат, то и пары в нем соответствуют валютным парам Чемпионата; в общем случае могут быть все инструменты, котируемые брокером).
  Замечание: к огромному сожалению, в режиме тестирования эксперт не имеет возможности получить перечень пар из окошка Market Watch (спасибо MetaQuotes-ам, здесь мы это выяснили - Нельзя!). Поэтому, если вы захотите прогнать эксперт в тестере отдельно для форекса и отдельно для акций, то просто возьмите и укажите перечень своих инструментов в ФФ и в функции GetTrainResults().
  

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

В приведенных примерах приведен вариант эксперта ДЛЯ ТЕСТИРОВАНИЯ!

Код для РЕАЛЬНОЙ ТОРГОВЛИ можно значительно облегчить, получая перечень инструментов из окошка Market Watch.

Для этого в ФФ и функции GetTrainResults() с комментариями "//--- ГА выбирает пару" и "//--- запоминаем лучшую пару" просто пишем:

//--- ГА выбирает пару
  z=(int)MathRound(Colony[GeneCount-1][chromos]*(SymbolsTotal(true)-1));
  s=SymbolName(z,true);

Таким образом, в начале ФФ описываем и инициализируем при необходимости переменные для моделирования торговли на истории. На втором этапе принимаем из генетического алгоритма различные значения оптимизируемых переменных, например в строке "optF=Colony[GeneCount][chromos];" внутрь ФФ передается из ГА значение доли депозита.

Далее узнаем доступное число баров в истории и, начиная или с 10000-го, или с первого доступного бара начинаем моделировать процесс поступления котировок в режиме "Только цены открытия" и принятия торговых решений:

• Копируем в буфера значения скользящих средних;
• Проверяем, это мертвый крест?
• Если мертвый крест и нет открытых позиций (if(trig==false)) - открываем виртуально позицию SELL (просто запоминаем цену открытия и направление);
• Если мертвый крест и открыта позиция BUY (if(dir=="BUY")) - берем цену открытия бара и далее три очень важных строки:

1. Моделируем закрытие позиции и изменение баланса: к текущему балансу прибавляем значение текущего баланса, умноженного на долю депозита, разрешенного для торговли, умноженного на разницу цен открытия и закрытия, умноженного на цену пипса (неточную);
2. Проверяем, не стал ли текущий баланс максимальным за историю моделирования торговли; если не стал, то вычисляем просадку в деньгах от макcимального баланса;
3. Переводим полученную ранее просадку в деньгах в относительную просадку по балансу;

• Открываем виртуально позицию SELL (просто запоминаем цену открытия и направление);
• Выполняем аналогичные проверки и расчеты для золотого креста.

Пройдя всю доступную историю и смоделировав виртуально торговлю, рассчитываем итоговое значение ФФ: если полученная относительная просадка меньше задаваемой для тестирования просадки, то ФФ=балансу, иначе ФФ=0. Генетический алгоритм настроен на максимизацию фитнес-функции!

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

Заключение

Краткий вывод таков: написать самообучающийся эксперт просто, сложно найти то, что ему подавать на вход (важна идея, реализация - дело техники).

Предупреждая вопрос пессимистов - "а оно работает?", скажу - работает; оптимистам скажу - не грааль.

В чем принципиальное отличие предлагаемого метода от метода Quantum-а? Наиболее ярко можно описать, сопоставив экспертов на МАшках:

1. В Адаптивной торговой системе решение о периодах МАшек необходимо принимать до компиляции, жестко прописывать в код и делать выбор только из этого ограниченного числа вариантов; в Генетически оптимизируемом эксперте до компиляции мы не принимаем никаких решений о периодах, это решение примет ГА и количество вариантов ограничивает только здравый смысл.
2. В Адаптивной торговой системе виртуальная торговля ведется побарно; в Генетически оптимизируемом эксперте изредка, при наступлении условий переоптимизации. При увеличении числа стратегий, параметров, инструментов производительность компьютера может стать для АТС ограничивающим фактором.

Приложение

Вот что получится, если нейросеть загнать в тестер не включая никакой оптимизации на дневках с 01.01.2010 г.:

и на выбор три момента переоптимизации:

раз...

два...

три

P.S. В качестве домашнего задания: реализовать выбор не только параметров определенной системы, но и выбор самой системы, наиболее соответствующей в данный момент рынку (подсказка - из банка систем).