"New Neural" es un proyecto de motor de red neuronal de código abierto para la plataforma MetaTrader 5. - página 78

Nuevo comentario
 
¿En qué fase se encuentra el proyecto? ¿Quién es el supervisor?
 
Mejor:
¿En qué fase se encuentra el proyecto? ¿Quién es el jefe?

No hay jefes, quieres ser tú.

ZS: Creo que mañana a la hora de comer sería un mejor momento para hablar.

 
Mejor:
¿En qué fase se encuentra el proyecto? ¿Quién es el jefe?
¿No es el apostador el que ganó el campeonato el otro día?
 
shyma:
¿No es el mismo apostador que una vez ganó el campeonato?
Ese mismo. Tenía una cuenta PAMM en alguna parte... Búscalo en Google.
 
R0MAN:
Ese mismo. Tenía una cuenta PAMM en alguna parte... Búscalo en Google.
A través de su perfil:-)
 
aharata:
A través del perfil:-)
Eso es lo primero que miré - no pude encontrarlo... sobre la marcha... :-) Todavía no estaba despierto... :-)
 

Pensé en sacar a relucir un viejo hilo.

Propongo un modelo universal de NS para su consideración.

¡¡¡Los opositores están invitados a presentar un tipo de parrilla que no es posible describir con este modelo!!!

El código es tosco, así que llega al fondo de la cuestión.

La implementación propuesta es fácilmente transformable tanto para la CPU como para la GPU. También se proporcionan operadores de retraso en la red.

hay 3 formas de transformación:

dejar como está (las 4 matrices son 2D), adecuado para la GPU

out es un array unidimensional, pero también utiliza una máscara bool bidimensional

out es una matriz unidimensional y se utiliza una matriz de índices construida a partir de la máscara en lugar de la máscara.

(antes hablamos de las máscaras binarias; es una máscara de este tipo que utiliza ceros y unos para mostrar si hay una conexión o no, en este caso una neurona es una matriz horizontal y sus conexiones con otras se indican en su horizonte mediante los valores correspondientes de una máscara binaria, en las mismas celdas pero en matrices paralelas se almacenan pesos, salidas y datos temporales, Zx son operadores de retardo de rango x)

Modelo de red

class CDmem
  {
public:
                     CDmem(void){};
                    ~CDmem(void){};
   double            m[];
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class CBmem
  {
public:
                     CBmem(void){};
                    ~CBmem(void){};
   bool              m[];
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class CProcessing
  {
public:
                     CProcessing(void){};
                    ~CProcessing(void){};
   virtual void      Processing(int i,CBmem &mask[],CDmem &weg[],CDmem &out[],CDmem &temp[],int I,int J)
     {
      for(int j=0;j<J;j++)
        {
         temp[i].m[j]=mask[i].m[j]*weg[i].m[j]*out[i].m[j];
        }
      double sum=0;
      for(int j=0;j<J;j++)
        {
         sum+=temp[i].m[j];
        }

      double outt=2./(1.+exp(-sum));
      for(int j=0;j<J;j++)
         out[i].m[j]=outt;
     };
   void              DelayOperator(int i,CDmem &out[])
     {
      // тут мы сдвишаем от конца к началу, реализуем оператор задержки
     };
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class Unet
  {
   int               cnt_prcss;
   CBmem             mask[];
   CDmem             weg[];
   CDmem             out[];
   CDmem             temp[];
   CProcessing      *prcss[];
   void              Init()
     {
      ArrayResize(mask,5);
      ArrayResize(weg,5);
      ArrayResize(out,5);
      ArrayResize(temp,5);
      for(int i=0;i<5;i++)
        {
         ArrayResize(mask[i].m,19);
         ArrayResize(weg[i].m,19);
         ArrayResize(out[i].m,19);
         ArrayResize(temp[i].m,19);
        }
     };
   void              InitProcessing(CProcessing *p)
     {
      prcss[cnt_prcss]=p;
      cnt_prcss++;
     };
public:
                     Unet(void){Init(); cnt_prcss=0;};
                    ~Unet(void)
     {
      for(int i=0;i<cnt_prcss;i++)
         delete prcss[i];
     };
   void              DonwloadMask(){};
   void              DonwloadWeg(){};
   void              Processing()
     {
      for(int i=0;i<cnt_prcss;i++)
         prcss[i].Processing(i,mask,weg,out,temp,5,19);
     };
   void              DelayOperator()
     {
      for(int i=0;i<cnt_prcss;i++)
         prcss[i].DelayOperator(i,out);
     };
  };
 

Eso no es un modelo. ¿Dónde están las neuronas? ¿Dónde están las conexiones? ¿Dónde está el proceso? ¿Dónde están las reacciones?

Y otra pregunta: ¿por qué hacer un modelo universal para todas las redes?

Prefiero hacer una red universal para la mayoría de las cosas (je)).

¿Y por qué saltas directamente a la aplicación? Para empezar, no tienes una arquitectura preparada.

 
TheXpert:

Esto no es un modelo. ¿Dónde están las neuronas? ¿Dónde están las conexiones? ¿Dónde está el proceso? ¿Dónde están las reacciones?

Y otra pregunta: ¿por qué hacer un modelo universal para todas las redes?

Mejor una red universal para la mayoría de las tareas (je) )

Las neuronas son matrices horizontales en la figura. Las conexiones se codifican con una máscara booleana.

Haz preguntas capciosas, te explicaré lo que no esté claro, no puedo describirlo todo a la vez.

La arquitectura se desprende del modelo y seguirá siéndolo.

Mejor que una red universal para la mayoría de las tareas (je) )

ZZZY y quiero comprobar si el modelo se adapta a todas las tareas o no. Una cabeza está bien, pero un coro es mejor.

Cambiando los descendientes de la clase CProcessing, puedes cambiar los tipos de neuronas uno por uno.

Adicionalmente, puede añadir una matriz de tipos de neuronas y asignar a cada una un tipo diferente (seleccionando de la descendiente CProcessing).

ZZZZY Los enlaces inversos están etiquetados como Zx en la figura

 
Urain:

Entonces, ¿por qué tiene la máscara unida a la salida y no de nuevo a las neuronas)?

¿Y cómo quieres poner la función de activación en la GPU?

Imho, vas a empollar lo que no puedes empollar, como la última vez. Pero es un imho, así que puedes ponerlo en la línea.

No te molestaré más, a menos que sea por negocios.

Ah, el cogitrón. Qué más... la red hopfield... donde la entrada es la salida. Luego está la escasa...

1...717273747576777879808182838485...100
Nuevo comentario