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

Nuovo commento
 
TheXpert:

Chi ha esperienza di lavoro in un team su un grande progetto?

Intendo anche l'esperienza con VCS.

In generale, per quanto posso capire, c'è una sorta di stallo - qui, per lo più, tutti gli uccelli indipendenti, capaci di risolvere da soli qualsiasi problema (dall'autoapprendimento del linguaggio alla descrizione della complessa logica di trading). E un cigno, un gambero e un luccio con tutte le loro qualità forti in un carrello, certo, possono essere imbrigliati, ma basta loro solo per 50 pagine di discussioni attive in questo ramo del forum...

Ora il punto è che il progetto deve avere un leader che:

  • in primo luogo, sarà interessato all'obiettivo finale del progetto,
  • In secondo luogo, sarà in grado di dividere il progetto in fasi, compiti e sottocompiti, che qualsiasi programmatore in questo thread sarebbe in grado di scrivere e fare in un tempo ragionevole. Allo stesso tempo, è desiderabile rendere i compiti e i sottocompiti indipendenti dal contesto, cioè astrarli da altro codice il più possibile.
  • In terzo luogo, bisogna stare al passo con il progetto e sapere quali parti sono pronte e in che misura; se è possibile integrare i sottocompiti risolti nella soluzione completa del compito.
La soluzione ideale sarebbe probabilmente qualcuno di MetaQuotes, avendo un'esperienza simile, + sarebbe un'opportunità per provare TeamWox in relazione a MQL-community, tanto più che Renat lo ha menzionato una volta prima.

 

Se i MC non sono attivi nelle prossime due settimane, il progetto può essere scartato, o spostato in un luogo commerciale altrove.

Senza il controllo dei MC, il progetto come opsource non ha senso.

 
Vladix:

In generale, per quanto posso capire, c'è una sorta di stallo - qui, per lo più, tutti gli uccelli indipendenti, capaci di risolvere da soli qualsiasi problema (dall'autoapprendimento del linguaggio alla descrizione della complessa logica del commercio). E un cigno, un gambero e un luccio con tutte le loro qualità forti in un carrello, certo, possono essere imbrigliati, ma basta loro solo per 50 pagine di discussioni attive in questo ramo del forum...

Ora il punto è che il progetto deve avere un leader che:

  • in primo luogo, sarà interessato all'obiettivo finale del progetto,
  • In secondo luogo, sarà in grado di dividere il progetto in fasi, compiti e sottocompiti, che qualsiasi programmatore in questo thread sarebbe in grado di scrivere e fare in un tempo ragionevole. I compiti e i sottocompiti dovrebbero essere preferibilmente indipendenti dal contesto, cioè astratti da altro codice il più possibile.
  • In terzo luogo, bisogna stare al passo con il progetto e sapere quali parti sono pronte e fino a che punto; se è possibile integrare la soluzione dei sottocompiti nell'intero compito.
La soluzione ideale sarebbe probabilmente qualcuno di MetaQuotes, che ha un'esperienza simile, + sarebbe un'opportunità per provare TeamWox in relazione a MQL-community, tanto più che Renat lo ha menzionato una volta prima.

Tutto sommato, quello che ha detto è vero. Ognuno di noi è in grado di fare questo progetto da solo.

Ma come al solito, il diavolo è nei dettagli.

Sui materiali di 50 pagine di assalto possiamo riassumere che ci sono idee e da esse si può fare un piano d'attacco abbastanza sensato.

Anche se la maggior parte sono individui, ma nessuno resiste al lavoro di squadra. Dopo tutto, il lavoro di squadra permette di parallelizzare i compiti, il che accelererà l'intero progetto.

E qui arrivano i dettagli: il lavoro di squadra in senso classico presuppone che l'esecutore riceva il compito e lo porti a termine nel tempo stabilito. Allora sarà possibile pianificare l'avanzamento del progetto da un unico centro e distribuire i compiti agli esecutori. Infatti, gli esecutori sono occupati a fare le loro cose e non possono concentrare tutto il loro tempo sul progetto in outsourcing. Quindi ci sarà inevitabilmente uno squilibrio nello sviluppo del progetto.

Penso che la soluzione potrebbe essere una bacheca dove il manager stabilirà i compiti e gli esecutori prenderanno quello che possono e riferiranno i progressi e le scadenze. Se il TOR sarà chiaramente formalizzato, il progetto sarà completato prima di iniziare :)

E un altro dettaglio, sarebbe bello avere una lista di nomi comunemente usati di variabili e metodi, non che sia fondamentalmente, ma sarà più facile se è standardizzato. Anche se, naturalmente, è difficile fare una tale lista, ma alcuni principi generali di creazione dei nomi possono essere elaborati (o presi in prestito).

 
TheXpert:

