Apprentissage automatique : Comment les machines à vecteurs de support peuvent être utilisées dans le trading

Qu'est-ce qu'une machine à vecteurs de support ?

Une machine à vecteurs de support est une méthode d'apprentissage automatique qui tente de prendre des données d'entrée et de les classer dans l'une des deux catégories. Pour qu'une machine à vecteurs de support soit efficace, il est nécessaire d'utiliser d'abord un ensemble de données d'entrée et de sortie d'entraînement pour construire le modèle de machine à vecteurs de support qui peut être utilisé pour classer de nouvelles données.

Une machine à vecteurs de support développe ce modèle en prenant les entrées d'entraînement, en les mappant dans un espace multidimensionnel, puis en utilisant la régression pour trouver un hyperplane (un hyperplan est une surface dans un espace à n dimensions qui il sépare l'espace en deux demi-espaces) qui sépare le mieux les deux classes d'entrées. Une fois la machine à vecteurs de support entraînée, elle est capable d'évaluer de nouvelles entrées par rapport à l'hyperplan séparateur et de le classer dans l'une des deux catégories.

Une machine à vecteurs de support est essentiellement une machine d'entrée/sortie. Un utilisateur est en mesure d'introduire une entrée et, sur la base du modèle développé par entraînement, celui-ci renvoie une sortie. Le nombre d'entrées pour une machine à vecteurs de support donnée varie théoriquement de un à l'infini, mais en termes pratiques, la puissance de calcul limite le nombre d'entrées pouvant être utilisées. Si, par exemple, N entrées sont utilisées pour une machine à vecteurs de support particulière (la valeur entière de N peut aller de un à l'infini), la machine à vecteurs de support doit mapper chaque ensemble d'entrées dans un espace à N dimensions et trouver un (N-1 )-dimensionnel hyperplan qui sépare le mieux les données d'entraînement.

Figure 1. Les machines à vecteurs de support sont des machines d'entrée/sortie

La meilleure façon de conceptualiser le fonctionnement d'une machine à vecteurs de support est de considérer le cas bidimensionnel. Supposons que nous voulions créer une machine à vecteurs de support qui a deux entrées et renvoie une seule sortie qui classe le point de données comme appartenant à l'une des deux catégories. Nous pouvons visualiser cela en le traçant sur un graphique en 2 dimensions tel que le graphique ci-dessous.

Figure 2. Gauche : Les entrées de la machine à vecteurs de support sont représentées sur un graphique en 2D. Les cercles rouges et les croix bleues sont utilisés pour désigner les deux classes d'entrées.

Figure 3. Droite : Les entrées de la machine à vecteurs de support sont représentées sur un graphique en 2D. Les cercles rouges et les croix bleues sont utilisés pour désigner les deux classes d'entrées avec une ligne noire indiquant l'hyperplan de séparation.

Dans cet exemple, les croix bleues indiquent les points de données qui appartiennent à la catégorie 1 et les cercles rouges qui représentent les points de données qui appartiennent à la catégorie 2. Chacun des points de données individuels a une valeur d'entrée 1 unique (représentée par leur position sur l'axe des x) et une valeur d'entrée 2 unique (représentée par leur position sur l'axe des y) et tous ces points ont été mappés sur le 2 -espace dimensionnel.

Une machine à vecteurs de support est capable de classer des données en créant un modèle de ces points dans un espace à 2 dimensions. La machine à vecteur de support observe les données dans un espace à 2 dimensions et utilise un algorithme de régression pour trouver un hyperplan à 1 dimension (alias ligne) qui sépare le plus précisément les données dans ses deux catégories. Cette ligne de séparation est ensuite utilisée par la machine à vecteurs de support pour classer les nouveaux points de données dans la catégorie 1 ou la catégorie 2.

