सपोर्ट वेक्टर मशीन लर्निंग टूल का डेमो - मेटाट्रेडर 5 के लिए

यह स्क्रिप्ट "मशीन लर्निंग: ट्रेडिंग में सपोर्ट वेक्टर मशीन का उपयोग कैसे करें" लेख का हिस्सा है, जो MQL5 वेबसाइट पर प्रकाशित हुआ है।

यह कोड का संस्करण विशेष रूप से डेमो संस्करण के साथ उपयोग के लिए लिखा गया है, जो फ्री में उपलब्ध है MQL5 मार्केट से।

आइए एक काल्पनिक परिदृश्य की कल्पना करें, आप एक शोधकर्ता हैं जो आर्कटिक की गहराइयों में पाए जाने वाले एक दुर्लभ जानवर, जिसका नाम श्निक है, का अध्ययन कर रहे हैं। इन जानवरों की दुर्गमता के कारण, अब तक केवल कुछ ही पाए गए हैं (मान लीजिए लगभग 5000)। एक शोधकर्ता के रूप में, आपके पास यह प्रश्न है... मैं एक श्निक को कैसे पहचान सकता हूं?

आपके पास केवल उन शोध पत्रों की जानकारी है जो पहले से ही कुछ शोधकर्ताओं द्वारा प्रकाशित किए गए हैं जिन्होंने एक श्निक देखा है। इन शोध पत्रों में, लेखक उस श्निक के बारे में कुछ विशेषताओं का वर्णन करते हैं, जैसे ऊँचाई, वजन, पैरों की संख्या आदि, लेकिन इन विशेषताओं के बीच कोई स्पष्ट पैटर्न नहीं है…

हम इस डेटा का उपयोग करके एक नए जानवर को श्निक के रूप में कैसे पहचान सकते हैं?

हमारी समस्या का एक संभावित समाधान यह है कि हम एक सपोर्ट वेक्टर मशीन का उपयोग करें ताकि डेटा में पैटर्न की पहचान की जा सके और एक ढांचा बनाया जा सके जिसका उपयोग जानवरों को श्निक या नॉन-श्निक के रूप में वर्गीकृत करने के लिए किया जा सके। पहला कदम यह है कि एक डेटा सेट बनाया जाए जिसका उपयोग आपकी सपोर्ट वेक्टर मशीन को श्निक की पहचान करने के लिए प्रशिक्षित करने के लिए किया जा सके। प्रशिक्षण डेटा एक इनपुट और मेल खाते आउटपुट का सेट है जिसे सपोर्ट वेक्टर मशीन विश्लेषण और पैटर्न निकालने के लिए उपयोग करेगी।

यह स्क्रिप्ट सपोर्ट वेक्टर मशीन के उपयोग की शक्ति को वर्गीकरण शैली की समस्याओं को हल करने के लिए प्रदर्शित करने का प्रयास करती है, जो कि MQL5 मार्केट में उपलब्ध सपोर्ट वेक्टर मशीन लर्निंग टूल का उपयोग करके। इस काल्पनिक समस्या और स्क्रिप्ट का पूरा विवरण लेख "मशीन लर्निंग: ट्रेडिंग में सपोर्ट वेक्टर मशीन का उपयोग कैसे करें" में पाया जा सकता है। लेख में स्क्रिप्ट का उपयोग कैसे करें और यह समस्या मशीन लर्निंग का उपयोग करके बाजार के रुझानों का आकलन करने में कैसे अंतर्दृष्टि दे सकती है, इसका विवरण है।

कोड:

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

