Bibliothèque: ALGLIB - Bibliothèque d'Analyse Numérique - page 4

Nouveau commentaire
[Supprimé]  
Yury Kulikov:

Magnifique MQ ! Un travail sérieux !

Un exemple d'utilisation de la bibliothèque est l'enseignement de la table de multiplication au réseau neuronal MLP.


:( J'ai peur de penser à ce qui arrivera au nuage lorsque les utilisateurs commenceront à utiliser activement la bibliothèque dans leurs experts.
Ce simple script pèse moins d'un mégaoctet.


La même chose mais pour RF :

les comptes ne sont pas très précis, je devrais essayer de les améliorer.

#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];
   
   // préparation des données
   PatternsMatrix.Resize(100,3);
   int m=0;     // premier modèle
   for(int i=1; i<=10; i++)
      for(int j=1; j<=10; j++)
      {
         PatternsMatrix[m].Set(0,i/10.0);       // entrée 1
         PatternsMatrix[m].Set(1,j/10.0);       // entrée 2
         PatternsMatrix[m].Set(2,(i*j)/100.0);  // cible
         m++; //suivant modèle
      }
   // RF Creation.
   CDForest::DFBuildRandomDecisionForest(PatternsMatrix,100,2,1,50,0.4,RFinfo,Trf,RF_report);
   Print("Info=",RFinfo,"  Error=",CDForest::DFAvgError(Trf,PatternsMatrix,100));  
   // vérifier le réseau sur des données entières
   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);
   // vérifier le réseau sur les données fractionnaires
   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);

c'est plus précis, 500 anciens et r=1, plus d'ajustement et moins de bruit.

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:


Même chose pour RF :

Considère qu'il n'est pas aussi précis, qu'il faut essayer de l'améliorer

PS

cette méthode est plus précise, 500 arbres et r=1, plus d'ajustement et moins de bruit.

Je me demande combien d'arbres il faut faire pour que les résultats soient précis. Et c'est la table de multiplication la plus simple, et s'il y a plusieurs fonctions, nous devons passer par RF et non par la table de multiplication, alors la réponse ressemblera évidemment à quelque chose de juste de loin ?
 
La bibliothèque MQL5 est en effet très puissante, voici comment appeler la bibliothèque plus en détail
 

Forum sur le trading, les systèmes de trading automatisés et les tests de stratégies de trading

Erreurs, bugs, questions

Andrey Khatimlianskii, 2019.01.30 04:57 AM

MQL5\Include\Math\AlgLib\dataanalysis.mqh - CLinReg::LRLine ne fonctionne pas pour 1M et plus de valeurs ?

Quelqu'un le sait-il ?

 

Merci @Rashid Umarov

Je recommande à tous d'aller sur le site web, car ce fil a été mis à jour depuis 3 ans, mais le site web continue d'être mis à jour.

 

Nous avons effectué une révision complète de la version GPL C++ de la bibliothèque ALGLIB, en la publiant sous le nom d'ALGLIB++. Cela permet de suivre la dernière version d'ALGLIB, qui est la 3.16.0, en date du 2019/12. Beaucoup de choses ont été ajoutées dans les modules Optimisation et Interpolation depuis les versions précédentes sur lesquelles MQL5 est synchronisé (par exemple, les splines à nuages de points( !), plus de méthodes d'interpolation pondérées par la distance inverse, de nombreuses méthodes d'optimisation supplémentaires, etc.)

ALGLIB++ est un dérivé d'ALGLIB qui est utilisé comme forme intermédiaire dans un processus de réingénierie/réfactorisation à plus long terme, dans lequel il sera recodé en C++ natif (comme avant la version 3), la couche supplémentaire et la duplication étant supprimées en vue de fournir un support plus direct pour le multithreading, ainsi que des tests et des modules supplémentaires et éventuellement un langage de script frontal.

Les différentes versions linguistiques d'ALGLIB ont toutes été générées à partir d'un noyau commun, la version C++ offrant un support limité (mais non officiel) pour le dialecte C90 de C. Cette caractéristique a rendu nécessaire la simulation, au sein de C, de fonctionnalités qui seraient autrement natives de C++, puis la fourniture d'un wrapper C++ au-dessus de cela. En conséquence, il y a deux espaces de noms séparés : alglib_impl, qui contient la version C, et alglib, qui contient les enveloppes C++. ALGLIB++ a conservé la plupart de cette structure et autant que possible le codage original, mais a réduit ou éliminé une grande partie de l'infrastructure globale comme une première étape pour son élimination et son remplacement par du code C++ natif multithread et a considérablement simplifié l'interface de l'encapsulation C++. En tant que telle, elle représente une forme intermédiaire entre ALGLIB, elle-même, et la future bibliothèque en laquelle ALGLIB++ est en train de se transformer.


