Schnick [Support Vector Machine Learning Tool Tester] - Skript für den MetaTrader 5

Dieses Skript wurde geschrieben um einen Teil des Artikels "Machinenlernen: Wie Stützvektormaschinen im Trading verwendet werden können" der auf der MQL5 Website gepostete wurde zu bilden.

Stellen Sie sich das hypothetische Szenario vor, sie wären ein Forscher, der seltene Tiere untersucht, die nur in den Tiefe der Arktis gefunden werden und Shnicks genannt werden. Durch die große Entfernung dieser Tiere wurde nur eine handvoll jemals gefunden (sagen wir rund 5000). Als Forscher hängen Sie nun an der Frage... wie kann ich einen Schnick identifizieren?

Alles was Ihnen zur Verfügung steht, sind die Forschungspapiere die bisher von einer handvoll von Forschern, die bisher einen gesehen haben, veröffentlicht wurden.. In diesen Forschungspapieren beschreiben die Autoren bestimmte Charakteristika der Schnicks, die sie gefunden haben, d.h. Größe, Gewicht, Anzahl der Beine usw. aber alle diese Charakteristika unterscheiden sich in den Forschungspapieren durch nicht erkennbare Muster...

Wie können Sie diese Daten verwenden um ein neues Tier als Schnick zu identifizieren?

Eine mögliche Lösung für unser Problem ist die Verwendung einer Stützvektormaschine um die Muster in den Daten zu identifizieren und einen Rahmen zu erzeugen der verwendet werden kann, um Tiere entweder als Schnick oder nicht als Schnick zu klassifizieren. Der erste Schritt ist die Erstellung der Menge von Daten die für das Training der Stützvektormaschine zur Identifikation von Schnicks verwendet werden kann. Die Trainingsdaten sind eine Menge von Eingaben und passenden Ausgaben für die Stützvektormaschine um diese zu analysieren und Muster daraus zu extrahieren.

Dieses Skript versucht die Macht von Stützvektormaschinen zu demonstrieren, indem ein Klassifizierungsproblem unter Verwendung des Stützvektormaschinentools, das im MQL5 Market verfügbar ist, zu lösen. Eine vollständige Beschreibung dieses hypothetischen Problems und Skripts kann im Artikel "Maschinenlernen: Wie Stützvektormaschinen im Trading verwendet werden können" gefunden werden. Der Artikel enthält eine Komplettlösung wie man das Skript verwendet und wie dieses Problem Einblick in das Maschinenlernen zur Bewertung von Markttrends gewähren kann.

Code:

//+------------------------------------------------------------------+
//|                                                      Schnick.mq5 |
//|                        Copyright 2011, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2011, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
#property version   "1.00"
//+------------------------------------------------------------------+
//| Dieses Skript demonstriert die Fähigkeiten des Stützvektors
//|                     Machine Learning Tool
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Der folgende Befehl importiert alle Funktionen die im
//| Support Vector Machine Tool 'svMachineTool.ex5' enthalten sind
//+------------------------------------------------------------------+
#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
//--- Anzahl von Eingaben, die wir für die svm verwenden werden
int N_Inputs=7;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnStart()
  {
   double inputs[];           //leeres Array vom Typ Double zur Verwendung für Trainingseingaben
   bool   outputs[];          //leeres Array vom Typ Bool zur Verwendung für Trainingseingaben
   int N_TrainingPoints=5000; //definiert die Anzahl von Samples die generiert werden sollen
   int N_TestPoints=5000;     //definiert die Anzahl von Samples die beim Testen verwendet werden sollen

   genTrainingData(inputs,outputs,N_TrainingPoints); //generiert die Eingaben und Ausgaben die für das Training der svm verwendet werden sollen

   int handle1=initSVMachine();             //initialisiert eine neue Stützvektormaschine und gibt einen Handle zurück
   setInputs(handle1,inputs,7);             //übergibt die Eingeaben (ohne Fehler) an die Stützvektormaschine
   setOutputs(handle1,outputs);             //übergibt die Ausgaben (ohne Fehler) an die Stützvektormaschine
   setParameter(handle1,OP_TOLERANCE,0.01); //setzt den Fehlertolzeranzparamter auf <5%
   training(handle1);                       //trainiert die Stützvektormaschine unter Verwendung der übergebenen Eingaben/Ausgaben

   insertRandomErrors(inputs,outputs,500);  //nimmt die original generierten Eingaben/Ausgaben und fügt zufällige Fehler zu den Daten hinzu

   int handle2=initSVMachine();             //initialisiert eine neue Stützvektormaschine und gibt einen Handle zurück
   setInputs(handle2,inputs,7);             //gibt die Eingaben (mit Fehlern) an die Stützvektormaschine
   setOutputs(handle2,outputs);             //gibt die Ausgaben (mit Fehlern) an die Stützvektormaschine
   setParameter(handle2,OP_TOLERANCE,0.01); //setzt den Fehlertoleranzparameter auf <5%
   training(handle2);                       //trainiert die Stützvektormaschine unter Verwendung der übergebenen Eingaben/Ausgaben

   double t1=testSVM(handle1,N_TestPoints); //prüft die Genauigkeit der trainierten Stützvektormaschine und speichert sie nach t1
   double t2=testSVM(handle2,N_TestPoints); //prüft die Genauigkeit der trainierten Stützvektormaschine und speichert sie nach t2

   Print("Die Genauigkeit der SVM ist ",NormalizeDouble(t1,2),"% (unter Verwendung von Trainingsein-/ausgaben ohne Fehler)");
   Print("Die Genauigkeit der SVM ist ",NormalizeDouble(t2,2),"% (unter Verwendung von Trainingsein-/ausgaben mit Fehlern)");
   deinitSVMachine(); //Räumt den Speicher auf der beim Generieren der SVM verwendet wurde um Speicherlecks zu vermeiden
  }
