Apprendimento automatico: Come le macchine a vettori di supporto possono essere utilizzate nel trading

Che cos'è una macchina a vettori di supporto?

Una macchina a vettori di supporto è un metodo di apprendimento automatico che tenta di prendere i dati di input e classificarli in una di due categorie. Affinché una macchina a vettori di supporto sia efficace, è necessario prima utilizzare un set di dati di input e output di addestramento per creare il modello di macchina a vettori di supporto che può essere utilizzato per classificare nuovi dati.

Una macchina a vettori di supporto sviluppa questo modello prendendo gli input di addestramento, mappandoli nello spazio multidimensionale, quindi usando la regressione per trovare un iperpiano (un iperpiano è una superficie nello spazio n-dimensionale che separa lo spazio in due semi spazi) che separi al meglio le due classi di input. Una volta che la macchina a vettori di supporto è stata addestrata, è in grado di valutare nuovi input rispetto all'iperpiano di separazione e classificarlo in una delle due categorie.

Una macchina a vettori di supporto è essenzialmente una macchina di input / output. Un utente è in grado di inserire un input e, in base al modello sviluppato attraverso l’addestramento, restituirà un output. Il numero di ingressi per una data macchina a vettori di supporto varia teoricamente da uno all'infinito, tuttavia in termini pratici la potenza di calcolo limita il numero di ingressi che possono essere utilizzati. Se, ad esempio, N input vengono utilizzati per una particolare macchina a vettori di supporto (il valore intero di N può variare da uno a infinito), la macchina a vettori di supporto deve mappare ogni set di input nello spazio N-dimensionale e trovare un iperpiano (N-1) dimensionale che separi al meglio i dati di addestramento.

Figura 1. Le macchine a vettori di supporto sono macchine di input / output

Il modo migliore per concettualizzare come funziona una macchina a vettori di supporto è considerare il caso bidimensionale. Supponiamo di voler creare una macchina a vettori di supporto che abbia due input e restituisca un singolo output che classifichi il punto dati come appartenente a una delle due categorie. Possiamo visualizzarlo tracciandolo su un grafico a 2 dimensioni come il grafico sottostante.

Figura 2. Sinistra: Gli input della macchina a vettori di supporto mappati su un grafico 2D. I cerchi rossi e le croci blu sono usati per indicare le due classi di input.

Figura 3. Destra: Gli input della macchina a vettori di supporto mappati su un grafico 2D. I cerchi rossi e le croci blu sono usati per indicare le due classi di ingressi con una linea nera che indica l'iperpiano di separazione.

In questo esempio, le croci blu indicano i punti dati che appartengono alla categoria 1 e i cerchi rossi che rappresentano i punti dati che appartengono alla categoria 2. Ciascuno dei singoli punti dati ha un valore di input 1 univoco (rappresentato dalla loro posizione sull'asse x) e un valore di input 2 univoco (rappresentato dalla loro posizione sull'asse y) e tutti questi punti sono stati mappati nello spazio bidimensionale.

Una macchina a vettori di supporto è in grado di classificare i dati creando un modello di questi punti nello spazio a 2 dimensioni. La macchina a vettori di supporto osserva i dati nello spazio bidimensionale e utilizza un algoritmo di regressione per trovare un iperpiano monodimensione (altrimenti detto linea) che separa il più accuratamente possibile i dati nelle sue due categorie. Questa linea di separazione viene quindi utilizzata dalla macchina a vettori di supporto per classificare i nuovi punti dati nella categoria 1 o nella categoria 2.

L'animazione seguente illustra il processo di addestramento di una nuova macchina a vettori di supporto. L'algoritmo inizierà facendo un'ipotesi casuale trovando un iperpiano separatore, quindi migliorerà iterativamente la precisione dell'iperpiano. Come puoi vedere l'algoritmo inizia in modo abbastanza aggressivo, ma poi rallenta quando inizia ad avvicinarsi alla soluzione desiderata.

Figura 4. Questa a nimazione mostra un addestramento per macchine a vettori di supporto. L'iperpiano converge progressivamente sulla geometria ideale per separare le due classi di dati

Dimensioni superiori

Lo scenario bidimensionale sopra presentato ci permette di visualizzare il processo di una macchina a vettori di supporto; tuttavia esso è in grado di classificare un punto dati solo utilizzando due ingressi. Cosa succede se vogliamo usare più input? Per fortuna, l'algoritmo della macchina a vettori di supporto ci consente di fare lo stesso in dimensioni superiori, anche se diventa molto più difficile da concettualizzare.

Considera questo: desideri creare una macchina a vettori di supporto che accetta 20 input e può classificare qualsiasi punto dati utilizzando questi input in categoria 1 o categoria 2. Per fare ciò, la macchina a vettori di supporto deve modellare i dati nello spazio 20-dimensionale e utilizzare un algoritmo di regressione per trovare un iperpiano a 19 dimensioni che separi i punti dati in due categorie. Questo diventa estremamente difficile da visualizzare in quanto è difficile per noi comprendere qualcosa al di sopra delle 3 dimensioni. Nonostante questo, sappi che funziona esattamente allo stesso modo in cui funziona per il caso bidimensionale.

Come funzionano le macchine a vettori di supporto? Esempio: È uno Schnick?

Immagina questo scenario ipotetico: sei un ricercatore che indaga su un animale raro trovato solo nelle profondità dell'Artico chiamato Shnicks. Data la lontananza di questi animali, solo una piccola quantità è mai stata trovata (diciamo circa 5000). Come ricercatore, sei bloccato con la domanda ... come posso identificare uno Schnick?

Tutto ciò che hai a disposizione sono i documenti di ricerca precedentemente pubblicati dalla manciata di ricercatori che ne hanno visto uno. In questi articoli di ricerca, gli autori descrivono alcune caratteristiche degli Schnick che hanno trovato, cioè altezza, peso, numero di gambe, ecc. Ma tutte queste caratteristiche variano tra i documenti di ricerca senza alcun modello distinguibile ...

Come possiamo usare questi dati per identificare un nuovo animale come uno schnick?

Una possibile soluzione al nostro problema è quella di utilizzare una macchina a vettori di supporto per identificare i modelli nei dati e creare un framework che possa essere utilizzato per classificare gli animali come schnick o non schnick. Il primo passo è creare un set di dati che possono essere utilizzati per addestrare la macchina a vettori di supporto per identificare schnicks. I dati di addestramento sono un insieme di input e output corrispondenti per la macchina a vettori di supporto per analizzare ed estrarre un modello.

Pertanto, dobbiamo decidere quali input verranno utilizzati e quanti. Teoricamente, possiamo avere tutti gli input che vogliamo, tuttavia questo può spesso portare a un allenamento lento (più input hai più tempo impiega la macchina a vettori di supporto per estrarre i modelli). Inoltre, si desidera scegliere valori di input che tenderanno ad essere relativamente coerenti tra tutti gli schnick. Ad esempio, l'altezza o il peso dell'animale sarebbero un buon esempio di input perché ci si aspetterebbe che questo sarebbe relativamente coerente tra tutti gli schnick. Tuttavia, l'età media di un animale sarebbe una scelta sbagliata di input perché ci si aspetterebbe che l'età degli animali identificati varierebbe considerevolmente.

Per questo motivo sono stati scelti i seguenti input:

• Altezza
• Peso
• Il numero di gambe
• Il numero di occhi
• La lunghezza delle braccia dell'animale
• La velocità media degli animali
• La frequenza della chiamata di accoppiamento degli animali

Con gli input scelti, possiamo iniziare a compilare i nostri dati di allenamento. I dati di addestramento efficaci per una macchina a vettori di supporto devono soddisfare determinati requisiti:

• I dati devono avere esempi di animali che sono schnicks
• I dati devono avere esempi di animali che non sono schnicks

In questo caso abbiamo i documenti di ricerca di uno scienziato che hanno identificato con successo uno schnick e elencato le loro proprietà. Pertanto possiamo leggere questi documenti di ricerca ed estrarre i dati sotto ciascuno degli input e allocare un output di vero o falso a ciascuno degli esempi. I dati di addestramento in questo caso potrebbero essere simili alla tabella seguente.

