Bibliothèque d'analyse numérique ALGLIB en MQL5
590
0
Introduction
Les marchés financiers génèrent des données comportant un grand nombre de relations complexes. Pour les analyser, nous devons utiliser les méthodes les plus modernes des mathématiques appliquées. Réussir à combiner la grande complexité des données financières avec la simplicité et l'efficacité de l'analyse est une tâche difficile. ALGLIB est une bibliothèque de haute performance, conçue spécifiquement pour travailler avec des méthodes numériques et des algorithmes d'analyse de données. Il s'agit d'un assistant fiable dans l'analyse des marchés financiers.
Polyvalence de ALGLIB
Aujourd'hui, ALGLIB est reconnue comme l'une des meilleures bibliothèques pour travailler avec des méthodes numériques. Elle prend en charge plusieurs langages de programmation (C++, C#, Java, Python, Delphi) et systèmes d'exploitation (Windows et POSIX, y compris Linux).
Parmi les nombreuses caractéristiques d'ALGLIB, les suivantes se distinguent :
- Algèbre linéaire : Comprend des algorithmes directs, les méthodes des valeurs propres (EVD) et des valeurs singulières (SVD), qui sont importantes pour l'analyse des données.
- Résolution d'équations : Prend en charge les systèmes d'équations linéaires et non linéaires, ce qui est utile lors de la modélisation de processus financiers complexes.
- Interpolation et approximation : Diverses méthodes d'interpolation et d'approximation des données sont prises en charge, ce qui est utile pour analyser et prévoir les tendances du marché.
- Optimisation : ALGLIB fournit des algorithmes pour trouver des solutions optimales, ce qui est important pour optimiser un portefeuille d'investissement et d'autres décisions financières.
- Intégration numérique : Permet de calculer des intégrales définies, ce qui est utile pour évaluer les instruments financiers.
- Apprentissage automatique : L'analyse des données, la classification, la régression et même l'utilisation de réseaux neuronaux ouvrent de nouvelles possibilités pour prédire les tendances du marché.
Avantages d'ALGLIB
Pourquoi choisir ALGLIB pour travailler avec des données financières ?
Voici les principaux avantages de la bibliothèque :
- Portabilité : ALGLIB se compile facilement sur différentes plateformes à l'aide de divers compilateurs, ce qui le rend accessible aux développeurs de tous horizons.
- Facilité d'utilisation : Prend en charge plusieurs langages de programmation afin que vous puissiez choisir le langage avec lequel vous êtes le plus à l'aise, sans avoir à apprendre une nouvelle syntaxe.
- Open source : ALGLIB est un logiciel libre et peut être utilisé sous licence GPL 2+. Il est donc accessible à la fois à la recherche scientifique et aux projets commerciaux.
- Soutien aux utilisateurs commerciaux : Les utilisateurs commerciaux peuvent acheter une licence qui leur assure une protection juridique lors de l'utilisation d'ALGLIB.
La bibliothèque contient de plus une vaste collection de cas de test couvrant la majeure partie des fonctionnalités des méthodes proposées. Cela vous permettra de réaliser les tests et de transmettre les erreurs détectées aux auteurs du projet. Des informations plus détaillées sur la bibliothèque sont disponibles sur le site web du projet https://www.alglib.net/.
ALGLIB a été adapté pour la première fois au langage MQL5 en 2012. Cette adaptation est une conversion de la bibliothèque à partir de la version 3.5. Plus de 10 ans se sont écoulés depuis. Au cours de cette période, ALGLIB a acquis une grande notoriété auprès des développeurs et des analystes dans le domaine du trading sur les marchés financiers. Au fil des ans, l'équipe de développement a travaillé activement à l'amélioration de la bibliothèque, apportant plus de 70 changements, dont l'ajout de nouvelles classes, fonctions et améliorations.
Il convient également de noter que les classes existantes de la bibliothèque ont été remaniées pour utiliser les matrices et les vecteurs, et que de nouvelles fonctionnalités introduites dans ALGLIB 3.19 ont été ajoutées. Le type de données "complexe" est désormais utilisé pour travailler avec des nombres complexes. Tous les codes sources ont été révisés et structurés conformément au style de conception unifiée.
Malheureusement, les changements apportés à la bibliothèque ALGLIB dans la version 3.19 pour MQL5 ont été assez importants, et la compatibilité ascendante n'est donc pas assurée. Les utilisateurs qui utilisent la version 3.5 d'ALGLIB dans leurs projets sont invités à revoir leurs programmes en profondeur et à procéder aux ajustements nécessaires.
Outre les bibliothèques elles-mêmes, les scripts de test ont également été mis à jour. Il y en a maintenant 91 pour les classes et 152 pour les interfaces. Cela permet de tester de manière plus fiable et plus complète les fonctionnalités de la bibliothèque.
La nouvelle version d'ALGLIB est disponible ici : ALGLIB - Bibliothèque d’Analyse Numérique - bibliothèque pour MetaTrader 5, et elle fait également partie de la plateforme MetaTrader 5 (\MQL5\Include\Math\Alglib\, y compris les cas de test dans \MQL5\Scripts\UnitTests\Alglib\).
1. Quoi de neuf dans ALGLIB 3.19 (liste des changements depuis la version 3.5) ?
3.19 :
- La caractéristique la plus importante d'ALGLIB 3.19.0 est le nouveau solveur RBF (Radial Basis Function) pour le traitement de grands ensembles de données, qui prend en charge les splines à plaques minces, les splines bi-harmoniques et les multi-quadriques. Ce solveur prend en charge les problèmes d'interpolation et d'ajustement (lissage) ;
- Le nouvel algorithme RBF utilise la méthode de décomposition du domaine pour résoudre les systèmes linéaires. Par conséquent, il nécessite O(N) de mémoire et O(N2) de temps d'exécution, ce qui représente une amélioration significative par rapport aux O(N2) de mémoire et O(N3) de temps d'exécution requis par d'autres implémentations open source. Il peut être utilisé pour des ensembles de données comportant plus de 100 000 points.
3.18 :
- Ajout d'un solveur Sparse GMRES pour les équations linéaires ;
- Amélioration des performances de l'algorithme AMD (lors de l'optimisation du traitement des matrices à lignes denses) ;
- Amélioration de la vitesse des solveurs de points intérieurs pour la programmation linéaire (LP) et la programmation quadratique (QP) grâce à la nouvelle décomposition de Cholesky et à une optimisation poussée du code du solveur.
3.17 :
- Ajout de la décomposition de Cholesky Supernodale Eparse (avec des fonctions expertes et des wrappers conviviaux) et du Solveur Linéaire Direct Epars correspondant. Activation de la réduction du remplissage des permutations et des factorisations indéfinies ;
- Ajout d'un solveur pour les problèmes de programmation linéaire (LP) à points intérieurs à grande échelle ;
- Ajout d'un solveur pour les problèmes de programmation quadratique (QP) semi-définie à points intérieurs à grande échelle.
3.16 :
- Mise en œuvre d'un solveur pour les problèmes de programmation quadratique en points intérieurs (QP) avec des versions denses et éparses ;
- Ajout d'un nouveau sous-programme pour l'ajustement rapide de splines cubiques pénalisées avec un temps d'exécution O(N*logN) ;
- Ajout d'un nouveau solveur SQP pour la programmation non linéaire ;
- Introduction d'un format de stockage binaire compressé pour les grandes forêts aléatoires (réduisant l'utilisation de la mémoire de 3,7 à 5,7 fois) ;
- Ajout de la fonction sparsegemv() pour les matrices CRS et Skyline ;
- Mise en œuvre des fonctions normales bivariées CDF et PDF.
- Les solveurs QP indiquent désormais les multiplicateurs de Lagrange ;
- Les solveurs QP prennent désormais en charge les contraintes linéaires à double sens ;
- Amélioration de la stabilité du solveur SLP ;
- Amélioration de la sélection des éléments de référence dans le solveur LP pour une solution plus précise.
3.15 :
- Mise en œuvre de l'algorithme d'Analyse Spectrale Singulière (SSA, "chenille") pour les séries temporelles (time series). La mise en œuvre est optimisée et comprend l'extraction de tendances, la prédiction, la prédiction moyenne et les mises à jour incrémentielles rapides du modèle ;
- Ajout d'un solveur direct pour les systèmes linéaires épars stockés au format Skyline (SKS) ;
- Amélioration des performances du solveur QP-DENSE-AUL pour les problèmes quadratiques comportant un grand nombre d'inégalités ;
- Augmentation significative de la vitesse des solveurs BLEIC et QP-BLEIC (jusqu'à 4x). Révision du code interne des solveurs, ce qui a permis d'améliorer considérablement la gestion des contraintes ;
- Ajout de la prise en charge du déclenchement thermique pour les solveurs de valeurs propres sous-dimensionnels. Lors de la résolution d'une séquence de problèmes de valeurs propres liés, il est possible de réutiliser une solution de base trouvée précédemment comme point de départ d'une nouvelle session de résolution ;
- Simplification de la création de matrices en bandes au format SKS (fonction sparsecreatesksband()) ;
- Ajout d'un nouvel ensemble de fonctions BLAS de niveau 2 pour les nombres réels : GEMV, SYMV, TRSV ;
- La fonction sparseset() supporte désormais les matrices SKS ;
- Le solveur minqp prend désormais en charge le calcul automatique des échelles de variables sur la base de la diagonale du terme quadratique.
3.12 :
- La fonction rbfsetpoints() vérifie désormais la présence de NAN/INF dans les données d'entrée ;
- Les algorithmes de regroupement k-means et de rétro-itération des valeurs propres utilisent désormais des valeurs déterministes pour l'initialisation, ce qui rend les résultats reproductibles d'une exécution à l'autre ;
- Correction d'un bug dans le solveur QQP - mise à l'échelle automatique incorrecte du terme quadratique.
3.11 :
- Ajout de la possibilité d'effectuer des moindres carrés non linéaires sous contrainte linéaire (MinLM et LSFit). Il est désormais possible d'effectuer une approximation non linéaire avec des contraintes linéaires sur les paramètres ;
- Ajout de la prise en charge de l'approximation des plus petites sphères circonscrites, de la surface minimale et des N-sphères inscrites maximales pour les données (en 2D - cercles circonscrits, en 3D - sphères inscrites) ;
- Amélioration de la stabilité du solveur MinNLC et ajout d'un autre mode de prétraitement - "précise stable" ;
- Ajout d'un nouvel optimiseur - MinBC avec des restrictions uniquement sur les variables dans l'état "actif". Ces restrictions permettent des stratégies d'activation qui ne sont pas possibles avec des contraintes linéaires générales ;
- Ajout de la sérialisation/désérialisation en continu dans les versions ALGLIB pour C# et C++ ;
- Mise en œuvre de résolveurs de valeurs propres directes/éparses/sans ordre utilisant la méthode du sous-espace et d'une analyse en composantes principales tronquée rapide (ACP) utilisant la méthode du sous-espace ;
- Amélioration des RBF hiérarchiques avec prise en charge du parallélisme - plusieurs ordres de grandeur plus rapides sur certains ensembles de données et capables de traiter plus de 100 000 points ;
- Ajout d'un résolveur de problèmes de programmation quadratique à contraintes linéaires (QP) ;
- Arbres kd améliorés - avec des requêtes sur des zones rectangulaires et des versions thread-safe des fonctions de requête.
3.10 :
- Ajout de la fonctionnalité d'import CSV - il est désormais possible de lire des matrices 2D à partir de fichiers CSV ;
- Introduction de l'algorithme AGS (Adaptive Gradient Sampling) pour optimiser les problèmes non linéaires, non lissés et soumis à des contraintes incohérentes, faisant d'ALGLIB l'un des rares logiciels commerciaux à prendre en charge l'optimisation non lissée ;
- Ajout de la méthode Ward pour le regroupement hiérarchique ;
- Mise en œuvre de solveurs linéaires légers sans estimation du nombre de conditions ni correction itérative - ils sont plusieurs fois plus rapides que leurs analogues "riches en fonctionnalités".
3.9 :
- Amélioration significative de la prise en charge de l'algèbre linéaire dense/épars : Format de stockage des matrices éparses SKS, opérations d'algèbre linéaire pour les matrices basées sur SKS, factoriseur de Cholesky pour SKS, nombreuses fonctions supplémentaires pour les matrices éparses ;
- Améliorations des solveurs et des optimiseurs : un nouveau solveur pour un problème de programmation quadratique limité avec des contraintes sur les variables - QuickQP, un optimiseur lagrangien augmenté non linéaire, un optimiseur BLEIC amélioré, un solveur polynomial et de nombreuses autres améliorations mineures ;
- Ajout de fonctions supplémentaires d'interpolation/d'ajustement : ajustement de courbe logistique avec 4/5 paramètres, algorithme Ramer-Douglas-Peucker (RDP) ;
- Amélioration de la vitesse de l'algorithme d'analyse discriminante linéaire (LDA).
3.8 :
- Ajout d'une fonctionnalité de classement (statistiques descriptives) - la fonction qui remplace les données par leur classement ;
- Introduction d'un nouveau solveur, QP-BLEIC, capable de résoudre des problèmes de programmation quadratique clairsemés et incohérents avec des contraintes limites et linéaires ;
- Amélioration des performances de la FFT (plus de performances, mais toujours en mode monotâche) ;
- Plusieurs améliorations mineures (montée en puissance de l'optimiseur BLEIC, meilleure initialisation des poids pour MLP, spline Akima pour moins de cinq points).
3.7 :
- L'optimiseur BLEIC a été considérablement remanié. Tout d'abord, il utilise un nouvel algorithme d'ensemble actif en 3 étapes proposé par Elvira Illarionova, qui combine la projection du gradient avec des itérations d'égalité des contraintes L-BFGS. Deuxièmement, comme l'algorithme ne comporte plus d'itérations extérieures/intérieures imbriquées, il est possible de définir des critères d'arrêt plus transparents pour l'algorithme. Troisièmement, il utilise une nouvelle stratégie d'activation/désactivation des contraintes qui gère correctement les contraintes dégénérées ;
- Amélioration significative de la prise en charge des réseaux neuronaux dans ALGLIB. Introduction d'une nouvelle interface de formation qui simplifie grandement la formation de plusieurs réseaux avec les mêmes paramètres et données. Il est désormais possible de spécifier l'ensemble d'apprentissage à l'aide d'une matrice peu dense ;
- Prise en charge améliorée du clustering - la nouvelle version d'ALGLIB inclut l'algorithme d'analyse de cluster hiérarchique du sous-paquet du cluster. Cet algorithme comprend plusieurs mesures de distance (Euclidien, norme 1, norme infinie, mesures basées sur la corrélation Pearson-Spearman, distance cosinus) et plusieurs types de liens (lien unique, lien complet, lien moyen). La fonctionnalité de regroupement K-means (qui existait bien avant le nouvel algorithme) a été combinée avec le nouvel algorithme de regroupement ;
- Les solveurs linéaires épars (CG et LSQR) prennent désormais en charge le préprocesseur diagonal automatique ;
- Les solveurs de moindres carrés linéaires/non linéaires (sous-paquetages lsfit) signalent désormais les erreurs dans les ratios ;
- La fonctionnalité de matrice éparse inclut désormais de nouvelles fonctions pour la conversion entre les tables de hachage et les vues CRS, ainsi que des améliorations de performance pour la fonction SparseRewriteExisting.
3.6 :
- L'optimiseur quadratique prend désormais en charge une combinaison arbitraire d'égalités/inégalités linéaires et de limites. La nouvelle version de l'optimiseur utilise une combinaison de la méthode de Lagrange augmentée et de la méthode des ensembles actifs ;
- Le module Spline1D prend désormais en charge l'interpolation avec des splines cubiques monotones ;
- Ajout de la prise en charge des splines vectorielles bilinéaires et bicubiques ;
- Ajout de la prise en charge des splines scalaires et vectorielles trilinéaires (3D) ;
- Amélioration de la prise en charge des matrices peu denses : énumération efficace des éléments non nuls à l'aide de la fonction SparseEnumerate(), accélération de la fonction SparseGet() pour les matrices stockées au format CRS ;
- Les algorithmes d'optimisation et d'approximation non linéaire (sous-packages LSFit, MinLM, MinBLEIC, MinLBFGS, MinCG) peuvent vérifier la validité du gradient fourni par l'utilisateur (l'erreur la plus courante dans les programmes numériques).
2. La bibliothèque ALGLIB dans la recherche scientifique
Grâce à son code open source et à son utilisation gratuite pour des projets non commerciaux, ALGLIB est devenu un outil important dans le monde de la recherche scientifique. La bibliothèque est utilisée avec succès pour résoudre des problèmes divers et complexes.
L'impact significatif d'ALGLIB est évident dans le développement de logiciels personnalisés, où de nombreux algorithmes d'ALGLIB deviennent la base de la création de solutions innovantes.
Les algorithmes monotâches d'ALGLIB servent également de référence pour le développement de versions parallèles d'algorithmes itératifs conçus pour résoudre d'énormes systèmes d'équations contenant environ 2 millions d'équations. Cela démontre la fiabilité et l'efficacité exceptionnelle des algorithmes fournis par la bibliothèque ALGLIB.
Les chercheurs ont noté la haute qualité et l'efficacité des algorithmes d'ALGLIB, ce qui en fait le choix privilégié pour résoudre des problèmes de recherche complexes dans une variété de domaines, y compris la recherche fondamentale et l'ingénierie.
2.1. ALGLIB dans les problèmes d'optimisation
2014 : Hugo J. Kuijf, Susanne J. van Veluw, Mirjam I. Geerlings, Max A. Viergever, Geert Jan Biessels & Koen L. Vincken. Automatic Extraction of the Midsagittal Surface from Brain MR Images using the Kullback–Leibler Measure. Neuroinform 12, 395–403 (2014)
The midsagittal plane computed in the previous section was used to initialize the computation of the midsagittal surface. The midsagittal surface was represented as a bicubic spline, as implemented in ALGLIB (Bochkanov and Bystritsky (2012)). Control points for the spline were placed in a regular grid on the computed midsagittal plane, with distance m between the control points.
2017 : Vadim Bulavintsev, A GPU-enabled Black-box Optimization in Application to Dispersion-based Geoacoustic Inversion, 2017, in Yu. G. Evtushenko, M. Yu. Khachay, O. V. Khamisov, Yu. A. Kochetov, V.U. Malkova, M.A. Posypkin (eds.) : Proceedings of the OPTIMA-2017 Conference, Petrovac, Montenegro, 02-Oct-2017
For reference, we provide the double-precision version based on the AlgLib library [Bochkanov & Bystritsky, 2016], that we used in our previous work [Zaikin et al., press]. The AlgLib library includes a state-of-the-art implementation of the bisection algorithm, thoroughly tuned to produce the most accurate results possible with the modern CPUs floating point units (FPUs). Our CPU-based implementation of bisection algorithm can not boast such accuracy. However, it is notably faster than AlgLib due to its simplicity. That is why, our and AlgLib-based algorithm’s results are different. The discrepancy between the outputs (residue) of the same algorithm on the CPU and GPU is the result of the different implementations of floating-point units on these platforms.
2.2. ALGLIB dans les problèmes d'interpolation
2021 : Jasek K., Pasternak M., Miluski W., Bugaj J., Grabka M, Application of Gaussian Radial Basis Functions for Fast Spatial Imaging of Ground Penetration Radar Data Obtained on an Irregular Grid. Electronics 2021, 10, 2965.
The ALGLIB package implements both kinds of RBFs: the global Gaussian function and compactly supported. The classical Gaussian function takes small values already at a distance of about 3R0 from the center and can easily be modified to be compactly supported.
In this paper, the RBF-ML algorithm implemented in the ALGLIB package was used. It has three parameters: the initial radius, R0, the number of layers, NL, and the regularisation coefficient, l. This algorithm builds a hierarchy of models with decreasing radii [13]. In the initial (optional) iteration, the algorithm builds a linear least squares model. The values predicted by the linear model are subtracted from the function values at the nodes, and the residual vector is passed to the next iteration. In the first iteration, a traditional RBF model with a radius equal to R0 is built. However, it does not use a dense solver and does not try to solve the problem exactly. It solves the least squares problem by performing a fixed number (approximately 50) of LSQR [22] iterations. Usually, the first iteration is sufficient. Additional iterations will not improve the situation because with such a large radius, the linear system is ill-conditioned. The values predicted by the first layer of the RBF model are subtracted from the function values at the nodes, and, again, the residual vector is passed to the next iteration. With each successive iteration, the radius is halved by performing the same constant number of LSQR iterations, and the forecasts of the new models are subtracted from the residual vector.In all subsequent iterations, a fine regularisation can be applied to improve the convergence of the LSQR solver. Larger values for the regularisation factor can help reduce data noise. Another way of controlled smoothing is to select the appropriate number of layers. Figure 2 shows an example of B-scan and a method of approximation by a hierarchical model. Subsequent layers have a radius that is twice as small and explain the residues after the previous layer. As the radius decreases, the finer details of the B-scan are reproduced.
The hierarchical algorithm has several significant advantages:
• Gaussian CS-RBFs produce linear systems with sparse matrices, enabling the use of the sparse LSQR solver, which can work with the rank defect matrix;
The presented hierarchical RBF approximation algorithm is one of the most efficient algorithms for processing large, scattered data sets. Its implementation, located in the ALGLIB library, enables simple software development, which can be successfully used to analyse GPR images.
• The time of the model building depends on the number of points, N, as N logN in contrast to simple RBF’s implementations with O(N3) efficiency;
• An iterative algorithm (successive layers correct the errors of the previous ones) creates a robust model, even with a very large initial radius. Successive layers have smaller radii and correct the inaccuracy introduced by the previous layer;
• The multi-layer model allows for control smoothing both by changing the regularisation coefficient and by a different number of layers.
2022 : Ruiz M., Nieto J., Costa V., Craciunescu T., Peluso E., Vega J, Murari A, JET Contributors, Acceleration of an Algorithm Based on the Maximum Likelihood Bolometric Tomography for the Determination of Uncertainties in the Radiation Emission on JET Using Heterogeneous Platforms. Appl. Sci. 2022, 12, 6798.
ALGLIB is a numeric library focused on solving general numerical problems. It can be used with different programming languages such as C++, C#, and Delphi. It offers a great variety of functions for different science fields. In this specific application, it is required to interpolate the 2D data arrays that can or cannot be equally spaced (nonuniformly distributed). The development of the function implementing the equivalent to griddata requires the use of ALGLIB 2D interpolation functions for sparse/non-uniform data. For the fitting part, the least square solver function is used, for which two options are available: BlockLLS or FastDDDM. The FastDDDM option was chosen to achieve the best possible performance.
While most of the code and functions of the algorithm in MATLAB were translated into C++ and optimized, others could not be translated directly. The reason is that there is no information about the internal calculations of some of the functions in MATLAB. This implies that the results obtained in both implementations are slightly different. These differences are mainly evident in the implementation of the griddata function. For this application, it has been used with the “bicubic splines” interpolation method, incorporated in the FastDDM solver belonging to the ALGLIB library.
ArrayFire provides a complete API that solves the most common functionalities implemented with MATLAB language. Therefore, it can be considered that porting MATLAB to C++ using ArrayFire API is relatively straightforward, and some parts of the code are even equivalent line by line. Nevertheless, ArrayFire does not include some powerful functions available in MATLAB. For example, the function “griddata” allows different types of interpolations using uniform and not-uniform input data distribution. This function in MATLAB has some parts of the internal code visible to the user, but other parts are not available, making it impossible to reproduce its calculations. While ArrayFire version 3.8.0 includes a function for interpolation, it expects that input data will be uniformly organized. To solve this problem, we chose the open-source library ALGLIB, which provides a set of functions for 2D interpolation that can be used to circumvent the problem.
2.3. Les algorithmes ALGLIB comme point de comparaison
2015 : Tarek Ibn Ziad, M. & Alkabani, Yousra & El-Kharashi, M. W. & Salah, Khaled & Abdelsalam, Mohamed. (2015). Accelerating Accelerating: A hardware emulation approach. 10.1109/ICECS.2015.7440386.
...Ibn Ziad et al. implemented a Jacobi iterative solver on a physical hardware emulation platform to accelerate the finite element solver of an EM simulator [5]. They demonstrated the efficiency of their solution via implementing a twodimensional (2D) edge element code for solving Maxwell’s equations for metamaterials using FEM. Their design achieved 101x speed-up over the same pure software implementation on MATLAB [13] and 35x over the best iterative software solver from ALGLIB C++ library [14] in case of solving 2 million equations.
In this paper, we present a scalable architecture that can efficiently accelerate the solver core of an EM simulator. The architecture is implemented on a physical hardware emulation platform and is compared to the state-of-the-art solvers. Experimental results show that the proposed solver is capable of 522x speed-up over the same pure software implementation on Matlab, 184x speed-up over the best iterative software solver from the ALGLIB C++ library, and 5x speed-up over another emulation-based hardware implementation from the literature, solving 2 million equations.
2016 : Liu, Yongchao & Pan, Tony & Aluru, Srinivas (2016), Parallel Pairwise Correlation Computation On Intel Xeon Phi Clusters.
Using both artificial and real gene expression datasets, we have compared LightPCC to two CPU-based counterparts: a sequential C++ implementation in ALGLIB (http://www.alglib.net) and an implementation based on a parallel GEMM routine in Intel Math Kernel Library(MKL). Our experimental results showed that by using one 5110P Phi and 16 Phis, LightPCC is able to run up to 20.6× and 218.2× faster than ALGLIB, and up to 6.8× and 71.4× faster than singled-threaded MKL, respectively.
2.4. Algorithmes ALGLIB dans le cadre de logiciels spécialisés
2015 : Kraff S, Lindauer A, Joerger M, Salamone SJ, Jaehde U. Excel-Based Tool for Pharmacokinetically Guided Dose Adjustment of Paclitaxel. Ther Drug Monit. 2015 Dec; 37(6):725-32
Methods: Population PK parameters of paclitaxel were taken from a published PK model. An Alglib VBA code was implemented in Excel 2007 to compute differential equations for the paclitaxel PK model. Maximum a posteriori Bayesian estimates of the PK parameters were determined with the Excel Solver using individual drug concentrations. Concentrations from 250 patients were simulated receiving 1 cycle of paclitaxel chemotherapy. Predictions of paclitaxel Tc > 0.05 μmol/L as calculated by the Excel tool were compared with NONMEM, whereby maximum a posteriori Bayesian estimates were obtained using the POSTHOC function.
2017 : Hogland, John & Anderson, Nathaniel. (2017). Function Modeling Improves the Efficiency of Spatial Modeling Using Big Data from Remote Sensing. Big Data and Cognitive Computing.1.3.
While the statistical and machine learning transformations can be used to build surfaces and calculate records within a tabular field, they do not in themselves define the relationships between response and explanatory variables like a predictive model. To define these relationships, we built a suite of classes that perform a wide variety of statistical testing and predictive modeling using many of the optimization algorithms and mathematical procedures found within ALGLIB and Accord.net [15,16]
Furthermore, we introduce a new coding library that integrates Accord.NET and ALGLIB numeric libraries and uses lazy evaluation to facilitate a wide range of spatial, statistical, and machine learning procedures within a new GIS modeling framework called function modeling. Results from simulations show a 64.3% reduction in processing time and an 84.4% reduction in storage space attributable to function modeling. In an applied case study, this translated to a reduction in processing time from 2247 h to 488 h and a reduction is storage space from 152 terabytes to 913 gigabytes.
3. Bibliothèque ALGLIB pour l'analyse des marchés financiers
La première version de la bibliothèque pour MQL5 (ALGLIB 3.5) a été largement utilisée dans l'analyse des données financières, pour résoudre divers problèmes à l'aide d'algorithmes modernes.
Vous trouverez ci-dessous une liste d'articles appliquant activement les classes et fonctions de la bibliothèque ALGLIB :
- Connaître la "mémoire" du marché grâce à la différenciation et à l'analyse entropique
Algorithme de régression logistique (classe CLogitModel) - Reçus statistiques pour un trader : Hypothèses
Tests d'hypothèses :
Test de rang signé de Wilcoxon (classe CWilcoxonSignedRank)
Test U de Mann-Whitney(classe CMannWhitneyU)
Test de signification du coefficient de corrélation de rang de Spearman (SpearmanRankCorrelationSignificance) - Le rôle des distributions statistiques dans le travail du trader
Tests d'hypothèses : Test de Jarque-Bera (classe CJarqueBera) - Réseau neuronal : Expert Advisor auto-optimisant
Algorithmes pour travailler avec des réseaux neuronaux
Classe CMLPBase - perceptron multicouche
Classe CMLPTrain - entraînement du perceptron multicouche
Classe CMLPE - ensembles de réseaux neuronaux - Optimiser la stratégie en fonction de la valeur de l'équilibre et comparer les résultats avec le critère "équilibre + ratio de Sharpe maximum".
Classes CLinReg, CLinearModel et CLRReport pour travailler avec la régression linéaire - Le carré R comme estimation de la qualité de la courbe d'équilibre de la stratégie
Classe CLinReg pour travailler avec la régression linéaire
Calcul des coefficients de corrélation linéaire de Pearson et de corrélation de rang de Spearman - Évaluation visuelle des résultats de l'optimisation
Modèle de régression linéaire ;
Calcul du coefficient de corrélation linéaire de Pearson - Exemple de développement d'une stratégie de spread pour les contrats à terme de la Bourse de Moscou
Modèle de régression linéaire - Guide d'écriture d'une DLL pour MQL5 dans Delphi
Modèle de régression linéaire - Étudier la classe CCanvas. Anti-crénelage et ombres
- Graphiques dans la bibliothèque DoEasy (partie 77) : Classe d'objets Shadow
- DoEasy. Contrôles (partie 27) : Travailler sur l'objet ProgressBar WinForms
Façonnage des ombres et flou gaussien - Le trading de portefeuilles dans MetaTrader 4
Méthode d'analyse en composantes principales (fonctions LRBuildZ, LSFitLinearC et PCABuildBasis) - Optimisation contrôlée : Recuit simulé
Générateur de nombres aléatoires (classe CHighQualityRandStateShell, fonctions HQRndRandomize, HQRndNormal, HQRndNormal2 et HQRndUniformR) - Utilisation pratique des réseaux neuronaux de Kohonen dans le trading algorithmique. Partie I. Outils
Algorithme de regroupement K-means - MQL5 Cookbook - Création d'un ring buffer pour le calcul rapide d'indicateurs dans une fenêtre glissante
Calcul des paramètres statistiques de base
- Moyenne
- écart-type (StdDev)
- asymétrie de la distribution en forme de cloche (Skewness)
- Kurtosis - Les techniques de l’Assistant MQL5 à connaître (Partie 06) : Transformée de Fourier
Transformation de Fourier rapide (FFTR1D) - Représentations des séries temporelles dans le domaine des fréquences : Le spectre de puissance
Transformation de Fourier rapide (FFTR1D) - Forêt de décision aléatoire dans l'apprentissage par renforcement
Algorithme Random Decision Forest (RDF) - Techniques de l’Assistant MQL5 à connaître (Partie 5) : Chaînes de Markov
chaînes de Markov (classe CMarkovCPD) - Prévision des séries temporelles (partie 2) : Machine à vecteur de support des moindres carrés (LS-SVM)
Solveurs linéaires de la bibliothèque ALGLIB - Techniques de l'Assistant MQL5 à connaître (Partie 04) : Analyse discriminante linéaire
Analyse discriminante linéaire (classe CLDA) - Prévision des mouvements du marché à l'aide de la classification bayésienne et d'indicateurs basés sur l'analyse spectrale singulière
Fonctions matricielles ALGLIB
La fonctionnalité de la bibliothèque mathématique ALGLIB s'est ainsi révélée être un outil utile pour l'analyse des données financières.
4. Analyse des spectres singuliers dans ALGLIB
Nous vous invitons à vous familiariser avec le fonctionnement pratique de cette méthode et à partager votre expérience de son utilisation lors de l'élaboration de stratégies de trading.
Vous trouverez ci-dessous un script de test avec des exemples d'utilisation de la méthode SSA. Vous trouverez des informations supplémentaires sur les exemples et les détails de l'utilisation de la méthode SSA dans la bibliothèque ALGLIB dans la section "Singular Spectrum Analysis" de l'aide officielle de la bibliothèque.
//+------------------------------------------------------------------+ //| SSA_Test.mq5 | //| Copyright 2023, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2023, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" #include <Math\Alglib\alglib.mqh> // Examples of SSA usage with ALGLIB // https://www.alglib.net/translator/man/manual.cpp.html#example_ssa_d_basic // https://www.alglib.net/translator/man/manual.cpp.html#example_ssВa_d_realtime // https://www.alglib.net/translator/man/manual.cpp.html#example_ssa_d_forecast //+------------------------------------------------------------------+ //| PrintMatrix | //+------------------------------------------------------------------+ void PrintMatrix(CMatrixDouble &x) { //--- print matrix string str="["; for(int i=0; i<x.Rows(); i++) { str+="["; for(int j=0; j<x.Cols(); j++) { str+=StringFormat("%f",x.Get(i,j)); if(j<x.Cols()-1) str+=","; } str+="]"; if(i<x.Rows()-1) str+=","; } str+="]"; printf("%s",str); } //+------------------------------------------------------------------+ //| PrintVector | //+------------------------------------------------------------------+ void PrintVector(CRowDouble &x) { //--- print vector string str="["; for(int i=0; i<x.Size(); i++) { str+=StringFormat("%f",x[i]); if(i<x.Size()-1) str+=","; } str+="]"; printf("%s",str); } //+------------------------------------------------------------------+ //| ssa_d_basic | //+------------------------------------------------------------------+ //| Here we demonstrate SSA trend/noise separation for some toy | //| problem: small monotonically growing series X are analyzed with | //| 3-tick window and "top-K" version of SSA, which selects K largest| //| singular vectors for analysis, with K=1. | //+------------------------------------------------------------------+ int ssa_d_basic(void) { //--- prepare input data double input_data[]= {0,0.5,1,1,1.5,2}; CRowDouble x=input_data; //--- first, we create SSA model, set its properties and add dataset. //--- we use window with width=3 and configure model to use direct SSA algorithm which runs exact O(N*W^2) analysis - to extract one top singular vector. //--- NOTE: SSA model may store and analyze more than one sequence (say, different sequences may correspond to data collected from different devices) //--- ALGLIB wrapper class CAlglib alglib; //--- SSA model CSSAModel ssa_model; //--- create SSA model alglib.SSACreate(ssa_model); //--- set window width for SSA model alglib.SSASetWindow(ssa_model,3); //--- adds data sequence to SSA model alglib.SSAAddSequence(ssa_model,x); //--- set SSA algorithm to "direct top-K" algorithm alglib.SSASetAlgoTopKDirect(ssa_model,1); //--- now we begin analysis. Internally SSA model stores everything it needs: //--- data, settings, solvers and so on. Right after first call to analysis-related function it will analyze dataset, build basis and perform analysis. //--- subsequent calls to analysis functions will reuse previously computed basis, unless you invalidate it by changing model settings (or dataset). //--- trend and noise CRowDouble trend,noise; //--- build SSA basis using internally stored (entire) dataset and return reconstruction for the sequence being passed to this function alglib.SSAAnalyzeSequence(ssa_model,x,x.Size(),trend,noise); //--- print result PrintVector(trend); //--- output: [0.381548,0.558290,0.781016,1.079470,1.504191,2.010505] //--- EXPECTED: [0.3815,0.5582,0.7810,1.0794,1.5041,2.0105] return 0; } //+------------------------------------------------------------------+ //| ssa_d_forecast | //+------------------------------------------------------------------+ //| Here we demonstrate SSA forecasting on some toy problem with | //| clearly visible linear trend and small amount of noise. | //+------------------------------------------------------------------+ int ssa_d_forecast(void) { //--- ALGLIB wrapper CAlglib alglib; //--- model CSSAModel ssa_model; //--- prepare input data double input_data[] = {0.05,0.96,2.04,3.11,3.97,5.03,5.98,7.02,8.02}; CRowDouble x=input_data; //--- first, we create SSA model, set its properties and add dataset. //--- we use window with width=3 and configure model to use direct SSA algorithm - one which runs exact O(N*W^2) analysis-to extract two top singular vectors //--- NOTE: SSA model may store and analyze more than one sequence (say, different sequences may correspond to data collected from different devices) //--- create SSA model alglib.SSACreate(ssa_model); //--- set window width for SSA model alglib.SSASetWindow(ssa_model,3); //--- set window width for SSA model alglib.SSAAddSequence(ssa_model,x); //--- set SSA algorithm to "direct top-K" algorithm alglib.SSASetAlgoTopKDirect(ssa_model,2); //--- now we begin analysis. Internally SSA model stores everything it needs: //--- data, settings, solvers and so on. Right after first call to analysis-related function it will analyze dataset, build basis and perform analysis. //--- subsequent calls to analysis functions will reuse previously computed basis, unless you invalidate it by changing model settings (or dataset). //--- in this example we show how to use ssaforecastlast() function, which predicts changed in the last sequence of the dataset. //--- if you want to perform prediction for some other sequence, use alglib.SSAForecastSequence(). //--- trend CRowDouble trend; alglib.SSAForecastLast(ssa_model,3,trend); //--- print result PrintVector(trend); //--- output: [9.000587,9.932294,10.805125] //--- EXPECTED: [9.0005,9.9322,10.8051] //--- well, we expected it to be [9,10,11]. There exists some difference, which can be explained by the artificial noise in the dataset. return 0; } //+------------------------------------------------------------------+ //| ssa_d_realtime | //+------------------------------------------------------------------+ //| Suppose that you have a constant stream of incoming data, and | //| you want to regularly perform singular spectral analysis | //| of this stream. | //| | //| One full run of direct algorithm costs O(N*Width^2) operations, | //| so the more points you have, the more it costs to rebuild basis | //| from scratch. | //| | //| Luckily we have incremental SSA algorithm which can perform | //| quick updates of already computed basis in O(K*Width^2) ops, | //| where K is a number of singular vectors extracted. Usually it | //| is orders of magnitude faster than full update of the basis. | //| | //| In this example we start from some initial dataset x0. Then we | //| start appending elements one by one to the end of the last | //| sequence | //| | //| NOTE: direct algorithm also supports incremental updates, but | //| with O(Width^3) cost. Typically K<<Width, so specialized | //| incremental algorithm is still faster. | //+------------------------------------------------------------------+ int ssa_d_realtime(void) { //--- ALGLIB wrapper CAlglib alglib; //--- model CSSAModel ssa_model1; //--- CMatrixDouble a1; CRowDouble sv1; int w,k; //--- prepare input data double input_data[]= {0.009,0.976,1.999,2.984,3.977,5.002}; CRowDouble x0=input_data; //--- create SSA model alglib.SSACreate(ssa_model1); //--- set window width for SSA model alglib.SSASetWindow(ssa_model1,3); //--- adds data sequence to SSA model alglib.SSAAddSequence(ssa_model1,x0); //--- set algorithm to the real-time version of top-K, K=2 alglib.SSASetAlgoTopKRealtime(ssa_model1,2); //--- one more interesting feature of the incremental algorithm is "power-up" cycle. //--- even with incremental algorithm initial basis calculation costs O(N*Width^2) ops. //--- if such startup cost is too high for your real-time app, then you may divide initial basis calculation //--- across several model updates. It results in better latency at the price of somewhat lesser precision during first few updates. alglib.SSASetPowerUpLength(ssa_model1,3); //--- now, after we prepared everything, start to add incoming points one by one; //--- in the real life, of course, we will perform some work between subsequent update (analyze something, predict, and so on). //--- after each append we perform one iteration of the real-time solver. Usually //--- one iteration is more than enough to update basis. If you have REALLY tight performance constraints, //--- you may specify fractional amount of iterations, which means that iteration is performed with required probability. double updateits = 1.0; //--- append single point to last data sequence stored in the SSA model and update model in the incremental manner alglib.SSAAppendPointAndUpdate(ssa_model1,5.951,updateits); //--- execute SSA on internally stored dataset and get basis found by current method alglib.SSAGetBasis(ssa_model1,a1,sv1,w,k); //--- append single point to last data sequence alglib.SSAAppendPointAndUpdate(ssa_model1,7.074,updateits); //--- execute SSA alglib.SSAGetBasis(ssa_model1,a1,sv1,w,k); //--- append single point to last data sequence alglib.SSAAppendPointAndUpdate(ssa_model1,7.925,updateits); //--- execute SSA alglib.SSAGetBasis(ssa_model1,a1,sv1,w,k); //--- append single point to last data sequence alglib.SSAAppendPointAndUpdate(ssa_model1,8.992,updateits); //--- execute SSA alglib.SSAGetBasis(ssa_model1,a1,sv1,w,k); //--- append single point to last data sequence alglib.SSAAppendPointAndUpdate(ssa_model1,9.942,updateits); //--- execute SSA alglib.SSAGetBasis(ssa_model1,a1,sv1,w,k); //--- append single point to last data sequence alglib.SSAAppendPointAndUpdate(ssa_model1,11.051,updateits); //--- execute SSA alglib.SSAGetBasis(ssa_model1,a1,sv1,w,k); //--- append single point to last data sequence alglib.SSAAppendPointAndUpdate(ssa_model1,11.965,updateits); //--- execute SSA alglib.SSAGetBasis(ssa_model1,a1,sv1,w,k); //--- append single point to last data sequence alglib.SSAAppendPointAndUpdate(ssa_model1,13.047,updateits); //--- execute SSA alglib.SSAGetBasis(ssa_model1,a1,sv1,w,k); //--- append single point to last data sequence alglib.SSAAppendPointAndUpdate(ssa_model1,13.970,updateits); //--- execute SSA alglib.SSAGetBasis(ssa_model1,a1,sv1,w,k); //--- ok, we have our basis in a1[] and singular values at sv1[]. But is it good enough? Let's print it. PrintMatrix(a1); //--- output: [[0.510607,0.753611],[0.575201,0.058445],[0.639081,-0.654717]] //--- EXPECTED: [[0.510607,0.753611],[0.575201,0.058445],[0.639081,-0.654717]] //--- ok, two vectors with 3 components each. but how to understand that is it really good basis? let's compare it with direct SSA algorithm on the entire sequence. CSSAModel ssa_model2; CMatrixDouble a2; CRowDouble sv2; //--- input data double input_data2[]= {0.009,0.976,1.999,2.984,3.977,5.002,5.951,7.074,7.925,8.992,9.942,11.051,11.965,13.047,13.970}; CRowDouble x2=input_data2; //--- create SSA model alglib.SSACreate(ssa_model2); //--- set window width for SSA model alglib.SSASetWindow(ssa_model2,3); //--- add data sequence to SSA model alglib.SSAAddSequence(ssa_model2,x2); //--- set SSA algorithm to "direct top-K" algorithm alglib.SSASetAlgoTopKDirect(ssa_model2,2); //--- execute SSA on internally stored dataset and get basis found by current method alglib.SSAGetBasis(ssa_model2,a2,sv2,w,k); //--- it is exactly the same as one calculated with incremental approach! PrintMatrix(a2); //--- output: [[0.510607,0.753611],[0.575201,0.058445],[0.639081,-0.654717]] //--- EXPECTED: [[0.510607,0.753611],[0.575201,0.058445],[0.639081,-0.654717]] return 0; } //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { //--- the very simple example of trend/noise separation ssa_d_basic(); //--- forecasting with SSA ssa_d_forecast(); //--- real-time analysis of constantly arriving data ssa_d_realtime(); } //+------------------------------------------------------------------+
Conclusion
ALGLIB est un outil puissant pour l'analyse des données des marchés financiers. Le multilinguisme, la nature multi-plateforme, la richesse des fonctionnalités et l’open source en font un choix attrayant pour les chercheurs et les développeurs dans le domaine de l'analyse et de la modélisation financières. Il existe un besoin permanent d'outils d'analyse de données fiables, et ALGLIB relève ce défi en soutenant le développement et l'amélioration continus.
Pour leur part, les développeurs de la plateforme MetaTrader 5 fournissent aux traders les meilleures solutions :
- Le langage MQL5, qui n'a rien à envier au langage C++ en termes de rapidité ;
- Le traitement intégré des bases de données SQLite, la possibilité d'effectuer des calculs à l'aide d'OpenCL, la prise en charge de DirectX, l’utilisation de modèles ONNX et l’intégration avec Python ;
- Les bibliothèques mathématiques, y compris de logique floue, statistiques et la version actualisée d'ALGLIB.
Traduit du russe par MetaQuotes Ltd.
Article original : https://www.mql5.com/ru/articles/13289
Les fonctionnalités de ChatGPT d'OpenAI dans le cadre du développement MQL4 et MQL5
Comment gagner de l'argent en remplissant les commandes des traders dans le service Freelance ?
Combinatoire et théorie des probabilités pour le trading (Partie I) : L'essentiel
Calculs de marché : bénéfices, pertes et coûts
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Vous acceptez la politique du site Web et les conditions d'utilisation