Schnick [Support Vector Machine Learning Tool Tester - DEMO] - эксперт для MetaTrader 5

Скрипт является составной частью статьи "Машинное обучение: Как метод опорных векторов может быть использован в трейдинге", опубликованной на сайте MQL5.

Представьте себе такой гипотетический сценарий, что вы занимаетесь исследованием редких диких животных, которые обитают только в глубинах Арктики и называются Шняками. За все время была найдена только небольшая горстка из этих животных, учитывая их удаленность (скажем около 5000). Как исследователя вас мучает вопрос - как же я могу узнать Шняка?

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

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

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

Этот скрипт является попыткой продемонстрировать силу использования метода опорных векторов для решения задач классификации с помощью "Support Vector Machine Learning Tool" доступной в MQL5 Маркете. Полное описание этой гипотетической проблемы и скрипта вы можете найти в статье "Машинное обучение: Как метод опорных векторов может быть использован в трейдинге". В статье приводится пошаговое руководство о том как использовать скрипт и раскрывается важность использования машинного обучения для оценки рыночных трендов.

Код:

//+------------------------------------------------------------------+
//|                                                 Schnick_Demo.mq5 |
//|                        Copyright 2011, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2011, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
#property version   "1.00"

//+------------------------------------------------------------------+
//| Этот скрипт демонстрирует возможности Support Vector
//|                     Machine Learning Tool
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Следующая строка импортирует все функции, включенные в
//| Support Vector Machine Tool 'svMachineTool.ex5'
//+------------------------------------------------------------------+
#import "svMachineTool_demo.ex5"
enum ENUM_TRADE {BUY,SELL};
enum ENUM_OPTION {OP_MEMORY,OP_MAXCYCLES,OP_TOLERANCE};
int  initSVMachine(void);
void setIndicatorHandles(int handle,int &indicatorHandles[],int offset,int N);
void setParameter(int handle,ENUM_OPTION option,double value);
bool genOutputs(int handle,ENUM_TRADE trade,int StopLoss,int TakeProfit,double duration);
bool genInputs(int handle);
bool setInputs(int handle,double &Inputs[],int nInputs);
bool setOutputs(int handle,bool &Outputs[]);
bool training(int handle);
bool classify(int handle);
bool classify(int handle,int offset);
bool classify(int handle,double &iput[]);
void deinitSVMachine(void);
#import
//--- Количество входов, которые будут исползоваться для svm
int N_Inputs=7;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
void OnInit()
  {
   double inputs[];           //пустой массив типа double, который будет использоваться для создания входов обучающей выборки 
   bool   outputs[];          //пустой массив типа bool, который будет использоваться для создания выходов обучающей выборки 
   int N_TrainingPoints=5000; //определяет размер генерируемой обучающей выборки
   int N_TestPoints=5000;     //определяет количество элементов выборки, которые будут использованы при тестировании

   genTrainingData(inputs,outputs,N_TrainingPoints); // определяет входы и выходы, которые будут использованы для тренировки svm

   int handle1=initSVMachine();             //инициализация нового объекта метода опорных векторов и возврат хэндла
   setInputs(handle1,inputs,7);             //отправляет входные данные (без ошибок) в объект метода опорных векторов
   setOutputs(handle1,outputs);             //отправляет выходные данные (без ошибок) в объект метода опорных векторов
   setParameter(handle1,OP_TOLERANCE,0.01); //установка параметра допустимой ошибки <5%
   training(handle1);                       //тренировка объекта метода опорных векторов используя входные/выходные данные 

   insertRandomErrors(inputs,outputs,500);  //берем оригинальные входы/выходы и добавляем в них случайные ошибки

   int handle2=initSVMachine();             //инициализация нового объекта метода опорных векторов и возврат хэндла
   setInputs(handle2,inputs,7);             //отправляет входные данные (с ошибками) в объект метода опорных векторов
   setOutputs(handle2,outputs);             //отправляет выходные данные (с ошибками) в объект метода опорных векторов
   setParameter(handle2,OP_TOLERANCE,0.01); //установка параметра допустимой ошибки <5%
   training(handle2);                       //тренировка объекта метода опорных векторов используя входные/выходные данные 

   double t1=testSVM(handle1,N_TestPoints); //тестирование на точность тренированного объекта и сохранение результатов в t1
   double t2=testSVM(handle2,N_TestPoints); //тестирование на точность тренированного объекта и сохранение результатов в t2

   Print("Точность SVM составила ",NormalizeDouble(t1,2),"% (использована обучающая выборка без ошибок)");
   Print("Точность SVM составила ",NormalizeDouble(t2,2),"% (использована обучающая выборка с ошибками)");
   deinitSVMachine(); //Очистка всей памяти, использованной при генерации SVM для избежания ее утечки
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- Нет функций, выполняемых в OnDeinit()
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- Нет функций, выполняемых в OnTick()   
  }
//+------------------------------------------------------------------+
//| Эта функция получает характеристики наблюдаемого животного и на
//| основе критерия, который мы выбрали, возвращает true/false 
//| в зависимости от того, является ли животное Шняком, или нет
//+------------------------------------------------------------------+
bool isItASchnick(double height,double weight,double N_legs,double N_eyes,double L_arm,double av_speed,double f_call)
  {
   if(height   < 1000  || height   > 1100)  return(false); //если рост находится за пределами отрезка > return(false)
   if(weight   < 40    || weight   > 50)    return(false); //если вес находится за пределами отрезка > return(false)
   if(N_legs   < 8     || N_legs   > 10)    return(false); //если параметр N_Legs находится за пределами отрезка > return(false)
   if(N_eyes   < 3     || N_eyes   > 4)     return(false); //если параметр the N_eyes находится за пределами отрезка > return(false)
   if(L_arm    < 400   || L_arm    > 450)   return(false); //если параметр L_arm  находится за пределами отрезка > return(false)
   if(av_speed < 2     || av_speed > 2.5)   return(false); //если параметр av_speed находится за пределами отрезка > return(false)
   if(f_call   < 11000 || f_call   > 15000) return(false); //если параметр f_call находится за пределами отрезка > return(false)
   return(true);                                           //в противном случае > return(true)
  }
