Librerie: ALGLIB - Libreria di Analisi Numerica - pagina 4

Nuovo commento
 
Yury Kulikov:

Bellissimo MQ!

Un esempio di utilizzo della libreria è l'insegnamento della tabella di moltiplicazione alla rete neurale MLP.


:( Ho paura di pensare a cosa succederà al cloud quando gli utenti inizieranno a usare attivamente la libreria nei loro esperti.
Questo semplice script pesa meno di un megabyte.


Lo stesso ma per RF:

conta che non è così preciso, dovrei provare a modificarlo.

#include <Math\Alglib\dataanalysis.mqh>
//+------------------------------------------------------------------+
#define _rand(min,max) ((rand()/(double)SHORT_MAX)*((max)-(min))+min)
//+------------------------------------------------------------------+
void OnStart()
{
   CDecisionForest      Trf;
   CDecisionForestShell RFshell;
   CMatrixDouble        PatternsMatrix;
   CDFReport            RF_report;
   int RFinfo;
   double vector[2], out[1];
   
   // preparazione dei dati
   PatternsMatrix.Resize(100,3);
   int m=0;     // primo modello
   for(int i=1; i<=10; i++)
      for(int j=1; j<=10; j++)
      {
         PatternsMatrix[m].Set(0,i/10.0);       // ingresso 1
         PatternsMatrix[m].Set(1,j/10.0);       // ingresso 2
         PatternsMatrix[m].Set(2,(i*j)/100.0);  // obiettivo
         m++; //il prossimo modello
      }
   // Creazione RF.
   CDForest::DFBuildRandomDecisionForest(PatternsMatrix,100,2,1,50,0.4,RFinfo,Trf,RF_report);
   Print("Info=",RFinfo,"  Error=",CDForest::DFAvgError(Trf,PatternsMatrix,100));  
   // controllare la rete sui dati interi
   string s="Prova 1 >>";
   for(int i=1; i<=10; i++)
   {
      int d1=(int)_rand(1,10), d2=(int)_rand(1,10);
      vector[0]=d1/10.0;
      vector[1]=d2/10.0;
      CDForest::DFProcess(Trf,vector,out);
      s+=(string)d1+"*"+(string)d2+"="+DoubleToString(out[0]*100,0)+" // ";
   }
   Print(s);
   // verifica della rete su dati frazionari
   s="Test 2 >>";
   for(int i=1; i<=5; i++)
   {
      double d1=NormalizeDouble(_rand(1,10),1), d2=NormalizeDouble(_rand(1,10),1);
      vector[0]=d1/10.0;
      vector[1]=d2/10.0;
       CDForest::DFProcess(Trf,vector,out);
      s+=DoubleToString(d1,1)+"*"+DoubleToString(d2,1)+"="+DoubleToString(out[0]*100,2)+
         "("+DoubleToString(d1*d2,2)+") // ";
   }
   Print(s);
}
2017.09.04 21:43:21.609 RF sample (EURUSD,H1)   Info=1  Error=0.01861400000000001
2017.09.04 21:43:21.610 RF sample (EURUSD,H1)   Тест 1 >> 6*9=55 // 7*3=21 // 6*6=38 // 9*7=65 // 9*9=80 // 8*4=32 // 4*1=6 // 1*8=13 // 4*3=12 // 2*2=5 // 
2017.09.04 21:43:21.610 RF sample (EURUSD,H1)   Тест 2 >> 7.7*5.8=46.64(44.66) // 3.0*3.3=9.70(9.90) // 6.0*9.2=55.32(55.20) // 2.6*6.7=20.08(17.42) // 2.5*4.0=12.54(10.00) //

PS

CDForest::DFBuildRandomDecisionForest(PatternsMatrix,100,2,1,500,1,RFinfo,Trf,RF_report);

è più accurato, 500 antichi e r=1, più aderente e meno rumore.

2017.09.04 22:08:33.227 RF sample (EURUSD,H1)   Info=1  Error=2.02997341158806 e-15
2017.09.04 22:08:33.228 RF sample (EURUSD,H1)   Тест 1 >> 2*2=4 // 2*6=12 // 1*9=9 // 9*1=9 // 4*7=28 // 9*6=54 // 5*6=30 // 5*5=25 // 4*1=4 // 1*4=4 // 
2017.09.04 22:08:33.230 RF sample (EURUSD,H1)   Тест 2 >> 4.0*3.8=16.00(15.20) // 9.6*3.1=30.00(29.76) // 5.5*6.4=36.00(35.20) // 4.0*4.4=16.00(17.60) // 1.6*4.2=8.00(6.72) //
 
Maxim Dmitrievsky:


Stessa cosa per RF:

Non è considerato così accurato, bisogna provare a modificarlo.

PS

questo modo è più accurato, 500 alberi e r=1, più adattamento e meno rumore.

Mi chiedo quanti alberi bisogna fare per rendere i risultati accurati. Ed è la tabella di moltiplicazione più semplice, e se ci sono diverse funzioni, abbiamo bisogno di eseguire attraverso RF e non la tabella di moltiplicazione, allora la risposta sarà ovviamente assomigliare a qualcosa di giusto da lontano?
 
La libreria MQL5 è davvero molto potente, ecco come chiamare la libreria in modo più dettagliato
 

Forum sul trading, sui sistemi di trading automatico e sulla verifica delle strategie di trading

Errori, bug, domande

Andrey Khatimlianskii, 2019.01.30 04:57 AM

MQL5\Include\Math\AlgLib\dataanalysis.mqh - CLinReg::LRLine non funziona per 1M e più valori?

Qualcuno lo sa?

 

Grazie @Rashid Umarov

Raccomando a tutti di andare sul sito web, perché questo thread è stato aggiornato per 3 anni, ma il sito web continua ad aggiornarsi.

 

Abbiamo effettuato una revisione completa della versione GPL C++ della libreria ALGLIB, rilasciandola come ALGLIB++. Questo segue l'ultima versione di ALGLIB, che è la 3.16.0, al 2019/12. Molto è stato aggiunto nei moduli di ottimizzazione e interpolazione rispetto alle versioni precedenti a cui MQL5 è sincronizzato (ad esempio, spline a nuvola di punti(!), più metodi di interpolazione ponderata a distanza inversa, numerosi metodi di ottimizzazione aggiuntivi e così via).

ALGLIB++ è un derivato di ALGLIB che viene utilizzato come forma intermedia in un processo di reingegnerizzazione/refactoring a più lungo termine, in cui verrà ricodificato in C++ nativo (in modo simile a come era prima della versione 3), rimuovendo lo strato aggiuntivo e la duplicazione in preparazione di un supporto più diretto per il multi-threading, oltre a test e moduli aggiuntivi e, infine, un front-end in linguaggio di scripting.

Le diverse versioni linguistiche di ALGLIB sono state tutte generate da un nucleo comune, con la versione C++ che fornisce un supporto limitato (ma non ufficiale) per il dialetto C90 del C. Questa caratteristica ha reso necessario simulare, all'interno del C, caratteristiche che altrimenti sarebbero state native del C++, per poi fornire un wrapper C++ su di esso. Di conseguenza, esistono due spazi di nomi separati: alglib_impl, che contiene la versione C, e alglib, che contiene i wrapper C++. ALGLIB++ ha mantenuto la maggior parte di questa struttura e la maggior parte possibile della codifica originale, ma ha ridotto o eliminato gran parte dell'infrastruttura globale come primo passo per la sua eliminazione e sostituzione con codice C++ nativo multi-thread e ha semplificato in modo significativo l'interfaccia del wrapper C++. Come tale, rappresenta una forma intermedia che fa da ponte tra ALGLIB stessa e la futura libreria in cui ALGLIB++ si sta trasformando.


Molti problemi che hanno portato a una crescita della complessità di ALGLIB, a partire dalle versioni adattate da MQL5, sono stati risolti, con una conseguente semplificazione della struttura e una riduzione della complessità. Nella sua forma attuale, dovrebbe risultare più facile da adattare a MQL5, da parte di coloro che attualmente mantengono la versione MQL5 di ALGLIB.

La distribuzione include una riformattazione completa del manuale di ALGLIB++ rispetto all'originale ALGLIB C++. Le sezioni sui pacchetti e sui sottopacchetti, tuttavia, sono compatibili con entrambe le versioni di ALGLIB e il layout e il contenuto dovrebbero essere facilmente adattati alla versione MQL5. MQL5 viene menzionato nella sezione "Riferimenti e link correlati" del manuale.


L'ultima versione è disponibile all'indirizzo per una futura integrazione in ALGLIB++. Anche altre librerie, tra cui MKL (che tra l'altro contiene routine per le reti neurali) sono in fase di studio per una futura integrazione.

LydiaMarieWilliamson/ALGLIB_cpp
LydiaMarieWilliamson/ALGLIB_cpp
  • LydiaMarieWilliamson
  • github.com
Dismiss Join GitHub today GitHub is home to over 40 million developers working together to host and review code, manage projects, and build software together. Sign up Permalink
 
Alcune note aggiuntive per gli sviluppatori della versione MQL5 di ALGLIB:

Quando avete adattato ALGLIB a MQL5, avete incontrato delle difficoltà con le routine "RCOMM".

Queste sono effettivamente routine multi-thread, in cui il cambio di thread è scritto direttamente nel codice tramite:
(1) la memorizzazione nella cache delle variabili locali del thread a ogni entrata e uscita - e le routine di iterazione eseguono potenzialmente milioni e miliardi di cicli di chiamata/ritorno!
(2) implementando il thread-switching saltando fuori dalla routine per "mettere in pausa" un evento e saltando di nuovo nella routine per "riprendere" dopo l'evento - il che significa un sacco di goto e punti di ingresso multipli.
(3) decimare la struttura del flusso di controllo di queste routine per collocare i punti di ingresso al livello superiore nel corpo della funzione.

Quando si è adattato ALGLIB a MQL5 si è mantenuta la decimazione del flusso di controllo, spedendo di fatto i frammenti di codice in routine separate. Questa soluzione, come avete scoperto alla fine, non è manutenibile, il che ha reso impossibile tenere il passo con gli aggiornamenti di ALGLIB. Anche ALGLIB è rimasto un po' indietro: le sue routine RCOMM a volte lasciano orfane strutture e variabili delle versioni precedenti.

In ALGLIB++, la struttura del flusso di controllo è reintegrata: i punti di ingresso saltano di nuovo nel mezzo di un ciclo o di un'altra struttura di flusso di controllo dove sono stati lasciati.
Le variabili thread-local non vengono memorizzate nella cache; per il momento sono state rese statiche (al costo della sicurezza dei thread, ma il multi-threading non fa formalmente parte di ALGLIB GPL).
Come in ALGLIB, questo significa che ci sono molte istruzioni goto per fare tutti i salti avanti e indietro, ma sono organizzate in modo più pulito.
Le riparazioni effettuate in ALGLIB++, da sole, accelerano le routine di circa il 20-25%, in base ai risultati dei nostri test.

Ci sono due modi per affrontare questa architettura e sbarazzarsi delle istruzioni goto e gestire più correttamente le variabili locali dei thread:
(1) Implementare un vero e proprio thread-switching, il che significa che le routine RCOMM inviano messaggi "evento" (che è ciò che i flag needf, ... algpowerup sono in realtà) e il chiamante deve impostare un event-handler per ricevere ed elaborare i messaggi. Non sono sicuro che MQL5 possa produrre e gestire eventi definiti dall'utente, tuttavia.
(2) Utilizzare puntatori a funzione per gli eventi.
Tenete presente che le routine RCOMM possono essere annidate e, in alcuni casi, possono trasmettere al loro chiamante eventi ottenuti dalle routine RCOMM che esse stesse chiamano.

Gli sviluppatori di ALGLIB hanno deciso di non utilizzare i puntatori di funzione o il multi-threading quando hanno implementato ALGLIB, perché quando ALGLIB è stato rilasciato per la prima volta non esisteva un supporto formale per la programmazione multi-thread in nessun linguaggio ampiamente distribuito e diffuso, e non tutti i linguaggi a cui ALGLIB era indirizzato avevano lo stesso o simile equivalente ai puntatori di funzione di C e C++. Ma MQL5 ha i puntatori di funzione. Se si adatta ALGLIB a MQL5, sarà molto più facile farlo da ALGLIB++, invece, grazie alla reintegrazione delle strutture del flusso di controllo.

La soluzione ideale, tuttavia, è quella di utilizzare il thread-switching. Alla fine, in ALGLIB++ verranno utilizzati sia i puntatori di funzione che il thread-switching; non abbiamo ancora deciso quale strada seguire.

 
LydiaMW:
Alcune note aggiuntive per gli sviluppatori della versione MQL5 di ALGLIB:

Quando avete adattato ALGLIB a MQL5, avete incontrato delle difficoltà con le routine "RCOMM".

Queste sono effettivamente routine multi-thread, dove il cambio di thread è scritto direttamente nel codice da:
(1) memorizzando nella cache le variabili locali del thread a ogni entrata e uscita - e le routine di iterazione eseguono potenzialmente milioni e miliardi di cicli di chiamata/ritorno!
(2) implementando il cambio di thread saltando fuori dalla routine per "mettere in pausa" un evento e saltando di nuovo nella routine per "riprendere" dopo l'evento, il che significa molti goto e punti di ingresso multipli.
(3) decimare la struttura del flusso di controllo di queste routine per collocare i punti di ingresso al livello superiore nel corpo della funzione.

Quando si è adattato ALGLIB a MQL5 si è mantenuta la decimazione del flusso di controllo, spedendo di fatto i frammenti di codice in routine separate. Questa soluzione, come avete scoperto alla fine, non è manutenibile, il che ha reso impossibile tenere il passo con gli aggiornamenti di ALGLIB. Anche ALGLIB è rimasto un po' indietro: le sue routine RCOMM a volte lasciano orfane strutture e variabili di versioni precedenti.

In ALGLIB++, la struttura del flusso di controllo viene reintegrata: i punti di ingresso tornano nel mezzo di un ciclo o di un'altra struttura di flusso di controllo dove erano stati lasciati.
Non è prevista la memorizzazione nella cache delle variabili thread-local; per il momento sono state rese statiche (al costo della sicurezza dei thread, ma il multi-threading non fa formalmente parte di ALGLIB GPL).
Come per ALGLIB, questo significa che ci sono molte istruzioni goto per fare tutti i salti avanti e indietro, ma sono organizzate in modo più pulito.
Le riparazioni effettuate in ALGLIB++, da sole, accelerano le routine di circa il 20-25%, in base ai risultati dei nostri test.

Ci sono due modi per gestire questa architettura, per eliminare le istruzioni goto e gestire in modo più adeguato le variabili locali dei thread:
(1) Implementare un vero e proprio thread-switching, il che significa che le routine RCOMM inviano messaggi "evento" (che è ciò che i flag needf, ... algpowerup sono in realtà) e il chiamante deve impostare un event-handler per ricevere ed elaborare i messaggi. Tuttavia, non sono sicuro che MQL5 sia in grado di produrre e gestire eventi definiti dall'utente.
(2) Utilizzare puntatori a funzione per gli eventi.
Tenete presente che le routine RCOMM possono essere annidate e, in alcuni casi, possono trasmettere al chiamante eventi ottenuti dalle routine RCOMM che esse stesse chiamano.

Gli sviluppatori di ALGLIB hanno deciso di non utilizzare i puntatori di funzione o il multi-threading quando hanno implementato ALGLIB, perché quando ALGLIB è stato rilasciato per la prima volta non esisteva un supporto formale per la programmazione multi-thread in nessun linguaggio ampiamente distribuito e diffuso, e non tutti i linguaggi a cui ALGLIB era indirizzato avevano lo stesso o simile equivalente ai puntatori di funzione di C e C++. Ma MQL5 ha i puntatori di funzione. Se si adatta ALGLIB a MQL5, sarà molto più facile farlo da ALGLIB++, invece, grazie alla reintegrazione delle strutture del flusso di controllo.

La soluzione ideale, tuttavia, è quella di utilizzare il thread-switching. Alla fine, in ALGLIB++ verranno utilizzati sia i puntatori di funzione che il thread-switching; non abbiamo ancora deciso quale strada seguire.

Cara Lydia： la tua libreria ALGLIB ++

Ma il tuo file di libreria ALGLIB ++ su github è ancora in formato C ++ CPP. Non è stato convertito in MQL5 mql. potresti fornire il file di libreria ALGLIB ++ come .mql? Grazie!

 

Cari sviluppatori, per favore aggiungete un metodo per calcolare il numero coniugato di unnumero complesso alla struttura complessa ( fonte in SB <Math\Alglib\complex.mqh>).

La mia versione:

   //--- operazioni
   void              Copy(const complex &rhs);
   bool              Eq(const complex &lhs, const complex &rhs);
   bool              NotEq(const complex &lhs, const complex &rhs);
   complex           Add(const complex &lhs, const complex &rhs);
   complex           Sub(const complex &lhs, const complex &rhs);
   complex           Mul(const complex &lhs, const complex &rhs);
   complex           Div(const complex &lhs, const complex &rhs);
   complex           Conjugate(void) const;


................


//+------------------------------------------------------------------+
//| Coniugato|
//+------------------------------------------------------------------+
complex complex::Conjugate(void) const
  {
   complex complex_val(re,-im);
   return complex_val;
  };


Dopo il rilascio di una nuova build, è necessario tornare allarevisione precedente. Il che è scomodo.

 
Denis Kirichenko:

Cari sviluppatori, aggiungete un metodo per calcolare il numero coniugato di unnumero complesso alla struttura complessa ( fonte in SB <Math\Alglib\complex.mqh>).

La mia versione:


Dopo il rilascio di una nuova build, è necessario tornare allarevisione precedente. Il che è scomodo.

Aggiunto

1234567
Nuovo commento