Bibliotheken: ALGLIB - Numerical Analysis Library - Seite 4

Neuer Kommentar
 
Yury Kulikov:

Schöne MQ! Seriöse Arbeit!

Ein Beispiel für die Verwendung der Bibliothek ist das Erlernen des Einmaleins durch ein neuronales MLP-Netz.


:( Ich habe Angst davor, was mit der Cloud passiert, wenn die Benutzer anfangen, die Bibliothek aktiv in ihren Experten zu verwenden.
Dieses einfache Skript wiegt weniger als ein Megabyte.


Das Gleiche, aber für RF:

zählt nicht so genau, ich sollte versuchen, es zu optimieren

#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];
   
   // Datenaufbereitung
   PatternsMatrix.Resize(100,3);
   int m=0;     // erstes Muster
   for(int i=1; i<=10; i++)
      for(int j=1; j<=10; j++)
      {
         PatternsMatrix[m].Set(0,i/10.0);       // Eingang 1
         PatternsMatrix[m].Set(1,j/10.0);       // Eingang 2
         PatternsMatrix[m].Set(2,(i*j)/100.0);  // Ziel
         m++; //nächstes Muster
      }
   // RF-Erstellung.
   CDForest::DFBuildRandomDecisionForest(PatternsMatrix,100,2,1,50,0.4,RFinfo,Trf,RF_report);
   Print("Info=",RFinfo,"  Error=",CDForest::DFAvgError(Trf,PatternsMatrix,100));  
   // Überprüfung des Netzes auf Integer-Daten
   string s="Test 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);
   // Überprüfung des Netzes auf gebrochene Daten
   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);

es ist genauer, 500 alt und r=1, mehr Anpassung und weniger Rauschen.

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:


Dasselbe gilt für RF:

Hält nicht für so genau, muss versuchen, es zu optimieren

PS

dieser Weg ist genauer, 500 Bäume und r=1, mehr Anpassung und weniger Rauschen.

Ich frage mich, wie viele Bäume man machen muss, damit die Ergebnisse genau sind? Und es ist die einfachste Multiplikationstabelle, und wenn es mehrere Funktionen gibt, müssen wir durch RF und nicht die Multiplikationstabelle laufen, dann wird die Antwort offensichtlich etwas fair aus der Ferne ähneln?
 
Die MQL5-Bibliothek ist in der Tat sehr leistungsfähig, es ist in der Tat, wie man die Bibliothek im Detail aufrufen
 

Forum zum Thema Handel, automatische Handelssysteme und Testen von Handelsstrategien

Fehler, Bugs, Fragen

Andrey Khatimlianskii, 2019.01.30 04:57 AM

MQL5\Include\Math\AlgLib\dataanalysis.mqh - CLinReg::LRLine funktioniert nicht für 1M und mehr Werte?

Weiß das jemand?

 

Vielen Dank @Rashid Umarov

Ich empfehle allen, auf die Website zu gehen, da dieser Thread seit 3 Jahren aktualisiert wird, aber die Website wird ständig aktualisiert.

 

Wir haben die GPL C++-basierte Version der ALGLIB-Bibliothek komplett überarbeitet und sie als ALGLIB++ veröffentlicht. Damit wird die neueste Version der ALGLIB verfolgt, die zum Zeitpunkt 2019/12 bei 3.16.0 liegt. Seit den früheren Versionen, mit denen MQL5 synchronisiert ist, wurde in den Modulen Optimierung und Interpolation viel hinzugefügt (z. B. Punktwolken-Splines(!), weitere Methoden der inversen abstandsgewichteten Interpolation, zahlreiche zusätzliche Optimierungsmethoden usw.).

ALGLIB++ ist ein Derivat von ALGLIB, das als Zwischenform in einem längerfristigen Reengineering/Refactoring-Prozess verwendet wird, in dem es in natives C++ umkodiert wird (ähnlich wie vor Version 3), wobei die zusätzliche Schicht und Duplizierung entfernt wird, um eine direktere Unterstützung für Multithreading sowie zusätzliche Tests und Module und schließlich ein Skriptsprachen-Frontend bereitzustellen.

