Aprendizado de máquina no trading: teoria, prática, negociação e não só - página 2312

Novo comentário
 
elibrarius:
Vi-o. Não é isso. Ele apenas reescreveu a matriz 3x3 em variáveis. Mas os novos vectores componentes não são calculados.
O resultado é obter 6 linhas para cada componente (de acordo com este exemplo).

Eu realmente perdi-o e não me lembro... havia uma versão pca do bot, se eu o encontrar, eu o postarei mais tarde.

 
Maxim Dmitrievsky:

realmente perdido e não me lembro... havia uma versão pca do bot, se eu conseguir encontrá-la eu a postarei mais tarde.

Pesquisar a palavra PCABuildBasis em todo o disco pode ajudar) Se o arquivo não for excluído.
 
elibrarius:
A pesquisa da palavra PCABuildBasis em todo o disco pode ajudar) Se o ficheiro não for apagado.

tudo o que está na nuvem nos arquivos é velho

aqui está um código de pca ou lda (o último é 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); }
 

Aqui está mais

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

Obrigado, eu vou investigar.

 
elibrarius:

Obrigado, vou ver isso.

aqui mais ou menos. Os traços são multiplicados por coeficientes vetoriais

então a floresta é treinada nos 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 tem modelos de aprendizagem profunda sem a necessidade de escrever código, sem conhecimentos de programação necessários para ensinar o 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:

assim. Os traços são multiplicados por coeficientes vetoriais

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

então a floresta é treinada nos componentes.

1) O significado não é muito claro. Em vez de 100 colunas de dados brutos, deveríamos ter alimentado 100 colunas de componentes principais que perderam alguma informação.
Em vez de 100 colunas de dados de entrada, deveria ter adicionado 10-20 componentes principais que compensariam a perda de informação com a velocidade do treinamento.


2) Ainda não descobri como fazer 10 colunas por 1000 filas de GC a partir de 100 colunas por 1000 filas.
Precisamos de gerar 1000 filas a partir dos primeiros 10 componentes. A matriz com componentes será 100x100.

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

1) O ponto não é bem claro. Em vez de 100 colunas de dados brutos, alimentamos 100 colunas de componentes principais, nas quais algumas informações são perdidas .
Ao invés de 100 colunas de dados de entrada, deveriam ter sido 10-20 componentes principais, e a perda de informação será compensada pela velocidade do treinamento.

))))

Se você fizer 100 componentes de 100 características, então a porcentagem de perda de informação é de 0,0%.

Talvez queiras estudar alguma teoria).

 
mytarmailS:

))))

Se de cem sinais uma centena de componentes são feitos, a percentagem de perda de informação é de 0,0%.

você deve estudar a teoria))

Em teoria, sim.
Mas mesmo assim, qual é o objectivo da acção? Se não há ganho de velocidade, mas sim uma desaceleração, para uma operação extra.
Preciso de 10 em cada 100. Existe uma solução?
1...230523062307230823092310231123122313231423152316231723182319...3399
Novo comentário