Esempi di addestramento	altezza [mm]	peso [kg]	N_legs	N_eyes	L_arm [mm]	av_speed [m/s]	f_call [Hz]	Schnick (vero/falso)
Esempio: +1.	1030	45	8	3	420	2.1	14000	TRUE
Esempio: +2.	1010	42	8	3	450	2.2	14000	TRUE
Esempio 3.	900	40	7	6	600	6	13000	FALSE
Esempio 4.	1050	43	9	4	400	2.4	12000	TRUE
Esempio 5.	700	35	2	8	320	21	13500	FALSE
Esempio 6.	1070	42	8	3	430	2.4	12000	TRUE
Esempio 7.	1100	40	8	3	430	2.1	11000	TRUE
Esempio N	...	...	...	...	...	...	...	...

Tabella 1. Tabella di esempio di osservazioni di Schnick

Una volta raccolti i dati per tutti i nostri input e output di formazione, possiamo usarli per addestrare la nostra macchina a vettori di supporto. Durante il processo di addestramento, la macchina a vettori di supporto creerà un modello in uno spazio a sette dimensioni che può essere utilizzato per ordinare ciascuno degli esempi di addestramento in vero o falso. La macchina a vettori di supporto continuerà a eseguire questa visualizzazione fino a quando non avrà un modello che rappresenti accuratamente i dati di addestramento (entro la tolleranza di errore specificata). Una volta completato l’addestramento, questo modello può essere utilizzato per classificare i nuovi punti dati come true o false.

La macchina a vettori di supporto funziona davvero?

Usando lo scenario di Schnick, ho scritto uno script che testa quanto bene una macchina a vettori di supporto possa effettivamente identificare nuovi schnick. Per fare ciò, ho utilizzato la libreria di funzioni "Support Vector Machine Learning Tool" che può essere scaricata dal Market.

Per modellare questo scenario in modo efficace, dobbiamo prima decidere quali sono le proprietà effettive di uno Schnick. Le proprietà che ho assunto in questo caso sono state elencate nella tabella seguente. Se un animale soddisfa tutti i criteri seguenti, allora è uno Schnick ...

Parametro	Gamma inferiore	Gamma superiore
altezza [mm]	1000	1100
peso [kg]	40	50
N_legs	8	10
N_eyes	3	4
L_arm [mm]	400	450
av_speed [m/s]	2	2.5
f_call [Hz]	11000	15000

Tabella 2. Riepilogo dei parametri che definiscono uno schnick

Ora che abbiamo definito il nostro Schnick, possiamo usare questa definizione per sperimentare con macchine a vettori di supporto. Il primo passo è quello di creare una funzione che sia in grado di prendere i sette input per ogni dato animale e restituire l'effettiva classificazione dell'animale come schnick o meno. Questa funzione verrà utilizzata per generare dati di addestramento per la macchina a vettori di supporto e per valutarne le prestazioni alla fine. Questo può essere fatto usando la funzione qui sotto;

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

Il passo successivo nel processo è quello di creare una funzione in grado di generare gli input e gli output di formazione. Gli input in questo caso verranno generati creando numeri casuali all'interno di un intervallo impostato per ciascuno dei sette valori di input. Quindi, per ciascuno dei set di input casuali generati, la funzione isItASchnick() di cui sopra verrà utilizzata per generare l'output desiderato corrispondente. Questo viene fatto nella funzione seguente:

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

Ora abbiamo una serie di input e output di formazione, è ora il momento di creare le nostre macchine a vettori di supporto utilizzando il "Support Vector Machine Learning Tool" disponibile sul Market. Una volta creata una nuova macchina a vettori di supporto, è necessario passare gli input e gli output di addestramento ad essa ed eseguire l'addestramento.

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
  }

Ora abbiamo una macchina a vettori di supporto che è stata addestrata con successo nell'identificazione di Scnhicks. Per verificarlo, possiamo testare la macchina a vettori di supporto finale chiedendogli di classificare nuovi punti dati. Questo viene fatto generando prima input casuali, quindi utilizzando la funzione isItASchnick() per determinare se questi input corrispondono a uno Schnick effettivo, quindi utilizzare la macchina a vettori di supporto per classificare gli input e determinare se il risultato previsto corrisponde al risultato effettivo. Questo viene fatto nella funzione seguente:

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

Consiglio di giocare con i valori all'interno delle funzioni di cui sopra per vedere come si comporta la macchina a vettori di supporto in condizioni diverse.

Perché Support Vector Machine è così utile?

