ForumSezioni

Regressione bayesiana - Qualcuno ha fatto un EA usando questo algoritmo? - pagina 3

Nuovo commento
new-rena:

Probabilmente proverei 10 su 10... //Bayesian non sembra funzionare affatto.

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

Cosa ne pensate?

L'idea era di vedere se la strategia di trading reale presentata da Devavrat Shah e Kang Zhang Laboratory for Information and Decision Systems, Department of EECS Massachusetts Institute of Technology fosse adatta al forex.
lilita bogachkova:
L'idea era di vedere se la strategia di trading reale che veniva presentata era adatta al forex
Pensavo di aver chiarito che non lo fosse. Ma la buona notizia è che i mercati non si limitano al forex. Le criptovalute hanno una soglia di ingresso di poche sterline.
lilita bogachkova:
L'idea era di vedere se la strategia di trading reale presentata da Devavrat Shah e Kang Zhang Laboratory for Information and Decision Systems, Department of EECS Massachusetts Institute of Technology fosse adatta al forex.

Ho detto no, non funziona.

La versione russa del link descrive il principio di calcolo.

"6. Laregressione bayesiana è simile alla regressione a pettine, ma si basa sul presupposto che il rumore (errore) nei dati sia normalmente distribuito - quindi si presume che ci sia già una comprensione generale della struttura dei dati "

Non c'è rumore nel forex, tanto meno una distribuzione normale. Se ci fosse, non ci sarebbe una linea di confine tra un piatto e una tendenza, non ci sarebbero inversioni di tendenza, cioè con una distribuzione normale. Se avessimo una distribuzione normale, il prezzo andrebbe con il rumore da una parte con un certo angolo e allora saremmo fregati.

new-rena:

Ho detto no, non funziona.

Nella versione russa del link, viene descritto il principio di calcolo.

"6. Laregressione bayesiana è simile alla regressione ridge, ma si basa sul presupposto che il rumore (errore) nei dati sia normalmente distribuito - quindi si presume che esista già una comprensione generale della struttura dei dati ".

Non c'è rumore nel forex, tanto meno la sua distribuzione normale. Se ci fosse, non ci sarebbe una linea di confine tra piatto e tendenza, non ci sarebbero inversioni di tendenza, cioè con la distribuzione normale. Se avessimo una distribuzione normale, il prezzo andrebbe con il rumore da una parte con un certo angolo e allora saremmo fregati.

Si potrebbe pensare che "Bitcoin" con il rumore vada nella stessa direzione con un certo angolo e faccia bip.

Se c'è un argomento, allora ci si aspetta che l'argomento sia il tema della conversazione. L'argomento riguarda la strategia presentata(regressione bayesiana - Qualcuno ha fatto un EA usando questo algoritmo?) ma non come una scelta tra metodi di calcolo della regressione.

Sembra che tutto sia implementato da mql - c'è ALGLIB- k-mean e multivariate linear-fit - disponibile. Resta da scoprire come funziona l'algoritmo (e nessuno è interessato - alcuni lodano R, altri sono bloccati nella regressione, chi si preoccupa di cosa in generale). Qualcuno vuole discutere l'algoritmo?

Valerii Mazurenko:

Sembra che tutto sia implementato da mql - c'è ALGLIB- k-mean e multivariate linear-fit - disponibile. Resta da scoprire come funziona l'algoritmo (e nessuno è interessato - alcuni lodano R, altri sono bloccati nella regressione, chi si preoccupa di cosa in generale). Qualcuno vuole discutere l'algoritmo?

Per farlo è necessario mandare tutti nella giusta direzione. k-mean è implementato dalla classeCKMeans situata nel filedataanalysis.mqh.

Ecco la classe stessa:

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

Si noti il parametro:

K           -   desired number of clusters, K>=1

Quindi devi impostare tu stesso il numero di centri desiderato.

lilita bogachkova:

Si potrebbe pensare che "Bitcoin" e il rumore vadano nella stessa direzione con qualche angolo e ppl.

Il topic riguarda la strategia presentata(regressione bayesiana - qualcuno ha fatto un EA usando questo algoritmo?) ma non la scelta tra i metodi di calcolo della regressione.

Valerii Mazurenko:

Sembra essere implementato da mql - c'è ALGLIB- k-mean e multivariate linear-fit - disponibile. Resta da scoprire come funziona l'algoritmo (e nessuno è interessato - alcuni lodano R, altri sono bloccati nella regressione, chi se ne frega di cosa in generale). Qualcuno è interessato a discutere l'algoritmo?

Ok.

L'implementazione pratica inizia sempre con un progetto, sempre che il progetto sia utile.

Perché hai deciso che questo metodo è applicabile al forex?

new-rena:

OK.

L'implementazione pratica inizia sempre con un progetto, sempre che il progetto sia utile.

Cosa ti fa pensare che questo metodo sia applicabile al forex?

Ora stiamo parlando di come funziona l'algoritmo.

Per quanto riguarda l'applicabilità, ci sarà qualche compito per il quale tornerà utile. Il clustering dei prezzi non funziona.

Dmitry Fedoseev:

Ora stiamo parlando di come funziona l'algoritmo.

È di questo che stiamo parlando.

nuovo-rena:

Ok.

L'implementazione pratica inizia sempre con un progetto, sempre che il progetto sia utile.

Perché hai deciso che questo metodo è applicabile al forex?

I ricercatori hanno scelto un periodo senza una tendenza pronunciata, ed è per questo che i risultati sono interessanti.

Bitcoin 2014.01 - 2014.09

12345678910...55
Nuovo commento