ForoSecciones

Regresión Bayesiana - ¿Alguien ha hecho un EA utilizando este algoritmo? - página 3

Nuevo comentario
new-rena:

Probablemente intentaría 10 de 10... //La bayesiana no parece funcionar en absoluto.

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

¿Qué te parece?

La idea era ver si la estrategia de negociación real que presentaron Devavrat Shah y Kang Zhang Laboratory for Information and Decision Systems, Department of EECS Massachusetts Institute of Technology era adecuada para el forex.
lilita bogachkova:
La idea era ver si la estrategia de trading real que se presentaba era adecuada para el forex
Pensé que había dejado claro que no lo era. Pero la buena noticia es que los mercados no se limitan a las divisas. Las criptomonedas tienen un umbral de entrada de unas pocas libras.
lilita bogachkova:
La idea era ver si la estrategia de negociación real que presentaron Devavrat Shah y Kang Zhang Laboratory for Information and Decision Systems, Department of EECS Massachusetts Institute of Technology era adecuada para el forex.

He dicho que no, que no funciona.

La versión rusa del enlace describe el principio de cálculo.

"6. Laregresión bayesiana es similar a la regresión de cresta, pero se basa en la suposición de que el ruido (el error) en los datos se distribuye normalmente, por lo que se supone que ya existe una comprensión general de la estructura de los datos "

En el mercado de divisas no hay ruido, y mucho menos una distribución normal. Si lo hubiera, no habría frontera entre un plano y una tendencia, no habría inversiones de tendencia, es decir, con una distribución normal. Si hubiera una distribución normal, el precio iría con el ruido hacia un lado en algún ángulo y luego desaparecería.

new-rena:

He dicho que no, que no funciona.

La versión rusa del enlace describe el principio de cálculo.

"6. Laregresión bayesiana es similar a la regresión de cresta, pero se basa en la suposición de que el ruido (el error) en los datos se distribuye normalmente, por lo que se supone que ya existe una comprensión general de la estructura de los datos ".

No hay ruido en el mercado de divisas, y mucho menos su distribución normal. Si lo hubiera, no habría frontera entre un plano y una tendencia, no habría inversiones de tendencia, es decir, con la distribución normal. Si hubiera una distribución normal, el precio iría con el ruido hacia un lado en algún ángulo y luego desaparecería.

Uno pensaría que el "Bitcoin" con ruido iría en la misma dirección en algún ángulo y pitido.

El tema es sobre la estrategia presentada(regresión bayesiana - ¿alguien ha hecho un EA usando este algoritmo?) pero no como una elección entre métodos de cálculo de regresión.

Parece que todo está implementado por mql - hay ALGLIB- k-mean y multivariate linear-fit - disponible. Queda por averiguar cómo funciona el algoritmo (y a nadie le interesa - algunos alaban R, otros se quedan en la regresión, a quién le importa qué en general). ¿Alguien quiere discutir el algoritmo?

Valerii Mazurenko:

Parece que todo está implementado por mql - hay ALGLIB- k-mean y multivariate linear-fit - disponible. Queda por averiguar cómo funciona el algoritmo (y a nadie le interesa - algunos alaban R, otros se quedan en la regresión, a quién le importa qué en general). ¿Alguien quiere discutir el algoritmo?

Para ello es necesario enviar a todos en la dirección correcta. k-mean es implementado por la claseCKMeans ubicada en el archivodataanalysis.mqh.

Aquí está la clase en sí:

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

Observe el parámetro:

K           -   desired number of clusters, K>=1

Por lo tanto, debe fijar usted mismo el número de centros deseado.

lilita bogachkova:

Uno pensaría que "Bitcoin" y el ruido irían en la misma dirección en algún ángulo y ppl.

Si hay un tema, se espera que el tema sea un tema. El tema es sobre la estrategia presentada(regresión bayesiana - ¿alguien ha hecho un EA usando este algoritmo?) pero no sobre la elección entre los métodos de cálculo de regresión.

Valerii Mazurenko:

Parece ser implementado por mql - hay ALGLIB- k-mean y multivariate linear-fit - disponible. Queda por saber cómo funciona el algoritmo (y a nadie le interesa -algunos alaban a R, otros se quedan en la regresión, a quién le importa qué en general). ¿Alguien está interesado en discutir el algoritmo?

Bien.

La aplicación práctica siempre empieza con un proyecto, siempre que éste merezca la pena.

¿Por qué ha decidido que este método es aplicable al mercado de divisas?

new-rena:

DE ACUERDO.

La aplicación práctica siempre comienza con un proyecto, siempre que éste merezca la pena.

¿Qué le hace pensar que este método es aplicable al mercado de divisas?

Ahora estamos hablando de cómo funciona el algoritmo.

En cuanto a la aplicabilidad, habrá alguna tarea para la que resulte útil. La agrupación de precios no funcionará.

Dmitry Fedoseev:

Ahora estamos hablando de cómo funciona el algoritmo.

De eso estamos hablando.

nuevo-rena:

De acuerdo.

La aplicación práctica siempre empieza con un proyecto, siempre que éste merezca la pena.

¿Por qué ha decidido que este método es aplicable al mercado de divisas?

Los investigadores eligieron un periodo sin una tendencia pronunciada, por lo que los resultados son interesantes.

Bitcoin 2014.01 - 2014.09

12345678910...55
Nuevo comentario