Schnick – Unterstützung durch maschinelles Lernen im Trading mit MetaTrader 5

Dieser Skript ist Teil des Artikels "Maschinelles Lernen: So können Support Vector Machines im Trading eingesetzt werden", der auf der MQL5-Website veröffentlicht wurde.

Diese Version des Codes wurde speziell für die Verwendung mit der Demo-Version des Support Vector Machine Learning Tools erstellt, das kostenlos im MQL5 Marktplatz erhältlich ist.

Stellen Sie sich folgendes hypothetische Szenario vor: Sie sind ein Forscher, der eine seltene Tierart namens Schnicks untersucht, die nur in den Tiefen der Arktis vorkommt. Aufgrund der Abgeschiedenheit dieser Tiere wurden nur wenige Exemplare (sagen wir etwa 5000) gefunden. Als Forscher stehen Sie vor der Frage: Wie kann ich einen Schnick identifizieren?

Alles, was Ihnen zur Verfügung steht, sind die Forschungsarbeiten, die von den wenigen Forschern veröffentlicht wurden, die einen Schnick gesehen haben. In diesen Arbeiten beschreiben die Autoren bestimmte Merkmale der gefundenen Schnicks, wie Größe, Gewicht, Anzahl der Beine usw., aber all diese Merkmale variieren stark zwischen den Forschungsarbeiten, ohne erkennbares Muster...

Wie können wir diese Daten nutzen, um ein neues Tier als Schnick zu identifizieren?

Eine mögliche Lösung für unser Problem ist die Verwendung eines Support Vector Machine (SVM), um die Muster in den Daten zu identifizieren und einen Rahmen zu schaffen, der verwendet werden kann, um Tiere als Schnick oder Nicht-Schnick zu klassifizieren. Der erste Schritt besteht darin, einen Datensatz zu erstellen, der zur Schulung Ihrer SVM verwendet werden kann, um Schnicks zu identifizieren. Die Trainingsdaten bestehen aus einer Reihe von Eingaben und den entsprechenden Ausgaben, die die SVM analysieren und aus denen sie ein Muster extrahieren kann.

Dieses Skript versucht, die Leistungsfähigkeit von Support Vector Machines bei der Lösung von Klassifikationsproblemen zu demonstrieren, indem es das Support Vector Machine Learning Tool verwendet, das im MQL5 Marktplatz erhältlich ist. Eine vollständige Beschreibung dieses hypothetischen Problems und Skripts finden Sie im Artikel "Maschinelles Lernen: So können Support Vector Machines im Trading eingesetzt werden". Der Artikel enthält eine Schritt-für-Schritt-Anleitung zur Verwendung des Skripts und wie dieses Problem Einblicke in die Verwendung von maschinellem Lernen zur Bewertung von Markttrends geben kann.

Code:

//+------------------------------------------------------------------+
//|                                                 Schnick_Demo.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 Support Vector
//|                     Machine Learning Tools
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Die folgende Anweisung importiert alle Funktionen, die im
//| Support Vector Machine Tool 'svMachineTool.ex5' enthalten sind
//+------------------------------------------------------------------+
#import "svMachineTool_demo.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
//--- Die Anzahl der Eingaben, die wir für die SVM verwenden werden
int N_Inputs=7;
//+------------------------------------------------------------------+
//| Expert-Initialisierungsfunktion                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   double inputs[];           //leeres double Array zur Erstellung von Trainingsdaten
   bool   outputs[];          //leeres bool Array zur Erstellung von Trainingsdaten
   int N_TrainingPoints=5000; //definiert die Anzahl der zu generierenden Trainingsproben
   int N_TestPoints=5000     //definiert die Anzahl der Proben zum Testen

   genTrainingData(inputs,outputs,N_TrainingPoints); //Generiert die Eingaben und Ausgaben für das Training der SVM

   int handle1=initSVMachine();             //initialisiert eine neue Support Vector Machine und gibt einen Handle zurück
   setInputs(handle1,inputs,7);             //gibt die Eingaben (ohne Fehler) an die Support Vector Machine weiter
   setOutputs(handle1,outputs);             //gibt die Ausgaben (ohne Fehler) an die Support Vector Machine weiter
   setParameter(handle1,OP_TOLERANCE,0.01); //setzt den Fehler-Toleranzparameter auf <5%
   training(handle1);                       //trainiert die Support Vector Machine mit den übergebenen Eingaben/Ausgaben

   insertRandomErrors(inputs,outputs,500);  //fügt zufällige Fehler zu den ursprünglichen Eingaben/Ausgaben hinzu

   int handle2=initSVMachine();             //initialisiert eine neue Support Vector Machine und gibt einen Handle zurück
   setInputs(handle2,inputs,7);             //gibt die Eingaben (mit Fehlern) an die Support Vector Machine weiter
   setOutputs(handle2,outputs);             //gibt die Ausgaben (mit Fehlern) an die Support Vector Machine weiter
   setParameter(handle2,OP_TOLERANCE,0.01); //setzt den Fehler-Toleranzparameter auf <5%
   training(handle2);                       //trainiert die Support Vector Machine mit den übergebenen Eingaben/Ausgaben

   double t1=testSVM(handle1,N_TestPoints); //testet die Genauigkeit der trainierten Support Vector Machine und speichert sie in t1
   double t2=testSVM(handle2,N_TestPoints); //testet die Genauigkeit der trainierten Support Vector Machine und speichert sie in t2

   Print("Die SVM-Genauigkeit beträgt ",NormalizeDouble(t1,2),"% (unter Verwendung von Trainingsdaten ohne Fehler)");
   Print("Die SVM-Genauigkeit beträgt ",NormalizeDouble(t2,2),"% (unter Verwendung von Trainingsdaten mit Fehlern)");
   deinitSVMachine(); //räumt den gesamten Speicher auf, der zur Generierung der SVM verwendet wurde, um Speicherlecks zu vermeiden
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert-Deinitialisierungsfunktion                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- Keine Funktionen in OnDeinit() ausgeführt
  }
//+------------------------------------------------------------------+
//| Expert-Tick-Funktion                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- Keine Funktionen in OnTick() ausgeführt   
  }
//+------------------------------------------------------------------+
//| Diese Funktion nimmt die Beobachtungsmerkmale des beobachteten 
//| Tieres und gibt basierend auf den gewählten Kriterien true/false zurück
//+------------------------------------------------------------------+
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 Höhe außerhalb der Parameter liegt, > return(false)
   if(weight   < 40    || weight   > 50)    return(false); //Wenn das Gewicht außerhalb der Parameter liegt, > return(false)
   if(N_legs   < 8     || N_legs   > 10)    return(false); //Wenn die N_Legs außerhalb der Parameter liegt, > return(false)
   if(N_eyes   < 3     || N_eyes   > 4)     return(false); //Wenn die N_Augen außerhalb der Parameter liegt, > return(false)
   if(L_arm   < 400   || L_arm    > 450)   return(false); //Wenn der L_arm außerhalb der Parameter liegt, > return(false)
   if(av_speed < 2     || av_speed > 2.5)   return(false); //Wenn das av_speed außerhalb der Parameter liegt, > return(false)
   if(f_call   < 11000 || f_call   > 15000) return(false); //Wenn der f_call außerhalb der Parameter liegt, > return(false)
   return(true);                                           //Andernfalls > return(true)
  }
//+------------------------------------------------------------------+
//| Diese Funktion nimmt ein leeres double Array und ein leeres bool Array
//| und generiert die Eingaben/Ausgaben, die für das Training der SVM verwendet werden
//+------------------------------------------------------------------+ 
void genTrainingData(double &inputs[],bool &outputs[],int N)
  {
   double in[];                //erstellt ein leeres double Array zur Verwendung
                                   //für vorübergehende Speicherung der generierten Eingaben
   ArrayResize(in,N_Inputs);       //passt das in[]-Array an N_Inputs an
   ArrayResize(inputs,N*N_Inputs); //passt das inputs[]-Array auf N*N_Inputs an
   ArrayResize(outputs,N);         //passt das outputs[]-Array auf N an
   for(int i=0;i<N;i++)
     {
      in[0]=    randBetween(980,1120);    //Zufällige Eingabe für die Höhe generiert
      in[1]=    randBetween(38,52);       //Zufällige Eingabe für das Gewicht generiert
      in[2]=    randBetween(7,11);        //Zufällige Eingabe für N_legs generiert
      in[3]=    randBetween(3,4.2);       //Zufällige Eingabe für N_eyes generiert
      in[4]=    randBetween(380,450);     //Zufällige Eingabe für L_arms generiert
      in[5]=    randBetween(2,2.6);       //Zufällige Eingabe für av_speed generiert
      in[6]=    randBetween(10500,15500); //Zufällige Eingabe für f_call generiert

      //--- kopiert die neuen zufälligen Eingaben in das Trainingsdaten-Array
      ArrayCopy(inputs,in,i*N_Inputs,0,N_Inputs);
      //--- bewertet die zufälligen Eingaben und bestimmt, ob es sich um einen Schnick handelt
      outputs[i]=isItASchnick(in[0],in[1],in[2],in[3],in[4],in[5],in[6]);
   }
  }