//+------------------------------------------------------------------+
//| Diese Funktion nimmt die Beobachtungseigenschaften des beobachteten 
//| Tiers entgegen und gibt aufgrund der gewählten Kriterien 
//| true/false zurück, je nachdem ob es ein Schnick ist
//+------------------------------------------------------------------+
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); //wenn die Größe außerhalb des Parameters ist > (false) zurückgeben
   if(weight   < 40    || weight   > 50)    return(false); //wenn das Gewicht außerhalb des Parameters ist >(false) zurückgeb en
   if(N_legs   < 8     || N_legs   > 10)    return(false); //wenn N_Legs außerhalb der Paramter ist -> (false) zurückgeben
   if(N_eyes   < 3     || N_eyes   > 4)     return(false); //wenn N_eyes außerhalb der Parameter ist > (false) zurückgeben
   if(L_arm    < 400   || L_arm    > 450)   return(false); //wenn L_arm  außerhalb der Parameter ist > (false) zurückgeben
   if(av_speed < 2     || av_speed > 2.5)   return(false); //wenn av_speed außerhalb der Parameter ist > (false) zurückgeben
   if(f_call   < 11000 || f_call   > 15000) return(false); //wenn f_call außerhalb der Parameter ist > (false) zurückgeben
   return(true);                                           //ansonsten > (true) zurückgeben
  }
//+------------------------------------------------------------------+
//| Die Funktion nimmt ein leeres Double Array und ein leeres Boolean Array entgegen
//| und generiert die für das Training der SVM zu verwendenden Eingaben/Ausgaben
//+------------------------------------------------------------------+ 
void genTrainingData(double &inputs[],bool &outputs[],int N)
  {
   double in[];                    //erzeugt ein leeres Double Array das vewendet werden soll
                                   //zur temporären Speicherung der generierten Eingaben
   ArrayResize(in,N_Inputs);       //Größe des in[] Array auf  N_Inputs anpassen
   ArrayResize(inputs,N*N_Inputs); //Größe des inputs[] Array auf N*N_Inputs anpassen 
   ArrayResize(outputs,N);         //Größe des outputs[] Array auf N anpassen
   for(int i=0;i<N;i++)
     {
      in[0]=    randBetween(980,1120);    //Zufällige Eingabe geneiert für Größe
      in[1]=    randBetween(38,52);       //Zufällige Eingabe geneiert für Gewicht
      in[2]=    randBetween(7,11);        //Zufällige Eingabe geneiert für N_legs
      in[3]=    randBetween(3,4.2);       //Zufällige Eingabe geneiert für N_eyes
      in[4]=    randBetween(380,450);     //Zufällige Eingabe geneiert für L_arms
      in[5]=    randBetween(2,2.6);       //Zufällige Eingabe geneiert für av_speed
      in[6]=    randBetween(10500,15500); //Zufällige Eingabe geneiert für f_call

      //--- kopiere die neuen zufällig generierten Eingaben in das Trainingseingabearray
      ArrayCopy(inputs,in,i*N_Inputs,0,N_Inputs);
      //--- bewertte die zufälligen Eingaben und bestimme, ob es ein Schnick ist
      outputs[i]=isItASchnick(in[0],in[1],in[2],in[3],in[4],in[5],in[6]);
     }
  }
