ベイズ回帰 - このアルゴリズムを使ってEAを作った方はいらっしゃいますか？ - ページ 3

[Lilita Bogachkova]

new-rena:

私なら10人中10人は試すかな...。//Bayesianは全く機能しないようです。

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

いかがでしょうか？

Devavrat ShahとKang Zhang Laboratory for Information and Decision Systems, Department of EECS Massachusetts Institute of Technologyが発表した実際の取引戦略が、FXに適しているかどうかを確認することでした。

[TheXpert]

lilita bogachkova:
提示された実際の取引戦略が、FXに適しているかどうかを確認することでした。

そうでないことを明確にしたつもりなのですが。しかし、良いニュースは、市場がFXに限定されないことです。暗号通貨は、数十円という参入障壁がある。

[Renat Akhtyamov]

lilita bogachkova:
Devavrat ShahとKang Zhang Laboratory for Information and Decision Systems, Department of EECS Massachusetts Institute of Technologyが発表した実際の取引戦略が、FXに適しているかどうかを確認することでした。

ダメだと言ったんです。

リンク先のロシア語版には、計算原理が書かれています。

"6.ベイズ回帰は リッジ回帰と似ていますが、データのノイズ（誤差）が正規分布しているという前提で成り立っています - したがって、データの構造について すでに一般的な理解があることが前提となっています"。

FXにはノイズはありませんし、ましてや正規の分布はありません。もしそうであれば、横ばいとトレンドの境界線はなく、トレンドの反転もない、つまり正規分布となります。もし正規分布だったら、価格はノイズと一緒にある角度で片側に寄ってしまい、そうなるともうダメです。

[Lilita Bogachkova]

new-rena:

ダメだと言ったんです。

リンク先のロシア語版には、計算原理が書かれています。

"6.ベイズ回帰は リッジ回帰と似ていますが、データのノイズ（誤差）が正規分布しているという前提で、データ構造の 一般的な理解が既にあることが前提です」。

FXにはノイズはなく、ましてやその正規分布はありません。もしそうであれば、フラットとトレンドの境界線はなく、トレンドの反転もない、すなわち正規分布となります。もし正規分布だったら、価格はノイズと一緒にある角度で片側に寄ってしまい、そうなるともうダメです。

ノイズを含んだ「ビットコイン」は、ある角度で同じ方向にピッと行くと思うんですね。

トピックがあれば、そのトピックが話題になることが予想されます。 トピックは、提示された戦略（ベイズ回帰-このアルゴリズムを使ってEAを行った人が いるか）についてですが、回帰計算方法の選択としてではありません。

[Valerii Mazurenko]

すべてmqlで実装されているようです。ALGLIB- k-mean and multivariate linear-fit - が利用できます。あとはアルゴリズムがどう動くか（誰も興味を示さない-Rを褒める人もいれば、回帰にはまる人もいる、一般的に誰が何を気にするのか）である。どなたか、アルゴリズムについて議論したい方はいらっしゃいますか？

[Dmitry Fedoseev]

Valerii Mazurenko:

すべてmqlで実装されているようです。ALGLIB- k-mean and multivariate linear-fit - が利用できます。あとはアルゴリズムがどう動くか（誰も興味を示さない-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]

パラメータに注目

K           -   desired number of clusters, K>=1

そのため、希望のセンター数を自分で設定する必要があります。

[Renat Akhtyamov]

lilita bogachkova:

ビットコイン」とノイズがある角度で同じ方向に行くと思いきや、プルンプルン。

トピックがあるのであれば、トピックを期待します。 トピックは、提示された戦略（ベイズ回帰-このアルゴリズムを使ってEAを作った人がいるか？ ）についてですが、回帰計算方法の選択についてではありません。

ヴァレリー・マズレンコ

mqlで実装されているようです。ALGLIB- k-mean and multivariate linear-fit - が利用できます。あとはアルゴリズムがどう動くか（誰も興味を示さない-Rを賞賛する人もいれば、回帰にはまる人もいる、一般的に誰が何を気にするのか）である。アルゴリズムの議論に興味のある方はいらっしゃいますか？

オッケーです。

実用化は常にプロジェクトから始まりますが、そのプロジェクトが価値あるものであることが前提です。

なぜ、この方法がFXに適用できると判断したのですか？

[Dmitry Fedoseev]

new-rena:

OKです。

実用化は常にプロジェクトから始まりますが、そのプロジェクトが価値あるものであることが前提です。

この方法がFXに適用できると考える理由は何ですか？

今度は、アルゴリズムの仕組みの話です。

応用性については、何かと重宝するタスクがあるはずです。クラスタリング価格が効かない

[Lilita Bogachkova]

Dmitry Fedoseev:

今、アルゴリズムの仕組みについて話しているところです。

そういうことなんです。

new-rena です。

なるほど。

実用化は常にプロジェクトから始まりますが、そのプロジェクトが価値あるものであることが前提です。

なぜ、この方法がFXに適用できると判断したのですか？

研究者は顕著な傾向のない時期を選んだからこそ、興味深い結果が得られたのだと思います。