Schnick [Ferramenta Testadora de Aprendizagem da Máquina de Vetor de Suporte - DEMO] - expert para MetaTrader 5

Este script foi escrito para fazer parte do artigo "Aprendizagem de máquina: Como as Máquinas de Vetores de Suportes de ser utilizadas nas Negociações" publicado no site da MQL5.

Imagine este cenário hipotético, você é um pesquisador investigando um animal raro chamado Shnicks somente encontrado nas profundezas dos Ártico. Dado o afastamento destes animais, apenas um pequeno punhado já foram encontrados (digamos que em torno de 500). Como pesquisador, você está preso com a pergunta ... como posso identificar um Schnick?

Tudo que você tem à sua disposição são os trabalhos de pesquisa publicados anteriormente por um punhado de exploradores que já viram um. Nestes trabalhos de pesquisa, os autores descrevem algumas características sobre os Schnicks que encontraram, ou seja, altura, peso, número de pernas, etc, mas todas essas características variam entre os trabalhos de pesquisa sem nenhum padrão discernível….

Como podemos usar esses dados para identificar um novo animal como um Schnick?

Uma possível solução para o nosso problema é a utilização de uma Máquina de Vetor de Suporte para identificar os padrões nos dados e criar uma estrutura que pode ser usada para classificar os animais como qualquer um Schnick ou nenhum Schnick. O primeiro passo é criar um conjunto de dados que pode ser usado para treinar a sua máquina de vetor de suporte para identificar schnicks. Os dados de treinamento são um conjunto de entradas e saídas correspondentes para a Máquina de Vetor de Suporte analisar e extrair um padrão do mesmo.

Este script tenta demonstrar o poder da utilização das máquinas de vetores de suportes na solução de problemas de estilo de classificação utilizando a Ferramenta de Aprendizagem da Máquina de Vetor de Suporte disponível no Mercado MQL5. Uma descrição completa do problema hipotético e script pode ser encontrada no artigo "Aprendizagem de máquina: Como as Máquinas de Vetores de Suportes podem ser utilizadas nas Negociações". O artigo inclui um passo a passo de como usar o script e como esse problema pode dar uma percepção sobre o uso de aprendizagem de máquina para avaliar as tendências de mercado.

Código:

//+------------------------------------------------------------------+
//|                                                 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"

//+------------------------------------------------------------------+
//| Este script demonstra as capacidades da Ferramenta de Aprendizagem
//|                     da Máquina de Vetor de Suporte(SVM)
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| A seguinte declaração importa todas as funções incluídas na
//| Ferramenta da Máquina de Vetor de Suporte '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
//--- O número de entradas que iremos utilizar para o svm
int N_Inputs=7;
//+------------------------------------------------------------------+
//| Função de inicialização do Expert                                |
//+------------------------------------------------------------------+
int OnInit()
  {
   double inputs[];           //array double vazia a ser usado para a criação de entradas experimentais
   bool   outputs[];          //array booleana vazia a ser usado para a criação de entradas experimentais
   int N_TrainingPoints=5000; //define o número de amostras de treino a serem geradas
   int N_TestPoints=5000;     //define o número de amostras usadas quando testadas

   genTrainingData(inputs,outputs,N_TrainingPoints); //Gera as entradas e saídas a serem utilizados para a formação da SVM (Máquina de Vetor de Suporte)

   int handle1=initSVMachine();             //inicializa uma nova máquina suporte de vetor e retorna um handle
   setInputs(handle1,inputs,7);             //passes das entradas (sem erros) para a Máquina de Vetor de Suporte
   setOutputs(handle1,outputs);             //passes das saídas (sem erros) para a máquina suporte de vetor
   setParameter(handle1,OP_TOLERANCE,0.01); //define o parâmetro de erro de tolerância <5%
   training(handle1);                       //treina a Máquina de Vetor de Suporte usando as entradas/saídas anteriores

   insertRandomErrors(inputs,outputs,500);  //usa as entradas/saídas originais geradas e adiciona erros aleatórios aos dados

   int handle2=initSVMachine();             //inicializa uma nova máquina suporte de vetor e retorna um handle
   setInputs(handle2,inputs,7);             //passes das entradas (com erros) para a Máquina de Vetor de Suporte
   setOutputs(handle2,outputs);             //passes das saídas (com erros) para a Máquina de Vetor de Suporte
   setParameter(handle2,OP_TOLERANCE,0.01); //define o parâmetro de erro de tolerância <5%
   training(handle2);                       //treina a Máquina de Vetor de Suporte usando as entradas/saídas anteriores

   double t1=testSVM(handle1,N_TestPoints); //testa a precisão da Máquina de Vetor de Suporte treinada e salva para t1
   double t2=testSVM(handle2,N_TestPoints); //testa a precisão da Máquina de Vetor de Suporte treinada e salva para t2

   Print("A precisão SVM é ",NormalizeDouble(t1,2),"% (usando treinamento sem erros das entradas/saídas)");
   Print("A precisão SVM é ",NormalizeDouble(t2,2),"% (usando treinamento sem erros das entradas/saídas)");
   deinitSVMachine(); //Limpa toda a memória utilizada na geração do SVM para evitar vazamento de memória
   return(0);
  }
