베이지안 회귀 - 이 알고리즘을 사용하여 Expert Advisor를 만든 사람이 있습니까? - 페이지 3

새 코멘트
 
new-rena :

나는 아마도 10개 중 10개를 시도할 것입니다... //베이지안은 제 생각에는 전혀 굴러가지 않습니다

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

당신의 의견?

EECS Massachusetts Institute of Technology의 Devavrat Shah와 Kang Zhang 정보 및 의사결정 시스템 연구소가 제시한 실제 거래 전략이 Forex에 적합한지 여부를 이해하기 위한 아이디어였습니다.
 
lilita bogachkova :
제시된 실제 거래 전략이 Forex에 적합한지 여부를 이해하는 것이 아이디어였습니다.
하지 않았다는 점을 분명히 했습니다. 그러나 좋은 소식이 있습니다. 시장은 외환에만 국한되지 않습니다. 암호 화폐에서 진입 임계값은 몇 달러입니다.
 
lilita bogachkova :
아이디어는 EECS Massachusetts Institute of Technology의 Devavrat Shah 및 Kang Zhang 정보 및 의사 결정 시스템 연구소가 제시한 실제 거래 전략이 Forex에 적합한지 이해하는 것이었습니다.

글쎄, 나는 대답했다 - 아니오, 그것은 굴러 가지 않습니다.

러시아어에서는 계산 원리가 참조로 설명됩니다.

" 6. 베이지안 회귀 는 릿지 회귀와 유사하지만 데이터에 노이즈(오차)가 정규 분포되어 있다는 가정을 기반으로 하므로 데이터 구조에 대한 공통적인 이해가 이미 있다고 가정합니다."

Forex에는 정규 분포는 고사하고 노이즈가 없습니다. 그렇다면 플랫과 추세 사이에 경계가 없고 추세 반전이 없을 것입니다. 즉, 정규 분포를 의미합니다. 정규 분포에서 가격은 어떤 각도에서 한 방향으로 노이즈와 PPC로 이동합니다.

 
new-rena :

글쎄, 나는 대답했다 - 아니오, 그것은 굴러 가지 않습니다.

러시아어에서는 계산 원리가 참조로 설명됩니다.

" 6. 베이지안 회귀 는 릿지 회귀와 유사하지만 데이터에 노이즈(오차)가 정규 분포되어 있다는 가정을 기반으로 하므로 데이터의 구조에 대한 공통적인 이해가 이미 있다고 가정합니다."

Forex에는 정규 분포는 고사하고 노이즈가 없습니다. 그렇다면 플랫과 추세 사이에 경계가 없고 추세 반전이 없을 것입니다. 즉, 정규 분포를 의미합니다. 정규 분포에서 가격은 어느 각도에서 한 방향으로 노이즈와 PPC로 이동합니다.

노이즈가 있는 '비트코인'은 어느 각도에서나 PPC가 한 방향으로 간다고 생각할 수 있습니다.

토픽이 있다면 토픽이 나올 것으로 예상된다. 주제는 제시된 전략( 베이지안 회귀 - 이 알고리즘을 사용하여 어드바이저를 수행한 사람이 있습니까? )에 관한 것이지만 회귀 계산 방법 중에서 선택하는 것은 아닙니다.

 

모든 것이 mql 도구를 사용하여 구현되는 것 같습니다. ALGLIB (k-mean 및 multidimensional linear-fit)를 사용할 수 있습니다. 알고리즘이 여전히 어떻게 작동하는지 알아내는 것이 남아 있습니다(그리고 이것은 누구에게도 관심이 없습니다. 일부는 R을 칭찬하고, 다른 일부는 회귀에 집착하고, 누가 일반적으로 무엇에 대해 이야기하는지). 알고리즘에 대해 논의할 의사가 있습니까?

 
Valerii Mazurenko :

모든 것이 mql 도구를 사용하여 구현되는 것 같습니다. ALGLIB (k-mean 및 multidimensional 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);
  }
 

매개변수에 주의하십시오.

K           -   desired number of clusters, K>=1

따라서 원하는 수의 센터를 독립적으로 설정해야합니다.

 
lilita bogachkova :

노이즈가 있는 '비트코인'은 어느 각도에서나 PPC가 한 방향으로 간다고 생각할 수 있습니다.

토픽이 있다면 토픽이 나올 것으로 예상된다. 주제는 제시된 전략( 베이지안 회귀 - 이 알고리즘을 사용하여 어드바이저를 수행한 사람이 있습니까? )에 관한 것이지만 회귀 계산 방법 중에서 선택하는 것은 아닙니다.

발레리 마주렌코 :

모든 것이 mql 도구를 사용하여 구현되는 것 같습니다. ALGLIB (k-mean 및 multidimensional linear-fit)를 사용할 수 있습니다. 알고리즘이 여전히 어떻게 작동하는지 알아내는 것이 남아 있습니다(그리고 이것은 누구에게도 관심이 없습니다. 일부는 R을 칭찬하고, 다른 일부는 회귀에 매달리고, 일반적으로 무엇에 대해 이야기하는지). 알고리즘에 대해 논의할 의사가 있습니까?

확인.

실제 구현은 프로젝트가 가치가 있는 한 항상 프로젝트에서 시작됩니다.

이 방법을 외환에 적용할 수 있다고 결정한 이유는 무엇입니까?

 
new-rena :

확인.

실제 구현은 프로젝트가 가치가 있는 한 항상 프로젝트에서 시작됩니다.

이 방법을 외환에 적용할 수 있다고 결정한 이유는 무엇입니까?

이제 그것에 대한 대화가 있습니다. 알고리즘이 작동하는 방식.

적용 가능성에 관해서는 유용한 작업이 있습니다. 가격은 클러스터링되지 않습니다.

 
Dmitry Fedoseev :

이제 그것에 대한 대화가 있습니다. 알고리즘이 작동하는 방식.

그것이 무엇인지에 관한 것입니다.

뉴 레나 :

확인.

실제 구현은 프로젝트가 가치가 있는 한 항상 프로젝트에서 시작됩니다.

이 방법을 외환에 적용할 수 있다고 결정한 이유는 무엇입니까?

연구자들은 뚜렷한 경향이 없는 기간을 선택했기 때문에 달성된 결과가 흥미롭습니다.

비트코인 2014.01 - 2014.09

12345678910...55
새 코멘트