Discussion de l'article "Utiliser des Cartes de Caractéristiques Auto-Organisatrices (Kohonen Maps) dans MetaTrader 5" - page 4

Nouveau commentaire
 
Graff:

Je ne sais pas à quoi ils servent. Vous pouvez obtenir les informations directement à partir du terminal.

C'est effrayant d'imaginer à quoi ils servent, probablement que quelqu'un les a comptés manuellement.

SZY : quelqu'un peut-il poster un mod pour que l'Expert Advisor puisse récupérer les informations directement depuis le terminal, sans script ?

Eh bien, si vous avez peur, alors bien sûr que non).
 
sergeev:
De quelles informations avez-vous besoin ?
C'est-à-dire pour que l'Expert Advisor SOM.mq5 puisse indépendamment (sans l'aide des scripts DJ.mq5 et FX.mq5) recevoir des données du terminal.
 

Est-ce que cet article comprend tout ce qu'il faut pour obtenir un expert advisor ?

Je suis intéressé par la mise en œuvre d'un conseiller expert en réseau neuronal.

 

Bonjour, chers membres du forum !

Article très intéressant ! J'essaie également d'utiliser ce code SOM.

somk

Pondérations p1-p4 - données du marché (jusqu'à présent, juste la différence entre les points ZZ).

p5 - résultat d'un achat virtuel - TP=1, SL=-1 (jusqu'à présent TP=SP=300pp). Sur le forward, un seul BMU p5 (vecteur le plus proche) n'est pas suffisant pour prédire le résultat, il me semble.

Quelqu'un peut-il me suggérer comment calculer le résultat de la zone autour de la BMU (pour plus de clarté, en bleu), en tenant compte de la distance par rapport à la BMU ?

 
sealdo:

Quelqu'un peut-il me dire s'il est plus facile de calculer le résultat de la zone autour de la BMU (entourée en bleu pour plus de clarté), en tenant compte de la distance par rapport à la BMU ?

Je me demandais, c'est ce à quoi je pensais aussi ? vous voulez dire comment trouver par programme cette zone avec des coordonnées ?
 
progma137:
Je me demande si c'est ce que j'ai pensé aussi, c'est-à-dire comment trouver par programme cette surface avec des coordonnées ?

Il existe déjà une fonction dans la classe CSOM :

int BestMatchingNode(double &vector[]) ; // trouver le meilleur noeud de la grille en fonction d'un vecteur donné

Connaissant la dimensionnalité de notre grille, il est facile de calculer les coordonnées de la BMU (ou BMN dans cette implémentation).
Ici, nous voulons faire exactement le calcul du résultat total (par un paramètre (poids)) de la zone autour de la BMU, en tenant compte de la distance par rapport à la BMU. Par exemple, nous prenons une région avec un diamètre de 10 neurones (cellules). Les neurones les plus proches ont une grande influence sur le résultat. Et plus ils sont éloignés, plus l'influence est faible....

La question se pose également de savoir comment traiter les coquilles BMU situées sur les bords de la grille. Après tout, elles ont moins de voisins.

 

Pouvez-vous me dire comment trouver des barres sur des cartes ?

Nous entrons quatre vecteurs et obtenons quatre cartes. J'aimerais dessiner une trajectoire sur chacune d'entre elles, par exemple, du jour actuel (pour les jours) jusqu'à trois barres en arrière et analyser l'état des grappes.

Il est possible de le faire par programme, par exemple avec la fonction void DrawTrajectory(int from, int count), qui dessinera une trajectoire à partir d'un numéro de barre donné sur toutes les cartes.

Deuxième question : comment obtenir la carte de sortie et, surtout, la carte de fréquence ?

 

Je n'ai pas attendu de réponse... J'ai écrit la méthode d'affichage sur les cartes d'entrée de la trajectoire à partir du nombre donné du vecteur d'entrée par le nombre donné de pas, ne me pardonnez pas si quelque chose ne va pas - je ne suis pas programmeur :)

Quelqu'un peut-il amener cette bibliothèque très intelligente (merci à l'auteur et à Alexey Sergeev) au niveau de l'application pratique ? ! !!!


//------------------------------------------------------------------ ShowTrajectory
void CSOM::ShowTrajectory(int n_patern, int m_cnt) // Méthode de représentation de la trajectoire des vecteurs d'entrée
{
        if(m_cnt<=0) return;
        int idx=0,x[],y[], dy=0;
        string name[];
        ArrayResize(x,m_cnt);
        ArrayResize(y,m_cnt);
        ArrayResize(name,m_cnt);
        double data[]; ArrayResize(data, m_dimension);
   for(int ind=0; ind<m_nSet; ind++) // définir les données par les valeurs vectorielles de l'ensemble d'apprentissage
  {
        if(ind<n_patern) continue;  // attendre le modèle d'entrée requis
        for(int k=0; k<m_dimension; k++) data[k]=m_set[m_dimension*(ind)+k];
        int winningnode=BestMatchingNode(data); // trouver l'indice du nœud le plus proche
                
         // sauvegarde des coordonnées des motifs d'entrée sélectionnés pour le traçage
        int x1,y1,x2,y2;
        m_node[winningnode].GetCoordinates(x1,y1,x2,y2);
        if(m_bHexCell) // si hexagones
      {
          int x_size=int(MathAbs(x2-x1));
          int y_size=int(MathAbs(y2-y1));
          dy=y_size;
          y1=y1+y_size/4; 
          y2=y2+y_size/4;
      }
        x[idx]=(x1+x2)/2;
        y[idx]=(y1+y2)/2;               
        name[idx]=(string)ind;
        //x[idx]=(int)m_node[winnode].X() ;
        //y[idx]=(int)m_node[winnode].Y() ;
        idx++;
        m_cnt--;        
        if(m_cnt==0) break;      // enregistrer le nombre requis de paternions d'entrée
  }
  // dessiner la trajectoire, les nœuds et les inscriptions
   int bcol=clrBlack;
   for(int k=0; k<m_dimension; k++)
  {
      int yp=0, yc;
      int sz=ArraySize(x);
      for(int j=0; j<sz; j++) 
    {
         yc=y[j];
         // nœud
         int sh=2;
         if(j>0) sh=1;
         m_bmp[k].DrawRectangle(x[j]-sh,y[j]-sh,x[j]+sh,y[j]+sh,bcol,true);
         // trajectoire
         if(j<sz-1) m_bmp[k].DrawLine(x[j],y[j],x[j+1],y[j+1],bcol);  
         yc=y[j]-dy;
         if(MathAbs(yp-yc)<dy) yc-=dy;
         yp=yc;
         // nombre de paternas (barres) 
         m_bmp[k].TypeText(x[j],yc,name[j], clrIndigo);
    }    
  }
}
 

Dans la classe CSOM, le compteur de vecteurs d'entraînement chargés m_nSet n'est remis à zéro que dans le constructeur CSOM::CSOM().

Par conséquent, le nombre de vecteurs d'entraînement augmente constamment dans le mode de recyclage en boucle.

Il est préférable d'ajouter la ligne m_nSet=0 ; à la méthode CSOM::LoadTrainData(...) .

 
GSB:

Peut-être que quelqu'un amènera une bibliothèque très utile (merci à l'auteur et à Alexey Sergeev) au niveau de l'utilisation pratique? ! !!!


Que voulez-vous dire ? un beau SDK ? ou de belles images produites par le programme ? qui a besoin de quoi, il le fait. ces cartes ne sont rien de plus qu'un moyen d'établir des données qui doivent être analysées et sur la base desquelles des conclusions peuvent être tirées.
123456
Nouveau commentaire