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

Novo comentário
 
TheXpert:

Quem tem experiência de trabalho em equipe em um grande projeto?

Também me refiro à experiência com VCS.

Em geral, tanto quanto posso compreender, existe uma espécie de impasse - aqui, no essencial, todas as aves independentes, capazes de resolver qualquer problema por si próprias (desde o auto-estudo da linguagem até à descrição de uma lógica comercial complexa). E um cisne, um lagostim e um lúcio com todas as suas fortes qualidades em uma única carroça, claro, podem ser aproveitados, mas suficientes apenas para 50 páginas de discussões ativas neste ramo do fórum...

Agora a questão é que o projeto deve ter um líder que:

  • em primeiro lugar, estará interessado no objectivo final do projecto,
  • Em segundo lugar, será capaz de dividir o projeto em etapas, tarefas e subtarefas, que qualquer programador neste tópico seria capaz de anotar e fazer em um tempo razoável. Ao mesmo tempo, é desejável tornar as tarefas e subtarefas independentes do contexto, ou seja, abstraí-las o máximo possível de outros códigos.
  • Em terceiro lugar, é preciso manter-se a par do projecto e saber que partes estão prontas e em que medida; se é possível integrar a solução das subtarefas em toda a tarefa.
A solução ideal seria provavelmente alguém da MetaQuotes, com experiência semelhante, + seria uma oportunidade de experimentar o TeamWox em relação à comunidade MQL, tanto mais que a Renat já o mencionou.

 

Se os MCs não estiverem ativos nas próximas semanas, o projeto pode ser sucateado, ou mudado para um local comercial em outro lugar.

Sem o controle dos MCs, o projeto como fonte opsológica não tem sentido.

 
Vladix:

Em geral, tanto quanto posso compreender, existe uma espécie de impasse - aqui, no essencial, todas as aves independentes, capazes de resolver qualquer problema por si próprias (desde o auto-estudo da linguagem até à descrição da complexa lógica do comércio). E um cisne, um lagostim e um lúcio com todas as suas fortes qualidades em uma única carroça, claro, podem ser aproveitados, mas suficientes apenas para 50 páginas de discussões ativas neste ramo do fórum...

Agora a questão é que o projeto deve ter um líder que:

  • em primeiro lugar, estará interessado no objectivo final do projecto,
  • Em segundo lugar, será capaz de dividir o projeto em etapas, tarefas e subtarefas, que qualquer programador neste tópico seria capaz de anotar e fazer em um tempo razoável. As tarefas e subtarefas devem ser de preferência independentes do contexto, ou seja, abstraídas de outros códigos tanto quanto possível.
  • Em terceiro lugar, é preciso manter-se a par do projecto e saber que partes estão prontas e em que medida; se é possível integrar a solução das subtarefas em toda a tarefa.
A solução ideal seria provavelmente alguém da MetaQuotes, que tenha experiência semelhante, + seria uma oportunidade de experimentar o TeamWox em relação à comunidade MQL, tanto mais que Renat já o mencionou uma vez.

Em suma, o que ele disse é verdade. Cada um de nós é capaz de fazer este projeto por conta própria.

Mas, como sempre, o diabo está nos detalhes.

Em materiais de 50 páginas de assalto podemos resumir que existem idéias e a partir delas você pode fazer um plano de ataque bastante sensato.

Embora a maioria sejam indivíduos, mas ninguém está resistindo ao trabalho em equipe. Afinal, o trabalho em equipe permite paralelizar tarefas, o que irá acelerar todo o projeto.

E aí vêm os detalhes: o trabalho em equipe no sentido clássico pressupõe que o artista recebe a tarefa e a completa dentro do tempo especificado. Então será possível planejar o progresso do projeto a partir de um único centro e distribuir tarefas aos artistas. Na verdade, os artistas estão ocupados fazendo suas próprias coisas e não podem se concentrar todo o seu tempo no projeto terceirizado. Assim, haverá inevitavelmente um desequilíbrio no desenvolvimento do projecto.

Penso que a solução pode ser um quadro de anúncios onde o gestor irá definir as tarefas e os artistas irão pegar o que puderem e relatar o progresso e os prazos. Se o TDR for claramente formalizado, o projecto será concluído antes do seu início :)

E mais um detalhe, seria bom ter uma lista de nomes de variáveis e métodos comumente usados, não que seja fundamentalmente, mas será mais fácil se for padronizado. Embora, é claro, seja difícil fazer tal lista, mas alguns princípios gerais de criação de nomes podem ser trabalhados (ou emprestados).

 
TheXpert:

Se os MCs não estiverem ativos nas próximas duas semanas, o projeto pode ser sucateado, ou movido comercialmente e em outro lugar.

Pois sem o controle da MK, o projeto como fonte opsital perde o seu significado.

Isso é o que estás a dizer.

Pelo menos dois de nós, tu e eu, podemos fazer tudo sozinhos.

ZZY e como você disse corretamente, o desenvolvimento personalizado já é um desenvolvimento comercial.

Como o tempo é gasto e apenas um tem o código fonte, a conclusão é simples.

 

Está bem, enquanto procuramos o Pai Natal,

Vou afixar todo o lixo que desenterrar no meu cérebro, talvez a partir disto seja possível compor pelo menos alguns TOR.