//+------------------------------------------------------------------+
//| Diese Funktion nimmt den Handle für die trainierte SVM entgegen und testet, wie
//| gut sie bei der Klassifizierung von neuen zufälligen Eingaben funktioniert
//+------------------------------------------------------------------+ 
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);    //Zufällige Eingabe geneiert für Größe
      in[1]=    randBetween(38,52);       //Zufällige Eingabe geneiert für Gewicht
      in[2]=    randBetween(7,11);        //Zufällige Eingabe geneiert für N_legs
      in[3]=    randBetween(3,4.2);       //Zufällige Eingabe geneiert für N_eyes
      in[4]=    randBetween(380,450);     //Zufällige Eingabe geneiert für L_arms
      in[5]=    randBetween(2,2.6);       //Zufällige Eingabe geneiert für av_speed
      in[6]=    randBetween(10500,15500); //Zufällige Eingabe geneiert für f_call

      //--- verwendet die isItASchnick Funktion um zu den aktuell notwendigen Output zu bestimmen
      Actual_Output=isItASchnick(in[0],in[1],in[2],in[3],in[4],in[5],in[6]);
      //--- verwendet die trainierte SVM um die vorausgesagte Ausgabe zurückzugeben.
      Predicted_Output=classify(handle,in);
      if(Actual_Output==Predicted_Output)
        {
         N_correct++; //Diese Anweisung speichert die Anzahl der korrekt vorausgesagten Ausgaben.
        }
     }
//--- gibt die Genauigkeit der trainierten SVM als Prozentsatz zurück
   return(100*((double)N_correct/(double)N));
  }
//+------------------------------------------------------------------+
//| Diese Funktion nimmt die korrekten generierten Trainingsein- und ausgaben entgegen, 
//| und fügt N zufällige Fehler in die Daten ein
//+------------------------------------------------------------------+ 
void insertRandomErrors(double &inputs[],bool &outputs[],int N)
  {
   int nTrainingPoints=ArraySize(outputs); //berechnet die Anzahl von Trainingspunkten
   int index;                              //erzeugt eine neue Ganzzahl 'index'
   bool randomOutput;                      //erzeugt einen neuen Boolean 'randomOutput'
   double in[];                            //erzeugt ein leeres Double Array das verwendet werden soll
                                           //zur temporären Speicherung der generierten Eingaben
   ArrayResize(in,N_Inputs);               //Größe des in[] Array auf N_Inputs ändern
   for(int i=0;i<N;i++)
     {
      in[0]=    randBetween(980,1120);    //Zufällige Eingabe geneiert für Größe
      in[1]=    randBetween(38,52);       //Zufällige Eingabe geneiert für Gewicht
      in[2]=    randBetween(7,11);        //Zufällige Eingabe geneiert für N_legs
      in[3]=    randBetween(3,4.2);       //Zufällige Eingabe geneiert für N_eyes
      in[4]=    randBetween(380,450);     //Zufällige Eingabe geneiert für L_arms
      in[5]=    randBetween(2,2.6);       //Zufällige Eingabe geneiert für av_speed
      in[6]=    randBetween(10500,15500); //Zufällige Eingabe geneiert für f_call

      //--- wählt zufällig eine der Trainingseingaen aus und fügt einen Fehler hinzu
      index=(int)MathRound(randBetween(0,nTrainingPoints-1));
      //--- generiert eine zufällige Boolean-Augabe um einen Fehler zu erzeugen
      if(randBetween(0,1)>0.5) randomOutput=true;
      else                     randomOutput=false;

      //--- kopiere die neuen zufällig generierten Eingaben in das Trainingseingabearray
      ArrayCopy(inputs,in,index*N_Inputs,0,N_Inputs);
      //--- kopiere die neu generierte zufällige Ausgabe in das Trainingsausgabearray
      outputs[index]=randomOutput;
     }
  }
//+------------------------------------------------------------------+
//| Diese Funktion wird verwendet, um einen zufälligen Wert zwischen t1 und t2 zu erzeugen
//+------------------------------------------------------------------+ 
double randBetween(double t1,double t2)
  {
   return((t2-t1)*((double)MathRand()/(double)32767)+t1);
  }
//+------------------------------------------------------------------+