Il vantaggio di utilizzare una macchina a vettori di supporto per estrarre un modello complesso dai dati è che non è necessaria una precedente comprensione del comportamento dei dati. Una macchina a vettori di supporto è in grado di analizzare i dati ed estrarre le sue uniche intuizioni e relazioni. In questo modo, funziona in modo simile a una scatola nera che riceve un input e genera un output che può rivelarsi molto utile per trovare modelli nei dati troppo complessi e non ovvi.

Una delle migliori caratteristiche delle macchine a vettori di supporto è che sono in grado di gestire molto bene errori e rumore nei dati. Sono spesso in grado di vedere il modello sottostante all'interno dei dati e filtrare i valori anomali dei dati e altre complessità. Considera il seguente scenario: nell'eseguire la tua ricerca su Schnicks, ti imbatti in più documenti di ricerca che descrivono Schnicks con caratteristiche enormemente diverse (come uno schnick che è di 200 kg ed è alto 15000 mm).

Errori come questo possono portare a distorsioni del tuo modello di ciò che è uno Schnick, che potrebbe potenzialmente farti commettere un errore quando classifichi nuove scoperte di Schnick. Il vantaggio della macchina a vettori di supporto è che svilupperà un modello che concorda con il modello sottostante anziché un modello che si adatta a tutti i punti dati di addestramento. Questo viene fatto consentendo un certo livello di errore nel modello per consentire alla macchina a vettori di supporto di trascurare eventuali errori nei dati.

Nel caso della macchina a vettori di supporto Schnick, se permettiamo una tolleranza di errore del 5%, l'addestramento cercherà solo di sviluppare un modello che concordi con il 95% dei dati di addestramento. Questo può essere utile perché consente alla formazione di ignorare la piccola percentuale di valori anomali.

Possiamo indagare ulteriormente questa proprietà della macchina a vettori di supporto modificando il nostro script Schnick. La funzione seguente è stata aggiunta per introdurre errori casuali deliberati nel nostro set di dati di allenamento. Questa funzione selezionerà i punti di allenamento a caso e sostituirà gli input e l'output corrispondente con variabili casuali.

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

Questa funzione ci consente di introdurre errori deliberati nei nostri dati di allenamento. Utilizzando questi dati pieni di errori, possiamo creare e addestrare una nuova macchina a vettori di supporto e confrontare le sue prestazioni con quella originale.

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
  }

Quando lo script viene eseguito, produce i seguenti risultati nel registro degli esperti. All'interno di un set di dati di allenamento con 5000 punti di allenamento, siamo stati in grado di introdurre 500 errori casuali. Quando si confrontano le prestazioni di questa macchina a vettori di supporto piena di errori con quella originale, le prestazioni sono ridotte solo del <1%. Questo perché la macchina a vettori di supporto è in grado di trascurare i valori anomali nel set di dati durante l'addestramento ed è comunque in grado di produrre un modello straordinariamente accurato dei dati reali. Ciò suggerisce che le macchine a vettori di supporto potrebbero potenzialmente essere uno strumento più utile per estrarre modelli complessi e approfondimenti da set di dati rumorosi.

Figura 5. Il registro degli Expert risultante dopo l'esecuzione dello script "Schnick" nel MetaTrader 5.

versioni demo

Una versione completa del codice di cui sopra può essere scaricata da Code Base, tuttavia questo script può essere eseguito nel terminale solo se è stata acquistata una versione completa dello strumento Support Vector Machine Learning dal Market. Se hai scaricato solo una versione demo di questo strumento, sarai limitato a utilizzare lo strumento tramite il tester di strategia. Per consentire il test del codice "Schnick" utilizzando la versione demo dello strumento, ho riscritto una copia dello script in un Expert Advisor che può essere distribuito utilizzando il tester di strategia. Entrambe queste versioni del codice possono essere scaricate seguendo i link seguenti:

• Versione completa - Utilizzando uno script distribuito nel terminale MetaTrader 5 (richiede una versione acquistata del Support Vector Machine Learning Tool)

• Versione demo - Utilizzando un Expert Advisor distribuito nel tester di strategia MetaTrader 5 (richiede solo una versione demo dello strumento di apprendimento automatico Support Vector)

Come possono essere utilizzate le macchine a vettori di supporto sul Market?