Die verschiedenen Sprachversionen der ALGLIB wurden alle aus einem gemeinsamen Kern generiert, wobei die C++-Version eine begrenzte (aber inoffizielle) Unterstützung für den C90-Dialekt von C bietet. Diese Eigenschaft machte es notwendig, in C Funktionen zu simulieren, die sonst nur in C++ vorhanden sind, und dann einen C++-Wrapper darüber zu legen. Dementsprechend gibt es zwei getrennte Namensräume: alglib_impl, der die C-Version enthält, und alglib, der die C++-Wrapper enthält. ALGLIB++ hat den größten Teil dieser Struktur und so viel wie möglich von der ursprünglichen Kodierung beibehalten, aber einen Großteil der globalen Infrastruktur reduziert oder eliminiert, als ersten Schritt zu ihrer Beseitigung und Ersetzung durch nativen C++-Multithreading-Code, und die C++-Wrapper-Schnittstelle erheblich vereinfacht. Als solche stellt sie eine Zwischenform dar, die eine Brücke zwischen ALGLIB selbst und der zukünftigen Bibliothek, in die ALGLIB++ umgewandelt wird, bildet.


Viele Probleme, die seit (und vor) den von MQL5 angepassten Versionen zu einer Zunahme der Komplexität in ALGLIB führten, wurden gelöst, was zu einer Vereinfachung der Struktur und einer Reduzierung der Komplexität führte. In seiner jetzigen Form sollte es sich als einfacher erweisen, die ALGLIB an MQL5 anzupassen, und zwar für diejenigen, die derzeit die MQL5-Version der ALGLIB pflegen.

Die Distribution enthält eine komplette Neuformatierung des Handbuchs für ALGLIB++ gegenüber dem ALGLIB C++ Original. Die Abschnitte über die Pakete und Unterpakete sind jedoch mit beiden Versionen von ALGLIB kompatibel, und sowohl das Layout als auch der Inhalt sollten leicht an die MQL5-Version angepasst werden können. MQL5 wird im Abschnitt "References & Related Links" des Handbuchs ausdrücklich erwähnt.


Die aktuellste Version finden Sie unter Zukunft in ALGLIB++ integriert werden soll. Andere Bibliotheken, einschließlich MKL (die übrigens über Routinen für neuronale Netze verfügt), werden ebenfalls für eine zukünftige Integration in Betracht gezogen.

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
 
Ein paar zusätzliche Hinweise an die Entwickler der MQL5-Version von ALGLIB:

Als Sie ALGLIB an MQL5 angepasst haben, sind Sie auf Schwierigkeiten mit den "RCOMM"-Routinen gestoßen.

Es handelt sich dabei effektiv um Multithreading-Routinen, bei denen das Thread-Switching direkt in den Code geschrieben wird, indem:
(1) Zwischenspeicherung von thread-lokalen Variablen bei jedem Ein- und Ausstieg - und Iterationsroutinen führen potenziell Millionen und Milliarden von Aufruf-/Rückkehrzyklen aus!
(2) Implementierung von Thread-Switching durch Springen aus der Routine, um bei einem Ereignis zu "pausieren", und Springen zurück in die Routine, um nach dem Ereignis "fortzufahren" - was eine Menge von goto's und mehrere Einstiegspunkte bedeutet.
(3) Dezimierung der Kontrollflussstruktur dieser Routinen, um die Einstiegspunkte auf die oberste Ebene des Funktionskörpers zu legen.

Bei der Anpassung von ALGLIB an MQL5 haben Sie die Dezimierung des Kontrollflusses beibehalten und die Codeschnipsel tatsächlich in separate Routinen ausgelagert. Diese Lösung ist - wie Sie schließlich herausgefunden haben - nicht wartbar, was es unmöglich gemacht hat, mit den ALGLIB-Aktualisierungen Schritt zu halten. ALGLIB selbst ist auch ein wenig in Verzug geraten - ihre RCOMM-Routinen hinterlassen manchmal verwaiste Strukturen und Variablen aus früheren Versionen.

