L'apprentissage automatique dans la négociation : théorie, modèles, pratique et algo-trading - page 2312

[Maxim Dmitrievsky]

elibrarius:
Vu. Ce n'est pas ça. Il a juste réécrit la matrice 3x3 en variables. Mais les nouveaux vecteurs de composantes ne sont pas calculés.
Le résultat est d'obtenir 6 lignes pour chaque composant (selon cet exemple).

Je l'ai vraiment perdu et je ne m'en souviens pas... il y avait une version pca du bot, si je la trouve je la posterai plus tard.

[Forester]

Maxim Dmitrievsky:

je suis vraiment perdue et je ne me souviens pas... il y avait une version pca du bot, si je peux la trouver je la posterai plus tard

La recherche du mot PCABuildBasis sur l'ensemble du disque peut aider) Si le fichier n'est pas supprimé.

[Maxim Dmitrievsky]

elibrarius:
Rechercher le mot PCABuildBasis dans tout le lecteur peut aider) Si le fichier n'est pas supprimé.

tout ce qui est dans le nuage dans les archives est vieux

voici un morceau de code de pca ou lda (ce dernier est commenté)

//+------------------------------------------------------------------+
//|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]

En savoir plus

//+------------------------------------------------------------------+
//|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]

Merci, je vais m'en occuper.

[Maxim Dmitrievsky]

elibrarius:

Merci, je vais m'en occuper.

ici, en quelque sorte. Les traits sont multipliés par des coefficients vectoriels

puis la forêt est entraînée sur les composants

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 dispose de modèles d'apprentissage profond sans qu'il soit nécessaire d'écrire du code, aucune compétence en programmation n'étant requise pour enseigner le modèle: https://ludwig-ai.github.io/ludwig-docs/.

[Forester]

Maxim Dmitrievsky:

comme ça. Les traits sont multipliés par des coefficients vectoriels

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

puis la forêt est entraînée sur les composants.

1) Le sens n'est pas tout à fait clair. Au lieu de 100 colonnes de données brutes, nous aurions dû fournir 100 colonnes de composantes principales qui ont perdu certaines informations.
Au lieu de 100 colonnes de données d'entrée, il aurait dû ajouter 10 à 20 composantes principales qui compenseraient la perte d'informations avec la rapidité de la formation.

2) Je n'ai toujours pas trouvé comment faire 10 colonnes pour 1000 lignes de GC à partir de 100 colonnes pour 1000 lignes.
Nous devons générer 1000 lignes à partir des 10 premiers composants. La matrice avec les composants sera de 100x100.

[mytarmailS]

elibrarius:

1) Le point n'est pas tout à fait clair. Au lieu de 100 colonnes de données brutes, nous avons alimenté 100 colonnes de composantes principales, dans lesquelles certaines informations sont perdues .
Au lieu de 100 colonnes de données d'entrée, il aurait fallu 10 à 20 composantes principales, et la perte d'information sera compensée par la rapidité de la formation.

))))

Si vous fabriquez 100 composants à partir de 100 traits, le pourcentage de perte d'information est de 0,0 %.

Vous pourriez vouloir étudier un peu la théorie).

[Forester]

mytarmailS:

))))

Si, sur cent signes, cent composants sont fabriqués, le pourcentage de perte d'informations est de 0,0 %.

vous devriez étudier la théorie))

En théorie, oui.
Mais quand même, quel est le but de l'action ? S'il n'y a pas de gain de vitesse, mais plutôt un ralentissement, pour une opération supplémentaire.
Je dois obtenir 10 sur 100. Existe-t-il une solution ?