Aprendizaje Automático: Cómo usar las Máquinas de Vectores de Soporte en Trading

¿Qué es una máquina de vectores de soporte?

Una máquina de vectores de soporte es un método de aprendizaje automático que intenta tomar datos de entrada y clasificarlos en una de dos categorías. Para que una máquina de vectores de soporte sea efectiva, es necesario usar primero un conjunto de datos de formación de entrada y salida (datos "input" y datos "output") para construir el modelo de máquina de vectores de soporte que se pueda usar para clasificar nuevos datos.

Una máquina de vectores de soporte desarrolla este modelo tomando los datos de formación, dibujándolos en un espacio multidimensional, y después usando regresión para encontrar un hiperplano (una superficie en un espacio dimensional n que separa el espacio en dos semi espacios) que separa de la mejor manera las dos clases de inputs. Una vez que la máquina de vectores de soporte se ha formado, es capaz de estudiar nuevos inputs con respecto al hiperplano separador y clasificarlos en una de las dos categorías.

Una máquina de vectores de soporte es esencialmente una máquina de entrada/salida de datos (input/output). Un usuario podrá introducir unos inputs y, basándose en el modelo desarrollado a través de la formación, devolverá unos outputs. El número de inputs para cualquier máquina de vectores de soporte teóricamente puede ir del uno al infinito, pero en términos prácticos, el poder de computación limita la cantidad de inputs que se pueden usar. Si, por ejemplo, se usan N inputs para una máquina de vectores de soporte concreta (el valor íntegro de N puede variar entre uno e infinito), la máquina de vectores de soporte debe dibujar cada conjunto de inputs en un espacio dimensional N y encontrar un hiperplano dimensional (N-1) que separe de la mejor manera los datos de formación.

Figura 1. Las máquinas de vectores de soporte son máquinas de input/output.

La mejor manera de conceptualizar cómo funciona una máquina de vectores de soporte es considerar el caso bidimensional. Asumamos que queremos crear una máquina de vectores de soporte que tiene dos inputs y devuelve un solo output que clasifica el punto de datos como perteneciente a una de las dos categorías. Podemos visualizar esto dibujándolo en un gráfico bidimensional como el que se muestra abajo.

Figura 2. Izquierda: Los inputs de una máquina de vectores de soporte dibujados en un gráfico 2D. Los círculos rojos y las cruces azules se usan para denotar los dos tipos de inputs.

Figura 3. Derecha: Los inputs de una máquina de vectores de soporte dibujados en un gráfico 2D. Los círculos rojos y las cruces azules se usan para denotar las dos clases de inputs con una línea negra indicando el hiperplano separador.

En este ejemplo, las cruces azules indican datos que pertenecen a la categoría 1, y los círculos rojos, datos que pertenecen a la categoría 2. Cada uno de los datos individuales tienen un valor de input único 1 (representado por su posición en el eje x) y un valor de input único 2 (representado por su posición en el eje y), y todos estos puntos se han dibujado en el espacio bidimensional.

Una máquina de vectores de soporte es capaz de clasificar datos creando un modelo de estos puntos en un espacio bidimensional. La máquina de vectores de soporte observa los datos en un espacio bidimensional y usa un algoritmo de regresión para encontrar un hiperplano de 1 dimensión (o línea) que separa de la forma más precisa los datos en sus dos categorías. Esta línea separadora se usa después por la máquina de vectores de soporte para clasificar nuevos datos en la categoría 1 y la categoría 2.

La animación abajo ilustra el proceso de formación de una nueva máquina de vectores de soporte. El algoritmo comenzará haciendo un cálculo aleatorio para encontrar un hiperplano separador, y después mejorar iterativamente la precisión del hiperplano. Como puede ver, el algoritmo comienza de forma bastante agresiva, pero después se ralentiza cuando comienza a acercarse a la solución deseada.

Figura 4. Una animación que muestra la formación de la máquina de vectores de soporte. El hiperplano converge progresivamente en la geometría ideal para separar las dos clases de datos.

Dimensiones más altas

El escenario bidimensional presentado arriba nos permite visualizar el proceso de una máquina de vectores de soporte, pero solo puede clasificar un punto de datos usando dos inputs. ¿Qué pasaría si quisiéramos usar más inputs? Afortunadamente, el algoritmo de la máquina de vectores de soporte nos permite hacer lo mismo en dimensiones más altas, aunque pasa a ser mucho más difícil de conceptualizar.

Considere que desea crear una máquina de vectores de soporte que toma 20 inputs y puede clasificar cualquier punto de datos usando estos inputs en la categoría 1 o 2. ello, la máquina de vectores de soporte debe modelar los datos en un espacio de 20 dimensiones y usar un algoritmo de regresión para encontrar un hiperplano de 19 dimensiones que separa los datos en dos categorías. Esto pasa a ser extremadamente difícil de visualizar, puesto que a las personas nos cuesta comprender algo que va más allá de las 3 dimensiones. No obstante, todo lo que usted debe saber es que funciona exactamente de la misma forma que en el caso del espacio bidimensional.

¿Cómo funcionan las máquinas de vectores de soporte? Ejemplo: ¿Es un schnick?

