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

[[Excluído]]

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.

[Aleksei Kuznetsov]

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.

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

[[Excluído]]

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

[Aleksei Kuznetsov]

Obrigado, eu vou investigar.

[[Excluído]]

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

[cemal]

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/

[Aleksei Kuznetsov]

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.

[mytarmailS]

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).

[Aleksei Kuznetsov]

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?