L'animation ci-dessous illustre le processus d’entraînement d'une nouvelle machine à vecteurs de support. L'algorithme commencera par faire une supposition aléatoire pour trouver un hyperplan de séparation, puis améliorera de manière itérative la précision de l'hyperplan. Comme vous pouvez le voir, l'algorithme démarre de manière assez agressive, mais ralentit ensuite à mesure qu'il commence à s'approcher de la solution des désirs.

Figure 4. Une animation montrant un entraînement de machine à vecteur de support. L'hyperplan converge progressivement vers la géométrie idéale pour séparer les deux classes de données

Dimensions supérieures

Le scénario bidimensionnel présenté ci-dessus nous permet de visualiser le processus d'une machine à vecteurs de support, cependant elle n'est capable de classer un point de données qu'à l'aide de deux entrées. Et si nous voulons utiliser plus d'entrées ? Heureusement, l'algorithme de la machine à vecteurs de support nous permet de faire la même chose dans des dimensions supérieures, bien que cela devienne beaucoup plus difficile à conceptualiser.

Considérez ceci, vous souhaitez créer une machine à vecteur de support qui prend 20 entrées et peut classer n'importe quel point de données en utilisant ces entrées dans la catégorie 1 ou la catégorie 2. Pour ce faire, la machine à vecteurs de support doit modéliser les données dans un espace à 20 dimensions et utiliser un algorithme de régression pour trouver un hyperplan à 19 dimensions qui sépare les points de données en deux catégories. Cela devient extrêmement difficile à visualiser car il est difficile pour nous de comprendre quoi que ce soit au-dessus des 3 dimensions, mais tout ce que vous devez savoir, c'est que cela fonctionne exactement de la même manière que pour le cas en 2 dimensions.

Comment fonctionnent les machines à vecteurs de support ? Exemple : Est-ce un schnick ?

Imaginez ce scénario hypothétique, vous êtes un chercheur enquêtant sur un animal rare que l'on ne trouve que dans les profondeurs de l'Arctique appelé Shnicks. Compte tenu de l'éloignement de ces animaux, seule une petite poignée a été retrouvée (disons environ 5000). En tant que chercheur, vous êtes coincé avec la question... comment puis-je identifier un Schnick ?

Tout ce que vous avez à votre disposition, ce sont les articles de recherche publiés précédemment par la poignée de chercheurs qui en ont vu un. Dans ces articles de recherche, les auteurs décrivent certaines caractéristiques des Schnicks qu'ils ont trouvés, à savoir la taille, le poids, le nombre de pattes, etc. Mais toutes ces caractéristiques varient entre les articles de recherche sans modèle discernable...

Comment pouvons-nous utiliser ces données pour identifier un nouvel animal comme un schnick ?

Une solution possible à notre problème consiste à utiliser une machine à vecteurs de support pour identifier les modèles dans les données et créer un cadre pouvant être utilisé pour classer les animaux en tant que schnick ou non. La première étape consiste à créer un ensemble de données qui peuvent être utilisées pour entraîner votre machine à vecteur de support à identifier les schnicks. Les données d'entraînement sont un ensemble d'entrées et de sorties correspondantes permettant à la machine à vecteurs de support d'analyser et d'extraire un modèle.

Par conséquent, nous devons décider quelles entrées seront utilisées et combien. Théoriquement, nous pouvons avoir autant d'entrées que nous le souhaitons, mais cela peut souvent conduire à un entraînement lent (plus vous avez d'entrées, plus il faut de temps à la machine à vecteurs de support pour extraire des motifs). En outre, vous souhaitez choisir des valeurs d'entrée qui auront tendance à être relativement cohérentes dans tous les schnicks. Par exemple, la taille ou le poids de l'animal serait un bon exemple d'entrée, car vous vous attendriez à ce que cela soit relativement cohérent pour tous les schnicks. Cependant, l'âge moyen d'un animal serait un mauvais choix d'entrée car on peut s'attendre à ce que l'âge des animaux identifiés varie considérablement.

Pour cette raison, les entrées suivantes ont été choisies :

