Maschinelles Lernen im Handel: Theorie, Modelle, Praxis und Algo-Trading - Seite 2312

[Maxim Dmitrievsky]

elibrarius:
Gesehen. Das ist nicht alles. Es hat die 3x3-Matrix einfach in Variablen umgeschrieben. Die neuen Komponentenvektoren werden jedoch nicht berechnet.
Das Ergebnis ist, dass Sie für jede Komponente 6 Zeilen erhalten (gemäß diesem Beispiel).

wirklich verloren und erinnere mich nicht... es gab eine pca-Version des Bots, wenn ich sie finde, werde ich sie später posten

[Forester]

Maxim Dmitrievsky:

wirklich verloren und kann mich nicht erinnern... es gab eine pca-Version des Bots, wenn ich sie finden kann, werde ich sie später posten

Die Suche nach dem Wort PCABuildBasis auf der gesamten Festplatte kann helfen).

[Maxim Dmitrievsky]

elibrarius:
Die Suche nach dem Wort PCABuildBasis auf der gesamten Festplatte kann helfen).

alles in der Cloud in den Archiven ist alt

Hier ist ein Stück Code von pca oder lda (letzteres ist auskommentiert)

//+------------------------------------------------------------------+
//|Use LDA for inputs transforming                                   |
//+------------------------------------------------------------------+
CRLAgent::PCApermutation(void) {                                         
 int inf;    
 double s2s[];            
 //CLDA::FisherLDAN(RDFPM,RDFPM.Size(),features,2,inf,LDAmatrix); 
 CPCAnalysis::PCABuildBasis(RDFPM,RDFPM.Size(),features,inf,s2s,LDAmatrix);  
 RDFPMPCA.Resize(RDFPM.Size(),this.features+2);  
 ArrayResize(PCAarr,features*features);
   
 int ldaind=0;
 for(int f=0;f<this.features;f++)
  for(int i=0;i<this.features;i++) {
   PCAarr[ldaind] = LDAmatrix[i][f];
   ldaind++; }
   
 for(int s=0; s<this.features; s++) {
  for(int i=0;i<RDFPMPCA.Size();i++) {
   double feach = 0;
   for(int f=0;f<this.features;f++)
    feach+=RDFPM[i][f]*LDAmatrix[f][s];   
    RDFPMPCA[i].Set(s,feach);
    RDFPMPCA[i].Set(this.features,RDFPM[i][this.features]);
    RDFPMPCA[i].Set(this.features+1,RDFPM[i][this.features+1]); } }                      
  CDForest::DFBuildRandomDecisionForest(RDFPMPCA,RDFPMPCA.Size(),this.features,2,trees,r,RDFinfo,RDF,RDF_report);
  RDF_report.m_oobrelclserror = CDForest::DFRelClsError(RDF,RDFPMPCA,RDFPMPCA.Size());
 
 ArrayResize(permutated,this.features);
 double buypass[]; ArrayResize(buypass,RDFPMPCA.Size());
 for(int s=0; s<this.features; s++) {
  for(int i=0;i<RDFPMPCA.Size();i++) {  
   buypass[i] = RDFPMPCA[i][s];
   RDFPMPCA[i].Set(s,rand()/32767.0); } 
  permutated[s][1] = s; double err = CDForest::DFRelClsError(RDF,RDFPMPCA,RDFPMPCA.Size()); if(err == 0.0) err = 0.001;
  permutated[s][0] = RDF_report.m_oobrelclserror / err; 
  for(int i=0;i<RDFPMPCA.Size();i++) RDFPMPCA[i].Set(s,buypass[i]); }
   
 ArraySort(permutated); ArrayResize(permutated,this.bf_n); 
 RDFPM.Resize(RDFPMPCA.Size(),this.bf_n+2);
  
 for(int s=0; s<this.bf_n; s++) {
  for(int i=0;i<RDFPMPCA.Size();i++) {   
   RDFPM[i].Set(s,RDFPMPCA[i][(int)permutated[s][1]]);
   RDFPM[i].Set(bf_n,RDFPMPCA[i][this.features]);
   RDFPM[i].Set(bf_n+1,RDFPMPCA[i][this.features+1]); } } 
 CDForest::DFBuildRandomDecisionForest(RDFPM,RDFPM.Size(),this.bf_n,2,trees,r,RDFinfo,RDF,RDF_report); }

[Maxim Dmitrievsky]

Hier ist mehr