Imagínese el siguiente escenario hipotético: usted es un científico que investiga un animal muy raro que solo se puede encontrar en las profundidades del Ártico, llamado “schnick”. Dada la rareza de estos animales, hasta ahora solo se han podido encontrar unos cuantos ejemplares (digamos unos 5.000). Como científico, usted se enfrenta a la pregunta: ¿cómo puedo identificar un schnick?

Todo lo que tiene a su disposición son los informes de investigación publicados anteriormente por los pocos investigadores que han visto alguno de estos animales. En estos informes, los autores describen ciertas características sobre los schnicks que se encontraron: altura, peso, número de patas, etc. Pero todas estas características varían en los diferentes informes, y no se observa un patrón fijo...

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

Una posible solución a nuestro problema es usar una máquina de vectores de soporte para identificar los patrones en los datos y crear un marco de trabajo que se puede usar para clasificar animales como schnick o como no schnick. El primer paso es crear un conjunto de datos que se pueden usar para formar su máquina de vectores de soporte para identificar schnicks. Los datos de formación son un conjunto de inputs y outputs correspondientes para la máquina de vectores de soporte para analizar y de donde extraer un patrón.

Por tanto, debemos decidir qué inputs se usarán, y cuántos. Teóricamente, podemos tener tantos inputs como queramos, pero esto a menudo puede llevar a una formación lenta (cuantos más inputs tenga, más tiempo tardará la máquina de vectores de soporte en extraer patrones). Además, usted quiere elegir valores de input que tenderán a ser relativamente consistentes en todos los schnicks. Por ejemplo, la altura o peso del animal sería un buen ejemplo de input, porque se espera que sean valores relativamente consistentes en todos los schnicks. No obstante, la edad media de un animal sería una mala elección de input, porque se puede esperar que la edad de los animales identificados como schnicks varíe considerablemente.

Por ello, se eligieron los siguientes patrones:

• Altura
• Peso
• Número de patas
• Número de ojos
• Longitud de las patas del animal
• Velocidad media del animal
• Frecuencia de llamada de apareamiento del animal

Con los inputs elegidos, podemos comenzar a compilar nuestros datos de formación. Para que los datos de formación para una máquina de vectores de soporte sean efectivos, deben cumplir determinados requisitos:

• Los datos deben tener ejemplos de animales que sean schnicks
• Los datos deben tener ejemplos de animales que no sean schnicks

En este caso, tenemos los informes de científicos que han identificado a un schnick con éxito y han alistado sus propiedades. Por tanto, podemos leer estos informes de investigación y extraer los datos para cada uno de los inputs y colocar un output de "verdadero" o "falso" a cada uno de los ejemplos. Los datos de formación en este caso pueden tener un aspecto similar a la tabla de abajo.

Muestras de Formación	altura [mm]	peso [kg]	N_patas	N_ojos	L_pata [mm]	vel_media [m/s]	f_llamada [Hz]	Schnick (true/false)
Ejemplo 1	1030	45	8	3	420	2.1	14000	TRUE
Ejemplo 2	1010	42	8	3	450	2.2	14000	TRUE
Ejemplo 3	900	40	7	6	600	6	13000	FALSE
Ejemplo 4	1050	43	9	4	400	2.4	12000	TRUE
Ejemplo 5	700	35	2	8	320	21	13500	FALSE
Ejemplo 6	1070	42	8	3	430	2.4	12000	TRUE
Ejemplo 7	1100	40	8	3	430	2.1	11000	TRUE
Ejemplo N	...	...	...	...	...	...	...	...

Tabla 1. Tabla de ejemplo de observaciones de schnick.

Una vez que hemos recopilado los datos para todos nuestros inputs y outputs de formación, podemos usarlos para formar nuestra máquina de vectores de soporte. Durante el proceso de formación, la máquina de vectores de soporte creará un modelo en un espacio de siete dimensiones que se usará para distribuir cada uno de los ejemplos de formación en las categorías de true (verdadero) o false (falso). La máquina de vectores de soporte continuará haciendo esto hasta que tenga un modelo que represente de forma precisa los datos de formación (con la tolerancia de error especificada). Una vez que la formación está completa, este modelo se puede usar para clasificar nuevos datos como verdaderos o falsos.

¿Funcional realmente la máquina de vectores de soporte?

Usando el escenario del schnick, he escrito un script que comprueba la efectividad de una máquina de vectores de soporte a la hora de identificar nuevos schnicks. Para ello, he usado la biblioteca de funciones “Support Vector Machine Learning Tool” ("Herramienta de Aprendizaje de Máquina de Vectores de Soporte"), que se puede descargar de Mercado (Market).

Para modelar este escenario de forma efectiva, necesitamos decidir primero cuáles son las propiedades reales de un schnick. Las propiedades que yo he asumido en este caso se especifican en la tabla de abajo. Si un animal satisface todos los criterios de abajo, entonces es un schnick.

Parámetro	Rango mínimo	Rango máximo
altura [mm]	1000	1100
peso [kg]	40	50
N_patas	8	10
N_ojos	3	4
L_pata [mm]	400	450
vel_media [m/s]	2	2.5
f_llamada [Hz]	11000	15000

Tabla 2. Resumen de parámetros que definen a un schnick.