• Hauteur
• Poids
• Le nombre de pattes
• Le nombre d’yeux
• La longueur des bras de l'animal
• La vitesse moyenne des animaux
• La fréquence de l'appel d'accouplement des animaux

Avec les entrées choisies, nous pouvons commencer à compiler nos données d'entraînement. Les données d'entraînement efficaces pour une machine à vecteurs de support doivent répondre à certaines exigences :

• Les données doivent avoir des exemples d'animaux qui sont des schnicks
• Les données doivent avoir des exemples d'animaux qui ne sont pas des schnicks

Dans ce cas, nous avons les documents de recherche de scientifiques qui ont identifié avec succès un schnick et répertorié leurs propriétés. Par conséquent, nous pouvons lire ces documents de recherche et extraire les données sous chacune des entrées et attribuer une sortie vraie ou fausse à chacun des exemples. Les données d'entraînement dans ce cas peuvent ressembler au tableau ci-dessous.

Échantillons d'entraînement	hauteur [mm]	poids (kg]	N_pattes	N_yeux	L_bras [mm]	vitesse_av [m/s]	f_appel [Hz]	Schnick (vrai/faux)
Exemple 1	1030	45	8	3	420	2.1	14000	VRAI
Exemple 2	1010	42	8	3	450	2.2	14000	VRAI
Exemple 3	900	40	7	6	600	6	13000	FAUX
Exemple 4	1050	43	9	4	400	2.4	12000	VRAI
Exemple 5	700	35	2	8	320	21	13500	FAUX
Exemple 6	1070	42	8	3	430	2.4	12000	VRAI
Exemple 7	1100	40	8	3	430	2.1	11000	VRAI
Exemple N	...	...	...	...	...	...	...	...

Tableau 1. Exemple de tableau d'observations de schnick

Une fois que nous avons rassemblé les données pour toutes nos entrées et sorties d’entraînement, nous pouvons les utiliser pour former notre machine à vecteur de support. Au cours du processus d'entraînement, la machine à vecteurs de support créera un modèle dans un espace à sept dimensions qui peut être utilisé pour trier chacun des exemples d'entraînement en vrai ou en faux. La machine à vecteurs de support continuera à le faire jusqu'à ce qu'elle dispose d'un modèle qui représente avec précision les données d'entraînement (dans la tolérance d'erreur spécifiée). Une fois l’entraînement terminé, ce modèle peut être utilisé pour classer les nouveaux points de données comme vrais ou faux.

La machine à vecteur de support fonctionne-t-elle réellement ?

En utilisant le scénario Schnick, j'ai écrit un script qui teste dans quelle mesure une machine à vecteur de support peut réellement identifier de nouveaux schnicks. Pour ce faire, j'ai utilisé la bibliothèque de fonctions de "l’outil d'apprentissage par machine à vecteur de support" téléchargeable sur le Market.

Pour modéliser efficacement ce scénario, nous devons d'abord décider quelles sont les propriétés réelles d'un Schnick. Les propriétés que j'ai supposées dans ce cas ont été répertoriées dans le tableau ci-dessous. Si un animal satisfait à tous les critères ci-dessous, alors c'est un Schnick...

Paramètre	Gamme inférieure	Gamme supérieure
hauteur [mm]	1000	1100
poids (kg]	40	50
N_pattes	8	10
N_yeux	3	4
L_bras [mm]	400	450
vitesse_av [m/s]	2	2.5
f_appel [Hz]	11000	15000

Tableau 2. Résumé des paramètres qui définissent un schnick

Maintenant que nous avons défini notre Schnick, nous pouvons utiliser cette définition pour expérimenter avec des machines à vecteurs de support. La première étape consiste à créer une fonction capable de prendre les sept entrées pour un animal donné et de renvoyer la classification réelle de l'animal en tant que schnick ou non. Cette fonction sera utilisée pour générer des données d'entraînement pour la machine à vecteurs de support ainsi que pour évaluer ses performances à la fin. Cela peut être fait en utilisant la fonction ci-dessous;

//+------------------------------------------------------------------+
//| 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)
  }

