"New Neural" est un projet de moteur de réseau neuronal Open Source pour la plateforme MetaTrader 5. - page 34

 
joo:
Je vais essayer d'entrer en contact avec lui - il disparaît pendant longtemps. Bien sûr, il serait formidable d'avoir un article dédié à OpenCL avec MQL5. Surtout maintenant.

Comment ça va ?JavaDev n'a pas été sur Skype depuis plus d'un mois.

Voici un morceau de code de lui démontrant le fonctionnement d'OpenCL

[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:

Comment ça va ?JavaDev n'a pas été sur Skype depuis plus d'un mois.

Je l'ai contacté, JavaDev garde un œil sur le sujet.
 
joo:
Je l'ai contacté, JavaDev garde un œil sur le sujet.
Hourra. Il y a un espoir que le projet ne meure pas :)
 

Lecture 1 ici https://www.mql5.com/ru/forum/4956/page23

Cours 2. Méthodes biologiques de traitement de l'information

Je laisserai brièvement le principe des décharges dans les réseaux et j'examinerai brièvement l'essence de la transformation biologique de l'information. Ensuite, je relierai tout. Par exemple, considérons la transformation de l'information dans le cortex visuel. Ce sujet est loin d'être commercial, mais il permet de dessiner des pensées intelligentes. D'ailleurs, de nombreux réseaux tels que les cartes de Kohonen et les méthodes d'auto-apprentissage des échelles ont été introduits pour tenter de modéliser le cortex visuel. Ainsi, les informations visuelles sont converties en signaux électriques par les cellules photoréceptrices de la rétine, puis filtrées par les cellules ganglionnaires de la rétine (CGR) et enfin envoyées au cortex visuel via les cellules relais du LGN, dont la fonction est encore mal comprise. Les cellules ganglionnaires de la rétine agissent comme des filtres spatiaux passe-bande, mettant en évidence les contours des objets. Leur fonctionnement est très similaire à celui de la fonction de détection des bords dans Photoshop. Il est assez intéressant de constater que nous percevons le monde à travers les limites des objets. Dans le cortex visuel, l'image filtrée passe par plusieurs couches neuronales aux noms et acronymes abscons. Il existe deux canaux de conversion de l'information visuelle : le canal "quoi", qui effectue la reconnaissance des objets, et un canal parallèle "où" pour localiser les objets et percevoir leur mouvement. Nous nous intéressons au premier canal, qui est constitué des couches bidimensionnelles V1, V2, V4 et IT, qui sont disposées parallèlement à la rétine (non pas dans l'espace, mais sur le plan fonctionnel). La structure de ces couches est assez complexe. Des signaux électriques sont transmis des cellules ganglionnaires de la rétine à V1, de V1 à V2, etc. Les cellules d'une couche prennent leurs entrées des cellules de la couche précédente (propagation directe du signal) ainsi que de leurs voisines (connexions récurrentes intra-couche). Il existe également des connexions récurrentes, qui sont souvent négligées car elles sont mal comprises. La conversion des informations dans le cortex visuel peut être représentée graphiquement sous la forme simplifiée suivante :

Les cellules simples S1 se trouvent dans V1. Elles filtrent des fragments élémentaires de contours (frontières d'objets), c'est-à-dire de courts segments de lignes ayant des angles de pente différents, des longueurs différentes, des polarités différentes (ligne claire sur fond sombre, ligne sombre sur fond clair) et des emplacements différents dans l'espace bidimensionnel. Chaque cellule S1 "regarde" essentiellement une certaine section de l'image à travers une "fente" étroite d'une certaine inclinaison et longueur, et ne réagit que lorsque le contour de cette section coïncide en inclinaison, longueur et polarité avec la "fente".

Les cellules complexes C1 se trouvent également sur la couche V1. Comme les cellules simples S1, elles répondent à de courts segments de contours d'une pente et d'une longueur particulières dans une certaine zone de l'image, mais sont moins sensibles aux déplacements parallèles à ces segments (invariance des déplacements).

Les cellules simples S2 se trouvent dans les couches V2 et V4. Ce sont des filtres spatiaux de formes plus complexes, constitués de deux segments rectilignes de pente et de longueur différentes (par exemple, G, T, L, V, X). Ils réagissent à ces formes à différents endroits de l'image.

Les cellules complexes C2 (cellules complexes C1) se trouvent dans les couches V2 et V4. Ils sont également des filtres spatiaux de formes plus complexes constituées de deux segments de ligne droite de pente et de longueur différentes, mais sont moins sensibles aux décalages parallèles de ces formes.

Les cellules de visualisation (ou cellules simples S3) se trouvent dans la couche IT. Ils sont sensibles à des formes encore plus complexes, de différentes orientations et tailles (objets).

Les ventes sélectives d'objets (ou cellules complexes C3) se trouvent également sur une couche informatique. Ils réagissent eux aussi à des objets de différentes orientations et tailles, mais indépendamment de leur emplacement.

Cette conversion multicouche des informations visuelles permet à notre cerveau de reconnaître un objet indépendamment de son emplacement dans l'image, de son orientation et de sa taille. La reconnaissance (classification) des objets a lieu dans la couche suivante du cortex visuel, appelée cortex préfrontal (CPF).

 
Comment devons-nous appeler le projet?
 
LeXpert:
Comment les appeler ?
Si la question s'adresse à moi, dans la littérature, les réseaux que j'ai décrits sont appelés réseaux neuronaux hiérarchiques.
 
LeXpert:
Pensez au logo :)
L'idée est qu'il doit entrer en résonance (se lier d'amitié) avec le logo methaquot.
 
LeXpert:
Comment l'appeler ?

Réseau neuronaluniversel méta (MUNN)

Ou vous ne prétendez pas être universel ?

 
Urain:
Revendication ?
Vous le faites. Mais pas tant que ça. La perception est la perception. Tout réseau peut être considéré comme une boîte noire qui reçoit et transforme les informations provenant des organes de perception (entrées).
 
Cerveauartificiel
Raison: