O "New Neural" é um projecto de motor de rede neural Open Source para a plataforma MetaTrader 5. - página 78

Novo comentário
 
Em que fase se encontra o projeto agora? Quem é o supervisor?
 
Melhor:
Em que fase se encontra o projeto agora? Quem é o chefe?

Não há patrões, podes ser tu a querer ser.

ZS: Acho que amanhã à hora do almoço seria uma melhor altura para falar.

 
Melhor:
Em que fase se encontra o projeto agora? Quem é o chefe?
O apostador não é aquele que ganhou o campeonato no outro dia?
 
Shyma:
O apostador não é o mesmo apostador que o neurónio coruja uma vez ganhou o campeonato?
Essa mesmo. Ele tinha uma conta PAMM algures... Procura-o no Google.
 
R0MAN:
Essa mesmo. Ele tinha uma conta PAMM algures... Procura-o no Google.
Através do seu perfil:-)
 
aharata:
Através do perfil:-)
Foi a primeira coisa que olhei - não consegui encontrá-lo... na mosca... :-) Ainda não estava acordada... :-)
 

Pensei em trazer à tona um fio antigo.

Eu proponho um modelo NS universal para consideração.

Os oponentes são convidados a submeter um tipo de grelha que não é possível descrever com este modelo!!!

O código é rudimentar, por isso vai até ao fundo da questão.

A implementação proposta é facilmente transformável tanto para a CPU como para a GPU. Os operadores com atrasos também são fornecidos na rede.

há 3 formas de transformação:

sair como está (todas as 4 arrays são 2D), adequado para GPU

é uma matriz unidimensional, mas também usa uma máscara bidimensional

out é um array unidimensional e um array índice construído a partir da máscara é usado em vez da máscara.

(falamos anteriormente sobre máscaras binárias; é uma máscara que usa zeros e uns para mostrar se existe ou não uma conexão, neste caso um neurônio é uma matriz horizontal e suas conexões com outras são indicadas em seu horizonte pelos valores correspondentes de uma máscara binária, nas mesmas células mas em matrizes paralelas são armazenados pesos, saídas e dados temporais, Zx são operadores de retardo de raio X)

Modelo Rede

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

Isso não é um modelo. Onde estão os neurónios? Onde estão as ligações? Onde está o processo? Onde estão os feedbacks?

E qual é outra questão - porquê fazer um modelo universal para todas as redes?

Eu prefiro fazer uma rede universal para a maioria das coisas (heh)).

E porque estás a saltar directamente para a implementação? Você não tem uma arquitetura pronta em primeiro lugar.

 
TheXpert:

Isto não é um modelo. Onde estão os neurónios? Onde estão as ligações? Onde está o processo? Onde estão os feedbacks?

E outra pergunta - porquê fazer um modelo universal para todas as redes?

Melhor uma rede universal para a maioria das tarefas (heh) )

Os neurónios são matrizes horizontais na figura. As ligações são codificadas com uma máscara booleana.

Faça perguntas importantes, vou explicar o que não está claro, não posso descrever tudo de uma vez.

A arquitetura segue o modelo e assim permanecerá.

Melhor do que uma rede universal para a maioria das tarefas (heh) )

A ZZZY e eu queremos verificar se o modelo se adequa a todas as tarefas ou não. Uma cabeça é boa, mas um refrão é melhor.

Ao mudar os descendentes da classe CProcessing, você pode mudar os tipos de neurônios um por um.

Você pode adicionalmente adicionar um conjunto de tipos de neurônios e atribuir a cada um deles um tipo diferente (selecionando a partir do CProcessamento descendente).

ZZZZY As ligações inversas estão etiquetadas como Zx na figura

 
Urain:

Então por que você tem a máscara presa à saída e não novamente aos neurônios?)

E como você quer colocar a função de ativação na GPU?

Imho, vais encher o que não consegues encher, tal como da última vez. Mas é um imho, por isso podes simplesmente arriscar.

Não te incomodarei mais, a menos que seja um negócio.

Ah, o cogitron. O que mais -- a rede hopfield -- onde a entrada é a saída. Depois há pouco...

1...717273747576777879808182838485...100
Novo comentário