Ahora que ya hemos definido a nuestro schnick, podemos usar esta definición para experimentar con máquinas de vectores de soporte. El primer paso es crear una función capaz de tomar los siete inputs para cualquier animal y devolver la clasificación real del animal como schnick o no. Esta función se usará para generar datos de formación para la máquina de vectores de soporte, así como para estudiar su rendimiento al final. Esto se puede hacer usando la función de abajo;

//+------------------------------------------------------------------+
//| This function takes the observation properties of the observed 
//| animal and based on the criteria we have chosen, returns true/false whether it is a 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);   // If the height is outside the parameters > return(false)
   if(weight   < 40    || weight   > 50)    return(false);   // If the weight is outside the parameters > return(false)
   if(N_legs   < 8     || N_legs   > 10)    return(false);   // If the N_Legs is outside the parameters > return(false)
   if(N_eyes   < 3     || N_eyes   > 4)     return(false);   // If the N_eyes is outside the parameters > return(false)
   if(L_arm    < 400   || L_arm    > 450)   return(false);   // If the L_arm  is outside the parameters > return(false)
   if(av_speed < 2     || av_speed > 2.5)   return(false);   // If the av_speed is outside the parameters > return(false)
   if(f_call   < 11000 || f_call   > 15000) return(false);   // If the f_call is outside the parameters > return(false)
   return(true);                                             // Otherwise > return(true)
  }

El siguiente paso en el proceso es crear una función capaz de generar los inputs y outputs de formación. Los inputs, en este caso, se generarán creando números aleatorios dentro de un intervalo específico para cada uno de los siete valores de input. A continuación, se usará la función isItASchnick() de arriba en los conjuntos de inputs generados para generar el output deseado correspondiente. Esto se puede hacer con la función de abajo:

//+------------------------------------------------------------------+
//| This function takes an empty double array and an empty boolean array,
//| and generates the inputs/outputs to be used for training the SVM
//+------------------------------------------------------------------+ 
void genTrainingData(double &inputs[],bool &outputs[],int N)
  {
   double in[];                    // Creates an empty double array to be used for temporarily storing the inputs generated
   ArrayResize(in,N_Inputs);       // Resize the in[] array to N_Inputs
   ArrayResize(inputs,N*N_Inputs); // Resize the inputs[] array to have a size of N*N_Inputs 
   ArrayResize(outputs,N);         // Resize the outputs[] array to have a size of N 
   for(int i=0;i<N;i++)
     {
      in[0]=    randBetween(980,1120);      // Random input generated for height
      in[1]=    randBetween(38,52);         // Random input generated for weight
      in[2]=    randBetween(7,11);          // Random input generated for N_legs
      in[3]=    randBetween(3,4.2);         // Random input generated for N_eyes
      in[4]=    randBetween(380,450);       // Random input generated for L_arms
      in[5]=    randBetween(2,2.6);         // Random input generated for av_speed
      in[6]=    randBetween(10500,15500);   // Random input generated for f_call
      ArrayCopy(inputs,in,i*N_Inputs,0,N_Inputs);                         // Copy the new random inputs generated into the training input array
      outputs[i]=isItASchnick(in[0],in[1],in[2],in[3],in[4],in[5],in[6]); // Assess the random inputs and determine if it is a schnick
     }
  }
//+------------------------------------------------------------------+
//| This function is used to create a random value between t1 and t2
//+------------------------------------------------------------------+ 
double randBetween(double t1,double t2)
  {
   return((t2-t1)*((double)MathRand()/(double)32767)+t1);
  }

Ahora tenemos un conjunto de inputs y outputs de formación. Es hora de crear nuestras máquinas de vectores de soporte usando la "Herramienta de Aprendizaje de Máquina de Vectores de Soporte" disponible en Mercado. Una vez que se crea una máquina de vectores de soporte, es necesario pasar los inputs y outputs de formación a ella y ejecutar la formación.

void OnStart()
  {
   double inputs[];              // Empty double array to be used for creating training inputs
   bool   outputs[];             // Empty bool array to be used for creating training inputs
   int    N_TrainingPoints=5000; // Defines the number of training samples to be generated
   int    N_TestPoints=5000;     // Defines the number of samples to be used when testing

   genTrainingData(inputs,outputs,N_TrainingPoints); //Generates the inputs and outputs to be used for training the SVM

   int handle1=initSVMachine();             // Initializes a new support vector machine and returns a handle
   setInputs(handle1,inputs,7);             // Passes the inputs (without errors) to the support vector machine
   setOutputs(handle1,outputs);             // Passes the outputs (without errors) to the support vector machine
   setParameter(handle1,OP_TOLERANCE,0.05); // Sets the error tolerance parameter to <5%
   training(handle1);                       // Trains the support vector machine using the inputs/outputs passed
  }

Ahora tenemos una máquina de vectores de soporte que se ha formado con éxito para identificar schnicks. Para verificar esto, podemos poner a prueba la máquina de vectores de soporte final pidiéndole que clasifique nuevos datos. Esto se hace generando primero inputs aleatorios, y después usando la función isItASchnick() para determinar si estos inputs se corresponden con un schnick real. Después usaremos la máquina de vectores de soporte para clasificar los inputs y determinar si el resultado previsto se corresponde con el resultado real. Esto se puede hacer con la función de abajo:

//+------------------------------------------------------------------+
//| This function takes the handle for the trained SVM and tests how
//| successful it is at classifying new random inputs
//+------------------------------------------------------------------+ 
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);      // Random input generated for height
      in[1]=    randBetween(38,52);         // Random input generated for weight
      in[2]=    randBetween(7,11);          // Random input generated for N_legs
      in[3]=    randBetween(3,4.2);         // Random input generated for N_eyes
      in[4]=    randBetween(380,450);       // Random input generated for L_arms
      in[5]=    randBetween(2,2.6);         // Random input generated for av_speed
      in[6]=    randBetween(10500,15500);   // Random input generated for f_call
      Actual_Output=isItASchnick(in[0],in[1],in[2],in[3],in[4],in[5],in[6]); // Uses the isItASchnick fcn to determine the actual desired output
      Predicted_Output=classify(handle,in);                                  // Uses the trained SVM to return the predicted output.
      if(Actual_Output==Predicted_Output)
        {
         N_correct++;   // This statement keeps count of the number of times the predicted output is correct.
        }
     }

   return(100*((double)N_correct/(double)N));   // Returns the accuracy of the trained SVM as a percentage
  }

Recomiendo jugar con los valores dentro de las funciones de arriba para ver cómo la máquina de vectores de soporte funciona en diferentes condiciones.

¿Por qué es una máquina de vectores de soporte tan útil?

El beneficio de usar una máquina de vectores de soporte para extraer patrones complejos de los datos es que no se necesita un entendimiento previo del comportamiento de los datos. Una máquina de vectores de soporte es capaz de analizar datos y extraer sus ideas y relaciones. De esta forma, funciona de forma similar a una caja negra que recibe inputs y genera outputs que puede resultar muy útil para encontrar patrones en los datos que no son demasiado complejos ni obvios.

Una de las mejores prestaciones de las máquinas de vectores de soporte es que son capaces de trabajar muy bien con errores y ruido en los datos. A menudo son capaces de ver el patrón subyacente dentro de los datos y filtrar los outliers (ivalores atípicos) y otras complejidades innecesarias. Imagínese el siguiente escenario: al realizar su investigación sobre schnicks, se encuentra con muchos informes que describen a los schnicks con características masivamente diferentes (por ejemplo, un schnick que pesa 200 kg y mide 15.000 mm de altura).

Este tipo de errores pueden llevar a una distorsión de su modelo de lo que es un schnick, lo que podría potencialmente conducir a errores a la hora de clasificar nuevos descubrimientos sobre schnicks. La ventaja de una máquina de vectores de soporte es que desarrollará un modelo que se corresponderá con el patrón subyacente, a diferencia de un modelo que se adapte a todos los datos. Esto se consigue permitiendo un cierto margen de error en el modelo para permitir a la máquina de vectores de soporte que se salte cualquier error en los datos.

En el caso de la máquina de vectores de soporte del schnick, si permitimos una tolerancia de error del 5%, entonces la formación solo tratará de formar un modelo que esté de acuerdo con el 95% de los datos de formación. Esto puede ser útil porque permite que la formación ignore el pequeño porcentaje de outliers.

Podemos investigar esta propiedad de la máquina de vectores de soporte más a fondo modificando nuestro script del schnick. La función de abajo se ha añadido para introducir errores aleatorios deliberados en nuestro conjunto de datos de formación. Esta función seleccionará puntos de formación aleatoriamente y sustituirá los inputs y su output correspondiente con variables aleatorias.

//+------------------------------------------------------------------+
//| This function takes the correct training inputs and outputs generated
//| and inserts N random errors into the data
//+------------------------------------------------------------------+ 
void insertRandomErrors(double &inputs[],bool &outputs[],int N)
  {
   int    nTrainingPoints=ArraySize(outputs); // Calculates the number of training points
   int    index;                              // Creates new integer 'index'
   bool   randomOutput;                       // Creates new bool 'randomOutput'
   double in[];                               // Creates an empty double array to be used for temporarily storing the inputs generated
   ArrayResize(in,N_Inputs);                  // Resize the in[] array to N_Inputs
   for(int i=0;i<N;i++)
     {
      in[0]=    randBetween(980,1120);        // Random input generated for height
      in[1]=    randBetween(38,52);           // Random input generated for weight
      in[2]=    randBetween(7,11);            // Random input generated for N_legs
      in[3]=    randBetween(3,4.2);           // Random input generated for N_eyes
      in[4]=    randBetween(380,450);         // Random input generated for L_arms
      in[5]=    randBetween(2,2.6);           // Random input generated for av_speed
      in[6]=    randBetween(10500,15500);     // Random input generated for f_call

      index=(int)MathRound(randBetween(0,nTrainingPoints-1)); // Randomly chooses one of the training inputs to insert an error
      if(randBetween(0,1)>0.5) randomOutput=true;             // Generates a random boolean output to be used to create an error
      else                     randomOutput=false;

      ArrayCopy(inputs,in,index*N_Inputs,0,N_Inputs);         // Copy the new random inputs generated into the training input array
      outputs[index]=randomOutput;                            // Copy the new random output generated into the training output array
     }
  }

