手工学习áquina: como as má支持向量机可用于谈判ções

2014年3月18日,14:23
乔什·雷德黑德
0
6 197

什么是支持向量机?

支持向量机(SVM)是一种机器学习方法,试图获取输入数据并将其分类为两类之一。为了使支持向量机有效,首先必须使用一组训练输入和输出数据来构建可用于对新数据进行分类的支持向量机模型。

支持向量机通过获取训练输入,在多维空间中映射它们并使用回归找到一个 超平面 (超平面是将其分为两半的n维空间表面),可以最好地分隔两类条目。一旦训练了支持向量机,就能够评估与划分超平面有关的新条目并将它们分类为两个类别之一。

支持向量机本质上是输入/输出机器。用户能够输入一个条目,并且根据通过培训开发的模型,它将返回一个出口。理论上,任何指定的支持向量机的输入数量从1到无限变化。但是,实际上,计算能力限制了可以使用的输入数量。例如,如果将N个输入用于特定的支持向量机(N的整数值可以从1到无穷大),则该机器必须在N维的空间中映射每组输入,并找到N个超平面-1个维度最能区分训练数据。

输入/输出机

图1.支持向量机是输入/输出机

概念化支持向量机功能的最佳方法是考虑二维情况。假设我们要创建一个具有两个输入的支持向量机,并返回一个将数据点分类为两个类别之一的单个输出。我们可以通过在二维图上进行如下表示来形象化这一点。

超平面分割器

图2。 剩下: 支持向量机以二维图形表示。红色圆圈和蓝色十字用于表示两类条目

图3。 对: 支持向量机以二维图形表示。红色圆圈和蓝色十字用于指示两类条目,黑色线指示分隔的超平面

在此示例中,蓝色叉号表示属于类别1的数据点,红色圆圈表示属于类别2的数据点。每个单独的数据点均具有唯一的输入值1(由其在轴上的位置表示) x)和单个输入值2​​(由其在y轴上的位置表示),所有这些点都映射在二维空间中。

支持向量机能够通过在二维空间中创建这些点的模型来对数据进行分类。支持向量机在二维空间中观察数据,并使用回归算法找到一维超平面(也称为直线),该平面可以更准确地将其两个类别之间的数据分开。然后,支持向量机使用该分界线对类别1或类别2中的新数据点进行分类。

下面的动画说明了训练新的支持向量机的过程。该算法将首先进行随机假设以找到划分的超平面,然后反复提高该超平面的精度。如您所见,该算法以一种非常烦躁的方式开始,但是随着它开始接近所需的解决方案而减慢了速度。

支持向量机回归算法寻找最优除数超平面

图4.动画,显示支持向量机训练。超平面逐渐收敛到理想的几何形状以分离两类数据

更大的尺寸

上面介绍的二维方案使我们可以可视化支持向量机的过程。但是,它只能使用两个条目对数据点进行分类。如果我们想使用更多的输入怎么办?幸运的是,支持向量机算法允许我们在更大的范围内执行相同的操作,尽管这在概念上变得更加困难。

假设您要创建一个支持向量机,该机器需要20个条目,并且可以使用类别1或类别2中的那些条目对任何数据点进行分类。为此,支持向量机需要对数据建模。 20维空间,并使用回归算法查找将数据点分为两类的19维超平面。由于很难理解3维以上的任何内容,因此可视化变得非常复杂。但是,您只需要知道它的工作原理与二维情况完全相同即可。


支持向量机如何工作?例子:是schnick吗?

想象一个假设的场景,您是一名研究人员,研究一种仅在北极深处发现的稀有动物schnick。由于这些动物之间的距离,仅发现了少量(例如约5000只)。作为研究人员,您会遇到一个问题……我该如何识别schnick?

您所拥有的只是以前从未见过动物的学者所发表的研究。在这些文章中,作者描述了与他们遇到的schnicks有关的某些特征,即身高,体重,腿数等。但是所有这些特征在不同的文章之间都会有所不同,没有任何可辨别的模式...

我们如何使用这些数据将新动物识别为schnick?

解决我们问题的一种可能的方法是使用支持向量机识别数据中的模式,并创建可用于将动物分类为schnick或不分类为schnick的结构。第一步是创建一个数据集,该数据集可用于训练支持向量机以识别schnicks。训练数据是支持向量机用于分析和提取模式的一组相应的输入和输出。

