Schnick [Herramienta de prueba del Soporte de la Máquina de Aprendizaje Vectorial (Support Vector Machine Learning Tool Tester)] - script para MetaTrader 5

Este script fue escrito para formar parte de la "Máquina de Aprendizaje: Cómo pueden utilizar soporte de máquinas de vectores en el Trading" artículo publicado en el sitio web MQL5.

Imagina este escenario hipotético, eres un investigador investigando un animal raro que sólo se encuentran en las profundidades del ártico llamada Shnicks. Dada la lejanía de estos animales, se han encontrado a penas un pequeño puñado (digamos que alrededor de 5000). Como investigador, estás con la pregunta... ¿Cómo puedo identificar un Schnick?

Todo lo que tienes a tu disposición son los artículos de investigación publicados previamente por un puñado de investigadores que han visto uno. En estos trabajos de investigación, los autores describen ciertas características que han encontrado en el Schnicks , por ejemplo, altura, peso, número de patas etc. pero todas estas características varían entre los artículos de investigación sin un patrón discernible.

¿Cómo podemos utilizar estos datos para identificar un nuevo animal como el schnick?

Una posible solución a nuestro problema consiste en utilizar una máquina de soporte de vectores para identificar los patrones de datos y crear un marco que pueda utilizarse para clasificar los animales como un schnick o no un schnick. El primer paso es crear un conjunto de datos que pueden ser utilizados para entrenar a su máquina de soporte de vectores para identificar schnicks. Los datos del entrenamiento son un conjunto de entradas y salidas que se emparejan para la máquina de soporte de vectores para analizar y extraer un patrón.

Este script intenta demostrar el poder de utilizar máquinas de soporte de vectores para resolver problemas de estilo de clasificación utilizando "Support Vector Machine Learning Tool" disponibles en el Market de MQL5. Una descripción completa de este hipotético problema y el script puede encontrarse en el artículo "Machine Learning: Cómo pueden utilizar máquinas de soporte de vectores en el Trading". El artículo incluye un tutorial de como usar el script y cómo este problema puede dar ideas sobre uso de aprendizaje automático para evaluar las tendencias del mercado.

Código:

//+------------------------------------------------------------------+
//|                                                      Schnick.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 demuestra las capacidades del Soporte de Vectores
//|                     Herramienta Maquina de aprendizage
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Las sentencia siguiente importa todas las funciones incluidas
//| the Support Vector Machine Tool 'svMachineTool.ex5'
//+------------------------------------------------------------------+
#import "svMachineTool.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
//--- El numero de entradas que se utilizaran por el svm
int N_Inputs=7;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnStart()
  {
   double inputs[];           //doble matriz vacía que se utiliza para la creación de entradas de entrenamiento
   bool   outputs[];          //matriz booleana vacia que se usara para la creación de entradas de entrenamiento
   int N_TrainingPoints=5000; //define el número de ejemplos de entrenamientos que se han generado
   int N_TestPoints=5000;     //define el numero de ejemplos que se usan en las pruebas

   genTrainingData(inputs,outputs,N_TrainingPoints); //genera entradas y salidas para usarse en el entrenamiento del svm

   int handle1=initSVMachine();             //inicia una nueva máquina de soporte de vectores y devuelve una manija
   setInputs(handle1,inputs,7);             //pases de entradas (sin errores) a la máquina de soporte de vectores
   setOutputs(handle1,outputs);             //pases de salidas (sin errores) a la máquina de soporte de vectores
   setParameter(handle1,OP_TOLERANCE,0.01); //establece el parámetro de tolerancia de error <5%
   training(handle1);                       //entrena a la máquina de soporte vectores utilizando las entradas / salidas que pasaron

   insertRandomErrors(inputs,outputs,500);  //toma entradas / salidas generadas originales y añade errores aleatorios en los datos

   int handle2=initSVMachine();             //inicia una nueva máquina de soprte de vectores y devuelve una manija
   setInputs(handle2,inputs,7);             //pases de entradas (con errores) a la máquina de soporte de vectores<
   setOutputs(handle2,outputs);             //pases de salidas (con errores) a la máquina de soporte de vectores
   setParameter(handle2,OP_TOLERANCE,0.01); //establece el parámetro de tolerancia de error <5%
   training(handle2);                       //entrena a la máquina de soporte vectores utilizando las entradas / salidas que pasaron

   double t1=testSVM(handle1,N_TestPoints); //prueba la precisión de la máquina de soporte de vectores entrenada y lo guarda en t1
   double t2=testSVM(handle2,N_TestPoints); //prueba la precisión de la máquina de soporte de vectores entrenada y lo guarda en t2

   Print("La precision del SVM es ",NormalizeDouble(t1,2),"% (utilizando entrenamiento de entradas / salidas sin errores)");
   Print("La precision del SVM es ",NormalizeDouble(t2,2),"% (utilizando entrenamiento de entradas / salidas con errores)");
   deinitSVMachine(); //Limpia toda la memoria utilizada en la generación del SVM para evitar fugas de memoria
  }
