"New Neural" è un progetto di motore di rete neurale Open Source per la piattaforma MetaTrader 5. - pagina 78

Nuovo commento
 
A che punto è il progetto ora? Chi è il supervisore?
 
Meglio:
A che punto è il progetto ora? Chi è il capo?

Nessun capo, vuoi essere tu.

ZS: Penso che domani a pranzo sarebbe un momento migliore per parlare.

 
Meglio:
A che punto è il progetto ora? Chi è il capo?
Lo scommettitore non è quello che ha vinto il campionato l'altro giorno?
 
shyma:
Lo scommettitore non è lo stesso scommettitore che il neurone gufo una volta ha vinto il campionato?
Quello. Aveva un conto PAMM da qualche parte... Cerca su Google.
 
R0MAN:
Quello. Aveva un conto PAMM da qualche parte... Cerca su Google.
Attraverso il suo profilo:-)
 
aharata:
Attraverso il profilo:-)
Questa è la prima cosa che ho guardato - non sono riuscito a trovarla... al volo... :-) Non era ancora sveglio... :-)
 

Ho pensato di riportare alla luce un vecchio thread.

Propongo un modello universale di NS da prendere in considerazione.

Gli avversari sono invitati a presentare un tipo di griglia che non è possibile descrivere con questo modello!!!

Il codice è approssimativo, quindi andate a fondo.

L'implementazione proposta è facilmente trasformabile sia per CPU che per GPU. Gli operatori di ritardo sono anche forniti nella griglia.

ci sono 3 modi di trasformazione:

lasciare così com'è (tutti e 4 gli array sono 2D), adatto alla GPU

out è un array monodimensionale, ma usa anche una maschera bool bidimensionale

out è un array unidimensionale e al posto della maschera viene usato un array di indici costruito dalla maschera.

(abbiamo parlato prima di maschere binarie; è una maschera di questo tipo che usa zeri e uno per mostrare se c'è una connessione o no, in questo caso un neurone è una matrice orizzontale e le sue connessioni con altri sono indicate nel suo orizzonte da valori corrispondenti di una maschera binaria, nelle stesse celle ma in matrici parallele sono memorizzati pesi, uscite, e dati temporali, Zx sono operatori di ritardo x-range)

Modello Net

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);
     };
  };
 

Non è un modello. Dove sono i neuroni? Dove sono le connessioni? Dov'è il processo? Dove sono i feedback?

E un'altra domanda: perché fare un modello universale per tutte le reti?

Preferirei fare una rete universale per la maggior parte delle cose (heh)).

E perché saltate direttamente all'implementazione? Non hai un'architettura pronta in primo luogo.

 
TheXpert:

Questo non è un modello. Dove sono i neuroni? Dove sono le connessioni? Dov'è il processo? Dove sono i feedback?

E un'altra domanda - perché fare un modello universale per tutte le reti?

Meglio una rete universale per la maggior parte dei compiti (heh) )

I neuroni sono array orizzontali nella figura. Le connessioni sono codificate con una maschera booleana.

Faccia domande dirette, le spiegherò ciò che non è chiaro, non posso descrivere tutto in una volta.

L'architettura segue il modello e rimarrà tale.

Meglio di una rete universale per la maggior parte dei compiti (heh) )

ZZZY e voglio verificare se il modello è adatto a tutti i compiti o no. Una testa è buona, ma un coro è meglio.

Cambiando i discendenti della classe CProcessing, potete cambiare i tipi di neuroni uno per uno.

Potete inoltre aggiungere un array di tipi di neuroni e assegnare a ciascuno un tipo diverso (selezionando dal discendente CProcessing).

ZZZZY I collegamenti inversi sono etichettati Zx nella figura

 
Urain:

Allora perché avete la maschera attaccata all'uscita e non di nuovo ai neuroni?)

E come volete mettere la funzione di attivazione nella GPU?

Imho, si sta andando a stipare ciò che non si può stipulare, proprio come l'ultima volta. Ma è un imho, quindi si può semplicemente mettere in gioco.

Non ti disturberò più, a meno che non si tratti di affari.

Ah, il cogitron. Cos'altro, la rete hopfield, dove l'input è l'output. Poi c'è la rada...

1...717273747576777879808182838485...100
Nuovo commento
Motivazione: