Discusión sobre el artículo "Utilizar Mapas con Función de Auto-Organización (Mapas Kohonen) en MetaTrader 5" - página 4

Nuevo comentario
 
Graff:

No sé para qué sirven. Puedes obtener la información directamente del terminal.

Da miedo siquiera imaginar para qué sirven, probablemente alguien los contaba manualmente.

SZY: ¿alguien puede poner un mod para que el Expert Advisor pueda sacar información directamente del terminal, sin script?

Bueno, si tienes miedo, entonces por supuesto que no).
 
sergeev:
¿Qué información necesita?
La que es descargada por el script en un archivo y retraída por el Asesor Experto para su análisis. Es decir, para que el Asesor Experto SOM.mq5 pueda recibir independientemente (sin la ayuda del script DJ.mq5 y FX.mq5) los datos del terminal.
 

¿Este artículo incluye todo lo necesario para obtener un asesor experto?

Im interesado en la aplicación de Red Neuronal Asesor de Expertos.

 

¡Hola, queridos miembros del foro!

Un artículo muy interesante. Yo también estoy intentando utilizar este código SOM.

somk

Pesos p1-p4 - datos del mercado (hasta ahora sólo la diferencia entre los puntos ZZ).

p5 - resultado de una operación de compra virtual - TP=1, SL=-1 (hasta ahora TP=SP=300pp). En el delantero sólo un p5 BMU (vector más cercano) no es suficiente para predecir el resultado, me parece.

¿Puede alguien sugerir cómo hacer el cálculo del resultado de la zona alrededor de la BMU (para mayor claridad obver azul), teniendo en cuenta la distancia de la BMU ?

 
sealdo:

¿Alguien puede decirme cómo es más fácil calcular el resultado del área alrededor de la BMU (rodeada en azul para mayor claridad), teniendo en cuenta la distancia desde la BMU?

¿se refiere a cómo encontrar programáticamente esta área con coordenadas?
 
progma137:
¿Se refiere a cómo encontrar programáticamente esta área con coordenadas?

Ya existe una función en la clase CSOM:

int BestMatchingNode(double &vector[]); // encontrar el mejor nodo de la rejilla basado en un vector dado

Conociendo la dimensionalidad de nuestra rejilla, es fácil calcular las coordenadas de la BMU (o BMN en esta implementación).
Aquí queremos hacer exactamente el cálculo del resultado total (por un parámetro (peso)) del área alrededor de la BMU, teniendo en cuenta la distancia desde la BMU. Por ejemplo, tomamos una región con un diámetro de 10 neuronas (células). Las neuronas más cercanas tienen una gran influencia en el resultado. Y cuanto más lejos, más débil....

Aquí se nos plantea la cuestión de cómo debemos tratar las BMU situadas en los bordes de la cuadrícula. Al fin y al cabo, tienen menos vecinos.

 

¿Pueden decirme cómo encontrar barras en los mapas?

Introducimos cuatro vectores y obtenemos 4 mapas. Me gustaría dibujar una trayectoria en todos ellos, por ejemplo, desde el día actual (para los días) hasta 3 barras atrás y analizar el estado de las agrupaciones.

Es posible hacerlo programáticamente, por ejemplo, con la función void DrawTrajectory(int from, int count), que dibujará una trayectoria desde un número de barra dado en todos los mapas.

Y la segunda pregunta, ¿cómo obtener el mapa de salida y, sobre todo, el mapa de frecuencias?

 

No esperé una respuesta ... Escribí el método de visualización en los mapas de entrada de la trayectoria desde el número dado del vector de entrada por el número dado de pasos, no me perdone si algo está mal - Yo no soy un programador :)

¿Puede alguien traer esta biblioteca muy inteligente (gracias al autor y Alexey Sergeev) al nivel de aplicación práctica? !!!!


//------------------------------------------------------------------ ShowTrajectory
void CSOM::ShowTrajectory(int n_patern, int m_cnt) // Método para mostrar la trayectoria de los vectores de entrada
{
        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++) // establecer datos por valores vectoriales del conjunto de entrenamiento
  {
        if(ind<n_patern) continue;  // esperar el patrón de entrada requerido
        for(int k=0; k<m_dimension; k++) data[k]=m_set[m_dimension*(ind)+k];
        int winningnode=BestMatchingNode(data); // encontrar el índice del nodo más cercano
                
         // guardar las coordenadas de los patrones de entrada seleccionados para el trazado
        int x1,y1,x2,y2;
        m_node[winningnode].GetCoordinates(x1,y1,x2,y2);
        if(m_bHexCell) // si hexágonos
      {
          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_nodo[winnode].X();
        //y[idx]=(int)m_nodo[winnode].Y();
        idx++;
        m_cnt--;        
        if(m_cnt==0) break;      // registrar el número necesario de paterniones de entrada
  }
  // dibujar la trayectoria, los nodos y las inscripciones
   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];
         // nodo
         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);
         // trayectoria
         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;
         // número de paternas (barras) 
         m_bmp[k].TypeText(x[j],yc,name[j], clrIndigo);
    }    
  }
}
 

En la clase CSOM el contador de vectores de entrenamiento cargados m_nSet se reinicia sólo en el constructor CSOM::CSOM().

Como resultado, el número de vectores de entrenamiento crece constantemente en el modo de reentrenamiento en bucle.

Es mejor añadir la línea m_nSet=0; al método CSOM::LoadTrainData(...) .

 
GSB:

¡¡¡¡Quizás alguien lleve una biblioteca muy útil (gracias al autor y a Alexey Sergeev) al nivel de uso práctico?!!!!


¿qué quieres decir? ¿hermoso SDK? o ¿hermosas imágenes producidas por el programa? ¿quién necesita qué, hace qué? estos mapas no son más que un medio para establecer datos que necesitan ser analizados y luego sacar conclusiones basadas en ellos.
123456
Nuevo comentario