L'étape suivante du processus consiste à créer une fonction qui peut générer les entrées et sorties d’entraînement. Les entrées dans ce cas seront générées en créant des nombres aléatoires dans une plage définie pour chacune des sept valeurs d'entrée. Ensuite, pour chacun des ensembles d'entrées aléatoires générés, la fonction isItASchnick() ci-dessus sera utilisée pour générer la sortie souhaitée correspondante. Cela se fait dans la fonction ci-dessous :

//+------------------------------------------------------------------+
//| 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);
  }

Nous avons maintenant un ensemble d'entrées et de sorties d’entraînement, il est maintenant temps de créer nos machines à vecteurs de support à l'aide de ’l'outil d'apprentissage par machine à vecteur de support’ disponible sur le Market. Une fois qu'une nouvelle machine à vecteurs de support est créée, il est nécessaire de lui transmettre les entrées et les sorties d'entraînement et d'exécuter l'entraînement.

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
  }

Nous avons maintenant une machine à vecteurs de support qui a été formée avec succès à l'identification des Scnhicks. Pour le vérifier, nous pouvons tester la machine à vecteurs de support finale en lui demandant de classer de nouveaux points de données. Cela se fait en générant d'abord des entrées aléatoires, puis en utilisant la fonction isItASchnick() pour déterminer si ces entrées correspondent à un Schnick réel, puis en utilisant la machine à vecteurs de support pour classer les entrées et déterminer si le résultat prévu correspond au résultat réel. Cela se fait dans la fonction ci-dessous :

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

Je recommande de jouer avec les valeurs dans les fonctions ci-dessus pour voir comment la machine à vecteur de support fonctionne dans différentes conditions.

Pourquoi la machine à vecteurs de support est-elle si utile ?

L'avantage d'utiliser une machine à vecteurs de support pour extraire un modèle complexe des données est qu'il n'est pas nécessaire de comprendre au préalable le comportement des données. Une machine à vecteur de support est capable d'analyser les données et d'extraire ses seules informations et relations. De cette façon, il fonctionne comme une boîte noire recevant une entrée et générant une sortie qui peut s'avérer très utile pour trouver des modèles dans les données qui sont trop complexes et pas évidents.

L'une des meilleures caractéristiques des machines à vecteurs de support est qu'elles sont capables de très bien gérer les erreurs et le bruit dans les données. Ils sont souvent capables de voir le modèle sous-jacent dans les données et de filtrer les données aberrantes et autres complexités. Considérez le scénario suivant, en effectuant vos recherches sur les Schnicks, vous rencontrez plusieurs documents de recherche qui décrivent des Schnicks avec des caractéristiques extrêmement différentes (comme un schnick de 200 kg et de 15 000 mm de hauteur).

De telles erreurs peuvent entraîner des distorsions dans votre modèle de ce qu'est un Schnick, ce qui pourrait vous amener à commettre une erreur lors de la classification des nouvelles découvertes de Schnick. L'avantage de la machine à vecteurs de support est qu'elle développera un modèle qui concorde avec le modèle sous-jacent par opposition à un modèle qui s'adapte à tous les points de données d'entraînement. Ceci est fait en permettant un certain niveau d'erreur dans le modèle pour permettre à la machine à vecteurs de support d'ignorer toute erreur dans les données.

Dans le cas de la machine à vecteurs de support de Schnick, si nous autorisons une tolérance d'erreur de 5 %, l'entraînement essaiera uniquement de développer un modèle qui concorde avec 95 % des données d'entraînement. Cela peut être utile car cela permet à l’entraînement d'ignorer le faible pourcentage de valeurs aberrantes.

Nous pouvons approfondir cette propriété de la machine à vecteurs de support en modifiant notre script Schnick. La fonction ci-dessous a été ajoutée pour introduire des erreurs aléatoires délibérées dans notre ensemble de données d'entraînement. Cette fonction sélectionnera les points d'entraînement au hasard et remplacera les entrées et la sortie correspondante par des variables aléatoires.

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

