Regressão Bayesiana - Alguém já fez um EA usando este algoritmo? - página 3

Novo comentário
 
new-rena:

Eu provavelmente tentaria 10 em cada 10... //Bayesian parece não funcionar em absoluto.

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

O que você acha?

A idéia era ver se a verdadeira estratégia comercial apresentada por Devavrat Shah e Kang Zhang Laboratory for Information and Decision Systems, Department of EECS Massachusetts Institute of Technology, era adequada para forex.
 
lilita bogachkova:
A idéia era ver se a verdadeira estratégia comercial que foi apresentada era adequada para forex
Pensei ter deixado claro que não era. Mas a boa notícia é que os mercados não estão limitados ao forex. As moedas criptográficas têm um limiar de entrada de algumas libras.
 
lilita bogachkova:
A idéia era ver se a verdadeira estratégia comercial apresentada por Devavrat Shah e Kang Zhang Laboratory for Information and Decision Systems, Department of EECS Massachusetts Institute of Technology, era adequada para forex.

Eu disse que não, não funciona.

A versão russa do link descreve o princípio de cálculo.

"6. Aregressão Bayesiana é semelhante à regressão da crista, mas se baseia na suposição de que o ruído (erro) nos dados é normalmente distribuído - portanto, assume-se que já existe um entendimento geral da estrutura dos dados ".

Não há barulho em forex, muito menos uma distribuição normal. Se houvesse, não haveria fronteira entre um plano e uma tendência, não haveria inversão de tendência, ou seja, com uma distribuição normal. Se tivéssemos uma distribuição normal, o preço iria com o barulho para um lado em algum ângulo e então seríamos aparafusados.

 
new-rena:

Eu disse que não, não funciona.

Na versão russa do link, o princípio de cálculo é descrito.

"6. Aregressão Bayesiana é semelhante à regressão da crista, mas se baseia na suposição de que o ruído (erro) nos dados é normalmente distribuído - portanto, supõe-se que já exista um entendimento geral da estrutura de dados ".

Não há ruído em forex, muito menos sua distribuição normal. Se houvesse, não haveria fronteira entre plano e tendência, não haveria inversão de tendência, ou seja, com a distribuição normal. Se tivéssemos uma distribuição normal, o preço iria com o barulho para um lado em algum ângulo e então seríamos aparafusados.

Seria de se pensar que 'Bitcoin' com ruído iria na mesma direção em algum ângulo e bleep.

Se houver um tópico, então espera-se que o tópico seja o tópico de conversa. O tópico é sobre a estratégia apresentada(regressão Bayesiana - Alguém fez uma EA usando este algoritmo?) mas não como uma escolha entre métodos de cálculo de regressão.

 

Parece que tudo é implementado por mql - há ALGLIB- k-mean e multivariada linear-fit - disponível. Resta saber como funciona o algoritmo (e ninguém está interessado - algumas pessoas elogiam R, outras estão presas em regressão, quem se importa com o quê em geral). Alguém quer discutir o algoritmo?

 
Valerii Mazurenko:

Parece que tudo é implementado por mql - há ALGLIB- k-mean e multivariada linear-fit - disponível. Resta saber como funciona o algoritmo (e ninguém está interessado - alguns elogiam R, outros estão presos na regressão, quem se importa com o quê em geral). Alguém gostaria de discutir o algoritmo?

Para fazer isso você precisa enviar todos na direção certa. k-mean é implementado pela classeCKMeans localizada no arquivodataanalysis.mqh.

Aqui está a própria classe:

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 o parâmetro:

K           -   desired number of clusters, K>=1

Portanto, você mesmo deve definir o número desejado de centros.

 
lilita bogachkova:

Seria de se pensar que 'Bitcoin' e o ruído iriam na mesma direção em algum ângulo e ppl.

Se houver um tópico, então espera-se que o tópico seja um tópico. O tópico é sobre a estratégia apresentada(regressão Bayesiana - alguém fez uma EA usando este algoritmo?) mas não sobre a escolha entre métodos de cálculo de regressão.

Valerii Mazurenko:

Parece ser implementado por mql - há ALGLIB- k-mean e multivariada linear-fit - disponível. Resta saber como funciona o algoritmo (e ninguém está interessado - algumas pessoas elogiam R, outras estão presas em regressão, quem se importa com o quê em geral). Alguém interessado em discutir o algoritmo?

Ok.

A implementação prática começa sempre com um projeto, desde que o projeto valha a pena.

Por que você decidiu que este método é aplicável ao forex?

 
new-rena:

OK.

A implementação prática começa sempre com um projeto, desde que o projeto valha a pena.

O que o faz pensar que este método é aplicável ao forex?

Agora estamos falando sobre como funciona o algoritmo.

Quanto à aplicabilidade, haverá alguma tarefa para a qual ela virá a calhar. Os preços de agrupamento não vão funcionar.

 
Dmitry Fedoseev:

Estamos agora falando sobre como funciona o algoritmo.

É disso que estamos falando.

nova-rena:

Certo.

A implementação prática começa sempre com um projeto, desde que o projeto valha a pena.

Por que você decidiu que este método é aplicável ao forex?

Os pesquisadores escolheram um período sem uma tendência pronunciada, razão pela qual os resultados são interessantes.

Bitcoin 2014.01 - 2014.09

12345678910...55
Novo comentário
Razão: