Bayes'sche Regression - Hat jemand einen EA mit diesem Algorithmus erstellt? - Seite 3

Neuer Kommentar
 
new-rena:

Ich würde wahrscheinlich 10 von 10 versuchen... //Bayesian scheint überhaupt nicht zu funktionieren.

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

Was meinen Sie dazu?

Die Idee war, herauszufinden, ob die von Devavrat Shah und Kang Zhang im Laboratory for Information and Decision Systems, Department of EECS Massachusetts Institute of Technology vorgestellte reale Handelsstrategie für den Devisenhandel geeignet ist.
 
lilita bogachkova:
Die Idee war, zu sehen, ob die vorgestellte reale Handelsstrategie für den Devisenhandel geeignet ist.
Ich dachte, ich hätte mich klar ausgedrückt, dass es nicht so ist. Aber die gute Nachricht ist, dass die Märkte nicht auf Devisen beschränkt sind. Kryptowährungen haben eine Einstiegsschwelle von ein paar Pfund.
 
lilita bogachkova:
Die Idee war, herauszufinden, ob die von Devavrat Shah und Kang Zhang im Laboratory for Information and Decision Systems, Department of EECS Massachusetts Institute of Technology vorgestellte reale Handelsstrategie für den Devisenhandel geeignet ist.

Ich sagte nein, das funktioniert nicht.

In der russischen Version des Links wird das Berechnungsprinzip beschrieben.

"6. DieBayes'sche Regression ähnelt der Ridge-Regression, basiert aber auf der Annahme, dass das Rauschen (der Fehler) in den Daten normalverteilt ist - es wird also davon ausgegangen, dass es bereits ein allgemeines Verständnis der Struktur der Daten gibt.

Im Devisenhandel gibt es kein Rauschen, geschweige denn eine Normalverteilung. Wäre dies der Fall, gäbe es keine Grenzlinie zwischen einer Flaute und einem Trend, es gäbe keine Trendumkehr, d. h. eine Normalverteilung. Bei einer Normalverteilung würde der Preis mit dem Rauschen in einem bestimmten Winkel zu einer Seite wandern und dann wäre er weg.

 
new-rena:

Ich sagte nein, das funktioniert nicht.

In der russischen Version des Links wird das Berechnungsprinzip beschrieben.

"6. DieBayes'sche Regression ähnelt der Ridge-Regression, basiert aber auf der Annahme, dass das Rauschen (der Fehler) in den Daten normalverteilt ist - es wird also davon ausgegangen, dass bereits ein allgemeines Verständnis der Datenstruktur vorhanden ist".

Im Devisenhandel gibt es kein Rauschen, geschweige denn eine Normalverteilung. Wäre dies der Fall, gäbe es keine Grenzlinie zwischen Flachland und Trend, es gäbe keine Trendumkehr, d.h. bei einer Normalverteilung. Bei einer Normalverteilung würde der Preis mit dem Rauschen in einem bestimmten Winkel zur Seite gehen, und dann wären wir aufgeschmissen.

Man könnte meinen, dass "Bitcoin" mit Lärm in einem bestimmten Winkel in dieselbe Richtung geht und piept.

Wenn es ein Thema gibt, dann wird erwartet, dass das Thema das Gesprächsthema ist. Das Thema ist die vorgestellte Strategie(Bayessche Regression - Hat jemand einen EA mit diesem Algorithmus gemacht?), aber nicht als Wahl zwischen Regressionsberechnungsmethoden.

 

Es scheint, dass alles von mql implementiert wird - es ist ALGLIB- k-mean und multivariate lineare Anpassung - verfügbar. Bleibt noch herauszufinden, wie der Algorithmus funktioniert (und das interessiert niemanden - die einen loben R, die anderen stecken in der Regression fest, wen interessiert das überhaupt). Hat jemand Lust, den Algorithmus zu diskutieren?

 
Valerii Mazurenko:

Es scheint, dass alles von mql implementiert wird - es ist ALGLIB- k-mean und multivariate lineare Anpassung - verfügbar. Bleibt noch herauszufinden, wie der Algorithmus funktioniert (und das interessiert niemanden - die einen loben R, die anderen stecken in der Regression fest, wen interessiert das überhaupt). Möchte jemand den Algorithmus diskutieren?

Dazu müssen Sie alle in die richtige Richtung schicken. k-mean wird durch die KlasseCKMeans in der Dateidataanalysis.mqh implementiert.

Hier ist die Klasse selbst:

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

Beachten Sie den Parameter:

K           -   desired number of clusters, K>=1

Sie müssen also die gewünschte Anzahl von Zentren selbst festlegen.

 
lilita bogachkova:

Man sollte meinen, dass "Bitcoin" und Lärm in einem bestimmten Winkel in dieselbe Richtung gehen würden.

Wenn es ein Thema gibt, dann wird erwartet, dass das Thema ein Thema ist. Das Thema bezieht sich auf die vorgestellte Strategie(Bayes'sche Regression - hat jemand einen EA mit diesem Algorithmus erstellt?), aber nicht auf die Wahl der Regressionsberechnungsmethoden.

Valerii Mazurenko:

Scheint von mql implementiert zu werden - es gibt ALGLIB- k-mean und multivariate lineare Anpassung - verfügbar. Bleibt noch herauszufinden, wie der Algorithmus funktioniert (und das interessiert niemanden - die einen loben R, die anderen stecken in der Regression fest, wen interessiert das überhaupt). Hat jemand Interesse an einer Diskussion über den Algorithmus?

Gut.

Die praktische Umsetzung beginnt immer mit einem Projekt, vorausgesetzt, das Projekt ist sinnvoll.

Warum haben Sie beschlossen, dass diese Methode für den Devisenhandel geeignet ist?

 
new-rena:

GUT.

Die praktische Umsetzung beginnt immer mit einem Projekt, vorausgesetzt, das Projekt ist sinnvoll.

Wie kommen Sie darauf, dass diese Methode auf Devisen anwendbar ist?

Jetzt geht es darum, wie der Algorithmus funktioniert.

Was die Anwendbarkeit anbelangt, so wird es einige Aufgaben geben, bei denen es sich als nützlich erweisen wird. Clustering-Preise werden nicht funktionieren.

 
Dmitry Fedoseev:

Wir sprechen jetzt darüber, wie der Algorithmus funktioniert.

Das ist es, worüber wir sprechen.

neu-rena:

Ja.

Die praktische Umsetzung beginnt immer mit einem Projekt, vorausgesetzt, das Projekt ist sinnvoll.

Warum haben Sie beschlossen, dass diese Methode für den Devisenhandel geeignet ist?

Die Forscher wählten einen Zeitraum ohne ausgeprägten Trend, weshalb die Ergebnisse interessant sind.

Bitcoin 2014.01 - 2014.09

12345678910...55
Neuer Kommentar