Esta función nos permite introducir errores deliberados en nuestros datos de formación. Usando estos datos llenos de errores, podemos crear y formar una nueva máquina de vectores de soporte y comparar su rendimiento con la original.

void OnStart()
  {
   double inputs[];              // Empty double array to be used for creating training inputs
   bool   outputs[];             // Empty bool array to be used for creating training inputs
   int    N_TrainingPoints=5000; // Defines the number of training samples to be generated
   int    N_TestPoints=5000;     // Defines the number of samples to be used when testing

   genTrainingData(inputs,outputs,N_TrainingPoints); // Generates the inputs and outputs to be used for training the svm

   int handle1=initSVMachine();             // Initializes a new support vector machine and returns a handle
   setInputs(handle1,inputs,7);             // Passes the inputs (without errors) to the support vector machine
   setOutputs(handle1,outputs);             // Passes the outputs (without errors) to the support vector machine
   setParameter(handle1,OP_TOLERANCE,0.05); // Sets the error tolerance parameter to <5%
   training(handle1);                       // Trains the support vector machine using the inputs/outputs passed

   insertRandomErrors(inputs,outputs,500);  // Takes the original inputs/outputs generated and adds random errors to the data

   int handle2=initSVMachine();             // Initializes a new support vector machine and returns a handle
   setInputs(handle2,inputs,7);             // Passes the inputs (with errors) to the support vector machine
   setOutputs(handle2,outputs);             // Passes the outputs (with errors) to the support vector machine
   setParameter(handle2,OP_TOLERANCE,0.05); // Sets the error tolerance parameter to <5%
   training(handle2);                       // Trains the support vector machine using the inputs/outputs passed

   double t1=testSVM(handle1,N_TestPoints); // Tests the accuracy of the trained support vector machine and saves it to t1
   double t2=testSVM(handle2,N_TestPoints); // Tests the accuracy of the trained support vector machine and saves it to t2

   Print("The SVM accuracy is ",NormalizeDouble(t1,2),"% (using training inputs/outputs without errors)");
   Print("The SVM accuracy is ",NormalizeDouble(t2,2),"% (using training inputs/outputs with errors)");
   deinitSVMachine();                       // Cleans up all of the memory used in generating the SVM to avoid memory leak
  }

Cuando ejecutamos el script, produce los siguientes resultados en el registro (log) del Asesor Experto. En un conjunto de datos de formación con 5000 datos, pudimos introducir 500 errores aleatorios. Al comparar el rendimiento de esta máquina de vectores de soporte llena de errores con la original, solo disminuye en un <1%. Esto es así porque la máquina de vectores de soporte es capaz de pasar por alto los outliers en el conjunto de datos durante la formación, y es aún así capaz de producir un modelo increíblemente preciso de los datos verdaderos. Esto implica que las máquinas de vectores de soporte podrían ser una herramienta muy útil para extraer patrones e ideas complejas de conjuntos de datos ruidosos.

Figura 5. Los resultados en el registro del Asesor Experto tras la ejecución del script "Schnick" en MetaTrader 5.

Versiones de Prueba

Puede descargarse una versión completa del código de arriba de Code Base. No obstante, este script solo se puede ejecutar en su terminal si ha comprado una versión completa de la Herramienta de Aprendizaje de Máquina de Vectores de Soporte de Market. Si solo tiene una versión de prueba de esta herramienta, estará limitado a usarla a través del Probador de Estrategias. Para permitir la simulación del código del "schnick" usando la versión de prueba de la herramienta he reescrito una copia del script en un Asesor Experto que se puede ejecutar usando el Probador de Estrategias. Ambas versiones del código se pueden descargar siguiendo los siguientes enlaces:

• Versión Completa - Usando un script que se ejecuta en el terminal de MetaTrader 5 (requiere una versión comprada de la Herramienta de Aprendizaje de Máquina de Vectores de Soporte)

• Versión de Prueba- Usando un Asesor Experto que se ejecuta en el Probador de Estrategias de MetaTrader 5 (requiere solo una versión de prueba de la Herramienta de Aprendizaje de Máquina de Vectores de Soporte)

¿Cómo se pueden usar las Máquinas de Vectores de Soporte en el mercado?

Debemos admitir que el ejemplo del schnick expuesto arriba es bastante sencillo. Sin embargo, hay bastantes similitudes entre este ejemplo y el uso de las máquinas de vectores de soporte para análisis técnicos de mercado.

El análisis técnico trata fundamentalmente de usar datos de mercado históricos para predecir futuros movimientos de precios. Al igual que en ejemplo del schnick: intentábamos usar las observaciones hechas por científicos anteriores para predecir si un animal era un schnick o no. Además, el mercado está plagado de ruido, errores y outliers estadísticos que hacen el uso de una máquina de vectores de soporte una opción interesante.

La base para un número significativo de enfoques de trading de análisis técnico incluye los siguientes pasos:

1. Monitorizar varios indicadores
2. Identificar qué condiciones para cada indicador se corresponden con una operación de trading potencialmente fructífera
3. Observar cada uno de los indicadores y estudiar cuándo todos ellos (o la mayoría de ellos) señalan a una operación de trading