Cette fonction nous permet d'introduire des erreurs délibérées dans nos données d'entraînement. En utilisant ces données remplies d'erreurs, nous pouvons créer et entraîner une nouvelle machine à vecteurs de support et comparer ses performances avec celles d'origine.

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
  }

Lorsque le script est exécuté, il produit les résultats suivants dans le journal Expert Log. Dans un ensemble de données d'entraînement avec 5000 points d'entraînement, nous avons pu introduire 500 erreurs aléatoires. Lorsque l'on compare les performances de cette machine à vecteur de support remplie d'erreurs avec celle d'origine, les performances ne sont réduites que de <1%. En effet, la machine à vecteurs de support est capable d'ignorer les valeurs aberrantes de l'ensemble de données lors de l'entraînement et est toujours capable de produire un modèle d'une précision impressionnante des données réelles. Cela suggère que les machines à vecteurs de support pourraient potentiellement être un outil plus utile pour extraire des modèles complexes et des informations à partir d'ensembles de données bruyants.

Figure 5. Le journal expert résultant suite à l'exécution du script "Schnick" dans le MetaTrader 5.

Versions de démo

Une version complète du code ci-dessus peut être téléchargée à partir de Code Base, mais ce script ne peut être exécuté sur votre terminal que si vous avez acheté une version complète de l'outil Support Vector Machine Learning sur le Market. Si vous n'avez téléchargé qu'une version démo de cet outil, vous serez limité à l'utilisation de l'outil via le testeur de stratégie. Pour permettre de tester le code "Schnick" à l'aide de la version démo de l'outil, j'ai réécrit une copie du script dans un Expert Advisor qui peut être déployé à l'aide du testeur de stratégie. Ces deux versions de code peuvent être téléchargées en suivant les liens ci-dessous :

• Version complète - Utilisation d'un script déployé dans le terminal MetaTrader 5 (nécessite une version achetée de l'outil d'apprentissage par machine à vecteur de support)

• Version de démonstration - Utilisation d'un Expert Advisor qui est déployé dans le testeur de stratégie MetaTrader 5 (nécessite uniquement une version de démonstration de l'outil d'apprentissage machine à vecteur de support)

Comment les machines à vecteurs de support peuvent-elles être utilisées sur le marché ?

Certes, l'exemple de Schnick discuté ci-dessus est assez simple, mais il existe de nombreuses similitudes qui peuvent être établies entre cet exemple et l'utilisation des machines à vecteurs de support pour l'analyse technique du marché.

L'analyse technique consiste fondamentalement à utiliser les données historiques du marché pour prédire les mouvements de prix futurs. De la même manière dans l'exemple du schnick, nous utilisions les observations faites par d'anciens scientifiques pour prédire si un nouvel animal est un schnick ou non. De plus, le marché est en proie à du bruit, des erreurs et des valeurs aberrantes statistiques qui font de l'utilisation d'une machine à vecteurs de support un concept intéressant.

La base d'un nombre important d'approches de trading d'analyse technique implique les étapes suivantes :

1. Suivi de plusieurs indicateurs
2. Identifier les conditions pour chaque indicateur en corrélation avec un trading potentiellement réussi
3. Regardez chacun des indicateurs et évaluez quand ils signalent tous (ou la plupart) un trading

Il est possible d'adopter une approche similaire pour utiliser des machines à vecteurs de support pour signaler de nouveaux trades de la même manière. L'outil d'apprentissage par machine à vecteurs de support a été développé dans cet esprit. Une description complète de l'utilisation de cet outil peut être trouvée dans le marché, je ne donnerai donc qu'un bref aperçu. Le processus d'utilisation de cet outil est le suivant :

Figure 6. Le schéma fonctionnel montrant le processus de mise en œuvre de l’outil de machine à vecteur de support dans un Expert Advisor