//+------------------------------------------------------------------+
//| यह स्क्रिप्ट सपोर्ट वेक्टर मशीन लर्निंग टूल की क्षमताओं को प्रदर्शित करती है
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| निम्नलिखित कथन सपोर्ट वेक्टर मशीन टूल 'svMachineTool.ex5' में शामिल सभी कार्यों को आयात करता है
//+------------------------------------------------------------------+
#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
//--- हम SVM के लिए उपयोग करने वाले इनपुट की संख्या
int N_Inputs=7;
//+------------------------------------------------------------------+
//| विशेषज्ञ प्रारंभिककरण कार्य                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   double inputs[];           //प्रशिक्षण इनपुट बनाने के लिए उपयोग की जाने वाली ख़ाली डबल ऐरे
   bool   outputs[];          //प्रशिक्षण इनपुट बनाने के लिए उपयोग की जाने वाली ख़ाली बूल ऐरे
   int N_TrainingPoints=5000; //प्रशिक्षण नमूनों की संख्या को परिभाषित करता है
   int N_TestPoints=5000;     //परीक्षण के लिए उपयोग किए जाने वाले नमूनों की संख्या को परिभाषित करता है

   genTrainingData(inputs,outputs,N_TrainingPoints); //SVM के लिए प्रशिक्षण के लिए उपयोग किए जाने वाले इनपुट और आउटपुट उत्पन्न करता है

   int handle1=initSVMachine();             //एक नए सपोर्ट वेक्टर मशीन को आरंभ करता है और हैंडल लौटाता है
   setInputs(handle1,inputs,7);             //सपोर्ट वेक्टर मशीन को इनपुट (बिना त्रुटियों के) देता है
   setOutputs(handle1,outputs);             //सपोर्ट वेक्टर मशीन को आउटपुट (बिना त्रुटियों के) देता है
   setParameter(handle1,OP_TOLERANCE,0.01); //त्रुटि सहिष्णुता पैरामीटर को <5% पर सेट करता है
   training(handle1);                       //प्रशिक्षण इनपुट/आउटपुट का उपयोग करके सपोर्ट वेक्टर मशीन का प्रशिक्षण

   insertRandomErrors(inputs,outputs,500);  //मूल इनपुट/आउटपुट को लेते हैं और डेटा में यादृच्छिक त्रुटियाँ जोड़ते हैं

   int handle2=initSVMachine();             //एक नए सपोर्ट वेक्टर मशीन को आरंभ करता है और हैंडल लौटाता है
   setInputs(handle2,inputs,7);             //सपोर्ट वेक्टर मशीन को इनपुट (त्रुटियों के साथ) देता है
   setOutputs(handle2,outputs);             //सपोर्ट वेक्टर मशीन को आउटपुट (त्रुटियों के साथ) देता है
   setParameter(handle2,OP_TOLERANCE,0.01); //त्रुटि सहिष्णुता पैरामीटर को <5% पर सेट करता है
   training(handle2);                       //प्रशिक्षण इनपुट/आउटपुट का उपयोग करके सपोर्ट वेक्टर मशीन का प्रशिक्षण

   double t1=testSVM(handle1,N_TestPoints); //प्रशिक्षित सपोर्ट वेक्टर मशीन की सटीकता का परीक्षण करता है और इसे t1 में सहेजता है
   double t2=testSVM(handle2,N_TestPoints); //प्रशिक्षित सपोर्ट वेक्टर मशीन की सटीकता का परीक्षण करता है और इसे t2 में सहेजता है

   Print("SVM की सटीकता है ",NormalizeDouble(t1,2),"% (बिना त्रुटियों के प्रशिक्षण इनपुट/आउटपुट का उपयोग करते हुए)");
   Print("SVM की सटीकता है ",NormalizeDouble(t2,2),"% (त्रुटियों के साथ प्रशिक्षण इनपुट/आउटपुट का उपयोग करते हुए)");
   deinitSVMachine(); //SVM का उपयोग कर सभी मेमोरी को साफ करता है ताकि मेमोरी रिसाव से बचा जा सके
   return(0);
  }
//+------------------------------------------------------------------+
//| विशेषज्ञ डिऐनिशियल कार्य                                   |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- OnDeinit() में कोई कार्य नहीं किया गया है
  }
//+------------------------------------------------------------------+
//| विशेषज्ञ टिक कार्य                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- OnTick() में कोई कार्य नहीं किया गया है   
  }