In ALGLIB++ ist die Kontrollflussstruktur wieder integriert: Einstiegspunkte springen in die Mitte einer Schleife oder einer anderen Kontrollflussstruktur zurück, wo sie aufgehört haben.
Es gibt keine Zwischenspeicherung von thread-lokalen Variablen; sie wurden vorerst statisch gemacht (auf Kosten der Thread-Sicherheit - aber Multi-Threading ist formal kein Teil der GPL ALGLIB).
Wie bei ALGLIB bedeutet dies, dass es eine Menge goto-Anweisungen gibt, um das ganze Hin- und Herspringen zu bewerkstelligen, aber sie sind sauberer organisiert.
Die in ALGLIB++ vorgenommenen Reparaturen allein beschleunigen die Routinen nach unseren Testergebnissen um etwa 20-25 %.

Es gibt zwei Möglichkeiten, mit dieser Architektur umzugehen, um die goto-Anweisungen loszuwerden und die thread-lokalen Variablen besser zu handhaben:
(1) Implementierung eines tatsächlichen Thread-Switching, was bedeutet, dass die RCOMM-Routinen "Event"-Nachrichten senden (was die needf-, ... algpowerup-Flags eigentlich sind) und der Aufrufer einen Event-Handler einrichten muss, um die Nachrichten zu empfangen und zu verarbeiten. Ich bin mir jedoch nicht sicher, ob MQL5 benutzerdefinierte Ereignisse erzeugen und verarbeiten kann.
(2) Verwendung von Funktionszeigern für die Ereignisse.
Bedenken Sie, dass die RCOMM-Routinen verschachtelt sein können; und in einigen Fällen können sie Ereignisse an ihren Aufrufer weitergeben, die sie von den RCOMM-Routinen erhalten, die sie selbst aufrufen.

Die ALGLIB-Entwickler entschieden sich bei der Implementierung von ALGLIB gegen die Verwendung von Funktionszeigern oder Multi-Threading, da es zum Zeitpunkt der Veröffentlichung von ALGLIB keine formale Unterstützung für Multi-Threading-Programmierung in irgendeiner weit verbreiteten und weit genutzten Sprache gab und nicht alle Sprachen, auf die ALGLIB abzielte, das gleiche oder ein ähnliches Äquivalent zu den Funktionszeigern von C und C++ hatten. Aber MQL5 hat Funktionszeiger. Wenn Sie ALGLIB an MQL5 anpassen, wird es viel einfacher sein, dies von ALGLIB++ aus zu tun, da die Kontrollflussstrukturen wieder integriert sind.

Die ideale Lösung ist jedoch die Verwendung von Thread-Switching. Letztendlich werden in ALGLIB++ entweder Funktionszeiger oder Thread-Switching verwendet werden; wir haben uns noch nicht entschieden, welchen Weg wir gehen werden.

 
LydiaMW:
Ein paar zusätzliche Hinweise für die Entwickler der MQL5-Version der ALGLIB:

Bei der Anpassung von ALGLIB an MQL5 sind Sie auf Schwierigkeiten mit den "RCOMM"-Routinen gestoßen.

Dies sind effektiv Multi-Thread-Routinen, bei denen das Thread-Switching direkt in den Code geschrieben ist:
(1) Zwischenspeichern von thread-lokalen Variablen bei jedem Ein- und Ausstieg - und Iterationsroutinen führen potenziell Millionen und Milliarden von Aufruf-/Rückkehrzyklen aus!
(2) Implementierung von Thread-Switching durch Sprünge aus der Routine, um bei einem Ereignis zu "pausieren", und Sprünge zurück in die Routine, um nach dem Ereignis "fortzufahren" - was eine Menge von Goto's und mehrere Einstiegspunkte bedeutet.
(3) Dezimierung der Kontrollflussstruktur dieser Routinen, um die Einstiegspunkte auf die oberste Ebene des Funktionskörpers zu legen.

Bei der Anpassung von ALGLIB an MQL5 haben Sie die Dezimierung des Kontrollflusses beibehalten und die Codeschnipsel tatsächlich in separate Routinen ausgelagert. Diese Lösung ist - wie Sie schließlich herausgefunden haben - nicht wartbar, was es unmöglich gemacht hat, mit den ALGLIB-Aktualisierungen Schritt zu halten. ALGLIB selbst ist auch ein wenig in Verzug geraten - ihre RCOMM-Routinen hinterlassen manchmal verwaiste Strukturen und Variablen aus früheren Versionen.