Es posible adoptar un enfoque similar para usar máquinas de vectores de soporte para señalar nuevas operaciones de trading de forma similar. La Herramienta de Aprendizaje de Máquina de Vectores de Soporte de desarrolló con esta idea. Puede encontrar una descripción completa sobre cómo se usa esta herramienta en Mercado, de modo que aquí solo daré un resumen. El proceso para usar esta herramienta es tal y como se muestra a continuación:

Figura 6. El diagrama de bloque que muestra el proceso para la implementación de la herramienta de la máquina de vectores de soporte en un Asesor Experto.

Antes de que pueda usar la Herramienta de Aprendizaje de Máquina de Vectores de Soporte, es importante entender primero cómo se generan los inputs y outputs de formación.

¿Cómo se generan los inputs de formación?

Ya se han inicializado los indicadores que usted desea usar como inputs, así como su nueva máquina de vectores de soporte. El siguiente paso es pasar los identificadores del indicador a su nueva máquina de vectores de soporte e instruirla sobre cómo generar los datos de formación. Esto se hace llamando a la función setIndicatorHandles(). Esta función le permite pasar los indicadores de indicadores inicializados a la máquina de vectores de soporte. Esto se hace pasando un array íntegro que contiene los identificadores. Los otros dos inputs para esta función son el valor de offset y el número de datos.

El valor de offset indica el offset entre la barra actual y la barra iniciadora que se usa al generar los inputs de formación, y el número de puntos de formación (indicado por N) configura el tamaño de sus datos de formación. El diagrama de abajo ilustra cómo usar estos valores. Un valor de offset de 4 y un valor N de 6 harán que la máquina de vectores de soporte solo use las barras capturadas en el cuadro blanco para generar inputs y outputs de formación. Del mismo modo, un valor de offset de 8 y un valor N de 8 harán que la máquina de vectores de soporte solo use las barras capturadas en el cuadro azul para generar inputs y outputs de formación.

Una vez que se ha llamado a la función setIndicatorHandles(), es posible llamar a la función genInputs(). Esta función usará los identificadores del indicador para generar un array de datos de entrada que usarán para la formación.

Figura 7. Gráfico de velas que ilustra los valores de Offset y N.

¿Cómo se generan outputs de formación?

Los outputs de formación se generan simulando operaciones de trading hipotéticas basadas en datos de precio históricos y determinando si tal operación habría tenido éxito o no. Para ello, hay varios parámetros que se usan para instruir a la Herramienta de Aprendizaje de Máquina de Vectores de Soporte sobre cómo determinar si una operación de trading hipotética tiene éxito o no.

La primera variable es OP_TRADE. El valor de esta puede ser BUY (compra) o SELL (venta), y se corresponderá con operaciones de trading de compra o venta hipotéticas. Si su valor es BUY, entonces, al generar los outputs, solo se basará en el potencial éxito de operaciones de trading de compra hipotéticas. Alternativamente, si su valor es SELL, entonces, al generar los outputs, solo se basará en el potencial éxito de operaciones de trading de venta hipotéticas.

El siguiente valor que se usa en estas operaciones de trading hipotéticas es el Stop Loss y el Take Profit. Los valores se establecen en pips, y pondrán los niveles de stop y limit para cada una de las operaciones de trading hipotéticas.

El parámetro final es la duración de la operación de trading. Esta variable se mide en horas, y asegurará que solo las operaciones de trading que se completen con esta duración máxima se consideren exitosas. La razón para incluir esta variable es evitar que la máquina de vectores de soporte señale operaciones de trading en un mercado lateral de movimiento lento.

Cosas a tener en cuenta al elegir inputs

Es importante pensar bien sobre la selección de inputs al implementar máquinas de vectores de soporte en su proceso de trading. De forma similar al ejemplo del schnick, es importante elegir un input que se espera que tenga incidencias de diferencia cruzada similares. Por ejemplo, puede que se sienta tentado a usar una media móvil como input, pero puesto que el precio medio a largo plazo tiende a cambiar de forma bastante dramática con el tiempo, una media móvil aislada podría no ser el mejor input. Esto es así porque no habrá ninguna similitud significativa entre el valor de la media móvil hoy y el valor de la media móvil hace seis meses.

Supongamos que estamos operando con EURUSD y usando una máquina de vectores de soporte con un input de media móvil que señale operaciones de trading de compra. Digamos que el precio actual es 1,10, pero está generando datos de formación de hace seis meses, cuando el precio era 0,55. Al formar la máquina de vectores de soporte, el patrón que se encuentra podría llevar solo a señalar una operación de trading cuando el precio está cerca de 0,55, puesto que este es el único dato que conoce. Por tanto, su máquina de vectores de soporte podría no llegar a señalar en ningún momento una operación hasta que el precio vuelva a bajar hasta 0,55.

En lugar de ello, un input mejor para su máquina de vectores de soporte podría ser un MACD o un oscilador similar, puesto que el valor de MACD es independiente del nivel de precio medio y solo señala movimiento relativo. Yo le recomiendo que experimente con esto para ver qué le reporta mejores resultados.