Certo, l'esempio di Schnick discusso sopra è abbastanza semplice, tuttavia ci sono alcune somiglianze che possono essere evidenziate tra questo esempio e l'utilizzo delle macchine a vettori di supporto per l'analisi tecnica del mercato.

L'analisi tecnica riguarda fondamentalmente l'utilizzo di dati storici di mercato per prevedere i futuri movimenti dei prezzi. Allo stesso modo all'interno dell'esempio di Schnick, stavamo usando le osservazioni fatte dagli scienziati del passato per prevedere se un nuovo animale è uno schnick o meno. Inoltre, il mercato è afflitto da rumore, errori e valori anomali statistici che rendono l'uso di una macchina a vettori di supporto un concetto interessante.

La base per un numero significativo di approcci di trading di analisi tecnica comporta i seguenti passaggi:

1. Monitoraggio di diversi indicatori
2. Identificare quali condizioni per ciascun indicatore è correlato a un trade potenzialmente di successo
3. Guarda ciascuno degli indicatori e valuta quando tutti (o la maggior parte) stanno segnalando un trade

È possibile adottare un approccio simile per utilizzare macchine a vettori di supporto per segnalare nuove operazioni in modo simile. Lo strumento di apprendimento automatico vettoriale di supporto è stato sviluppato con questo in mente. Una descrizione completa di come utilizzare questo strumento può essere trovata nel Market, quindi darò solo una rapida panoramica. Il processo per l'utilizzo di questo strumento è il seguente:

Figura 6. Il diagramma a blocchi che mostra il processo di implementazione della macchina a vettore di supporto in un Expert Advisor

Prima di poter utilizzare Support Vector Machine Learning Tool, è importante innanzitutto comprendere come vengono generati gli input e gli output di addestramento.

Come vengono generati gli input di addestramento?

Pertanto, gli indicatori che si desidera utilizzare come input sono già stati inizializzati e la nuova macchina a vettori di supporto. Il passo successivo consiste nel passare le maniglie dell'indicatore alla nuova macchina a vettori di supporto e istruirla su come generare i dati di addestramento. Questo viene eseguito chiamando la funzione setIndicatorHandles(). Questa funzione consente di passare le maniglie degli indicatori inizializzati nella macchina a vettori di supporto. Questo viene fatto passando e matrice intera contenente le maniglie. Gli altri due input per questa funzione sono il valore di offset e il numero di punti dati.

Il valore di offset indica l'offset tra la barra corrente e la barra di partenza da utilizzare per generare gli input di allenamento e il numero di punti di allenamento (indicato con N) imposta la dimensione dei dati di allenamento. Il diagramma seguente illustra come utilizzare questi valori. Un valore di offset di 4 e un valore N di 6 diranno alla macchina a vettori di supporto di utilizzare solo le barre catturate nel quadrato bianco per generare input e output di addestramento. Allo stesso modo, un valore di offset di 8 e un valore N di 8 dirà alla macchina a vettori di supporto di utilizzare solo le barre catturate nel quadrato blu per generare input e output di addestramento.

Una volta chiamata la funzione setIndicatorHandles(), è possibile chiamare la funzione genInputs(). Questa funzione utilizzerà le maniglie degli indicatori da passare per generare una matrice di dati di input da utilizzare per l'allenamento.

Figura 7. Grafico a candele che illustra i valori di Offset e N

Come vengono generati gli output di formazione?

I risultati della formazione sono generati simulando operazioni ipotetiche basate su dati storici sui prezzi e determinando se tale operazione avrebbe avuto successo o meno. Per fare ciò, ci sono alcuni parametri che vengono utilizzati per istruire lo strumento di apprendimento automatico vettoriale di supporto su come valutare un'ipotetica operazione come riuscita o non riuscita.

La prima variabile è OP_TRADE. Il valore di questo può essere COMPRA o VENDI e corrisponderà a ipotetiche operazioni di acquisto o vendita. Se il valore di questo è BUY, quando genera gli output guarderà solo al potenziale successo di ipotetiche operazioni di acquisto. In alternativa, se il valore di questo è SELL, quando genera gli output guarderà solo al potenziale successo di ipotetiche operazioni di vendita.

I prossimi valori utilizzati sono lo Stop Loss e il Take Profit per queste ipotetiche operazioni. I valori sono impostati in pip e impostano i livelli di stop e limite per ciascuna delle operazioni ipotetiche.

