"New Neural" es un proyecto de motor de red neuronal de código abierto para la plataforma MetaTrader 5. - página 49

Nuevo comentario
 
TheXpert:

¿Quién tiene experiencia en trabajar en equipo en un gran proyecto?

También me refiero a la experiencia con VCS.

En general, por lo que puedo entender, hay una especie de punto muerto - aquí, en su mayoría, todas las aves independientes, capaces de resolver cualquier problema por su cuenta (de auto-estudio del lenguaje a la descripción de la lógica comercial compleja). Y un cisne, un cangrejo de río y un lucio con todas sus cualidades fuertes en un solo carro, por supuesto, pueden ser aprovechados, pero basta con ellos sólo para 50 páginas de discusiones activas en esta rama del foro...

Ahora la cuestión es que el proyecto debe tener un líder que:

  • en primer lugar, se interesará por el objetivo final del proyecto,
  • En segundo lugar, será capaz de dividir el proyecto en etapas, tareas y subtareas, que cualquier programador de este hilo sería capaz de escribir y hacer en un tiempo razonable. Es preferible que las tareas y subtareas sean independientes del contexto, es decir, que se abstraigan de otro código en la medida de lo posible.
  • En tercer lugar, hay que estar al tanto del proyecto y saber qué partes están listas y en qué medida; si es posible integrar la solución de las subtareas en la tarea completa.
La solución ideal sería probablemente alguien de MetaQuotes, teniendo una experiencia similar, + sería una oportunidad para probar TeamWox en relación con MQL-comunidad, tanto más que Renat lo mencionó una vez antes.

 

Si los MCs no están activos en las próximas semanas, el proyecto puede ser desechado, o trasladado a una ubicación comercial en otro lugar.

Sin el control de los CM, el proyecto como fuente de operaciones no tiene sentido.

 
Vladix:

En general, por lo que puedo entender, hay una especie de punto muerto - aquí, en su mayoría, todas las aves independientes, capaces de resolver cualquier problema por su cuenta (de auto-estudio de la lengua para describir la compleja lógica del comercio). Y un cisne, un cangrejo de río y un lucio con todas sus cualidades fuertes en un solo carro, por supuesto, pueden ser aprovechados, pero basta con ellos sólo para 50 páginas de discusiones activas en esta rama del foro...

Ahora la cuestión es que el proyecto debe tener un líder que:

  • en primer lugar, se interesará por el objetivo final del proyecto,
  • En segundo lugar, será capaz de dividir el proyecto en etapas, tareas y subtareas, que cualquier programador de este hilo sería capaz de escribir y hacer en un tiempo razonable. Es preferible que las tareas y subtareas sean independientes del contexto, es decir, que se abstraigan de otro código en la medida de lo posible.
  • En tercer lugar, hay que estar al tanto del proyecto y saber qué partes están listas y en qué medida; si es posible integrar la solución de las subtareas en la tarea completa.
La solución ideal sería probablemente alguien de MetaQuotes, que tiene una experiencia similar, + sería una oportunidad para probar TeamWox en relación con MQL-comunidad, tanto más que Renat lo mencionó una vez antes.

En definitiva, lo que ha dicho es cierto. Cada uno de nosotros es capaz de realizar este proyecto por sí mismo.

Pero, como siempre, el diablo está en los detalles.

Sobre materiales de 50 páginas de asalto podemos resumir que hay ideas y a partir de ellas se puede hacer un plan de ataque bastante sensato.

Aunque la mayoría son individuos, pero nadie se resiste a trabajar en equipo. Al fin y al cabo, el trabajo en equipo permite paralelizar las tareas, lo que acelerará todo el proyecto.

Y aquí vienen los detalles: el trabajo en equipo en el sentido clásico supone que el ejecutante recibe la tarea y la completará en el tiempo especificado. Entonces será posible planificar el progreso del proyecto desde un único centro y distribuir las tareas a los ejecutantes. De hecho, los ejecutores están ocupados haciendo sus propias cosas y no pueden concentrar todo su tiempo en el proyecto externalizado. De ahí que sea inevitable el desequilibrio en el desarrollo del proyecto.

Creo que la solución podría ser un tablón de anuncios en el que el director establezca las tareas y los ejecutantes se encarguen de lo que puedan e informen de los progresos y los plazos. Si los términos de referencia se formalizan claramente, el proyecto estará terminado antes de empezar :)

Y un detalle más, estaría bien tener una lista de nombres de variables y métodos de uso común, no es que sea fundamentalmente, pero será más fácil si se estandariza. Aunque, por supuesto, es difícil hacer una lista así, pero se pueden elaborar (o tomar prestados) algunos principios generales de creación de nombres.

 
TheXpert:

Si los MCs no están activos en las próximas semanas, el proyecto puede ser desechado, o trasladado a una ubicación comercial en otro lugar.

Ya que sin el control del MK, el proyecto como fuente de opsión pierde su sentido.

Eso es lo que estás diciendo.

Al menos dos de nosotros, tú y yo, podemos hacerlo todo nosotros mismos.

ZZY y como bien has dicho, el desarrollo a medida ya es un desarrollo comercial.

Como el tiempo se gasta y sólo uno tiene el código fuente, la conclusión es sencilla.

 

Bien, mientras buscamos a Papá Noel,

Voy a postear toda la basura que desentierre en mi cerebro, quizás a partir de esto se pueda componer al menos algo de TOR.

Motor de cuadrícula
1. inicialización de la cuadrícula
2. flujo de trabajo de la cuadrícula
3. formación de la cuadrícula

1) la topología de la cuadrícula puede establecerse mediante campos binarios
más detalles aquí http://cgm.computergraphics.ru/content/view/25 sección 7.Codificación directa

La separación en gramáticas o la codificación directa es ya una superestructura sobre el método de inicialización, de todos modos al final todo se reduce a la codificación directa.
Así, las topologías propiamente dichas (que constituyen la mayor parte de las dificultades para especificar una red) se reducen a escribir métodos para hacer una tabla de codificación directa.
El artículo dice que es imposible especificar los enlaces inversos, pero si para cada rango de operador de retardo crear su propia matriz de enlaces entonces el problema desaparece (aunque la matriz será completa y no triangular como en el retardo cero).
Resulta que la superestructura sobre el método de codificación directa debe saber qué rango de retardo utiliza la red.
Los tipos de neuronas también deben ser especificados en la superestructura (aquí este punto aún no lo he resuelto, no estoy seguro de si necesito escribir y sobrecargar los tipos de neuronas o establecerlos mediante algunos métodos más liberales) ?
Podemos detenernos en la sobrecarga de tipos duros por ahora y si habrá método de codificación suave añadirlo como uno de los sobrecargados.

2) La carrera de trabajo está condicionada por los enlaces prescritos (usando la agregación de datos) y los tipos de neuronas, lo he expuesto en la página 5. Debería haber 4 matrices de datos fuera: Entradas de rejilla, salidas de neuronas, pesos, salidas de rejilla. El acceso externo a las entradas y salidas de la red es necesario para, por ejemplo, alimentar y utilizar la red. El acceso externo a los pesos es necesario para el aprendizaje. El acceso externo a las salidas de las neuronas es necesario para enviarlas a la GPU para su cálculo. En principio, creo que las matrices de datos deberían ser inicialmente externas, y ya estos datos externos deberían agregarse a la red.

3) Formación. Me inclino por el entrenamiento con GA como método independiente de la topología de la red, propongo tomarlo como base y si es posible/necesario sobrecargarlo a la derecha.

En el orden del día hay tres tareas.

Una capa es una unión de neuronas que no dependen de la misma iteración y tienen el mismo tipo.


 

La separación es realmente muy realista.

Por ejemplo, existe la interfaz IEvolvable. Una interfaz para la parte genética de la red. Así, por ejemplo, tú y Andrei podéis serrar tranquilamente la genética, usando sólo esta interfaz.

 

Aquí es donde la herencia múltiple sería realmente útil, por cierto.

________________

De acuerdo, intentaré escribir las interfaces hoy.

Por cierto. El director del proyecto puede ser gpwr. Seré parcialmente responsable de ello.

En principio, podemos iniciar el proyecto.

 
Ugh. Va cuesta abajo.
 

Esto es un recordatorio para ti mismo y para los demás de los tipos de vinculación de datos.

//+------------------------------------------------------------------+
//| Пример Ассоциации, Агрегации, Композиции                         |
//+------------------------------------------------------------------+
/*///
   * Ассоциация обозначает связь между объектами. Агрегация и композиция это частные случаи ассоциации.
   * Агрегация предполагает, что объекты связаны взаимоотношением "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));
  }
 

Hay un matiz en el problema del flujo de trabajo, ya que los métodos de procesamiento de datos dependen del tipo de neurona, deben ser parte de un objeto del tipo de neurona.

El matiz está en qué considerar como capa. Si tal formulación, que di, sería difícil organizar el cálculo en la GPU.

Si nos atenemos a la formulación de TheXpert , habría problemas con la carga de la GPU.

En general, me inclino por la formulación de compromiso (combinar), tiene menos problemas, aunque hereda el problema de la carga de la GPU.

La capa es una unión de neuronas que no dependen de la misma iteración y tienen el mismo tipo.

¿Alguna idea?

PS ¿alguna objeción?

1...424344454647484950515253545556...100
Nuevo comentario
Razón de la queja: