贝叶斯回归 - 有没有人用这种算法做了一个EA？ - 交易系统 - MQL5 算法交易论坛

Lilita Bogachkova 2016.02.01 21:19 #21

new-rena:

我可能会尝试10分之10...//贝叶斯似乎根本不起作用。

http://datareview.info/article/10-tipov-regressii-kakoy-vyibrat/

你怎么看？

我们的想法是看看Devavrat Shah和Kang Zhang提出的真实交易策略是否适用于外汇市场，EECS麻省理工学院信息和决策系统实验室。

TheXpert 2016.02.01 21:42 #22

lilita bogachkova:
我们的想法是，看看所介绍的真实交易策略是否适合外汇市场。

我想我已经说得很清楚了，它不是。但好消息是，市场并不限于外汇。加密货币的准入门槛为几英镑。

Renat Akhtyamov 2016.02.01 21:49 #23

lilita bogachkova:
我们的想法是看看Devavrat Shah和Kang Zhang提出的真实交易策略是否适用于外汇市场，EECS麻省理工学院信息和决策系统实验室。

我说，不，这不起作用。

俄文版的链接描述了计算原理。

"6.贝叶斯回归 与岭回归相似，但它是基于数据中的噪声（误差）是正态分布的假设--因此它假定已经有了对数据结构的一般理解"。

外汇中没有噪音，更没有正态分布。如果有的话，就不会有平坦和趋势之间的边界线，就不会有趋势逆转，也就是说，有了正态分布。如果我们有一个正态分布，价格就会随着噪音以某种角度向一边移动，然后我们就会完蛋了。

Lilita Bogachkova 2016.02.01 22:39 #24

new-rena:

我说不，这不起作用。

俄文版的链接描述了计算原理。

"6.贝叶斯回归 与岭回归相似，但它是基于数据中的噪声（误差）是正态分布的假设--所以它假设已经有了对数据结构的一般理解"。

外汇中没有噪音，更没有其正常分布。如果有的话，就不会有平坦和趋势之间的边界线，就不会有趋势的逆转，也就是有正态分布。如果我们有一个正态分布，价格就会随着噪音以某种角度向一边移动，然后我们就会完蛋了。

你会认为带有噪音的'比特币'会以某种角度朝同一个方向走，并发出哔哔声。

如果有一个话题，那么这个话题就应该是谈话的主题。这个话题是关于提出的策略（贝叶斯回归--有人用这个算法做了EA吗？），但不是作为回归计算方法的选择。

Valerii Mazurenko 2016.02.01 22:41 #25

似乎一切都由mql实现--有ALGLIB--k-mean和多变量线性拟合--可用。剩下的就是找出算法的工作原理（而且没有人感兴趣--有些人赞美R，有些人陷于回归，一般情况下谁会关心什么）。有人想讨论一下这个算法吗？

Dmitry Fedoseev 2016.02.02 03:03 #26

Valerii Mazurenko:

似乎一切都由mql实现--有ALGLIB--k-mean和多变量线性拟合--可用。剩下的就是找出算法的工作原理（而且没有人感兴趣--有人赞美R，有人陷于回归，一般情况下谁会关心什么）。有人想讨论一下这个算法吗？

要做到这一点，你需要把大家送到正确的方向。K-mean由位于dataanalysis.mqh 文件中的CKMeans类实现。

下面是这个班级本身。

class CKMeans
  {
private:
   //--- private method
   static bool       SelectCenterPP(CMatrixDouble &xy,const int npoints,const int nvars,CMatrixDouble &centers,bool &cbusycenters[],const int ccnt,double &d2[],double &p[],double &tmp[]);
public:
   //--- constructor, destructor
                     CKMeans(void);
                    ~CKMeans(void);
   //--- public method
   static void       KMeansGenerate(CMatrixDouble &xy,const int npoints,const int nvars,const int k,const int restarts,int &info,CMatrixDouble &c,int &xyc[]);
  };