//+------------------------------------------------------------------+
//| यह कार्य अवलोकन की विशेषताओं को लेता है और हमारे द्वारा चुने गए मानदंड के आधार पर, यह
//| सही/गलत लौटाता है कि यह एक श्निक है या नहीं
//+------------------------------------------------------------------+
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); //यदि ऊँचाई मानदंड से बाहर है तो > false लौटाएँ
   if(weight   < 40    || weight   > 50)    return(false); //यदि वजन मानदंड से बाहर है तो > false लौटाएँ
   if(N_legs   < 8     || N_legs   > 10)    return(false); //यदि N_Legs मानदंड से बाहर है तो > false लौटाएँ
   if(N_eyes   < 3     || N_eyes   > 4)     return(false); //यदि N_eyes मानदंड से बाहर है तो > false लौटाएँ
   if(L_arm    < 400   || L_arm    > 450)   return(false); //यदि L_arm मानदंड से बाहर है तो > false लौटाएँ
   if(av_speed < 2     || av_speed > 2.5)   return(false); //यदि av_speed मानदंड से बाहर है तो > false लौटाएँ
   if(f_call   < 11000 || f_call   > 15000) return(false); //यदि f_call मानदंड से बाहर है तो > false लौटाएँ
   return(true);                                           //अन्यथा > true लौटाएँ
  }
//+------------------------------------------------------------------+
//| यह कार्य एक ख़ाली डबल ऐरे और ख़ाली बूल ऐरे को लेता है
//| और SVM के लिए उपयोग किए जाने वाले इनपुट/आउटपुट उत्पन्न करता है
//+------------------------------------------------------------------+ 
void genTrainingData(double &inputs[],bool &outputs[],int N)
  {
   double in[];                    //उपयोग के लिए एक ख़ाली डबल ऐरे बनाता है
                                   //अस्थायी रूप से उत्पन्न इनपुट को संग्रहीत करने के लिए
   ArrayResize(in,N_Inputs);       //in[] ऐरे को N_Inputs पर आकार बदलता है
   ArrayResize(inputs,N*N_Inputs); //inputs[] ऐरे को N*N_Inputs के आकार में बदलता है
   ArrayResize(outputs,N);         //outputs[] ऐरे को N के आकार में बदलता है
   for(int i=0;i<N;i++)
     {
      in[0]=    randBetween(980,1120);    //ऊँचाई के लिए यादृच्छिक इनपुट उत्पन्न किया गया
      in[1]=    randBetween(38,52);       //वजन के लिए यादृच्छिक इनपुट उत्पन्न किया गया
      in[2]=    randBetween(7,11);        //N_legs के लिए यादृच्छिक इनपुट उत्पन्न किया गया
      in[3]=    randBetween(3,4.2);       //N_eyes के लिए यादृच्छिक इनपुट उत्पन्न किया गया
      in[4]=    randBetween(380,450);     //L_arms के लिए यादृच्छिक इनपुट उत्पन्न किया गया
      in[5]=    randBetween(2,2.6);       //av_speed के लिए यादृच्छिक इनपुट उत्पन्न किया गया
      in[6]=    randBetween(10500,15500); //f_call के लिए यादृच्छिक इनपुट उत्पन्न किया गया

      //--- नए यादृच्छिक इनपुट को प्रशिक्षण इनपुट ऐरे में कॉपी करें
      ArrayCopy(inputs,in,i*N_Inputs,0,N_Inputs);
      //--- यादृच्छिक इनपुट का आकलन करें और निर्धारित करें कि क्या यह एक श्निक है
      outputs[i]=isItASchnick(in[0],in[1],in[2],in[3],in[4],in[5],in[6]);
   }
  }
//+------------------------------------------------------------------+
//| यह कार्य प्रशिक्षित SVM के हैंडल को लेता है और यह परीक्षण करता है कि कितनी सफलतापूर्वक
//| यह नए यादृच्छिक इनपुट को वर्गीकृत करता है
//+------------------------------------------------------------------+ 
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);    //ऊँचाई के लिए यादृच्छिक इनपुट उत्पन्न किया गया
      in[1]=    randBetween(38,52);       //वजन के लिए यादृच्छिक इनपुट उत्पन्न किया गया
      in[2]=    randBetween(7,11);        //N_legs के लिए यादृच्छिक इनपुट उत्पन्न किया गया
      in[3]=    randBetween(3,4.2);       //N_eyes के लिए यादृच्छिक इनपुट उत्पन्न किया गया
      in[4]=    randBetween(380,450);     //L_arms के लिए यादृच्छिक इनपुट उत्पन्न किया गया
      in[5]=    randBetween(2,2.6);       //av_speed के लिए यादृच्छिक इनपुट उत्पन्न किया गया
      in[6]=    randBetween(10500,15500); //f_call के लिए यादृच्छिक इनपुट उत्पन्न किया गया

      //--- isItASchnick कार्य का उपयोग करके वास्तविक वांछित आउटपुट निर्धारित करें
      Actual_Output=isItASchnick(in[0],in[1],in[2],in[3],in[4],in[5],in[6]);
      //--- प्रशिक्षित SVM का उपयोग करके पूर्वानुमानित आउटपुट प्राप्त करें।
      Predicted_Output=classify(handle,in);
      if(Actual_Output==Predicted_Output)
        {
         N_correct++; //यह कथन भविष्यवाणी की गई आउटपुट की सहीत की संख्या को गिनता है।
        }
     }