Avant de pouvoir utiliser l'outil d'apprentissage par machine à vecteur de support, il est important de comprendre d'abord comment les entrées et les sorties d’entrainement sont générées.

Comment sont générées les entrées d’entraînement ?

Ainsi, les indicateurs que vous souhaitez utiliser comme entrées ont déjà été initialisés ainsi que votre nouvelle machine à vecteur de support. L'étape suivante consiste à transmettre les poignées d'indicateur à votre nouvelle machine à vecteur de support et à lui indiquer comment générer les données d'entraînement. Cela se fait en appelant la fonction setIndicatorHandles(). Cette fonction permet de passer les descripteurs des indicateurs initialisés dans la machine à vecteurs de support. Cela se fait en passant un tableau d'entiers contenant les poignées. Les deux autres entrées de cette fonction sont la valeur de décalage et le nombre de points de données.

La valeur de décalage indique le décalage entre la barre actuelle et la barre de départ à utiliser pour générer les entrées d'entraînement et le nombre de points d'entraînement (indiqué par N) définit la taille de vos données d'entraînement. Le schéma ci-dessous montre comment utiliser ces valeurs. Une valeur de décalage de 4 et une valeur N de 6 indiqueront à la machine à vecteurs de support d'utiliser uniquement les barres capturées dans le carré blanc pour générer des entrées et des sorties d'entraînement. De même, une valeur de décalage de 8 et une valeur N de 8 indiqueront à la machine à vecteur de support d'utiliser uniquement les barres capturées dans le carré bleu pour générer des entrées et des sorties d'entraînement.

Une fois la fonction setIndicatorHandles() appelée, il est possible d'appeler la fonction genInputs(). Cette fonction utilisera les descripteurs d'indicateur à transmettre pour générer un tableau de données d'entrée à utiliser pour l'entraînement.

Figure 7. Graphique en bougies illustrant les valeurs de Offset et N

Comment sont générées les sorties d’entraînement ?

Les sorties d’entraînement sont générées en simulant des trades hypothétiques basées sur des données de prix historiques et en déterminant si un tel trade aurait été réussie ou non. Pour ce faire, quelques paramètres sont utilisés pour indiquer à l'outil d'apprentissage par machine à vecteur de support comment évaluer un trade hypothétique comme réussi ou non.

La première variable est OP_TRADE. La valeur de celui-ci peut être ACHAT ou VENTE et correspondra à des trades hypothétiques d'achat ou de vente. Si la valeur de ceci est BUY, alors lors de la génération des sorties, il ne considérera que le succès potentiel des trades d'achat hypothétiques. Alternativement, si la valeur de ceci est SELL, alors lors de la génération des sorties, il ne considérera que le succès potentiel des trades de vente hypothétiques.

Les prochaines valeurs utilisées sont le Stop Loss et le Take Profit pour ces trades hypothétiques. Les valeurs sont définies en pips et définiront les niveaux d'arrêt et de limite pour chacune des trades hypothétiques.

Le dernier paramètre est la durée du trade. Cette variable est mesurée en heures et garantira que seules les trades terminés dans cette durée maximale seront considérées comme réussis. La raison de l'inclusion de cette variable est d'éviter que la machine à vecteur de support signale les trades dans un marché latéral lent.

Considérations à prendre en compte lors du choix des entrées

Il est important de réfléchir à la sélection des entrées lors de la mise en œuvre de machines à vecteurs de support dans votre trading. Semblable à l'exemple de Schnick, il est important de choisir une entrée qui devrait avoir des incidences de différence similaires. Par exemple, vous pouvez être tenté d'utiliser une moyenne mobile comme entrée, mais étant donné que le prix moyen à long terme a tendance à changer considérablement au fil du temps, une moyenne mobile isolée peut ne pas être la meilleure entrée à utiliser. En effet, il n'y aura pas de similitude significative entre la valeur moyenne mobile d'aujourd'hui et les valeurs moyennes mobiles d'il y a six mois.