Motor da grade
1. inicialização da grade http://cgm.computergraphics 2. fluxo de trabalho da grade
3. treinamento da grade

1) a topologia da grade pode ser definida por campos binários
mais detalhes aqui .ru/content/view/25 secção 7.Direct coding

A separação em gramáticas ou codificação directa já é uma superestrutura sobre o método de inicialização, de qualquer forma no final tudo se resume à codificação directa.
Assim, as próprias topologias (que é a maior parte das dificuldades em especificar uma rede) são reduzidas a métodos de escrita para fazer uma tabela de codificação direta.
O artigo diz que é impossível especificar links inversos, mas se para cada rank de operadores de atraso criar a sua própria matriz de links, o problema desaparece (embora a matriz esteja cheia e não triangular como no atraso zero).
Acontece que a superestrutura sobre o método de codificação direta deve saber qual o atraso que a rede usa.
Os tipos de neurônios também devem ser especificados na superestrutura (aqui este ponto eu ainda não resolvi, não tenho certeza se preciso escrever e sobrecarregar os tipos de neurônios ou defini-los por alguns métodos mais liberais) ?
Podemos parar com a sobrecarga de tipos duros por agora e se houver um método de codificação suave adicioná-lo como um de sobrecarga.

2) O curso de trabalho é condicionado por links prescritos (usando agregação de dados) e tipos de neurônios, eu o expus na página 5. Deve haver 4 matrizes de dados no exterior: Entradas da Rede, Saídas de Neurônio, Pesos, Saídas da Rede. O acesso externo às entradas e saídas da rede é necessário, por exemplo, para a alimentação e para o uso operacional da rede. O acesso externo a Weights é necessário para a aprendizagem. O acesso externo às saídas do Neuron é necessário para enviar para a GPU para cálculo. Em princípio, penso que as matrizes de dados devem ser inicialmente externas, e já esses dados externos devem ser agregados na rede.

3 ) Treinamento. Estou inclinado a treinar com a GA como um método independente da topologia da rede, proponho-me tomá-la como base e, se possível/necessário, sobrecarregá-la para o método certo.

As que estão na agenda são três tarefas.

Uma camada é uma união de neurónios que não dependem da mesma iteração e têm o mesmo tipo.


 

A separação é na verdade muito realista.

Por exemplo, existe a interface IEvolvable. Uma interface para o lado genético da grelha. Assim, por exemplo, você e Andrei podem serrar a genética silenciosamente, usando apenas esta interface.

 

A propósito, é aqui que a herança múltipla seria realmente útil.

________________

Concordo, vou tentar escrever as interfaces hoje.

A propósito. O gerente de projeto pode ser gpwr. Eu serei parcialmente responsável por isso.

Em princípio, podemos iniciar o projecto.

 
Ugh. Está a descer a colina.
 

Este é um lembrete para si e para os outros sobre os tipos de ligação de dados.

//+------------------------------------------------------------------+
//| Пример Ассоциации, Агрегации, Композиции                         |
//+------------------------------------------------------------------+
/*///
   * Ассоциация обозначает связь между объектами. Агрегация и композиция это частные случаи ассоциации.
   * Агрегация предполагает, что объекты связаны взаимоотношением "part-of" (часть-целое). 
     Агрегация может быть множественной, 
     то есть один и тот же объект одновременно может быть агрегирован в несколько классов, либо объектов.
   * Композиция более строгий вариант агрегации. Дополнительно к требованию part-of накладывается условие, 
     что "часть" не может одновременно принадлежать разным "хозяевам", и заканчивает свое существование вместе с владельцем.
/*///
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class Base
  {
public:
                     Base(void){};
                    ~Base(void){};
   int               a;
  };
//+------------------------------------------------------------------+

class A_Association
  {
public:
                     A_Association(void){};
                    ~A_Association(void){};
   void              Association(Base *a_){};
   // При ассоциации данные связываемого объекта 
   // будут доступны через указатель объекта только в методе, 
   // в который передан указатель.
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class A_Aggregation
  {
   Base             *a;
public:
                     A_Aggregation(void){};
                    ~A_Aggregation(void){};
   void              Aggregation(Base *a_){a=a_;};
   // При агрегации данные связываемого объекта 
   // будут доступны через указатель объекта в любом методе класса.
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class A_Composition
  {
   Base             *a;
public:
                     A_Composition(void){ a=new Base();};
                    ~A_Composition(void){delete a;};
   // При композиции объект становится частью класса.
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnStart()
  {
   Base a; 
   A_Association b;
   b.Association(GetPointer(a));
  }
 

Há uma nuance no problema do fluxo de trabalho, já que os métodos de processamento de dados dependem do tipo de neurônio, eles devem fazer parte de um objeto do tipo neurônio.

A nuance está no que se deve considerar como uma camada. Se tal formulação, que eu dei, seria difícil organizar o cálculo na GPU.

Se nos cingirmos à formulação do TheXpert , haveria problemas com a carga na GPU.

No conjunto, inclino-me para a formulação de compromisso (combinação), tem menos problemas, embora herde o problema da carga da GPU.

A camada é uma união de neurónios que não dependem da mesma iteração e têm o mesmo tipo.

Alguma ideia?

O PS tem alguma objecção?

1...424344454647484950515253545556...100
Novo comentário