//+------------------------------------------------------------------+
//| Constructor without parameters                                   |
//+------------------------------------------------------------------+
CKMeans::CKMeans(void)
  {

  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CKMeans::~CKMeans(void)
  {

  }
//+------------------------------------------------------------------+
//| k-means++ clusterization                                         |
//| INPUT PARAMETERS:                                                |
//|     XY          -   dataset, array [0..NPoints-1,0..NVars-1].    |
//|     NPoints     -   dataset size, NPoints>=K                     |
//|     NVars       -   number of variables, NVars>=1                |
//|     K           -   desired number of clusters, K>=1             |
//|     Restarts    -   number of restarts, Restarts>=1              |
//| OUTPUT PARAMETERS:                                               |
//|     Info        -   return code:                                 |
//|                     * -3, if task is degenerate (number of       |
//|                           distinct points is less than K)        |
//|                     * -1, if incorrect                           |
//|                           NPoints/NFeatures/K/Restarts was passed|
//|                     *  1, if subroutine finished successfully    |
//|     C           -   array[0..NVars-1,0..K-1].matrix whose columns|
//|                     store cluster's centers                      |
//|     XYC         -   array[NPoints], which contains cluster       |
//|                     indexes                                      |
//+------------------------------------------------------------------+
static void CKMeans::KMeansGenerate(CMatrixDouble &xy,const int npoints,
                                    const int nvars,const int k,
                                    const int restarts,int &info,
                                    CMatrixDouble &c,int &xyc[])
  {
//--- create variables
   int    i=0;
   int    j=0;
   double e=0;
   double ebest=0;
   double v=0;
   int    cclosest=0;
   bool   waschanges;
   bool   zerosizeclusters;
   int    pass=0;
   int    i_=0;
   double dclosest=0;
//--- creating arrays
   int    xycbest[];
   double x[];
   double tmp[];
   double d2[];
   double p[];
   int    csizes[];
   bool   cbusy[];
   double work[];
//--- create matrix
   CMatrixDouble ct;
   CMatrixDouble ctbest;
//--- initialization
   info=0;
//--- Test parameters
   if(npoints<k || nvars<1 || k<1 || restarts<1)
     {
      info=-1;
      return;
     }
//--- TODO: special case K=1
//--- TODO: special case K=NPoints
   info=1;
//--- Multiple passes of k-means++ algorithm
   ct.Resize(k,nvars);
   ctbest.Resize(k,nvars);
   ArrayResizeAL(xyc,npoints);
   ArrayResizeAL(xycbest,npoints);
   ArrayResizeAL(d2,npoints);
   ArrayResizeAL(p,npoints);
   ArrayResizeAL(tmp,nvars);
   ArrayResizeAL(csizes,k);
   ArrayResizeAL(cbusy,k);
//--- change value
   ebest=CMath::m_maxrealnumber;
//--- calculation
   for(pass=1;pass<=restarts;pass++)
     {
      //--- Select initial centers  using k-means++ algorithm
      //--- 1. Choose first center at random
      //--- 2. Choose next centers using their distance from centers already chosen
      //--- Note that for performance reasons centers are stored in ROWS of CT,not
      //--- in columns. We'll transpose CT in the end and store it in the C.
      i=CMath::RandomInteger(npoints);
      for(i_=0;i_<=nvars-1;i_++)
         ct[0].Set(i_,xy[i][i_]);
      cbusy[0]=true;
      for(i=1;i<=k-1;i++)
         cbusy[i]=false;
      //--- check
      if(!SelectCenterPP(xy,npoints,nvars,ct,cbusy,k,d2,p,tmp))
        {
         info=-3;
         return;
        }
      //--- Update centers:
      //--- 2. update center positions
      for(i=0;i<=npoints-1;i++)
         xyc[i]=-1;
      //--- cycle
      while(true)
        {
         //--- fill XYC with center numbers
         waschanges=false;
         for(i=0;i<=npoints-1;i++)
           {
            //--- change values
            cclosest=-1;
            dclosest=CMath::m_maxrealnumber;
            for(j=0;j<=k-1;j++)
              {
               //--- calculation
               for(i_=0;i_<=nvars-1;i_++)
                  tmp[i_]=xy[i][i_];
               for(i_=0;i_<=nvars-1;i_++)
                  tmp[i_]=tmp[i_]-ct[j][i_];
               v=0.0;
               for(i_=0;i_<=nvars-1;i_++)
                  v+=tmp[i_]*tmp[i_];
               //--- check
               if(v<dclosest)
                 {
                  cclosest=j;
                  dclosest=v;
                 }
              }
            //--- check
            if(xyc[i]!=cclosest)
               waschanges=true;
            //--- change value
            xyc[i]=cclosest;
           }
         //--- Update centers
         for(j=0;j<=k-1;j++)
            csizes[j]=0;
         for(i=0;i<=k-1;i++)
           {
            for(j=0;j<=nvars-1;j++)
               ct[i].Set(j,0);
           }
         //--- change values
         for(i=0;i<=npoints-1;i++)
           {
            csizes[xyc[i]]=csizes[xyc[i]]+1;
            for(i_=0;i_<=nvars-1;i_++)
               ct[xyc[i]].Set(i_,ct[xyc[i]][i_]+xy[i][i_]);
           }
         zerosizeclusters=false;
         for(i=0;i<=k-1;i++)
           {
            cbusy[i]=csizes[i]!=0;
            zerosizeclusters=zerosizeclusters || csizes[i]==0;
           }
         //--- check
         if(zerosizeclusters)
           {
            //--- Some clusters have zero size - rare,but possible.
            //--- We'll choose new centers for such clusters using k-means++ rule
            //--- and restart algorithm
            if(!SelectCenterPP(xy,npoints,nvars,ct,cbusy,k,d2,p,tmp))
              {
               info=-3;
               return;
              }
            continue;
           }
         //--- copy
         for(j=0;j<=k-1;j++)
           {
            v=1.0/(double)csizes[j];
            for(i_=0;i_<=nvars-1;i_++)
               ct[j].Set(i_,v*ct[j][i_]);
           }
         //--- if nothing has changed during iteration
         if(!waschanges)
            break;
        }
      //--- 3. Calculate E,compare with best centers found so far
      e=0;
      for(i=0;i<=npoints-1;i++)
        {
         for(i_=0;i_<=nvars-1;i_++)
            tmp[i_]=xy[i][i_];
         for(i_=0;i_<=nvars-1;i_++)
            tmp[i_]=tmp[i_]-ct[xyc[i]][i_];
         //--- calculation
         v=0.0;
         for(i_=0;i_<=nvars-1;i_++)
            v+=tmp[i_]*tmp[i_];
         e=e+v;
        }
      //--- check
      if(e<ebest)
        {
         //--- store partition.
         ebest=e;
         //--- function call
         CBlas::CopyMatrix(ct,0,k-1,0,nvars-1,ctbest,0,k-1,0,nvars-1);
         //--- copy
         for(i=0;i<=npoints-1;i++)
            xycbest[i]=xyc[i];
        }
     }
//--- Copy and transpose
   c.Resize(nvars,k);
//--- function call
   CBlas::CopyAndTranspose(ctbest,0,k-1,0,nvars-1,c,0,nvars-1,0,k-1);
//--- copy
   for(i=0;i<=npoints-1;i++)
      xyc[i]=xycbest[i];
  }
//+------------------------------------------------------------------+
//| Select center for a new cluster using k-means++ rule             |
//+------------------------------------------------------------------+
static bool CKMeans::SelectCenterPP(CMatrixDouble &xy,const int npoints,
                                    const int nvars,CMatrixDouble &centers,
                                    bool &cbusycenters[],const int ccnt,
                                    double &d2[],double &p[],double &tmp[])
  {
//--- create variables
   bool   result;
   int    i=0;
   int    j=0;
   int    cc=0;
   double v=0;
   double s=0;
   int    i_=0;
//--- create array
   double busycenters[];
//--- copy
   ArrayCopy(busycenters,cbusycenters);
//--- initialization
   result=true;
//--- calculation
   for(cc=0;cc<=ccnt-1;cc++)
     {
      //--- check
      if(!busycenters[cc])
        {
         //--- fill D2
         for(i=0;i<=npoints-1;i++)
           {
            d2[i]=CMath::m_maxrealnumber;
            for(j=0;j<=ccnt-1;j++)
              {
               //--- check
               if(busycenters[j])
                 {
                  for(i_=0;i_<=nvars-1;i_++)
                     tmp[i_]=xy[i][i_];
                  for(i_=0;i_<=nvars-1;i_++)
                     tmp[i_]=tmp[i_]-centers[j][i_];
                  //--- calculation
                  v=0.0;
                  for(i_=0;i_<=nvars-1;i_++)
                     v+=tmp[i_]*tmp[i_];
                  //--- check
                  if(v<d2[i])
                     d2[i]=v;
                 }
              }
           }
         //--- calculate P (non-cumulative)
         s=0;
         for(i=0;i<=npoints-1;i++)
            s=s+d2[i];
         //--- check
         if(s==0.0)
            return(false);
         //--- change value
         s=1/s;
         for(i_=0;i_<=npoints-1;i_++)
            p[i_]=s*d2[i_];
         //--- choose one of points with probability P
         //--- random number within (0,1) is generated and
         //--- inverse empirical CDF is used to randomly choose a point.
         s=0;
         v=CMath::RandomReal();
         //--- calculation
         for(i=0;i<=npoints-1;i++)
           {
            s=s+p[i];
            //--- check
            if(v<=s || i==npoints-1)
              {
               for(i_=0;i_<=nvars-1;i_++)
                  centers[cc].Set(i_,xy[i][i_]);
               busycenters[cc]=true;
               //--- break the cycle
               break;
              }
           }
        }
     }
//--- return result
   return(result);
  }

Dmitry Fedoseev 2016.02.02 03:11 #27

注意这个参数。

K - desired number of clusters, K>=1

所以你必须自己设定所需的中心数量。

Renat Akhtyamov 2016.02.02 05:43 #28

lilita bogachkova:

你会认为'比特币'和噪音会以某种角度和方式向同一个方向发展。

如果有一个主题，那么这个主题就应该是一个主题。这个主题是关于提出的策略（贝叶斯回归--有人用这个算法做了一个EA吗？），但不是关于回归计算方法之间的选择。

Valerii Mazurenko:

似乎是由mql实现的--有ALGLIB--k-mean和多变量线性拟合--可用。剩下的就是找出算法的工作原理（而且没有人感兴趣--有些人赞美R，有些人陷于回归，一般情况下谁会关心什么）。有没有人有兴趣讨论一下这个算法？

好的。

实际的实施总是从一个项目开始，只要这个项目是值得的。

为什么你决定这种方法适用于外汇？

Dmitry Fedoseev 2016.02.02 06:09 #29

new-rena:

好的。

实际的实施总是从一个项目开始，只要这个项目是值得的。

你为什么认为这种方法适用于外汇？

现在我们讨论的是算法如何工作。

关于适用性，会有一些任务，它将会派上用场。聚集价格是行不通的。

Lilita Bogachkova 2016.02.02 06:25 #30

Dmitry Fedoseev:

我们现在讨论的是算法如何工作。

这就是我们正在谈论的问题。

new-rena:

好的。

实际的实施总是从一个项目开始，只要这个项目是值得的。

为什么你决定这种方法适用于外汇？

研究人员选择了一个没有明显趋势的时期，这就是为什么结果是有趣的。

贝叶斯回归 - 有没有人用这种算法做了一个EA？ - 页 3