Il parametro finale è la durata del trade. Questa variabile è misurata in ore e garantirà che solo le negoziazioni completate entro questa durata massima saranno considerate di successo. Il motivo per includere questa variabile è quello di evitare le negoziazioni di segnalazione della macchina a vettori di supporto in un mercato laterale che si muove lentamente.

Considerazioni da fare quando si scelgono gli input

È importante riflettere sulla selezione degli input quando si implementano macchine a vettori di supporto nel trading. Simile all'esempio di Schnick, è importante scegliere un input che dovrebbe avere incidenze simili tra le differenze. Ad esempio, potresti essere tentato di utilizzare una media mobile come input, tuttavia poiché il prezzo medio a lungo termine tende a cambiare in modo abbastanza drammatico nel tempo, una media mobile isolata potrebbe non essere il miglior input da utilizzare. Questo perché non ci sarà alcuna somiglianza significativa tra il valore della media mobile oggi e i valori della media mobile sei mesi fa.

Supponiamo di negoziare EURUSD e di utilizzare una macchina a vettori di supporto con un input di media mobile per segnalare operazioni di "acquisto". Supponiamo che il prezzo corrente sia 1,10, tuttavia sta generando dati di formazione di sei mesi fa, quando il prezzo era 0,55. Quando si addestra la macchina a vettori di supporto, il modello che essa trova può portare a segnalare un'operazione solo quando il prezzo è intorno a 0,55, poiché questo è l'unico dato che conosce. Pertanto, la tua macchina a vettori di supporto potrebbe non segnalare mai uno scambio fino a quando il prezzo non scende di nuovo a 0,55.

Invece, un input migliore da utilizzare per la macchina a vettori di supporto può essere un MACD o un oscillatore simile perché il valore del MACD è indipendente dal livello medio del prezzo e segnala solo il movimento relativo. Ti consiglio di sperimentare con questo per vedere cosa produce i migliori risultati per te.

Un'altra considerazione da fare quando si scelgono gli input è assicurarsi che la macchina a vettori di supporto abbia un'istantanea adeguata di un indicatore per segnalare un nuovo trade. Potresti scoprire nella tua esperienza di trading che un MACD è utile solo quando hai le ultime cinque barre da guardare, in quanto ciò mostrerà una tendenza. Una singola barra del MACD può essere inutile in isolamento a meno che non si possa dire se si sta dirigendo verso l'alto o verso il basso. Pertanto, potrebbe essere necessario passare le ultime barre dell'indicatore MACD alla macchina a vettori di supporto. Ci sono due modi possibili per farlo:

1. È possibile creare un nuovo indicatore personalizzato che utilizza le ultime cinque barre dell'indicatore MACD per calcolare una tendenza come singolo valore. Questo indicatore personalizzato può quindi essere passato alla macchina a vettori di supporto come singolo input, oppure

2. È possibile utilizzare le cinque barre precedenti dell'indicatore MACD nella macchina a vettori di supporto come cinque ingressi separati. Il modo per farlo è inizializzare cinque diverse istanze dell'indicatore MACD. Ciascuno degli indicatori può essere inizializzato con un offset diverso dalla barra corrente. Quindi le cinque maniglie degli indicatori separati possono essere passate alla macchina a vettori di supporto. Va notato che l'opzione 2 tenderà a causare tempi di esecuzione più lunghi per il tuo Expert Advisor. Più input hai, più tempo ci vorrà per allenarti con successo.

Implementazione di macchine a vettori di supporto in ed Expert Advisor

