"New Neural" è un progetto di motore di rete neurale Open Source per la piattaforma MetaTrader 5. - pagina 34
Ti stai perdendo delle opportunità di trading:
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Registrazione
Accedi
Accetti la politica del sito e le condizioni d’uso
Se non hai un account, registrati
Cercherò di mettermi in contatto con lui - sparisce per molto tempo. Naturalmente, sarebbe bello avere un articolo dedicato a OpenCL con MQL5. Soprattutto ora.
Come va?JavaDev non è su Skype da oltre un mese.
Questo è un suo pezzo di codice che dimostra come funzionaOpenCL
[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); } };Come va?JavaDev non è su Skype da oltre un mese.
L'ho contattato, JavaDev sta tenendo d'occhio l'argomento.
Lezione 1 qui https://www.mql5.com/ru/forum/4956/page23
Lezione 2. Metodi biologici di elaborazione delle informazioni
Lascio brevemente il principio delle scariche nelle reti e considero brevemente l'essenza della trasformazione biologica dell'informazione. Per esempio, consideriamo la trasformazione dell'informazione nella corteccia visiva. Questo argomento è lontano dal trading, ma aiuta a disegnare pensieri intelligenti. A proposito, molte reti come le mappe di Kohonen e i metodi di auto-addestramento delle scale sono stati introdotti nel tentativo di modellare la corteccia visiva. Così, le informazioni visive sono convertite in segnali elettrici dalle cellule fotorecettrici retiniche, poi filtrate dalle cellule gangliari retiniche (RGC) e quindi inviate alla corteccia visiva attraverso le cellule relè LGN, il cui scopo è ancora poco compreso. Le cellule gangliari retiniche agiscono come filtri spaziali passa-banda, evidenziando i contorni degli oggetti. Il modo in cui funzionano è molto simile alla funzione di rilevamento dei bordi in Photoshop. È abbastanza interessante che percepiamo il mondo attraverso i confini degli oggetti. Nella corteccia visiva, l'immagine filtrata passa attraverso diversi strati neurali con nomi e sigle astruse. Ci sono due canali di conversione dell'informazione visiva: il canale "cosa", che esegue il riconoscimento degli oggetti, e un canale parallelo "dove" per localizzare gli oggetti e percepire il loro movimento. Siamo interessati al primo canale, che consiste negli strati bidimensionali V1, V2, V4 e IT, che sono disposti in parallelo alla retina (non nello spazio, ma funzionalmente). La struttura di questi strati è abbastanza complessa. I segnali elettrici sono trasmessi dalle cellule gangliari della retina alla V1, dalla V1 alla V2, ecc. Le cellule di uno strato prendono i loro input dalle cellule dello strato precedente (propagazione diretta del segnale) così come dai loro vicini (connessioni ricorrenti intra-strato). Ci sono anche connessioni ricorrenti, che sono spesso trascurate perché sono poco comprese. La conversione delle informazioni nella corteccia visiva può essere rappresentata graficamente nella seguente forma semplificata:
Le cellule semplici S1 si trovano in V1. Sono filtri di frammenti elementari di contorni (bordi di oggetti), cioè brevi segmenti di linee con diversi angoli di pendenza, diverse lunghezze, diverse polarità (linea chiara su sfondo scuro, linea scura su sfondo chiaro), e diverse posizioni nello spazio bidimensionale. Ogni cellula S1 essenzialmente "guarda" una certa sezione dell'immagine attraverso una stretta "fessura" di una certa inclinazione e lunghezza, e reagisce solo quando il contorno in quella sezione coincide per inclinazione, lunghezza e polarità con la "fessura".
Le cellule complesse C1 si trovano anche sullo strato V1. Come le cellule semplici S1, rispondono a brevi segmenti di contorno di una particolare pendenza e lunghezza all'interno di una certa area dell'immagine, ma sono meno sensibili agli spostamenti paralleli a questi segmenti (invarianza di spostamento).
Le cellule semplici S2 si trovano negli strati V2 e V4. Sono filtri spaziali di forme più complesse, costituiti da due segmenti rettilinei di diversa pendenza e lunghezza (per esempio, G, T, L, V, X). Rispondono a queste forme in diversi punti dell'immagine.
Le cellule complesse C2 (cellule complesse C1) si trovano negli strati V2 e V4. Anch'essi sono filtri spaziali di forme più complesse che consistono in due segmenti di linea retta di diversa inclinazione e lunghezza, ma sono meno sensibili agli spostamenti paralleli di queste forme.
Le celle di visualizzazione (o celle semplici S3) si trovano nello strato IT. Sono sensibili a forme ancora più complesse di diversi orientamenti e dimensioni (oggetti).
Le vendite selettive di oggetti (o cellule complesse C3) sono anche su uno strato IT. Anch'essi reagiscono a oggetti di diverso orientamento e dimensione, ma indipendentemente dal loro posizionamento.
Questa conversione multistrato delle informazioni visive permette al nostro cervello di riconoscere un oggetto indipendentemente dalla sua posizione nell'immagine, dal suo orientamento e dalle sue dimensioni. Il riconoscimento degli oggetti (classificazione) avviene nello strato successivo della corteccia visiva, chiamato corteccia prefrontale (PFC).
Come li chiameremo?
Pensa al logo :)
Come lo chiamiamo?
Rete NeuraleMeta Universale (MUNN)
O non pretende di essere universale?
Rivendicazione?