//--- प्रशिक्षित SVM की सटीकता को प्रतिशत के रूप में लौटाता है
   return(100*((double)N_correct/(double)N));
  }
//+------------------------------------------------------------------+
//| यह कार्य सही प्रशिक्षण इनपुट और आउटपुट को लेता है
//| उत्पन्न करता है और डेटा में N यादृच्छिक त्रुटियों को सम्मिलित करता है
//+------------------------------------------------------------------+ 
void insertRandomErrors(double &inputs[],bool &outputs[],int N)
  {
   int nTrainingPoints=ArraySize(outputs); //प्रशिक्षण बिन्दुओं की संख्या की गणना करता है
   int index;                              //नया पूर्णांक 'index' बनाता है
   bool randomOutput;                      //नया बूल 'randomOutput' बनाता है
   double in[];                            //उपयोग के लिए एक ख़ाली डबल ऐरे बनाता है
                                           //अस्थायी रूप से उत्पन्न इनपुट को संग्रहीत करने के लिए
   ArrayResize(in,N_Inputs);           //in[] ऐरे को N_Inputs पर आकार बदलता है
   for(int i=0;i<N;i++)
     {
      in[0]=    randBetween(980,1120);    //ऊँचाई के लिए यादृच्छिक इनपुट उत्पन्न किया गया
      in[1]=    randBetween(38,52);       //वजन के लिए यादृच्छिक इनपुट उत्पन्न किया गया
      in[2]=    randBetween(7,11);        //N_legs के लिए यादृच्छिक इनपुट उत्पन्न किया गया
      in[3]=    randBetween(3,4.2);       //N_eyes के लिए यादृच्छिक इनपुट उत्पन्न किया गया
      in[4]=    randBetween(380,450);     //L_arms के लिए यादृच्छिक इनपुट उत्पन्न किया गया
      in[5]=    randBetween(2,2.6);       //av_speed के लिए यादृच्छिक इनपुट उत्पन्न किया गया
      in[6]=    randBetween(10500,15500); //f_call के लिए यादृच्छिक इनपुट उत्पन्न किया गया

      //--- यादृच्छिक त्रुटियों को डालने के लिए प्रशिक्षण इनपुट में से एक को यादृच्छिक रूप से चुनता है
      index=(int)MathRound(randBetween(0,nTrainingPoints-1));
      //--- यादृच्छिक बूल आउटपुट उत्पन्न करने के लिए
      if(randBetween(0,1)>0.5) randomOutput=true;
      else                     randomOutput=false;

      //--- नए यादृच्छिक इनपुट को प्रशिक्षण इनपुट ऐरे में कॉपी करें
      ArrayCopy(inputs,in,index*N_Inputs,0,N_Inputs);
      //--- नए यादृच्छिक आउटपुट को प्रशिक्षण आउटपुट ऐरे में कॉपी करें
      outputs[index]=randomOutput;
     }
  }
//+------------------------------------------------------------------+
//| यह कार्य t1 और t2 के बीच एक यादृच्छिक मान बनाने के लिए उपयोग किया जाता है
//+------------------------------------------------------------------+ 
double randBetween(double t1,double t2)
  {
   return((t2-t1)*((double)MathRand()/(double)32767)+t1);
  }
//+------------------------------------------------------------------+

सपोर्ट वेक्टर मशीन लर्निंग टूल का डेमो - मेटाट्रेडर 5 के लिए

संबंधित पोस्ट