//+------------------------------------------------------------------+
//| Diese Funktion testet die Erfolgsquote der trainierten SVM bei der Klassifizierung neuer zufälliger Eingaben
//+------------------------------------------------------------------+ 
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 für die Höhe generiert
      in[1]=    randBetween(38,52);       //Zufällige Eingabe für das Gewicht generiert
      in[2]=    randBetween(7,11);        //Zufällige Eingabe für N_legs generiert
      in[3]=    randBetween(3,4.2);       //Zufällige Eingabe für N_eyes generiert
      in[4]=    randBetween(380,450);     //Zufällige Eingabe für L_arms generiert
      in[5]=    randBetween(2,2.6);       //Zufällige Eingabe für av_speed generiert
      in[6]=    randBetween(10500,15500); //Zufällige Eingabe für f_call generiert

      //--- verwendet die isItASchnick-Funktion, um die tatsächliche gewünschte Ausgabe 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 prognostizierte Ausgabe zurückzugeben.
      Predicted_Output=classify(handle,in);
      if(Actual_Output==Predicted_Output)
        {
         N_correct++; //Diese Anweisung zählt die Anzahl der Male, die die prognostizierte Ausgabe korrekt ist.
        }
     }
//--- gibt die Genauigkeit der trainierten SVM als Prozentsatz zurück
   return(100*((double)N_correct/(double)N));
  }
//+------------------------------------------------------------------+
//| Diese Funktion nimmt die korrekten Trainingsdaten und Ausgaben 
//| 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 der Trainingspunkte
   int index;                              //erstellt eine neue Ganzzahl 'index'
   bool randomOutput;                      //erstellt einen neuen bool 'randomOutput'
   double in[];                                   //erstellt ein leeres double Array zur Verwendung
   ArrayResize(in,N_Inputs);               //passt das in[]-Array auf N_Inputs an
   for(int i=0;i<N;i++)
     {
      in[0]=    randBetween(980,1120);    //Zufällige Eingabe für die Höhe generiert
      in[1]=    randBetween(38,52);       //Zufällige Eingabe für das Gewicht generiert
      in[2]=    randBetween(7,11);        //Zufällige Eingabe für N_legs generiert
      in[3]=    randBetween(3,4.2);       //Zufällige Eingabe für N_eyes generiert
      in[4]=    randBetween(380,450);     //Zufällige Eingabe für L_arms generiert
      in[5]=    randBetween(2,2.6);       //Zufällige Eingabe für av_speed generiert
      in[6]=    randBetween(10500,15500); //Zufällige Eingabe für f_call generiert

      //--- wählt zufällig einen der Trainingsinputs aus, um einen Fehler einzufügen
      index=(int)MathRound(randBetween(0,nTrainingPoints-1));
      //--- generiert eine zufällige boolesche Ausgabe zur Erstellung eines Fehlers
      if(randBetween(0,1)>0.5) randomOutput=true;
      else                     randomOutput=false;

      //--- kopiert die neuen zufälligen Eingaben in das Trainingsdaten-Array
      ArrayCopy(inputs,in,index*N_Inputs,0,N_Inputs);
      //--- kopiert die neue zufällige Ausgabe in das Trainingsdaten-Array
      outputs[index]=randomOutput;
     }
  }
//+------------------------------------------------------------------+
//| Diese Funktion wird verwendet, um einen zufälligen Wert zwischen t1 und t2 zu erstellen
//+------------------------------------------------------------------+ 
double randBetween(double t1,double t2)
  {
   return((t2-t1)*((double)MathRand()/(double)32767)+t1);
  }
//+------------------------------------------------------------------+

Schnick – Unterstützung durch maschinelles Lernen im Trading mit MetaTrader 5

Verwandte Beiträge