Aprendizaje automático en el trading: teoría, práctica, operaciones y más - página 2312

Nuevo comentario
 
elibrarius:
Lo he visto. No es eso. Sólo reescribió la matriz 3x3 en variables. Pero los nuevos vectores componentes no se calculan.
El resultado es obtener 6 filas para cada componente (según este ejemplo).

realmente me perdí y no me acuerdo... había una versión pca del bot, si la encuentro, la posteo después

 
Maxim Dmitrievsky:

realmente perdido y no puedo recordar... había una versión pca del bot, si puedo encontrarlo lo publicaré más tarde

Buscar la palabra PCABuildBasis en todo el disco puede ayudar) Si el archivo no se borra.
 
elibrarius:
Buscar la palabra PCABuildBasis en toda la unidad puede ayudar) Si el archivo no se borra.

todo lo que está en la nube en los archivos es viejo

aquí hay un trozo de código de pca o lda (este último está comentado)

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

Aquí hay más

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

Gracias, lo investigaré.

 
elibrarius:

Gracias, lo investigaré.

aquí más o menos. Los rasgos se multiplican por coeficientes vectoriales

entonces el bosque se entrena con los componentes

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 tiene modelos de aprendizaje profundo sin necesidad de escribir código, no se requieren conocimientos de programación para enseñar el modelo: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:

así. Los rasgos se multiplican por coeficientes vectoriales

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

entonces el bosque se entrena en los componentes.

1) El significado no está muy claro. En lugar de 100 columnas de datos brutos, deberíamos haber alimentado 100 columnas de componentes principales que han perdido algo de información.
En lugar de 100 columnas de datos de entrada, debería haber añadido entre 10 y 20 componentes principales que compensaran la pérdida de información con la velocidad de entrenamiento.


2) Todavía no he encontrado la forma de hacer 10 columnas por 1000 filas de GC a partir de 100 columnas por 1000 filas.
Necesitamos generar 1000 filas de los primeros 10 componentes. La matriz con componentes será de 100x100.

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

1) El punto no está del todo claro. En lugar de 100 columnas de datos brutos, alimentamos 100 columnas de componentes principales, en las que se pierde algo de información .
En lugar de 100 columnas de datos de entrada, deberían haber sido 10-20 componentes principales, y la pérdida de información se verá compensada por la rapidez del entrenamiento.

))))

Si se hacen 100 componentes de 100 rasgos, el porcentaje de pérdida de información es del 0,0%.

Quizá quieras estudiar algo de teoría).

 
mytarmailS:

))))

Si de cien señales se hacen cien componentes, el porcentaje de pérdida de información es del 0,0%.

deberías estudiar la teoría))

En teoría, sí.
Pero aún así, ¿qué sentido tiene la acción? Si no hay ganancia de velocidad, sino una ralentización, para una operación extra.
Necesito obtener 10 de 100. ¿Hay alguna solución?
1...230523062307230823092310231123122313231423152316231723182319...3399
Nuevo comentario