Otra acción importante a la hora de elegir inputs es asegurar que la máquina de vectores de soporte tiene una imagen adecuada de un indicador para señalar una nueva operación de trading. Puede que descubra en su propia experiencia de trading que un MACD solo resulta útil cuando dispone de las últimas cinco barras para observar, ya que así se reconocerá una tendencia. Una sola barra del MACD podría resultar inútil, a no ser que usted mismo pueda ver si va hacia arriba o hacia abajo. Por tanto, puede que sea necesario pasar las últimas barras del indicador MACD a la máquina de vectores de soporte. Hay dos posibles formas de hacer esto:

1. puede crear un indicador personalizado nuevo que use las cinco barras pasadas del indicador MACD para calcular una tendencia como un valor único. Este indicador personalizado se puede pasar después a la máquina de vectores de soporte como un input único, o

2. puede usar las cinco barras anteriores del indicador MACD en la máquina de vectores de soporte como cinco inputs separados. La forma para hacer esto es inicializar cinco instancias separadas del indicador MACD. Cada uno de los indicadores se puede inicializar con un offset diferente de la barra actual. A continuación, los cinco identificadores de los indicadores separados se pueden pasar a la máquina de vectores de soporte. Se debería señalar que la segunda opción suele conllevar tiempos más prolongados de ejecución para su Asesor Experto. Cuantos más inputs tenga, más tiempo le llevará una formación exitosa.

Implementar las máquinas de vectores de soporte en un Asesor Experto

