Régression bayésienne - Est-ce que quelqu'un a fait un EA en utilisant cet algorithme ? - page 3

Nouveau commentaire
 
new-rena:

J'essaierais probablement 10 sur 10... //Bayesian ne semble pas fonctionner du tout.

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

Qu'en pensez-vous ?

L'idée était de voir si la stratégie de trading réelle présentée par Devavrat Shah et Kang Zhang Laboratory for Information and Decision Systems, Department of EECS Massachusetts Institute of Technology était adaptée au forex.
 
lilita bogachkova:
L'idée était de voir si la stratégie de trading réelle qui était présentée était adaptée au forex.
Je pensais avoir été clair sur le fait que ça ne l'était pas. Mais la bonne nouvelle est que les marchés ne se limitent pas au forex. Les crypto-monnaies ont un seuil d'entrée de quelques quidams.
 
lilita bogachkova:
L'idée était de voir si la stratégie de trading réelle présentée par Devavrat Shah et Kang Zhang Laboratory for Information and Decision Systems, Department of EECS Massachusetts Institute of Technology était adaptée au forex.

J'ai dit non, ça ne marche pas.

La version russe du lien décrit le principe de calcul.

"6. Larégression bayésienne est similaire à la régression ridge, mais elle repose sur l'hypothèse que le bruit (erreur) dans les données est normalement distribué - on suppose donc qu'une compréhension générale de la structure des données est déjà disponible".

Il n'y a pas de bruit dans le forex, et encore moins une distribution normale. Si c'était le cas, il n'y aurait pas de frontière entre un plat et une tendance, il n'y aurait pas de retournement de tendance, c'est-à-dire avec une distribution normale. Si nous avions une distribution normale, le prix irait avec le bruit d'un côté à un certain angle et alors nous serions foutus.

 
new-rena:

J'ai dit non, ça ne marche pas.

Dans la version russe du lien, le principe de calcul est décrit.

"6. Larégression bayésienne est similaire à la régression ridge, mais elle est basée sur l'hypothèse que le bruit (erreur) dans les données est normalement distribué - on suppose donc qu'une compréhension générale de la structure des données existe déjà".

Il n'y a pas de bruit dans le forex, et encore moins sa distribution normale. Si c'était le cas, il n'y aurait pas de frontière entre le plat et la tendance, il n'y aurait pas de retournement de tendance, c'est-à-dire avec la distribution normale. Si nous avions une distribution normale, le prix irait avec le bruit d'un côté à un certain angle et alors nous serions foutus.

On pourrait penser qu'un "bitcoin" avec du bruit irait dans la même direction, avec un certain angle et un bip.

S'il y a un sujet, alors on s'attend à ce que le sujet soit le sujet de la conversation. Le sujet porte sur la stratégie présentée(régression bayésienne - quelqu'un a-t-il fait un EA en utilisant cet algorithme ?) mais pas sur le choix entre les méthodes de calcul de la régression.

 

Il semble que tout soit implémenté par mql - il y a ALGLIB- k-mean et multivariate linear-fit - disponible. Il reste à découvrir comment l'algorithme fonctionne (et cela n'intéresse personne - certains font l'éloge de R, d'autres sont bloqués sur la régression, qui se soucie de quoi en général). Quelqu'un veut discuter de l'algorithme ?

 
Valerii Mazurenko:

Il semble que tout soit implémenté par mql - il y a ALGLIB- k-mean et multivariate linear-fit - disponible. Il reste à découvrir comment l'algorithme fonctionne (et cela n'intéresse personne - certains font l'éloge de R, d'autres sont bloqués sur la régression, qui se soucie de quoi en général). Quelqu'un souhaite-t-il discuter de l'algorithme ?

Pour ce faire, vous devez envoyer tout le monde dans la bonne direction. k-mean est implémenté par la classeCKMeans située dans le fichierdataanalysis.mqh.

Voici le cours lui-même :

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

Notez le paramètre :

K           -   desired number of clusters, K>=1

Vous devez donc définir vous-même le nombre de centres souhaité.

 
lilita bogachkova:

On pourrait penser que "Bitcoin" et le bruit vont dans la même direction, à un certain angle, et les gens...

S'il y a un sujet, alors on s'attend à ce que le sujet soit un sujet. Le sujet concerne la stratégie présentée(régression bayésienne - quelqu'un a-t-il fait un EA en utilisant cet algorithme ?) mais pas le choix entre les méthodes de calcul de la régression.

Valerii Mazurenko:

Il semble être implémenté par mql - il y a ALGLIB- k-mean et multivariate linear-fit - disponible. Il reste à découvrir comment l'algorithme fonctionne (et cela n'intéresse personne - certains font l'éloge de R, d'autres sont bloqués sur la régression, qui se soucie de quoi en général). Quelqu'un souhaite discuter de l'algorithme ?

Ok.

La mise en œuvre pratique commence toujours par un projet, à condition que le projet en vaille la peine.

Pourquoi avez-vous décidé que cette méthode est applicable au forex ?

 
new-rena:

OK.

La mise en œuvre pratique commence toujours par un projet, à condition que le projet en vaille la peine.

Qu'est-ce qui vous fait penser que cette méthode est applicable au forex ?

Nous parlons maintenant du fonctionnement de l'algorithme.

En ce qui concerne l'applicabilité, il y aura toujours une tâche pour laquelle il sera utile. Le regroupement des prix ne fonctionnera pas.

 
Dmitry Fedoseev:

Nous parlons maintenant du fonctionnement de l'algorithme.

C'est de ça qu'il s'agit.

new-rena:

Ok.

La mise en œuvre pratique commence toujours par un projet, à condition que le projet en vaille la peine.

Pourquoi avez-vous décidé que cette méthode est applicable au forex ?

Les chercheurs ont choisi une période sans tendance prononcée, d'où l'intérêt des résultats.

Bitcoin 2014.01 - 2014.09

12345678910...55
Nouveau commentaire