//+------------------------------------------------------------------+
//|Função de desinicialização do Expert                              |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- Não executa funções em OnDeinit()
  }
//+------------------------------------------------------------------+
//| Função tick do Expert                                            |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- Não executa funções em OnTick()   
  }
//+------------------------------------------------------------------+
//| Esta função tem as propriedades de visualização do animal 
//| observado e baseado nos critérios escolhidos, retorna
//| verdadeiro/falso se é um schnick
//+------------------------------------------------------------------+
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); //Se a altura é fora dos parâmetros > retorna (falso)
   if(weight   < 40    || weight   > 50)    return(false); //Se a largura é fora dos parâmetros > retorna (falso)
   if(N_legs   < 8     || N_legs   > 10)    return(false); //Se N_pernas é fora dos parâmetros > retorna (falso)
   if(N_eyes   < 3     || N_eyes   > 4)     return(false); //Se N_olhos é fora dos parâmetros > retorna (falso)
   if(L_arm    < 400   || L_arm    > 450)   return(false); //Se L_braços é fora dos parâmetros > retorna (falso)
   if(av_speed < 2     || av_speed > 2.5)   return(false); //Se velocidade_média é fora dos parâmetros > retorna (falso)
   if(f_call   < 11000 || f_call   > 15000) return(false); //Se f_chamada é fora dos parâmetros > retorna (falso)
   return(true);                                           //caso contrario > retorna verdadeiro
  }
//+------------------------------------------------------------------+
//| Esta função recebe uma array double  vazio e uma array booleano vazia
//| e gera as entradas/saídas para ser usado para na formação da SVM
//+------------------------------------------------------------------+ 
void genTrainingData(double &inputs[],bool &outputs[],int N)
  {
   double in[];                    //cria uma array double vazia a ser usada
                                   //para armazenar temporariamente as entradas geradas
   ArrayResize(in,N_Inputs);       //redimensionar a array in[] para N_Inputs
   ArrayResize(inputs,N*N_Inputs); //redimensionar a array inputs[] para obter o tamanho de N*N_Inputs 
   ArrayResize(outputs,N);         //redimensionar a array outputs[] para obter o tamanho de N 
   for(int i=0;i<N;i++)
     {
      in[0]=    randBetween(980,1120);    //Entrada aleatória gerado para altura 
      in[1]=    randBetween(38,52);       //Entrada aleatória gerado para largura
      in[2]=    randBetween(7,11);        //Entrada aleatória gerado para N_pernas
      in[3]=    randBetween(3,4.2);       //Entrada aleatória gerado para N_olhos
      in[4]=    randBetween(380,450);     //Entrada aleatória gerado para L_braços
      in[5]=    randBetween(2,2.6);       //Entrada aleatória gerado para velocidade_média
      in[6]=    randBetween(10500,15500); //Entrada aleatória gerado para f_chamada

      //--- copiar as novas entradas aleatórios gerados na array de entrada de treinamento
      ArrayCopy(inputs,in,i*N_Inputs,0,N_Inputs);
      //--- avaliar as entradas aleatórias e determinar se é um schnick
      outputs[i]=isItASchnick(in[0],in[1],in[2],in[3],in[4],in[5],in[6]);
     }
  }