He preparado un Asesor Experto que es un ejemplo de cómo alguien podría potencialmente usar máquinas de vectores de soporte en sus propias operaciones de trading (se puede descargar una copia siguiendo este enlace: https://www.mql5.com/es/code/1229). Espero que el Asesor Experto le permita experimentar un poco con máquinas de vectores de soporte. Le recomiendo copiarse/cambiar/modificar el Asesor Experto para adaptarlo a su propio estilo de trading. El EA funciona de la siguiente manera:

1. Se crean dos nuevas máquinas de vectores de soporte usando la biblioteca svMachineTool. Una se configura para señalar nuevas operaciones de trading de compra, y la otra se configura para señalar nuevas operaciones de trading de venta.

2. Se inicializan siete indicadores estándar con cada uno de sus identificadores guardados en un array íntegro (nota: cualquier combinación de indicadores se puede usar como inputs, solo deben ser pasados al SVM en un array íntegro único).

3. El array de identificadores de indicadores se pasa a las nuevas máquinas de vectores de soporte.

4. Usando el array de identificadores de indicadores y otros parámetros, se usan los datos de precio históricos para generar inputs y outputs precisos para utilizarse en la formación de las máquinas de vectores de soporte.

5. Una vez que se han generado los inputs y outputs, se forman ambas máquinas de vectores de soporte.

6. Las máquinas de vectores de soporte formadas se usan en el EA para señalar nuevas operaciones de trading de compra y venta. Allá donde se señale una nueva operación de trading de compra o venta, se abre la operación junto con órdenes manuales de Stop Loss y Take Profit.

La inicialización y formación de la máquina de vectores de soporte se ejecutan dentro de la función onInit(). Para su referencia, este segmento del EA svTrader se ha incluido debajo con comentarios.

#property copyright "Copyright 2011, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"

#property indicator_buffers 7

//+---------Support Vector Machine Learning Tool Functions-----------+
//| The following #import statement imports all of the support vector
//| machine learning tool functions into the EA for use. Please note, if
//| you do not import the functions here, the compiler will not let you
//| use any of the functions
//+------------------------------------------------------------------+
#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

#include <Trade\Trade.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\HistoryOrderInfo.mqh>

//+-----------------------Input Variables----------------------------+
input int            takeProfit=100;      // TakeProfit level measured in pips
input int            stopLoss=150;        // StopLoss level measured in pips
input double         hours=6;             // The maximum hypothetical trade duration for calculating training outputs.
input double         risk_exp=5;          // Maximum simultaneous order exposure to the market
input double         Tolerance_Value=0.1; // Error Tolerance value for training the SVM (default is 10%)
input int            N_DataPoints=100;    // The number of training points to generate and use.

//+---------------------Indicator Variables--------------------------+
//| Only the default indicator variables have been used here. I
//| recommend you play with these values to see if you get any 
//| better performance with your EA.                    
//+------------------------------------------------------------------+
int bears_period=13;
int bulls_period=13;
int ATR_period=13;
int mom_period=13;
int MACD_fast_period=12;
int MACD_slow_period=26;
int MACD_signal_period=9;
int Stoch_Kperiod=5;
int Stoch_Dperiod=3;
int Stoch_slowing=3;
int Force_period=13;

//+------------------Expert Advisor Variables------------------------+
int         tickets[];
bool        Opn_B,Opn_S;
datetime    New_Time;
int         handleB,handleS;
double      Vol=1;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int OnInit()
  {
   New_Time=0;
   int handles[];ArrayResize(handles,7);
//+------------------------------------------------------------------+
//| The following statements are used to initialize the indicators to be used for the support 
//| vector machine. The handles returned are stored to an int[] array. I have used standard 
//| indicators in this case however, you can also you custom indicators if desired
//+------------------------------------------------------------------+
   handles[0]=iBearsPower(Symbol(),0,bears_period);
   handles[1]=iBullsPower(Symbol(),0,bulls_period);
   handles[2]=iATR(Symbol(),0,ATR_period);
   handles[3]=iMomentum(Symbol(),0,mom_period,PRICE_TYPICAL);
   handles[4]=iMACD(Symbol(),0,MACD_fast_period,MACD_slow_period,MACD_signal_period,PRICE_TYPICAL);
   handles[5]=iStochastic(Symbol(),0,Stoch_Kperiod,Stoch_Dperiod,Stoch_slowing,MODE_SMA,STO_LOWHIGH);
   handles[6]=iForce(Symbol(),0,Force_period,MODE_SMA,VOLUME_TICK);

//----------Initialize, Setup and Training of the Buy-Signal support vector machine----------
   handleB=initSVMachine();                             // Initializes a new SVM and stores the handle to 'handleB'
   setIndicatorHandles(handleB,handles,0,N_DataPoints); // Passes the initialized indicators to the SVM with the desired offset 
                                                        // and number of data points
   setParameter(handleB,OP_TOLERANCE,Tolerance_Value);  // Sets the maximum error tolerance for SVM training
   genInputs(handleB);                                  // Generates inputs using the initialized indicators
   genOutputs(handleB,BUY,stopLoss,takeProfit,hours);   // Generates the outputs based on the desired parameters for taking hypothetical trades

//----------Initialize, Setup and Training of the Sell-Signal support vector machine----------
   handleS=initSVMachine();                             // Initializes a new SVM and stores the handle to 'handleS'
   setIndicatorHandles(handleS,handles,0,N_DataPoints); // Passes the initialized indicators to the SVM with the desired offset 
                                                        // and number of data points
   setParameter(handleS,OP_TOLERANCE,Tolerance_Value);  // Sets the maximum error tolerance for SVM training
   genInputs(handleS);                                  // Generates inputs using the initialized indicators
   genOutputs(handleS,SELL,stopLoss,takeProfit,hours);  // Generates the outputs based on the desired parameters for taking hypothetical trades
//----------
   training(handleB);   // Executes training on the Buy-Signal support vector machine
   training(handleS);   // Executes training on the Sell-Signal support vector machine   
   return(0);
  }

Trading avanzado de máquina de vectores de soporte

En la Herramienta de Aprendizaje de Máquina de Vectores de Soporte se incluyeron capacidades adicionales para los usuarios más avanzados. La herramienta les permite a los usuarios pasar sus propios datos de input y output personalizados (como en el ejemplo del schnick). Esto le permite diseñar de forma personalizada sus propios criterios para inputs y outputs de máquina de vectores de soporte, y pasar estos datos manualmente para su formación. De este modo, podrá usar máquinas de vectores de soporte en cualquier aspecto de su proceso de trading.

No solo es posible usar máquinas de vectores de soporte para señalar nuevas operaciones de trading, sino que también se pueden usar para señalar el cierre de operaciones, dinero y gestión, nuevos indicadores avanzados, etc. No obstante, para asegurarse de que no recibe errores, es importante entender cómo se deben estructurar estos inputs y outputs.

Inputs: los inputs se pasan a SVM como un array monodimensional de valores dobles. Por favor, tenga en cuenta que cualquier input que cree debe pasarse como valor doble. Booleano, íntegro, etc. todo ello debe convertirse en un valor doble antes de pasarse a la máquina de vectores de soporte. Los inputs se requieren en el siguiente formato. Por ejemplo, supongamos que estamos pasando inputs con 3 inputs x 5 datos de formación. Para conseguir esto, nuestro array doble debe tener 15 unidades de longitud en el formato:

| A¹ | B¹ | C¹ | A² | B² | C² | A³ | B³ | C³ | A⁴ | B⁴ | C⁴ | A⁵ | B⁵ | C⁵ |

También es necesario pasar un valor para el número de inputs. En este caso, N_Inputs=3.

Outputs: los outputs se pasan como un array de valores booleanos. Estos valores booleanos son el output deseado del SVM correspondiente con cada uno de los conjuntos de inputs pasados. Siguiendo el ejemplo de arriba, digamos que tenemos 5 puntos de formación. En este caso, pasaremos un array booleano de valores de output que tendrá 5 unidades de longitud.

Notas generales:

• Al generar sus propios inputs y outputs, asegúrese de que la longitud de sus arrays coincide con los valores que pasan. Si no coinciden, se generará un error, notificándole la discrepancia. Por ejemplo, si hemos pasado N_Inputs=3, y los inputs son un array de longitud 16, aparecerá un error (puesto que un valor de 3 de N_inputs significará que la longitud de cualquier array de inputs deberá ser múltiplo de 3). Igualmente, asegúrese de que el número de conjuntos de inputs y el número de outputs que pasa es igual. De nuevo, si tiene N_Inputs=3, una longitud de inputs de 15 y una longitud de outputs de 6, aparecerá otro error (puesto que tiene 5 conjuntos de inputs y 6 outputs).

• Asegúrese de que tiene variación suficiente en sus outputs de formación. Por ejemplo, si pasa 100 puntos de formación, lo que significa que tendrá un array de output de longitud 100, y todos los valores son falsos excepto uno, entonces la diferenciación entre el caso verdadero y el caso falso no es suficiente. Esto llevará generalmente a una formación muy rápida del SVM, pero la solución final será muy pobre. Un conjunto de formación más diverso llevará a menudo a un SVM más efectivo.