因此,我们必须决定将使用哪些输入和多少输入。从理论上讲,我们可以有任意多个条目。但是,这通常会导致训练缓慢(输入越多,训练向量机提取模式所花费的时间越长)。此外,您想选择对于所有schnick而言相对一致的输入值。例如,动物的身高或体重将是一个很好的进入例子,因为对于所有schnicks,这预计是相对一致的。但是,动物的平均年龄将是一个较差的入境选择,因为预计已鉴定动物的年龄会相差很大。

因此,选择了以下条目:

  • 高度;
  • 重量;
  • 腿数;
  • 眼睛数;
  • 动物手臂的长度;
  • 动物的平均速度;
  • 动物交配的频率。

通过选择条目,我们可以开始编译我们的训练数据。支持向量机的有效训练数据必须满足某些要求:

  • 数据必须包含schnicks动物的示例
  • 数据必须包含不是schnicks的动物的示例

在这种情况下,我们有来自科学家的研究文章,他们成功地确定了schnicks并列出了它们的特征。因此,我们可以阅读文章,并提取与每个输入有关的数据,并为每个示例分配正确或错误的输出。在这种情况下,训练数据可能类似于下表。

训练样本 高度[mm] 体重[公斤] N_腿 N_眼 L_臂[mm] average_speed [m / s] f_称为[Hz] Schnick(对/错)
例子1 1030 45 8 3 420 2,1 14000 真正
例子2 1010 42 8 3 450 2,2 14000 真正
例子3 900 40 7 6 600 6 13000
例子4 1050 43 9 4 400 2,4 12000 真正
例子5 700 35 2 8 320 21 13500
例子6 1070 42 8 3 430 2,4 12000 真正
例子7 1100 40 8 3 430 2,1 11000 真正
实施例N ... ... ... ... ... ... ... ...

表1. schnick观察的示例表

一旦我们收集了所有训练输入和输出的数据,就可以使用它来训练我们的支持向量机。在训练过程中,支持向量机将创建一个七维空间模型,该模型可用于将所有训练示例分类为真或假。支持向量机将继续执行此操作,直到获得准确表示训练数据的模型(在指定的容错范围内)。训练完成后,可以使用此模型将新数据点分类为是或否。


支持向量机真的有效吗?

使用schnick方案,我编写了一个脚本来检查支持向量机实际识别新schnicks的能力。为此,我使用了可从Market下载的“支持向量机学习工具”功能的库。

为了有效地模拟这种情况,我们首先需要确定什么是 真实 schnick的特征。下表列出了我在这种情况下考虑的特性。如果动物符合以下所有条件,那么它就是schnick ...

参数 最低限度 最高限额
高度[mm] 1000 1100
体重[公斤] 40 50
N_腿 8 10
N_眼 3 4
L_臂[mm] 400 450
average_speed [m / s] 2 2,5
f_称为[Hz] 11000 15000

表2.定义schnick的参数摘要

现在我们已经定义了schnick,我们可以使用该定义在支持向量机上运行测试。第一步是创建一个函数,该函数能够为任何指定的动物输入七个条目,并返回该动物的实际分类(无论是否是schnick)。此功能将用于生成支持向量机的训练数据,并最终评估其性能。可以使用以下功能完成此操作:

//+------------------------------------------------------------------+
//| This function takes the observation properties of the observed 
//| animal and based 上  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)
  }

该过程的下一步是创建一个可以生成培训输入和输出的角色。在这种情况下,将通过在七个输入值的每个定义范围内创建随机数来生成输入。然后,对于生成的每组随机输入,上面的isItASchnick()函数将用于生成所需的对应输出。这是在以下功能中完成的:

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

现在我们有了一组训练输入和输出,是时候使用市场上可用的“支持向量机学习工具”来创建支持向量机了。一旦创建了新的支持向量机,就必须将训练输入和输出传送到该支持向量机并运行训练。

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
  }

现在,我们拥有一台支持向量机,该机器已经过成功地训练以识别schnicks。为了验证这一点,我们可以通过要求最终支持向量机分类新的入口点来对其进行测试。首先通过生成随机条目,然后使用isItASchnick()函数确定这些条目是否对应于schnick来完成此操作。 真实 然后使用支持向量机对输入进行排序并确定结果是否 预见的 匹配结果 真实。这是在以下功能中完成的:

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

我建议对上述函数中的值进行实验,以了解支持向量机在不同条件下的性能。


支持向量机为何如此有用?

使用支持向量机从数据中提取复杂模式的好处是无需了解有关数据行为的先验知识。支持向量机能够分析数据并仅提取见解和关系。这样,它的工作方式类似于黑匣子,接收输入并生成输出,这对于查找非常复杂且不明显的数据模式非常有用。