//+------------------------------------------------------------------+
//| Эта функция получает пустые массивы типа double и bool, и
//| генерирует входные/выходные данные, используемые при обучении SVM
//+------------------------------------------------------------------+ 
void genTrainingData(double &inputs[],bool &outputs[],int N)
  {
   double in[];                    //создание пустого массива типа double для временного хранения входов
   ArrayResize(in,N_Inputs);       //изменение размера массива in[] до N_Inputs
   ArrayResize(inputs,N*N_Inputs); //изменение размера массива inputs[] до N*N_Inputs 
   ArrayResize(outputs,N);         //изменение массива outputs[] до N 
   for(int i=0;i<N;i++)
     {
      in[0]=    randBetween(980,1120);    //Создание случайного входа для роста
      in[1]=    randBetween(38,52);       //Создание случайного входа для веса
      in[2]=    randBetween(7,11);        //Создание случайного входа для N_legs
      in[3]=    randBetween(3,4.2);       //Создание случайного входа для N_eyes
      in[4]=    randBetween(380,450);     //Создание случайного входа для L_arms
      in[5]=    randBetween(2,2.6);       //Создание случайного входа для av_speed
      in[6]=    randBetween(10500,15500); //Создание случайного входа для f_call

      //--- копирование новых случайных входов в массив входов обучающей выборки
      ArrayCopy(inputs,in,i*N_Inputs,0,N_Inputs);
      //--- оценка случайных входов и определение, является ли животное Шняком
      outputs[i]=isItASchnick(in[0],in[1],in[2],in[3],in[4],in[5],in[6]);
     }
  }
//+------------------------------------------------------------------+
//| Эта функция получает хэндл обученного SVM и проверяет на сколько
//| успешно он классифицирует новые входные данные
//+------------------------------------------------------------------+ 
double testSVM(int handle,int N)
  {
   double in[];
   int atrue=0;
   int afalse=0;
   int N_correct=0;
   bool Predicted_Output;
   bool Actual_Output;
   ArrayResize(in,N_Inputs);
   for(int i=0;i<N;i++)
     {
      in[0]=    randBetween(980,1120);    //Создание случайного входа для роста
      in[1]=    randBetween(38,52);       //Создание случайного входа для веса
      in[2]=    randBetween(7,11);        //Создание случайного входа для N_legs
      in[3]=    randBetween(3,4.2);       //Создание случайного входа для N_eyes
      in[4]=    randBetween(380,450);     //Создание случайного входа для L_arms
      in[5]=    randBetween(2,2.6);       //Создание случайного входа для av_speed
      in[6]=    randBetween(10500,15500); //Создание случайного входа для f_call

      //--- использует функцию isItASchnick для определения фактического желаемого результата
      Actual_Output=isItASchnick(in[0],in[1],in[2],in[3],in[4],in[5],in[6]);
      //--- использование обученного SVM для возврата прогноза.
      Predicted_Output=classify(handle,in);
      if(Actual_Output==Predicted_Output)
        {
         N_correct++; //Эта переменная хранит число верных прогнозов.
        }
     }
//--- возвращает точность обученного SVM в процентах
   return(100*((double)N_correct/(double)N));
  }
//+------------------------------------------------------------------+
//| Эта функция получает корректные входные и выходные данные 
//| обучающей выборки и вводит N случайных ошибок в них
//+------------------------------------------------------------------+ 
void insertRandomErrors(double &inputs[],bool &outputs[],int N)
  {
   int nTrainingPoints=ArraySize(outputs); //вычисляет размер обучающей выборки
   int index;                              //создание целочисленной переменной 'index'
   bool randomOutput;                      //сооздание новой переменной 'randomOutput' типа 'bool'
   double in[];                            //создание пустого массива типа double для временного хранения входов
   ArrayResize(in,N_Inputs);               //изменение размера массива in[] до N_Inputs
   for(int i=0;i<N;i++)
     {
      in[0]=    randBetween(980,1120);    //Создание случайного входа для роста
      in[1]=    randBetween(38,52);       //Создание случайного входа для веса
      in[2]=    randBetween(7,11);        //Создание случайного входа для N_legs
      in[3]=    randBetween(3,4.2);       //Создание случайного входа для N_eyes
      in[4]=    randBetween(380,450);     //Создание случайного входа для L_arms
      in[5]=    randBetween(2,2.6);       //Создание случайного входа для av_speed
      in[6]=    randBetween(10500,15500); //Создание случайного входа для f_call

      //--- случайным образом выбирается один из обучающих входов для добавления в него ошибки
      index=(int)MathRound(randBetween(0,nTrainingPoints-1));
      //--- генерируем случайное значение типа bool для создания ошибки
      if(randBetween(0,1)>0.5) randomOutput=true;
      else                     randomOutput=false;

      //--- копирование новых случайных входов в массив входов обучающей выборки
      ArrayCopy(inputs,in,index*N_Inputs,0,N_Inputs);
      //--- копирование новых случайных выходов в массив выходов обучающей выборки
      outputs[index]=randomOutput;
     }
  }
//+------------------------------------------------------------------+
//| Эта функция используется для создания случайного значения между 
//| t1 и t2
//+------------------------------------------------------------------+ 
double randBetween(double t1,double t2)
  {
   return((t2-t1)*((double)MathRand()/(double)32767)+t1);
  }
//+------------------------------------------------------------------+