De nombreux problèmes à l'origine de la complexité croissante d'ALGLIB, depuis (et avant) les versions adaptées par MQL5, ont été résolus, ce qui a permis de simplifier la structure et de réduire la complexité. Dans sa forme actuelle, elle devrait s'avérer plus facile à adapter à MQL5 par ceux qui maintiennent actuellement la version MQL5 d'ALGLIB.

La distribution comprend un reformatage complet du manuel d'ALGLIB++ à partir de l'original d'ALGLIB C++. Les sections sur les paquets et sous-paquets sont cependant compatibles avec les deux versions d'ALGLIB, et la présentation et le contenu devraient être facilement adaptés à la version MQL5. MQL5 fait l'objet d'une mention dans la section "Références et liens connexes" du manuel.


La dernière version est disponible à l'en vue d'une intégration future dans ALGLIB++. D'autres bibliothèques, dont MKL (qui contient des routines de réseaux neuronaux, soit dit en passant), sont également à l'étude en vue d'une intégration future.

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
 
Quelques remarques supplémentaires à l'attention des développeurs de la version MQL5 d'ALGLIB :

Lorsque vous avez adapté ALGLIB à MQL5, vous avez rencontré des difficultés avec les routines "RCOMM".

Il s'agit en fait de routines multithread, où le changement de thread est écrit directement dans le code en :
(1) en mettant en cache les variables locales à chaque entrée et sortie - et les routines d'itération effectuent potentiellement des millions et des milliards de cycles d'appel/retour !
(2) en mettant en œuvre le changement de thread en sautant hors de la routine pour "faire une pause" lors d'un événement, et en sautant à nouveau dans la routine pour "reprendre" après l'événement - ce qui signifie un grand nombre de "goto" et de points d'entrée multiples.
(3) décimer la structure du flux de contrôle de ces routines afin de placer les points d'entrée au niveau supérieur dans le corps de la fonction.

Lors de l'adaptation d'ALGLIB à MQL5, vous avez conservé la décimation du flux de contrôle, en expédiant les extraits de code dans des routines distinctes. Cette solution - comme vous l'avez finalement découvert - n'est pas maintenable, ce qui a rendu impossible le suivi des mises à jour d'ALGLIB. ALGLIB, lui-même, a pris un peu de retard - leurs routines RCOMM laissent parfois des structures et des variables orphelines de versions antérieures.

Dans ALGLIB++, la structure du flux de contrôle est réintégrée : les points d'entrée reviennent au milieu d'une boucle ou d'une autre structure de flux de contrôle à l'endroit où ils se sont arrêtés.
Il n'y a pas de mise en cache des variables locales aux threads ; pour l'instant, elles ont été rendues statiques (au détriment de la sécurité des threads - mais le multithreading ne fait pas formellement partie de la GPL ALGLIB).
Comme pour ALGLIB, cela signifie qu'il y a beaucoup d'instructions goto pour faire tous les allers-retours, mais elles sont organisées plus proprement.
Les réparations effectuées dans ALGLIB++, en elles-mêmes, accélèrent les routines d'environ 20-25%, d'après les résultats de nos tests.

Il y a deux façons de traiter cette architecture pour se débarrasser des instructions goto et gérer plus correctement les variables locales des threads :
(1) Implémenter un véritable changement de thread, ce qui signifie que les routines RCOMM envoient des messages "événementiels" (ce que sont les drapeaux needf, ... algpowerup), et que l'appelant doit mettre en place un gestionnaire d'événements pour recevoir et traiter les messages. Il n'est pas certain que MQL5 puisse produire et gérer des événements définis par l'utilisateur.
(2) Utiliser des pointeurs de fonction pour les événements.
Gardez à l'esprit que les routines RCOMM peuvent être imbriquées et que, dans certains cas, elles peuvent relayer à leur appelant des événements obtenus à partir des routines RCOMM qu'elles appellent elles-mêmes.

Les développeurs d'ALGLIB ont décidé de ne pas utiliser les pointeurs de fonction ou le multithreading lorsqu'ils ont mis en œuvre ALGLIB, parce qu'à l'époque où ALGLIB a été publié pour la première fois, il n'y avait pas de support formel pour la programmation multithread dans un langage largement distribué et largement utilisé, et tous les langages auxquels ALGLIB était destiné n'avaient pas d'équivalent identique ou similaire aux pointeurs de fonction du C et du C++. Mais MQL5 possède des pointeurs de fonction. Si vous adaptez ALGLIB à MQL5, il sera beaucoup plus facile de le faire à partir d'ALGLIB++, en raison de la réintégration des structures de flux de contrôle.

La solution idéale consiste toutefois à utiliser la commutation de threads. Finalement, soit les pointeurs de fonction, soit le thread-switching seront utilisés dans ALGLIB++ ; nous n'avons pas encore décidé de la voie à suivre.

 
LydiaMW:
Quelques remarques supplémentaires à l'attention des développeurs de la version MQL5 d'ALGLIB :