支持向量机的最佳功能之一是它们能够很好地处理数据中的错误和噪声。他们通常能够感知数据中的背景图案并过滤出异常数据值和其他复杂性。请考虑以下情形:在对Schnicks进行研究时,您会发现几篇科学文章描述了这些动物,它们具有截然不同的特征(例如200 kg和15000mm高的Schnick)。

这样的错误可能会导致您的schnick模型失真,这可能会导致您在对新的schnick发现进行分类时出错。支持向量机的好处是它将开发符合背景图案的模型,而不是包含所有训练数据点的模型。这是通过在模型中设置一定程度的错误来完成的,以允许训练向量机忽略数据中的任何错误。

对于schnicks支持向量机,如果我们允许5%的误差容限,则训练将仅尝试开发与95%训练数据相符的模型。这是有用的,因为它允许训练忽略一小部分离群值。

我们可以通过修改schnick脚本来进一步研究支持向量机的此属性。添加了以下功能,以将故意的随机错误引入我们的训练数据集中。此功能将随机选择训练点,并用随机变量替换相应的输入和输出。

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

此功能使我们可以在训练数据中引入故意的错误。使用此错误填充数据,我们可以创建和训练新的支持向量机,并将其性能与原始计算机进行比较。

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
  }

执行脚本后,它将在专家记录中产生以下结果。在具有5000个训练点的训练数据集中,有可能引入500个随机错误。与原始机器一起购买此误差向量支持机器的性能时,性能只会降低<1%。这是因为支持向量机能够在训练过程中忽略数据集的异常值,却能够生成令人印象深刻的实际数据模型。这表明支持向量机可能是从噪声数据集中提取复杂模式和洞察力的更有用的工具。

专家注册

图5.在MetaTrader 5中执行“ Schnick”脚本后生成的专家记录。


演示版本

可以从代码库中下载上述代码的完整版本,但是,如果您从Market购买了支持向量机的完整版本的学习工具,则只能在您的终端上运行此脚本。如果您只是下载了该工具的演示版,则只能通过策略测试器使用该工具。为了允许使用该工具的演示版本测试“ Schnick”代码,我在EA中重写了脚本的副本,该脚本可以使用策略测试器来实现。可以通过以下链接下载这两个版本的代码:

  • 完整版 -使用在MetaTrader 5终端中实现的脚本 (需要购买的支持向量机学习工具版本)

  • 演示版-使用在MetaTrader 5策略测试器中实现的EA交易 (仅需要支持向量机学习工具的演示版)


支持向量机如何在市场上使用?

诚然,上面讨论的schnicks示例非常简单。但是,在此示例与使用支持向量机进行技术市场分析之间可以找到一些相似之处。

技术分析从根本上与使用历史市场数据预测未来价格走势有关。像我们关于schnicks的例子一样,我们使用以前的科学家所做的观察来预测新动物是否为schnick。此外,市场上充斥着噪声,错误和异常的统计值,这使得使用支持向量机成为一个有趣的概念。

大量技术分析交易方法的基础包括以下步骤:

  1. 监测几个指标。
  2. 确定每个指标的条件与潜在成功的谈判相关。
  3. 观察每个指标并评估何时所有(或大多数)指标都在发出谈判信号。

可以采用相似的方法来使用支持向量机以相似的方式发出新的交易信号。考虑到这一点,开发了支持向量机学习工具。在市场上可以找到有关如何使用此工具的完整说明,这就是为什么我仅作一个简短的摘要。使用此工具的过程如下:

框图

图6.该框图显示了在EA交易中实施支持向量机工具的过程

在开始使用支持向量机学习工具之前,重要的是首先了解如何生成训练输入和输出。

培训条目如何生成?

然后,您要用作输入的指标以及新的支持向量机已被初始化。下一步是将指示器手柄转移到新的支持向量机上,并指导您如何生成训练数据。这是通过调用setIndicatorHandles()函数来完成的。此功能使您可以将初始化指标的句柄转移到支持向量机。这是通过传输包含句柄的整数数组来完成的。此功能的另外两个条目是偏移值和数据点数。

偏移值指示将用于生成训练条目的当前条和开始条之间的偏移,训练点的数量(由N表示)确定训练数据的大小。下图说明了如何使用这些值。位移值为4且N值为6将确定训练向量机仅使用在白色正方形中捕获的条来生成训练输入和输出。类似地,位移值为8且N值为8将确定训练向量机仅使用在蓝色正方形中捕获的条来生成训练输入和输出。

一旦调用了setIndicatorHandles()函数,就可以调用genInputs()函数。该功能将使用指示器手柄来生成将用于训练的输入数据数组。

图7.蜡烛图,说明了位移和N值

图7.蜡烛图,说明了位移和N值


训练结果如何产生?

通过基于历史价格数据模拟假设交易并确定这些交易是否成功来生成训练输出。为此,有一些参数用于指导支持向量机学习工具如何评估假设交易是否成功。

第一个变量是OP_TRADE。它的值可以是“买”(买)或“卖”(卖),并且对应于买卖谈判。如果值为BUY,则在生成输出时,机器将仅寻找假设的购买协商的潜在成功。或者,如果值为SELL,则在生成输出时,机器将仅寻找假设的销售谈判的潜在成功。

这些假设交易的下一个价值是止损和获利。值以哔哔声确定,并将为每个假设交易建立止损和限制水平。

最后一个参数是协商的持续时间。此变量以小时为单位,将确保只有在该最大持续时间内完成的协商才被认为是成功的。包含此变量的原因是为了防止支持向量机在缓慢移动的对角市场中发出交易信号。


选择条目时要考虑的因素

在谈判中实施支持向量机时,反思输入的选择很重要。就像schnicks的例子一样,选择一个在不同问题之间显示相似性的条目很重要。例如,您可能要使用移动平均线作为输入。但是,由于长期平均价格往往会随时间发生显着变化,因此仅移动平均线可能并不是最佳的使用方法。这是因为今天的移动平均值和六个月前的移动平均值之间没有显着相似之处。

假设我们正在交易EURUSD,并使用带有移动平均线的支持向量机来表示“买入”交易。假设当前价格为1.10。但是,它正在生成六个月前价格为0.55的训练数据。在训练支持向量机时,它找到的模式只能在价格接近0.55时导致协商的信号,因为这是她知道的唯一数据。因此,在价格再次跌至0.55之前,您的支持向量机将永远无法发出交易信号。

取而代之的是,可以用于输入向量机的更好的输入可以是MACD或类似的振荡器,因为MACD值与平均价格水平无关,并且仅发出相对运动信号。我建议您对此进行测试,以查看哪种方法可以为您带来最佳效果。

选择输入时要考虑的另一个考虑因素是确保支持向量机具有足够的指标图像来发出新的交易信号。您可能会从自己的交易经验中发现,MACD仅在您拥有最后五个观察柱时才有用,因为这会显示趋势。除非您可以确定单个MACD柱是上升还是下降,否则它可能毫无用处。因此,可能有必要将一些最后的柱从MACD指标转移到支持向量机。有两种方法可以做到这一点:

  1. 您可以创建一个新的自定义指标,该指标使用MACD指标的最后五个柱形将趋势计算为单个值。然后,可以将这个自定义指标作为单个条目传输到支持向量机,或者

  2. 您可以将支持向量机上MACD指标的最后五个小节用作五个单独的输入。这样做的方法是初始化MACD指示器的五个不同实例。可以使用与当前条不同的偏差来初始化每个指标。然后可以将不同指示器的五个手柄转移到支持向量机上。应该注意的是,选项2往往会导致您的EA交易执行时间更长。您拥有的门票越多,培训成功所需的时间就越长。


支持向量机在EA交易中的实现

我准备了一个EA交易,此示例演示了某人如何在自己的协商中潜在地使用支持向量机(可以在此链接中下载其副本) //www.tbxfkj.com/pt/code/1229)。我希望EA能允许您试用支持向量机。我建议您复制/更改/修改EA交易以适合您自己的交易风格。 EA的工作方式如下:

  1. 使用svMachineTool库创建了两个新的支持向量机。一个配置为发出新的“购买”协商信号,另一种配置为发出新的“销售”协商信号。

  2. 初始化七个标准指标,它们的每个句柄都存储在整数数组中(注意:指标的任何组合都可以用作输入,它们只需要以单个整数数组形式传输到SVM)。

  3. 指标的句柄数组将转移到新的支持向量机。

  4. 使用指标手柄和其他参数,历史价格数据可用于生成准确的输入和输出,这些数据将用于训练支持向量机。

  5. 一旦所有输入和输出都生成,就训练了两个支持向量机。

  6. 支持向量机在EA中用于发信号通知新的“购买”和“出售”谈判。当发出新的“买入”或“卖出”交易信号时,该交易与手动止损和获利定单一起被打开。