//+------------------------------------------------------------------+
//|Use LDA for inputs transforming                                   |
//+------------------------------------------------------------------+
CRLAgent::LDA(void) {                                        
   CDecisionForest   mRDF;                                                  
   CDFReport         mRep;   
   int inf;    
   double s2s[];            
   //CLDA::FisherLDAN(RDFpolicyMatrix,RDFpolicyMatrix.Size(),features,2,inf,LDAmatrix); 
   CPCAnalysis::PCABuildBasis(RDFpolicyMatrix,RDFpolicyMatrix.Size(),features,inf,s2s,LDAmatrix);
   
   
   RDFpolicyMatrix2.Resize(RDFpolicyMatrix.Size(),bestfeatures_num+2);
   
   ArrayResize(LDAarr,features*features);
   
   int ldaind=0;
   for(int f=0;f<this.features;f++)
     for(int i=0;i<this.features;i++){
       LDAarr[ldaind] = LDAmatrix[i][f];
       ldaind++;
      }
   
   for(int s=0; s<this.bestfeatures_num; s++) {
     for(int i=0;i<RDFpolicyMatrix.Size();i++) {
       double feach = 0;
       for(int f=0;f<this.features;f++)
         {
          feach+=RDFpolicyMatrix[i][f]*LDAmatrix[f][s];
         }
        RDFpolicyMatrix2[i].Set(s,feach);
        RDFpolicyMatrix2[i].Set(bestfeatures_num,RDFpolicyMatrix[i][this.features]);
        RDFpolicyMatrix2[i].Set(bestfeatures_num+1,RDFpolicyMatrix[i][this.features+1]);
       }
    }
                        
  CDForest::DFBuildRandomDecisionForest(RDFpolicyMatrix2,RDFpolicyMatrix2.Size(),bestfeatures_num,2,trees,r,RDFinfo,RDF,RDF_report);
 }

[Forester]

Danke, ich werde es mir ansehen.

[Maxim Dmitrievsky]

elibrarius:

Danke, ich werde es mir ansehen.

hier sozusagen. Merkmale werden mit Vektorkoeffizienten multipliziert

dann wird der Wald auf die Komponenten trainiert

for(int s=0; s<this.bestfeatures_num; s++) {
     for(int i=0;i<RDFpolicyMatrix.Size();i++) {
       double feach = 0;
       for(int f=0;f<this.features;f++)
         {
          feach+=RDFpolicyMatrix[i][f]*LDAmatrix[f][s];
         }
        RDFpolicyMatrix2[i].Set(s,feach);
        RDFpolicyMatrix2[i].Set(bestfeatures_num,RDFpolicyMatrix[i][this.features]);
        RDFpolicyMatrix2[i].Set(bestfeatures_num+1,RDFpolicyMatrix[i][this.features+1]);
       }
    }

[cemal]

Ludwig verfügt über Deep-Learning-Modelle, für die man keinen Code schreiben muss und für die keine Programmierkenntnisse erforderlich sind, um das Modell zu lernen:https://ludwig-ai.github.io/ludwig-docs/

[Forester]

Maxim Dmitrievsky:

wie diese. Merkmale werden mit Vektorkoeffizienten multipliziert

for(int s=0; s<this.bestfeatures_num; s++) {
     for(int i=0;i<RDFpolicyMatrix.Size();i++) {
       double feach = 0;
       for(int f=0;f<this.features;f++)
         {
          feach+=RDFpolicyMatrix[i][f]*LDAmatrix[f][s];
         }
        RDFpolicyMatrix2[i].Set(s,feach);
        RDFpolicyMatrix2[i].Set(bestfeatures_num,RDFpolicyMatrix[i][this.features]);
        RDFpolicyMatrix2[i].Set(bestfeatures_num+1,RDFpolicyMatrix[i][this.features+1]);
       }
    }

dann wird der Wald auf die Komponenten trainiert.

1) Die Bedeutung ist nicht ganz klar. Anstelle von 100 Spalten mit Rohdaten hätten wir 100 Spalten mit Hauptkomponenten einspeisen müssen, die einige Informationen verloren haben.
Anstelle von 100 Spalten von Eingabedaten hätten 10-20 Hauptkomponenten hinzugefügt werden müssen, um den Informationsverlust durch die Geschwindigkeit des Trainings auszugleichen.

2) Ich habe immer noch nicht herausgefunden, wie man aus 100 Spalten pro 1000 Zeilen von GC 10 Spalten pro 1000 Zeilen machen kann.
Wir müssen 1000 Zeilen aus den ersten 10 Komponenten erzeugen. Die Matrix mit Komponenten wird 100x100 sein.

[mytarmailS]

elibrarius:

1) Der Punkt ist nicht ganz klar. Anstelle von 100 Spalten mit Rohdaten haben wir 100 Spalten mit Hauptkomponenten eingespeist, bei denen einige Informationen verloren gehen .
Anstelle von 100 Spalten von Eingabedaten hätten es 10-20 Hauptkomponenten sein sollen, und der Informationsverlust wird durch die Geschwindigkeit des Trainings kompensiert.

))))

Wenn Sie 100 Komponenten aus 100 Merkmalen herstellen, beträgt der prozentuale Informationsverlust 0,0 %.

Vielleicht sollten Sie sich mit der Theorie befassen.)

[Forester]

mytarmailS:

))))

Wenn aus hundert Zeichen hundert Komponenten hergestellt werden, beträgt der Prozentsatz des Informationsverlusts 0,0 %.

Sie sollten die Theorie studieren))

Theoretisch, ja.
Aber was ist der Sinn der Aktion? Wenn es keinen Geschwindigkeitsgewinn, sondern eher eine Verlangsamung gibt, für einen zusätzlichen Vorgang.
Ich muss 10 von 100 Punkten erreichen. Gibt es eine Lösung?