//+------------------------------------------------------------------+
//|Esta función toma las propiedades de la observación de lo observado 
//| animales y basados en los criterios hemos elegido, retorno 
//| verdadero/falso si es un 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); //Si la altura esta de fuera de los parámetros > devuelve (falso)
   if(weight   < 40    || weight   > 50)    return(false); //Si el peso está fuera de los parámetros > devuelve (falso)
   if(N_legs   < 8     || N_legs   > 10)    return(false); //Si N_Legs está fuera de los parámetros > devuelve (falso)
   if(N_eyes   < 3     || N_eyes   > 4)     return(false); //Si N_eyes está fuera de los parámetros > devuelve (falso)
   if(L_arm    < 400   || L_arm    > 450)   return(false); //Si L_arm está fuera de los parámetros > devuelve (falso)
   if(av_speed < 2     || av_speed > 2.5)   return(false); //Si av_speed está fuera de los parámetros > devuelve (falso)
   if(f_call   < 11000 || f_call   > 15000) return(false); //Si f_call está fuera de los parámetros> devuelve (falso)
   return(true);                                           //De otra manera > devuelve(verdadero)
  }
//+---------------------------------------------------------------------------------+
//| Esta función toma una doble matriz vacía y una matriz booleana vacía 
//| y genera las entradas / salidas que se utilizarán para el entrenamiento del SVM
//+---------------------------------------------------------------------------------+ 
void genTrainingData(double &inputs[],bool &outputs[],int N)
  {
   double in[];                    //crea una doble matriz vacía para ser utilizada
                                   //para almacenar temporalmente las entradas generadas
   ArrayResize(in,N_Inputs);       //cambiar el tamaño de la matriz in[] por N_Inputs
   ArrayResize(inputs,N*N_Inputs); //cambiar el tamaño de la matriz inputs[] para tener el tamaño de N*N_Inputs 
   ArrayResize(outputs,N);         //cambiar el tamaño de la matriz outputs[] para tener el tamaño N 
   for(int i=0;i<N;i++)
     {
      in[0]=    randBetween(980,1120);    //Entrada aleatoria generada para la altura
      in[1]=    randBetween(38,52);       //Entrada aleatoria generada para el peso
      in[2]=    randBetween(7,11);        //Entrada aleatoria generada para N_legs
      in[3]=    randBetween(3,4.2);       //Entrada aleatoria generada para N_eyes
      in[4]=    randBetween(380,450);     //Entrada aleatoria generada para L_arms
      in[5]=    randBetween(2,2.6);       //Entrada aleatoria generada para av_speed
      in[6]=    randBetween(10500,15500); //Entrada aleatoria generada para f_call

      //--- copiar las nuevos entradas aleatorias generadas en la matriz de entrada de entrenamiento
      ArrayCopy(inputs,in,i*N_Inputs,0,N_Inputs);
      //--- evaluar las entradas aleatorias y determinar si es un Schnick
      outputs[i]=isItASchnick(in[0],in[1],in[2],in[3],in[4],in[5],in[6]);
     }
  }
//+------------------------------------------------------------------+
//| Esta función toma la manija para el SVM entrenado y lo pone a prueba
//| éxito es en la clasificación de las nuevas entradas al azar
//+------------------------------------------------------------------+ 
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 aleatoria generada para la altura
      in[1]=    randBetween(38,52);       //Entrada aleatoria generada para el peso
      in[2]=    randBetween(7,11);        //Entrada aleatoria generada para N_legs
      in[3]=    randBetween(3,4.2);       //Entrada aleatoria generada para N_eyes
      in[4]=    randBetween(380,450);     //Entrada aleatoria generada para L_arms
      in[5]=    randBetween(2,2.6);       //Entrada aleatoria generada para av_speed
      in[6]=    randBetween(10500,15500); //Entrada aleatoria generada para f_call

      //--- utiliza el isItASchnick FCN para determinar la salida real deseada
      Actual_Output=isItASchnick(in[0],in[1],in[2],in[3],in[4],in[5],in[6]);
      //--- utiliza la SVM entrenado para devolver la salida prevista .
      Predicted_Output=classify(handle,in);
      if(Actual_Output==Predicted_Output)
        {
         N_correct++; //Esta declaración mantiene un recuento del número de veces que la salida predicha es correcta.
        }
     }
//--- devuelve la exactitud de la SVM entrenado como un porcentaje
   return(100*((double)N_correct/(double)N));
  }
//+------------------------------------------------------------------+
//| Esta función toma las entradas y salidas correctas entrenadas 
//| generada e inserta N errores aleatorios en los datos
//+------------------------------------------------------------------+ 
void insertRandomErrors(double &inputs[],bool &outputs[],int N)
  {
   int nTrainingPoints=ArraySize(outputs); //calcula el número de puntos de entrenamiento
   int index;                              //crea un 'index' nuevo entero
   bool randomOutput;                      //crea un nuevo booleano 'randomOutput'
   double in[];                            //crea una doble matriz vacía para ser utilizada
                                           //para almacenar temporalmente las entradas generadas
   ArrayResize(in,N_Inputs);               //cambiar el tamaño de la matriz in[] a N_Inputs
   for(int i=0;i<N;i++)
     {
      in[0]=    randBetween(980,1120);    //Entrada aleatoria generada para la altura
      in[1]=    randBetween(38,52);       //Entrada aleatoria generada para el peso
      in[2]=    randBetween(7,11);        //Entrada aleatoria generada para N_legs
      in[3]=    randBetween(3,4.2);       //Entrada aleatoria generada para N_eyes
      in[4]=    randBetween(380,450);     //Entrada aleatoria generada para L_arms
      in[5]=    randBetween(2,2.6);       //Entrada aleatoria generada para av_speed
      in[6]=    randBetween(10500,15500); //Entrada aleatoria generada para f_call

      //--- elige al azar una de las entradas de entrenamiento para insertar un error
      index=(int)MathRound(randBetween(0,nTrainingPoints-1));
      //--- genera una salida booleana al azar para ser utilizada para crear de error
      if(randBetween(0,1)>0.5) randomOutput=true;
      else                     randomOutput=false;

      //--- copiar las nuevas entradas aleatorias generados en la matriz de entrada de entrenamiento
      ArrayCopy(inputs,in,index*N_Inputs,0,N_Inputs);
      //--- copiar la nueva salida aleatoria generada en la matriz de salida de entrenamiento
      outputs[index]=randomOutput;
     }
  }
//+------------------------------------------------------------------+
//| Esta función se utiliza para crear un valor aleatorio entre t1 y t2
//+------------------------------------------------------------------+ 
double randBetween(double t1,double t2)
  {
   return((t2-t1)*((double)MathRand()/(double)32767)+t1);
  }
//+------------------------------------------------------------------+