Supposons que nous négocions l'EURUSD et que nous utilisions une machine à vecteur de support avec une entrée de moyenne mobile pour signaler les trades ’d'achat’. Supposons que le prix actuel est de 1,10, mais qu'il génère des données d'entraînement d'il y a six mois lorsque le prix était de 0,55. Lors de l'entraînement de la machine à vecteurs de support, le modèle qu'elle trouve peut uniquement conduire à un signal de trade lorsque le prix est d'environ 0,55, car ce sont les seules données qu'il connaît. Par conséquent, votre machine à vecteur de support peut ne jamais signaler un trade jusqu'à ce que le prix retombe à 0,55.

Au lieu de cela, une meilleure entrée à utiliser pour la machine à vecteurs de support peut être un MACD ou un oscillateur similaire car la valeur du MACD est indépendante du niveau de prix moyen et signale uniquement un mouvement relatif. Je vous recommande d'expérimenter cela pour voir ce qui produit les meilleurs résultats pour vous.

Une autre considération à prendre en compte lors du choix des entrées est de s'assurer que la machine à vecteur de support a un instantané adéquat d'un indicateur pour signaler un nouveau trade. Vous constaterez peut-être dans votre propre expérience de trading qu'un MACD n'est utile que lorsque vous avez les cinq dernières barres à regarder, car cela montrera une tendance. Une seule barre du MACD peut être inutile isolément, à moins que vous ne sachiez si elle monte ou descend. Par conséquent, il peut être nécessaire de transmettre les dernières barres de l'indicateur MACD à la machine à vecteur de support. Vous pouvez procéder de deux manières :

1. Vous pouvez créer un nouvel indicateur personnalisé qui utilise les cinq dernières barres de l'indicateur MACD pour calculer une tendance en tant que valeur unique. Cet indicateur personnalisé peut ensuite être transmis à la machine à vecteurs de support en tant qu'entrée unique, ou

2. Vous pouvez utiliser les cinq barres précédentes de l'indicateur MACD dans la machine à vecteur de support comme cinq entrées distinctes. Pour ce faire, il faut initialiser cinq instances différentes de l'indicateur MACD. Chacun des indicateurs peut être initialisé avec un décalage différent de la barre actuelle. Ensuite, les cinq poignées des indicateurs séparés peuvent être transmises à la machine à vecteur de support. Il est à noter que l'option 2 aura tendance à entraîner des délais d'exécution plus longs pour votre Expert Advisor. Plus vous avez d'entrées, plus il faudra de temps pour réussir l'entraînement.

Implémentation de machines à vecteurs de support dans et Expert Advisor

J'ai préparé un Expert Advisor qui est un exemple de la façon dont quelqu'un pourrait potentiellement utiliser des machines à vecteurs de support dans son propre trading (une copie de ceci peut être téléchargée en suivant ce lien https://www.mql5.com/fr/code/1229). Espérons que l'Expert Advisor vous permettra d'expérimenter un peu avec les machines à vecteurs de support. Je vous recommande de copier/changer/modifier l'Expert Advisor en fonction de votre propre style de trading. L'EA fonctionne comme suit :

1. Deux nouvelles machines à vecteurs de support sont créées à l'aide de la bibliothèque svMachineTool. L'un est configuré pour signaler de nouveaux trades ’Acheter’ et l'autre est configuré pour signaler de nouveaux trades ’Vendre’.

2. Sept indicateurs standard sont initialisés avec chacun de leurs poignées stockées dans un tableau d'entiers (Remarque : n'importe quelle combinaison d'indicateurs peut être utilisée comme entrées, il suffit de les transmettre au SVM dans un seul tableau d'entiers).

3. Le tableau des poignées d'indicateurs est transmis aux nouvelles machines à vecteurs de support.

4. À l'aide de la gamme de poignées d'indicateur et d'autres paramètres, les données de prix historiques sont utilisées pour générer des entrées et des sorties précises à utiliser pour l'entraînement des machines à vecteur de support.