Se i MC non sono attivi nelle prossime due settimane, il progetto può essere scartato, o spostato in un luogo commerciale altrove.

Perché senza il controllo della MK, il progetto come opsource perde il suo significato.

Questo è quello che stai dicendo.

Almeno due di noi, io e te, possono fare tutto da soli.

ZZY e come hai detto correttamente, lo sviluppo personalizzato è già uno sviluppo commerciale.

Poiché il tempo è speso e solo uno ha il codice sorgente, la conclusione è semplice.

 

Ok, mentre cerchiamo Babbo Natale,

Ho intenzione di postare tutta la spazzatura che scavo nel mio cervello, forse da questo sarà possibile comporre almeno qualche TOR.

Grid engine
1. inizializzazione della griglia
2. flusso di lavoro della griglia
3. formazione della griglia

1) la topologia della griglia può essere impostata da campi binari
maggiori dettagli qui http://cgm.computergraphics.ru/content/view/25 section 7.Direct coding

La separazione in grammatiche o la codifica diretta è già una sovrastruttura sul metodo di inizializzazione, comunque alla fine tutto si riduce alla codifica diretta.
Così le topologie stesse (che è la parte del leone delle difficoltà nello specificare una rete) si riducono a scrivere metodi per fare una tabella di codifica diretta.
L'articolo dice che è impossibile specificare i collegamenti inversi, ma se per ogni rango di operatori di ritardo creare la propria matrice di collegamenti allora il problema scompare (anche se la matrice sarà piena e non triangolare come nel ritardo zero).
Si scopre che la sovrastruttura sul metodo di codifica diretta dovrebbe sapere quale rango di ritardo utilizza la rete.
I tipi di neuroni devono anche essere specificati nella sovrastruttura (qui questo punto non l'ho ancora capito, non sono sicuro se devo scrivere e sovraccaricare i tipi di neuroni o impostarli con qualche metodo più liberale) ?
Possiamo fermarci a sovraccaricare i tipi hard per ora e se ci sarà un metodo di codifica soft aggiungerlo come uno degli overloaded.

2) Il colpo di lavoro è condizionato dai collegamenti prescritti (usando l'aggregazione dei dati) e dai tipi di neuroni, l'ho esposto a pagina 5. Ci dovrebbero essere 4 matrici di dati all'esterno: Ingressi della griglia, uscite dei neuroni, pesi, uscite della griglia. L'accesso esterno agli ingressi e alle uscite della rete è necessario per l'alimentazione dell'esempio e per l'uso operativo della rete. L'accesso esterno ai Pesi è necessario per l'apprendimento. L'accesso esterno alle uscite dei neuroni è necessario per inviare alla GPU per il calcolo. In linea di principio, penso che gli array di dati dovrebbero essere inizialmente esterni, e già questi dati esterni dovrebbero essere aggregati nella rete.

3) Formazione. Sono incline ad allenarmi con GA come metodo indipendente dalla topologia della rete, propongo di prenderlo come base e se possibile/necessario sovraccaricarlo al giusto.

Quelli all'ordine del giorno sono tre compiti.

Uno strato è un'unione di neuroni che non dipendono dalla stessa iterazione e hanno lo stesso tipo.


 

La separazione è in realtà molto realistica.

Per esempio, c'è l'interfaccia IEvolvable. Un'interfaccia per il lato genetico della griglia. Così, per esempio, tu e Andrei potete segare tranquillamente la genetica, usando solo questa interfaccia.

 

Qui è dove l'eredità multipla sarebbe davvero utile, a proposito.

________________

Sono d'accordo, cercherò di scrivere le interfacce oggi.

A proposito. Il responsabile del progetto può essere gpwr. Ne sarò parzialmente responsabile.

In linea di principio, possiamo iniziare il progetto.

 
Ugh. Sta andando in discesa.
 

Questo è un tale promemoria per te stesso e per gli altri dei tipi di legame dei dati.

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

C'è una sfumatura nel problema del flusso di lavoro, poiché i metodi di elaborazione dei dati dipendono dal tipo di neurone, devono essere parte di un oggetto del tipo di neurone.

La sfumatura sta in cosa considerare come un livello. Se tale formulazione, che ho dato, sarebbe difficile organizzare il calcolo nella GPU.

Se ci atteniamo alla formulazione di TheXpert , ci sarebbero problemi con il carico sulla GPU.

Nel complesso, propendo per la formulazione di compromesso (combinazione), ha meno problemi, anche se eredita il problema del carico della GPU.

Lo strato è un'unione di neuroni che non dipendono dalla stessa iterazione e hanno lo stesso tipo.

Qualche pensiero?

PS qualche obiezione?

1...424344454647484950515253545556...100
Nuovo commento