Diskussion zum Artikel "Verwendung von selbstorganisierenden Karten (Kohonenkarten) in MetaTrader 5" - Seite 4

Neuer Kommentar
 
Graff:

Ich weiß nicht, wofür sie sind. Sie können die Informationen direkt vom Terminal abrufen.

Es ist beängstigend, sich überhaupt vorzustellen, wofür sie verwendet werden, wahrscheinlich hat sie jemand manuell gezählt.

SZY: Kann jemand einen Mod posten, so dass der Expert Advisor Informationen direkt vom Terminal abrufen kann, ohne ein Skript?

Nun, wenn Sie Angst haben, dann natürlich nicht).
 
sergeev:
Welche Informationen benötigen Sie?
Die vom Skript in eine Datei entladen und vom Expert Advisor zur Analyse eingezogen werden. D.h. damit der SOM.mq5 Expert Advisor selbstständig (ohne Hilfe des DJ.mq5 und FX.mq5 Skripts) Daten vom Terminal empfangen kann.
 

Enthält dieser Artikel alles, um einen Expert Advisor zu erhalten?

Ich interessiere mich für die Implementierung von Neural Network Expert Advisor.

 

Hallo, liebe Forumsmitglieder!

Sehr interessanter Artikel! Ich versuche auch, diesen SOM-Code zu verwenden.

somk

Gewichte p1-p4 - Daten aus dem Markt (bisher nur die Differenz zwischen ZZ-Punkten).

p5 - Ergebnis eines virtuellen Buy-Trade - TP=1, SL=-1 (bisher TP=SP=300pp). Ein p5 BMU (nächstgelegener Vektor) reicht nicht aus, um das Ergebnis vorherzusagen, so scheint es mir.

Kann jemand vorschlagen, wie man die Berechnung des Ergebnisses der Bereich um die BMU (für Klarheit obver blau), unter Berücksichtigung der Entfernung von der BMU zu machen?

 
sealdo:

Kann mir jemand sagen, wie man das Ergebnis der Fläche um das BMU (zur Verdeutlichung blau eingekreist) unter Berücksichtigung der Entfernung vom BMU einfacher berechnen kann?

Ich habe mich gefragt, ob ich das auch gedacht habe... Sie meinen, wie man diese Fläche mit Koordinaten programmatisch ermitteln kann?
 
progma137:
Ich frage mich, ob es das ist, was ich mir auch gedacht habe: Sie meinen, wie man diese Fläche mit Koordinaten programmatisch findet?

Es gibt bereits eine Funktion in der CSOM-Klasse:

int BestMatchingNode(double &vector[]); // Finde den besten Knoten im Gitter basierend auf einem gegebenen Vektor

Da wir die Dimensionalität unseres Gitters kennen, ist es einfach, die Koordinaten der BMU (oder BMN in dieser Implementierung) zu berechnen.
Hier wollen wir genau die Berechnung des Gesamtergebnisses (durch einen Parameter (Gewicht)) des Bereichs um die BMU durchführen, wobei die Entfernung von der BMU berücksichtigt wird. Wir nehmen zum Beispiel eine Region mit einem Durchmesser von 10 Neuronen (Zellen). Die nächstgelegenen Neuronen haben einen großen Einfluss auf das Ergebnis. Und je weiter weg, desto schwächer....

Hier stellt sich die Frage, wie wir BMU-Hüllen behandeln sollen, die sich an den Rändern des Gitters befinden. Schließlich haben sie weniger Nachbarn.

 

Können Sie mir bitte sagen, wie man Balken auf Karten findet?

Wir geben vier Vektoren ein und erhalten 4 Karten. Ich möchte eine Trajektorie auf allen Karten zeichnen, z. B. vom aktuellen Tag (für die Tage) bis zu 3 Balken zurück, und den Zustand der Cluster analysieren.

Es ist möglich, dies programmatisch zu tun, z. B. mit der Funktion void DrawTrajectory(int from, int count), die eine Trajektorie ab einer bestimmten Taktnummer auf allen Karten zeichnet.

Und die zweite Frage: Wie erhält man die Ausgabekarte und vor allem die Frequenzkarte?

 

Ich habe nicht auf eine Antwort gewartet... Ich schrieb die Methode der Anzeige auf den Eingangskarten der Trajektorie von der gegebenen Nummer des Eingangsvektors durch die gegebene Anzahl von Schritten, verzeihen Sie mir nicht, wenn etwas falsch ist - ich bin kein Programmierer :)

Kann jemand diese sehr kluge Bibliothek (Dank an den Autor und Alexey Sergeev) auf die Ebene der praktischen Anwendung zu bringen?!!!!


//------------------------------------------------------------------ ShowTrajectory
void CSOM::ShowTrajectory(int n_patern, int m_cnt) // Methode zur Darstellung der Trajektorie von Eingangsvektoren
{
        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++) // Daten durch Vektorwerte aus dem Trainingssatz setzen
  {
        if(ind<n_patern) continue;  // Warten auf das gewünschte Eingabemuster
        for(int k=0; k<m_dimension; k++) data[k]=m_set[m_dimension*(ind)+k];
        int winningnode=BestMatchingNode(data); // Suche nach dem Index des nächstgelegenen Knotens
                
         // Koordinaten der für die Verfolgung ausgewählten Eingabemuster speichern
        int x1,y1,x2,y2;
        m_node[winningnode].GetCoordinates(x1,y1,x2,y2);
        if(m_bHexCell) // wenn Hexagone
      {
          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;      // Erfassen der erforderlichen Anzahl von Eingabepaternionen
  }
  // Zeichnen der Flugbahn, der Knoten und der Beschriftungen
   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];
         // Knoten
         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);
         // Flugbahn
         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;
         // Anzahl der Paternas (Balken) 
         m_bmp[k].TypeText(x[j],yc,name[j], clrIndigo);
    }    
  }
}
 

In der Klasse CSOM wird der Zähler der geladenen Trainingsvektoren m_nSet nur im Konstruktor CSOM::CSOM() zurückgesetzt.

Dies hat zur Folge, dass die Anzahl der Trainingsvektoren in der Umschulungsschleife ständig ansteigt.

Es ist besser, die Zeile m_nSet=0; in die Methode CSOM::LoadTrainData(...) einzufügen.

 
GSB:

Vielleicht wird jemand eine sehr nützliche Bibliothek (Dank an den Autor und Alexey Sergeev) auf die Ebene der praktischen Nutzung zu bringen?!!!!


Was meinen Sie? schöne SDK? oder schöne Bilder durch das Programm produziert? wer braucht was, er tut es. diese Karten sind nichts anderes als ein Mittel, um Daten, die analysiert werden müssen und auf der Grundlage von ihnen, um Schlussfolgerungen zu machen etablieren
123456
Neuer Kommentar