5. Une fois que toutes les entrées et sorties ont été générées, les deux machines à vecteurs de support sont entraînées.

6. Les machines à vecteurs de support entraînées sont utilisées dans l'EA pour signaler des nouveaux trades d'achat et de 'vente'. Lorsqu'un nouveau trade 'd'achat' ou de 'vente' est signalé, le trade s'ouvre avec les ordres manuels Stop Loss et Take Profit.

L'initialisation et l'entraînement de la machine à vecteurs de support sont exécutés dans la fonction onInit(). Pour votre information, ce segment de l'EA svTrader a été inclus ci-dessous avec des notes.

#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 de machines à vecteur de support avancé

Des capacités supplémentaires ont été intégrées à l'outil d'apprentissage par machine à vecteur de support pour les utilisateurs les plus avancés. L'outil permet aux utilisateurs de transmettre leurs propres données d'entrée et données de sortie personnalisées (comme dans l'exemple de Schnick). Cela vous permet de personnaliser vos propres critères de prise en charge des entrées et sorties de machines vectorielles, et de transmettre manuellement ces données pour les entraîner. Cela ouvre la possibilité d'utiliser des machines à vecteurs de support dans n'importe quel aspect de votre trading.

Il est non seulement possible d'utiliser des machines à vecteurs de support pour signaler des nouveaux trades, mais il peut également être utilisé pour signaler la fermeture des trades, la gestion de l'argent, de nouveaux indicateurs avancés, etc. Cependant, pour vous assurer de ne pas recevoir d'erreurs, il est important de comprendre comment ces entrées et sorties doivent être structurées.

Entrées : Les entrées sont transmises à SVM sous la forme d'un tableau à 1 dimension de valeurs doubles. Veuillez noter que toute entrée que vous créez doit être transmise en tant que valeur double. Booléen, entier, etc. doivent tous être convertis en valeur double avant d'être passés dans la machine à vecteurs de support. Les entrées sont requises sous la forme suivante. Par exemple, supposons que nous transmettons des entrées avec 3 entrées x 5 points d'entraînement. Pour y parvenir, notre double tableau doit avoir 15 unités de long au format :

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

Il faut également passer une valeur pour le nombre d'entrées. Dans le cas, N_Inputs=3.

Sorties : les sorties sont transmises sous la forme d'un tableau de valeurs booléennes. Ces valeurs booléennes sont la sortie souhaitée du SVM correspondant à chacun des ensembles d'entrées transmis. En suivant l'exemple ci-dessus, disons que nous avons 5 points d'entraînement. Dans ce scénario, nous transmettrons un tableau booléen de valeurs de sortie d'une longueur de 5 unités.

Remarques générales:

• Lorsque vous générez vos propres entrées et sorties, assurez-vous que la longueur de vos tableaux correspond aux valeurs que vous transmettez. S'ils ne correspondent pas, une erreur sera générée vous informant de l'écart. Par exemple, si nous avons passé N_Inputs=3, et que les entrées est un tableau de longueur 16, une erreur sera renvoyée (puisque, une valeur N_inputs de 3 signifiera que la longueur de tout tableau d'entrée devra être un multiple de 3). De même, assurez-vous que le nombre d'ensembles d'entrées et le nombre de sorties que vous transmettez sont égaux. Encore une fois, si vous avez N_Inputs=3, une longueur d'entrées de 15 et une longueur de sorties de 6, une autre erreur sera renvoyée (car vous avez 5 ensembles d'entrées et 6 sorties).

• Essayez de vous assurer que vos résultats d'entraînement varient suffisamment. Par exemple, si vous transmettez 100 points d'entraînement, ce qui signifie un tableau de sortie de longueur 100, et que toutes les valeurs sont fausses avec un seul vrai, alors la différenciation entre le cas vrai et le cas faux n'est pas suffisante. Cela aura tendance à conduire à un entraînement SVM très rapide, mais la solution finale sera très mauvaise. Un ensemble d’entraînement plus diversifié conduira souvent à un SVM plus affectif.