Ho preparato un Expert Advisor che è un esempio di come qualcuno potrebbe potenzialmente utilizzare macchine a vettori di supporto nel proprio trading (una copia di questo può essere scaricata seguendo questo link https://www.mql5.com/it/code/1229). Speriamo che l'Expert Advisor ti permetta di sperimentare un po 'con le macchine a vettori di supporto. Ti consiglio di copiare / cambiare / modificare l'Expert Advisor per adattarlo al tuo stile di trading. L'EA funziona come segue:

1. Due nuove macchine a vettori di supporto vengono create utilizzando la libreria svMachineTool. Uno è impostato per segnalare nuove operazioni "Acquista" e l'altro è impostato per segnalare nuove operazioni "Vendi".

2. Sette indicatori standard vengono inizializzati con ciascuno dei loro handle memorizzati in un array intero (Nota: qualsiasi combinazione di indicatori può essere utilizzata come input, devono solo essere passati all'SVM in un singolo array intero).

3. La matrice di maniglie degli indicatori viene passata alle nuove macchine a vettori di supporto.

4. Utilizzando l’array di maniglie degli indicatori e altri parametri, i dati storici sui prezzi vengono utilizzati per generare input e output accurati da utilizzare per l'addestramento delle macchine a vettori di supporto.

5. Una volta generati tutti gli ingressi e le uscite, vengono addestrate entrambe le macchine a vettori di supporto.

6. Le macchine a vettori di supporto addestrate sono utilizzate nell'EA per segnalare nuove operazioni di "acquisto" e "vendita". Quando viene segnalato un nuovo trade 'buy' o 'sell', il trade si apre insieme agli ordini manuali Stop Loss e Take Profit.

L'inizializzazione e l'addestramento della macchina a vettori di supporto vengono eseguiti all'interno della funzione onInit(). Per riferimento, questo segmento di svTrader EA è stato incluso di seguito con note.

#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);
  }

Supporto avanzato Vector Machine Trading

Funzionalità aggiuntive sono state integrate nello strumento di apprendimento automatico vettoriale di supporto per gli utenti più avanzati là fuori. Lo strumento consente agli utenti di trasmettere i propri dati di input e output personalizzati (come nell'esempio di Schnick). Ciò consente di personalizzare i propri criteri per supportare gli input e le uscite della macchina vettoriale e di passare manualmente questi dati per addestrarlo. Questo apre l'opportunità di utilizzare macchine a vettori di supporto in qualsiasi aspetto del tuo trading.

Non solo è possibile utilizzare macchine a vettori di supporto per segnalare nuove operazioni, ma può anche essere utilizzato per segnalare la chiusura delle negoziazioni, la gestione del denaro, nuovi indicatori avanzati ecc. Tuttavia, per assicurarti di non ricevere errori, è importante capire come devono essere strutturati questi input e output.

Inputs: Gli input vengono passati a SVM come matrice unidimensionale di valori doppi. Tieni presente che qualsiasi input creato deve essere passato come valore doppio. Boolean, integer, ecc. devono essere tutti convertiti in un doppio valore prima di essere passati nella macchina a vettori di supporto. Gli input sono richiesti nel seguente modulo. Ad esempio, supponiamo di passare in input con 3 ingressi x 5 punti di allenamento. Per raggiungere questo obiettivo, il nostro doppio array deve essere lungo 15 unità nel formato:

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

È inoltre necessario passare un valore per il numero di input. Nel caso, N_Inputs=3.

Outputs: gli output vengono passati come matrice di valori booleani. Questi valori booleani sono l'output desiderato dell'SVM corrispondente a ciascuno dei set di input passati. Seguendo l'esempio sopra, supponiamo di avere 5 punti di allenamento. In questo scenario, passeremo una matrice booleana di valori di output lunga 5 unità.

Note generali:

• Quando si generano input e output propri, assicurarsi che la lunghezza degli array corrisponda ai valori passati. Se non corrispondono, verrà generato un errore che ti avvisa della discrepanza. Ad esempio, se abbiamo superato N_Inputs = 3 e input è un array di lunghezza 16, verrà generato un errore (poiché, un valore di N_inputs di 3 significherà che la lunghezza di qualsiasi array di input dovrà essere un multiplo di 3). Analogamente, assicurarsi che il numero di set di input e il numero di output passati siano uguali. Ancora una volta, se hai N_Inputs = 3, lunghezza degli ingressi di 15 e una lunghezza delle uscite di 6, verrà generato un altro errore (poiché hai 5 set di ingressi e 6 uscite).

• Cerca di assicurarti di avere abbastanza variazioni nei tuoi risultati di allenamento. Ad esempio, se si passano 100 punti di addestramento, il che significa una matrice di output di lunghezza 100, e tutti i valori sono falsi con un solo true, la differenziazione tra il caso vero e il caso falso non è sufficiente. Questo tenderà a portare all’addestramento SVM molto velocemente, ma la soluzione finale è molto scarsa. Un set di addestramento più diversificato porterà spesso a una SVM più affettiva.