支持向量机的初始化和训练在onInit()函数中执行。作为参考,EA svTrader的此部分已在下面包含注释。

#property copyright "Copyright 2011, MetaQuotes Software Corp."
#property 链接      "//www.tbxfkj.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 上  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 上  the desired parameters for taking hypothetical trades
//----------
   training(handleB);   // Executes training 上  the Buy-Signal support vector machine
   training(handleS);   // Executes training 上  the Sell-Signal support vector machine   
   return(0);
  }


支持向量机的高级协商

支持向量机学习工具中已集成了其他功能,供更高级的用户使用。该工具允许用户传输自己的个性化输入和输出数据(如schnicks的示例)。这使您可以为支持向量机的输入和输出设计自己的自定义条件,并手动传输此数据以对其进行训练。这样可以保证在谈判的任何方面都可以使用支持向量机。

不仅可以使用支持向量机来发出新的交易信号,而且还可以发出结束交易,资金管理,新的高级指标等信号。但是,为确保您不会收到错误,了解这些输入和输出的结构是很重要的。

开胃菜: 使用一维双精度值数组将条目传输到SVM。请注意,您创建的所有条目都必须作为双精度值传输。布尔值,整数等-在将所有内容传输到支持向量机之前,必须将其转换为双精度值。必须以以下格式输入。例如,假设我们正在转移具有3个条目x 5个训练点的条目。为此,我们的double数组必须为15个单位长,格式为:

|的1 |乙1 | C1 |的2 |乙2 | C2 |的3 |乙3 | C3 |的4 |乙4 | C4 |的5 |乙5 | C5 |

还需要为条目数传送一个值。在这种情况下,N_Inputs = 3。

输出: 输出以布尔值数组的形式传输。这些布尔值是SVM所需的输出,对应于传输的每组输入。像上面的示例一样,请考虑我们有5个训练点。在这种情况下,我们将传输一个长度为5个单位的输出值的布尔数组。

一般注意事项:

  • 生成自己的输入和输出时,请确保数组的长度与要传输的值兼容。如果它们不匹配,将生成错误通知您差异。例如,如果我们传输N_Inputs = 3,并且输入是长度为16的数组,则将引发错误(因为N_inputs值为3将意味着任何输入数组的长度必须是3的倍数)。同样,请确保输入的套数和传输的输出的数相同。同样,如果N_Inputs = 3,输入长度等于15,输出长度等于6,则将引发另一个错误(因为您有5组输入和6个输出)。

  • 尝试确保您的训练输出有足够的变化。例如,如果您转移100个训练点,这意味着长度为100且所有值都是假的输出数组,并且只有一个真实值,那么真实容器与错误案例之间的区分是不够的。这将使训练机器变得非常快,但是最终的解决方案将非常薄弱。更加多样化的培训设置通常将导致更有效的SVM。

由MetaQuotes Software Corp.从英语翻译而来。
来源文章: //www.tbxfkj.com/en/articles/584

附加的文件 |
schnick.mq5 (10.8 KB)
schnick_demo.mq5 (11.39 KB)
换对â用户面板可立即显示EA的米数ário 换对â用户面板可立即显示EA的米数ário

本文提供了一个小示例演示实现çãEA交易中â可以从用户面板控制仪表á河。何时换对âmetros para "rápidos",EA交易将从信息面板中获取的值写入çõ进入文件以供将来读取文件并相应地显示在面板上。本文可能与那些以手动或半自动模式进行交易的人有关ático.

基本原理básicos da programação MQL5: arrays 基本原理básicos da programação MQL5: arrays

随变áveis e funções, os arrays são几乎所有程序语言的组成部分çã哦本文应该主要对新手MQL5程序员感兴趣,而经验丰富的开发人员ão一个很好的机会来总结和系统化您的知识。

MQL5编程的基本原理:字符串 基本原理básicos da programação MQL5: strings

本文涵盖了您的所有内容ê可以处理MQL5中的字符串。主要对新手MQL5程序员感兴趣,而经验丰富的开发人员则对ão一个很好的机会来总结和系统化您的知识。

购买前如何测试交易机器人 如何测试抢劫ô de negociação antes da compra

抢劫ô de negociação在MQL5市场中,相对于ção其他所有操作ções similares - 所提供的自动化系统可以直接在MetaTrader 5终端上进行全面测试,在购买之前,可以并且应该在所有n种模式下仔细执行EA交易ão favorá在集成的策略测试器中,以便您ê充分了解系统。