//+------------------------------------------------------------------+
//| Esta função recebe o handle para a SVM treinada e testa como
//|bem sucedida, é a classificação de novas entradas aleatórios
//+------------------------------------------------------------------+ 
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);    //Entrada aleatória gerado para altura
      in[1]=    randBetween(38,52);       //Entrada aleatória gerado para largura
      in[2]=    randBetween(7,11);        //Entrada aleatória gerado para N_pernas
      in[3]=    randBetween(3,4.2);       //Entrada aleatória gerado para N_olhos
      in[4]=    randBetween(380,450);     //Entrada aleatória gerado para L_braços
      in[5]=    randBetween(2,2.6);       //Entrada aleatória gerado para velocidade_média
      in[6]=    randBetween(10500,15500); //Entrada aleatória gerado para f_chamada

      //--- usar a função isItASchnick para determinar a saída real desejada 
      Actual_Output=isItASchnick(in[0],in[1],in[2],in[3],in[4],in[5],in[6]);
      //--- utiliza a SVM treinada para voltar a saída prevista.
      Predicted_Output=classify(handle,in);
      if(Actual_Output==Predicted_Output)
        {
         N_correct++; //Esta afirmação mantém a conta do número de vezes que a saída prevista é correta.
        }
     }
//--- retorna a precisão da SVM treinada como um percentual
   return(100*((double)N_correct/(double)N));
  }
//+------------------------------------------------------------------+
//| Esta função recebe as entradas e saídas de treinamento corretas 
//| geradas e insere N erros aleatórios para os dados
//+------------------------------------------------------------------+ 
void insertRandomErrors(double &inputs[],bool &outputs[],int N)
  {
   int nTrainingPoints=ArraySize(outputs); //calcula o número de pontos do treinamento
   int index;                              //cria um novo inteiro 'index'
   bool randomOutput;                      //cria um novo booleano 'randomOutput'
   double in[];                            //cria uma array double vazia a ser usada
                                           //para armazenar temporariamente as entradas geradas
   ArrayResize(in,N_Inputs);               //redimensionar a array in[] para N_Inputs
   for(int i=0;i<N;i++)
     {
      in[0]=    randBetween(980,1120);    //Entrada aleatória gerado para altura
      in[1]=    randBetween(38,52);       //Entrada aleatória gerado para largura
      in[2]=    randBetween(7,11);        //Entrada aleatória gerado para N_pernas
      in[3]=    randBetween(3,4.2);       //Entrada aleatória gerado para N_olhos
      in[4]=    randBetween(380,450);     //Entrada aleatória gerado para L_braços
      in[5]=    randBetween(2,2.6);       //Entrada aleatória gerado para velocidade_média
      in[6]=    randBetween(10500,15500); //Entrada aleatória gerado para f_chamada

      //--- escolhe aleatoriamente uma das entradas experimentais para inserir um erro
      index=(int)MathRound(randBetween(0,nTrainingPoints-1));
      //--- gera uma saída booleana aleatório a ser usada para criar um erro
      if(randBetween(0,1)>0.5) randomOutput=true;
      else                     randomOutput=false;

      //--- copiar as novas entradas aleatórios gerados na array de entrada do treinamento
      ArrayCopy(inputs,in,index*N_Inputs,0,N_Inputs);
      //--- copiar as novas saídas aleatórios geradas na array de saída do treinamento
      outputs[index]=randomOutput;
     }
  }
//+------------------------------------------------------------------+
//| Esta função é usada para criar um valor aleatório entre t1 e t2
//+------------------------------------------------------------------+ 
double randBetween(double t1,double t2)
  {
   return((t2-t1)*((double)MathRand()/(double)32767)+t1);
  }
//+------------------------------------------------------------------+