In ALGLIB++ ist die Kontrollflussstruktur wieder integriert: Einstiegspunkte springen in die Mitte einer Schleife oder einer anderen Kontrollflussstruktur zurück, wo sie aufgehört haben.
Es gibt keine Zwischenspeicherung von thread-lokalen Variablen; sie wurden vorerst statisch gemacht (auf Kosten der Thread-Sicherheit - aber Multi-Threading ist formal kein Teil der GPL ALGLIB).
Wie bei ALGLIB bedeutet dies, dass es eine Menge goto-Anweisungen gibt, um das ganze Hin- und Herspringen zu erledigen; aber sie sind sauberer organisiert.
Die in ALGLIB++ vorgenommenen Reparaturen allein beschleunigen die Routinen nach unseren Testergebnissen um etwa 20-25 %.

Es gibt zwei Möglichkeiten, mit dieser Architektur umzugehen, um die goto-Anweisungen loszuwerden und die thread-lokalen Variablen besser zu handhaben:
(1) Implementierung eines tatsächlichen Thread-Switching, was bedeutet, dass die RCOMM-Routinen "Event"-Nachrichten senden (was die needf-, ... algpowerup-Flags eigentlich sind) und der Aufrufer einen Event-Handler einrichten muss, um die Nachrichten zu empfangen und zu verarbeiten. Ich bin mir jedoch nicht sicher, ob MQL5 benutzerdefinierte Ereignisse erzeugen und verarbeiten kann.
(2) Verwendung von Funktionszeigern für die Ereignisse.
Bedenken Sie, dass die RCOMM-Routinen verschachtelt sein können; und in einigen Fällen können sie Ereignisse an ihren Aufrufer weitergeben, die sie von den RCOMM-Routinen erhalten, die sie selbst aufrufen.

Die ALGLIB-Entwickler entschieden sich bei der Implementierung von ALGLIB gegen die Verwendung von Funktionszeigern oder Multi-Threading, da es zum Zeitpunkt der Veröffentlichung von ALGLIB keine formale Unterstützung für Multi-Threading-Programmierung in irgendeiner weit verbreiteten und weit genutzten Sprache gab und nicht alle Sprachen, auf die ALGLIB abzielte, das gleiche oder ein ähnliches Äquivalent zu den Funktionszeigern von C und C++ hatten. Aber MQL5 hat Funktionszeiger. Wenn Sie ALGLIB an MQL5 anpassen, wird es viel einfacher sein, dies von ALGLIB++ aus zu tun, da die Kontrollflussstrukturen wieder integriert sind.

Die ideale Lösung ist jedoch die Verwendung von Thread-Switching. Letztendlich werden in ALGLIB++ entweder Funktionszeiger oder Thread-Switching verwendet werden; wir haben uns noch nicht entschieden, welchen Weg wir gehen werden.

Liebe Lydia：

Aber deine ALGLIB ++ Bibliotheksdatei auf github ist immer noch im C ++ CPP Format. Sie wurde nicht in MQL5 mql konvertiert. Würden Sie die ALGLIB ++ Bibliotheksdatei als .mql bereitstellen? Vielen Dank！

 

Liebe Entwickler, bitte fügen Sie der komplexen Struktur ( Quelle in SB <Math\Alglib\complex.mqh>) eine Methode zur Berechnung der konjugierten Zahl einer komplexenZahl hinzu.

Meine Version:

   //--- Vorgänge
   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;


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


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


Nach dem nächsten Release eines neuen Builds muss man auf die vorherigeRevision zurücksetzen. Das ist lästig.

 
Denis Kirichenko:

Sehr geehrte Entwickler, bitte fügen Sie eine Methode zur Berechnung der konjugierten Zahl einer komplexenZahl in die komplexe Struktur ein ( Quelle in SB <Math\Alglib\complex.mqh>).

Meine Version:


Nach dem nächsten Release eines neuen Builds muss man auf die vorherigeRevision zurückgehen. Das ist lästig.

Hinzugefügt

1234567
Neuer Kommentar