L'apprendimento automatico nel trading: teoria, modelli, pratica e algo-trading - pagina 2312

Nuovo commento
 
elibrarius:
Visto. Non è così. Ha appena riscritto la matrice 3x3 in variabili. Ma i nuovi vettori componenti non vengono calcolati.
Il risultato è quello di ottenere 6 righe per ogni componente (secondo questo esempio).

L'ho davvero perso e non ricordo... c'era una versione pca del bot, se la trovo la posterò più tardi

 
Maxim Dmitrievsky:

davvero perso e non riesco a ricordare... c'era una versione pca del bot, se riesco a trovarla la posterò più tardi

Cercare la parola PCABuildBasis su tutto il disco può aiutare) Se il file non viene cancellato.
 
elibrarius:
Cercare la parola PCABuildBasis in tutto il disco può aiutare) Se il file non viene cancellato.

tutto ciò che si trova nella nuvola negli archivi è vecchio

ecco un pezzo di codice da pca o lda (quest'ultimo è commentato)

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

Qui c'è di più

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

Grazie, ci darò un'occhiata

 
elibrarius:

Grazie, darò un'occhiata.

qui più o meno. I tratti sono moltiplicati per i coefficienti del vettore

poi la foresta è addestrata sulle componenti

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]);
       }
    }
 
Ludwig ha modelli di deep learning senza la necessità di scrivere codice, nessuna abilità di programmazione richiesta per insegnare il modello:https://ludwig-ai.github.io/ludwig-docs/
Ludwig - code-free deep learning toolbox
Ludwig - code-free deep learning toolbox
  • ludwig-ai.github.io
Ludwig is a toolbox for training and testing deep learning models without writing code
 
Maxim Dmitrievsky:

come questo. I tratti sono moltiplicati per i coefficienti del vettore

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

poi la foresta viene addestrata sui componenti.

1) Il significato non è molto chiaro. Invece di 100 colonne di dati grezzi, avremmo dovuto alimentare 100 colonne di componenti principali che hanno perso alcune informazioni.
Invece di 100 colonne di dati di input, avrebbe dovuto aggiungere 10-20 componenti principali che avrebbero compensato la perdita di informazioni con la velocità di formazione.


2) Non ho ancora scoperto come fare 10 colonne per 1000 righe di GC da 100 colonne per 1000 righe.
Abbiamo bisogno di generare 1000 righe dai primi 10 componenti. La matrice con i componenti sarà 100x100.

Индикаторы: Portfolio Optimizer
Индикаторы: Portfolio Optimizer
  • 2018.12.01
  • www.mql5.com
Portfolio Optimizer: Автор: transcendreamer...
 
elibrarius:

1) Il punto non è molto chiaro. Invece di 100 colonne di dati grezzi, abbiamo alimentato 100 colonne di componenti principali, in cui alcune informazioni vengono perse .
Invece di 100 colonne di dati di input, avrebbero dovuto essere 10-20 componenti principali, e la perdita di informazioni sarà compensata dalla velocità di formazione.

))))

Se si fanno 100 componenti su 100 tratti, allora la percentuale di perdita di informazioni è dello 0,0%.

Potresti voler studiare un po' di teoria).

 
mytarmailS:

))))

Se su cento segni si fanno cento componenti, la percentuale di perdita di informazioni è dello 0,0%.

dovresti studiare la teoria))

In teoria, sì.
Ma comunque, qual è lo scopo dell'azione? Se non c'è un guadagno di velocità, ma piuttosto un rallentamento, per un'operazione in più.
Ho bisogno di ottenere 10 su 100. C'è una soluzione?
1...230523062307230823092310231123122313231423152316231723182319...3399
Nuovo commento