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

 
joo:
Intentaré ponerme en contacto con él - desaparece durante mucho tiempo. Por supuesto, sería genial tener un artículo dedicado a OpenCL con MQL5. Especialmente ahora.

¿Cómo va todo?JavaDev no haestado en Skype desde hace más de un mes.

Este es un trozo de código suyo que demuestra cómo funcionaOpenCL

[05.06.2011 17:29:59] JavaDev:    __kernel void MFractal(                           \r\n"
"                        float x0,                    \r\n"
"                        float y0,                    \r\n"
"                        float x1,                    \r\n"
"                        float y1,                    \r\n"
"                        uint  max,                   \r\n"
"         __global       uint *out)                   \r\n"
"     {//------------------------------------------   \r\n"
"         size_t  w = get_global_size(0);             \r\n"
"         size_t  h = get_global_size(1);             \r\n"
"         size_t gx = get_global_id(0);               \r\n"
"         size_t gy = get_global_id(1);               \r\n"


"         float dx = x0 + gx * (x1-x0) / (float) w;           \r\n"
"         float dy = y0 + gy * (y1-y0) / (float)h;           \r\n"

"         float x  = 0;                               \r\n"
"         float y  = 0;                               \r\n"
"         float xx = 0;                               \r\n"
"         float yy = 0;                               \r\n"
"         float xy = 0;                               \r\n"

"         uint i = 0;                                  \r\n"
"         while ((xx+yy)<4 && i<max) {                \r\n"
"            xx = x*x;                                \r\n"
"            yy = y*y;                                \r\n"
"            xy = x*y;                                \r\n"
"            y = xy+xy+dy;                            \r\n"
"            x = xx-yy+dx;                            \r\n"
"            i++;                                     \r\n"
"      }                                              \r\n"

"      if (i == max) {                                \r\n"
"         out[w*gy+gx] = 0;                           \r\n"
"      } else {                                       \r\n"
"        out[w*gy+gx] = (uint)((float)0xFFFFFF/(float)max)*i;                \r\n"
"    }                                               \r\n"
"   }//--------------------------------------------   \r\n"

 

   int calcOCL() {
      ulong startTime = GetTickCount();
      CL_STATUS status;
      cl_mem data_buf;
      data_buf = ctx.CreateBuffer(CL_MEM_ALLOC_HOST_PTR,CL_MEM_READ_WRITE,m_SizeX*m_SizeY,FLOAT,status);
      if (status!=CL_SUCCESS) {
         Alert("CreateBuffer: ", EnumToString(status));
         return (-1);
      }
      float x0 = -2;
      float y0 = -0.5;
      float x1 = -1;
      float y1 =  0.5;
      uint  max = iterations;
      
      
      kernel.SetArg(0,x0);
      kernel.SetArg(1,y0);
      kernel.SetArg(2,x1);
      kernel.SetArg(3,y1);
      kernel.SetArg(4,max);
      kernel.SetArg(5,data_buf);
      
      uint offset[2] =  {0,0};
      uint work  [2];  work[0]= m_SizeX; work[1]= m_SizeY;
      uint group [2];  group [0] = wgs; group [1] = 1; 
      
      status = queue.NDRange(kernel, 2, offset, work, group);
      oclFlush(queue);
      
      for (int y=0;y<m_SizeY;y++) {
         status = queue.ReadBuffer(data_buf,true,y*m_SizeX,m_SizeX,Line[y].Pixel);
         if (status!=CL_SUCCESS) {
            Alert("ReadBuffer: ", EnumToString(status));
            break;
         }
      }
      oclFinish(queue);
      
      data_buf.Release();
      queue.Release();
      uint endTime = GetTickCount();
      return (int)(endTime-startTime);
   }
   
   uint calcMQL() {
      uint startTime = GetTickCount();
      float x0 = -2;
      float y0 = -0.5;
      float x1 = -1;
      float y1 =  0.5;
      uint  max = iterations;
      uint  w = m_SizeX;
      uint  h = m_SizeY;
      
      for (uint gy =0;gy<h;gy++) {
         for (uint gx =0;gx<w;gx++) {
            float dx = x0 + gx * (x1-x0) / w;
            float dy = y0 + gy * (y1-y0) / h;

            float x  = 0;
            float y  = 0;
            float xx = 0;
            float yy = 0;
            float xy = 0;
            uint i = 0;
            while ((xx+yy)<4 && i<max) {
               xx = x*x;
               yy = y*y;
               xy = x*y;
               y = xy+xy+dy;
               x = xx-yy+dx;
               i++;
            }

            if (i == max) {
               Line[gy].Pixel[gx]=0;
            } else {
               Line[gy].Pixel[gx] = (int) (((float)i/max)*0xFFFFFF);
                 }
         }
      }
      uint endTime = GetTickCount();
      return (int)(endTime-startTime);
   }
};
 
Graff:

¿Cómo va todo?JavaDev no haestado en Skype desde hace más de un mes.

Me he puesto en contacto con él, JavaDev está pendiente del tema.
 