Lorsque vous avez adapté ALGLIB à MQL5, vous avez rencontré des difficultés avec les routines "RCOMM".

Il s'agit en fait de routines multithread, où le changement de thread est écrit directement dans le code par :
(1) en mettant en cache les variables locales du thread à chaque entrée et sortie - et les routines d'itération effectuent potentiellement des millions et des milliards de cycles d'appel/retour !
(2) en mettant en œuvre la commutation de threads en sautant hors de la routine pour "faire une pause" lors d'un événement, et en sautant à nouveau dans la routine pour "reprendre" après l'événement - ce qui signifie beaucoup de "goto" et de points d'entrée multiples.
(3) décimer la structure du flux de contrôle de ces routines afin de placer les points d'entrée au niveau supérieur dans le corps de la fonction.

Lors de l'adaptation d'ALGLIB à MQL5, vous avez conservé la décimation du flux de contrôle, en expédiant les extraits de code dans des routines distinctes. Cette solution - comme vous l'avez finalement découvert - n'est pas maintenable, ce qui a rendu impossible le suivi des mises à jour d'ALGLIB. ALGLIB, lui-même, a pris un peu de retard - leurs routines RCOMM laissent parfois des structures et des variables orphelines de versions antérieures.

Dans ALGLIB++, la structure du flux de contrôle est réintégrée : les points d'entrée reviennent au milieu d'une boucle ou d'une autre structure de flux de contrôle là où ils se sont arrêtés.
Il n'y a pas de mise en cache des variables locales aux threads ; pour l'instant, elles ont été rendues statiques (au détriment de la sécurité des threads - mais le multithreading ne fait pas formellement partie de la GPL ALGLIB).
Comme pour ALGLIB, cela signifie qu'il y a beaucoup d'instructions goto pour faire tous les allers-retours, mais elles sont organisées plus proprement.
Les réparations effectuées dans ALGLIB++, en elles-mêmes, accélèrent les routines d'environ 20-25%, d'après les résultats de nos tests.

Il y a deux façons de traiter cette architecture pour se débarrasser des instructions goto et gérer plus correctement les variables locales du thread :
(1) Implémenter un véritable changement de thread, ce qui signifie que les routines RCOMM envoient des messages "événementiels" (ce que sont les drapeaux needf, ... algpowerup), et que l'appelant doit mettre en place un gestionnaire d'événements pour recevoir et traiter les messages. Cependant, il n'est pas certain que MQL5 puisse produire et gérer des événements définis par l'utilisateur.
(2) Utiliser des pointeurs de fonction pour les événements.
Gardez à l'esprit que les routines RCOMM peuvent être imbriquées et que, dans certains cas, elles peuvent relayer à leur appelant des événements obtenus à partir des routines RCOMM qu'elles appellent elles-mêmes.

Les développeurs d'ALGLIB ont décidé de ne pas utiliser les pointeurs de fonction ou le multithreading lorsqu'ils ont mis en œuvre ALGLIB, parce qu'à l'époque où ALGLIB a été publié pour la première fois, il n'y avait pas de support formel pour la programmation multithread dans un langage largement distribué et largement utilisé, et tous les langages auxquels ALGLIB était destiné n'avaient pas d'équivalent identique ou similaire aux pointeurs de fonction du C et du C++. Mais MQL5 possède des pointeurs de fonction. Si vous adaptez ALGLIB à MQL5, il sera beaucoup plus facile de le faire à partir d'ALGLIB++, en raison de la réintégration des structures de flux de contrôle.

La solution idéale consiste toutefois à utiliser la commutation de threads. Finalement, soit les pointeurs de fonction, soit le thread-switching seront utilisés dans ALGLIB++ ; nous n'avons pas encore décidé de la voie à suivre.

Chère Lydia：

Mais votre fichier de bibliothèque ALGLIB ++ sur github est toujours au format C ++ CPP. Il n'a pas été converti en MQL5 mql. Pourriez-vous fournir le fichier de la bibliothèque ALGLIB ++ au format .mql ? Merci！

 

Chers développeurs, veuillez ajouter une méthode pour calculer le nombre conjugué d'unnombre complexe à la structure complexe ( source dans SB <Math\Alglib\complex.mqh>).

Ma version :

   //--- opérations
   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;


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


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


Après la sortie d'une nouvelle version, il faut revenir à larévision précédente. Ce qui n'est pas pratique.

 
Denis Kirichenko:

Chers développeurs, veuillez ajouter une méthode de calcul du nombre conjugué d'unnombre complexe à la structure complexe ( source dans SB <Math\Alglib\complex.mqh>).

Ma version :


Après la sortie d'une nouvelle version, il faut revenir à larévision précédente. Ce qui n'est pas pratique.

Ajouté

1234567
Nouveau commentaire