joo:
Me he puesto en contacto con él, JavaDev está pendiente del tema.
Hurra. Hay esperanza de que el proyecto no muera :)
 

Conferencia 1 aquí https://www.mql5.com/ru/forum/4956/page23

Conferencia 2. Métodos biológicos de procesamiento de la información

Dejaré brevemente el principio de las descargas en las redes y consideraré brevemente la esencia de la transformación biológica de la información. Por ejemplo, consideremos la transformación de la información en la corteza visual. Este tema está lejos del comercio, pero ayuda a dibujar pensamientos inteligentes. Por cierto, se introdujeron muchas redes, como los mapas de Kohonen y los métodos de autoaprendizaje de escalas, en un intento de modelar la corteza visual. Así, la información visual es convertida en señales eléctricas por las células fotorreceptoras de la retina, luego filtrada por las células ganglionares de la retina (CGR) y después enviada a la corteza visual a través de las células de relevo de la LGN, cuya finalidad es aún poco conocida. Las células ganglionares de la retina actúan como filtros espaciales de paso de banda, resaltando los contornos de los objetos. Su funcionamiento es muy similar al de la función de detección de bordes de Photoshop. Es muy interesante que percibamos el mundo a través de los límites de los objetos. En la corteza visual, la imagen filtrada pasa por varias capas neuronales con nombres y siglas abstrusas. Hay dos canales de conversión de la información visual: el canal "qué", que realiza el reconocimiento de los objetos, y un canal paralelo "dónde" para localizar los objetos y percibir su movimiento. Nos interesa el primer canal, que consiste en las capas bidimensionales V1, V2, V4 e IT, que están dispuestas en paralelo a la retina (no en el espacio, sino funcionalmente). La estructura de estas capas es bastante compleja. Las señales eléctricas se transmiten de las células ganglionares de la retina a V1, de V1 a V2, etc. Las células de una capa toman sus entradas de las células de la capa anterior (propagación directa de la señal), así como de sus vecinas (conexiones recurrentes intracapa). También hay conexiones recurrentes, que a menudo se descuidan porque son poco conocidas. La conversión de información en la corteza visual puede representarse gráficamente de la siguiente forma simplificada:

Las células simples S1 se encuentran en V1. Son filtros de fragmentos elementales de contornos (bordes de objetos), es decir, segmentos cortos de líneas con diferentes ángulos de inclinación, diferentes longitudes, diferentes polaridades (línea clara sobre fondo oscuro, línea oscura sobre fondo claro) y diferentes ubicaciones en el espacio bidimensional. Cada célula S1 "mira" esencialmente una determinada sección de la imagen a través de una estrecha "rendija" de cierta inclinación y longitud, y reacciona sólo cuando el contorno de esa sección coincide en inclinación, longitud y polaridad con la "rendija".

Las células complejas C1 también se encuentran en la capa V1. Al igual que las células simples S1, responden a segmentos cortos de contornos de una determinada pendiente y longitud dentro de un área determinada de la imagen, pero son menos sensibles a los desplazamientos paralelos a estos segmentos (invariabilidad al desplazamiento).

Las células simples S2 se encuentran en las capas V2 y V4. Son filtros espaciales de formas más complejas, formados por dos segmentos rectos de diferente pendiente y longitud (por ejemplo, G, T, L, V, X). Responden a estas formas en diferentes lugares de la imagen.

Las células complejas C2 (células complejas C1) se encuentran en las capas V2 y V4. También son filtros espaciales de formas más complejas que consisten en dos segmentos de línea recta de diferente pendiente y longitud, pero son menos sensibles a los desplazamientos paralelos de estas formas.

Las celdas de visualización (o celdas simples S3) se encuentran en la capa IT. Son sensibles a formas aún más complejas de diferentes orientaciones y tamaños (objetos).

Las ventas selectivas de objetos (o células complejas C3) también se encuentran en una capa IT. También reaccionan ante objetos de diferentes orientaciones y tamaños, pero independientemente de su ubicación.

Esta conversión de la información visual en varias capas permite a nuestro cerebro reconocer un objeto independientemente de su ubicación en la imagen, su orientación y su tamaño. El reconocimiento de los objetos (clasificación) tiene lugar en la siguiente capa de la corteza visual, denominada corteza prefrontal (CPF).

 
¿Cómo llamaremos al proyecto?
 
TheXpert:
¿Cómo debemos llamarlos?
Si la pregunta es para mí, en la literatura, las redes que he descrito se llaman redes neuronales jerárquicas.
 
TheXpert:
Piensa en el logotipo :)
La idea es que resuene (se haga amigo) del logo methaquot
 
TheXpert:
¿Cómo lo llamamos?

Red NeuralMeta Universal (MUNN)

¿O no pretende ser universal?

 
Urain:
¿Reclamar?
Lo haces. Pero no tanto. La percepción es la percepción. Cualquier red puede considerarse como una caja negra que recibe y transforma la información de los órganos de percepción (inputs).
 
Cerebroartificial