Magie algorithmique : exploiter la théorie des graphes dans le domaine des changes

Si vous êtes familier avec le secteur des startups FinTech, vous avez peut-être entendu parler de Revolut, un géant FinTech bien connu basé à Londres, au Royaume-Uni. Fondée en 2015, Revolut a recueilli des investissements substantiels et est devenue l'une des startups à la croissance la plus rapide au Royaume-Uni, fournissant des services bancaires à de nombreux citoyens européens. Alors que les opérations bancaires sont souvent entourées de mystère quant à la manière dont elles génèrent des revenus, certains chiffres clés de Revolut pour les années 2020 et 2021 ont mis en lumière leurs sources de revenus : Comme illustré, une part importante des revenus de cette néobanque provient du change (FX), de la gestion de patrimoine (y compris les cryptomonnaies) et des services de cartes. Notamment, en 2021, les changes sont devenus le secteur le plus rentable. Un de mes amis, qui est également ingénieur logiciel, a un jour partagé une histoire intrigante sur son entretien technique au département de génie logiciel de Revolut il y a quelques années. Il a été chargé de développer un algorithme permettant d'identifier le moyen le plus rentable de convertir deux devises en utilisant une ou plusieurs devises intermédiaires. En d’autres termes, ils recherchaient une stratégie d’arbitrage de devises. est une stratégie de trading dans laquelle un trader de devises exploite différents spreads proposés par les courtiers pour une paire de devises particulière via plusieurs transactions. L'arbitrage de devises Il a été explicitement mentionné dans la tâche que les fondements de l'algorithme doivent être ancrés dans la théorie des graphes. Notions de base sur les effets de change Le FX, ou Foreign Exchange, joue un rôle central dans le commerce mondial, soutenant le fonctionnement de notre monde interconnecté. Il est évident que le change joue également un rôle important en faisant des banques les organisations les plus riches. Le profit généré par les changes est principalement la différence ou l’écart entre les prix d’achat (BID) et de vente (ASK). Même si cette différence peut paraître minime par transaction, elle peut se chiffrer en millions de dollars de bénéfices compte tenu du volume des opérations quotidiennes. Cela permet à certaines entreprises de prospérer uniquement grâce à ces opérations financières hautement automatisées. Dans le domaine du FX (Foreign Exchange), nous travaillons toujours avec des paires de devises, comme l'EUR/USD. Dans la plupart des cas, ces échanges sont bidirectionnels (c'est-à-dire EUR/USD et USD/EUR) et la valeur du taux de change diffère dans chaque direction. Une représente un rapport numérique entre les valeurs de deux devises (l'EUR et le dollar américain, par exemple), déterminant le taux de change entre elles. paire d'arbitrage Potentiellement, nous pouvons utiliser plusieurs devises intermédiaires pour réaliser des échanges rentables, ce que l'on appelle un . pari sûr est un ensemble de paires à utiliser de manière circulaire. Le pari sûr d’arbitrage En savoir plus De nombreux fournisseurs ont recours à la modélisation et à l'analyse mathématiques pour garantir leurs propres bénéfices et empêcher les autres d'en profiter. C’est pourquoi le terme potentiellement est souligné ici. fait référence au nombre de paires qui constituent un ensemble d’opportunités d’arbitrage potentielles. La longueur du pari sûr Dans le monde réel, les taux de change peuvent varier selon les différentes banques ou plateformes d'échange. Il n'est pas rare que des touristes parcourent une ville pour trouver le meilleur tarif possible. Avec un logiciel informatique, ce processus peut être accompli en quelques millisecondes lorsque vous avez accès à une liste de fournisseurs. Dans des transactions pratiques et rentables, plusieurs étapes peuvent impliquer des conversions dans différentes devises sur différentes plateformes d'échange. En d’autres termes, le cercle d’arbitrage peut être assez étendu. consiste à acquérir une devise, à la transférer vers une autre plateforme, à effectuer un échange contre d'autres devises et finalement à revenir à la devise d'origine. L'Arbitrage Circle Le taux de change entre deux monnaies via une ou plusieurs monnaies intermédiaires est calculé comme . le produit des taux de change de ces transactions intermédiaires Un exemple Par exemple, imaginons que nous voulions acheter des francs suisses contre du dollar américain, puis échanger des francs contre des yens japonais, puis revendre des yens contre du dollar américain. À l’automne 2023, nous avons les taux de change suivants : Nous pouvons acheter 0,91 CHF (Franc suisse) pour 1 USD. Nous pouvons acheter 163,16 yens japonais pour 1 CHF. Nous pouvons acheter 0,0067 USD pour 1 yen japonais. Présentons-le avec un tableau : 1 USD | 1 CHF | 1 YEN 0.91 CHF | 163.16 YEN | 0.0067 USD ----------------|-------------------|-------------- 1.098901099 | 0.006128953 | 149.2537313 Maintenant, nous devons trouver un produit de ces valeurs. Une séquence de transactions : devient rentable lorsque ce produit rapporte une valeur inférieure à un 1.098901099 * 0.006128953 * 149.2537313 = 1.005240803 Comme nous pouvons le constater, le résultat est supérieur à un, il semble donc que nous ayons perdu 0,05 % de notre argent. Mais combien exactement ? Nous pouvons trier cela comme ceci : 0.91 CHF * 163.16 (YEN per 1 CHF) * 0.0067 (USD per 1 YEN) = 0.99478652 US Dollars Ainsi, après avoir vendu 1 dollar américain au début, nous avons obtenu 0,994, soit moins de 1 dollar américain à la fin. En termes plus simples, le cycle d'arbitrage est rentable lorsqu'une unité monétaire peut être obtenue pour moins d'une unité de la même monnaie. Imaginons que nous ayons trouvé une opportunité de prendre 0,92 CHF pour 1 dollar américain lors de la transaction initiale, au lieu de 0,91 CHF : 1 USD | 1 CHF | 1 YEN 0.92 CHF | 163.16 YEN | 0.0067 USD ----------------|-------------------|-------------- 1.086956522 | 0.006128953 | 149.2537313 Un produit sera inférieur à 1 : 1.086956522 * 0.006128953 * 149.2537313 = 0.994314272 Ce qui signifie que dans les monnaies réelles, cela nous donnera plus de 1 dollar américain : 0.92 CHF * 163.16 (YEN per 1 CHF) * 0.0067 (USD per 1 YEN) = 1.00571824 US Dollars Wuolah, Voyons maintenant comment automatiser cela à l'aide de l'analyse graphique. nous avons fait du PROFIT ! Ainsi, la formule pour vérifier les profits ou les pertes dans un cercle d'arbitrage de 3 paires d'arbitrage ressemblerait à ceci : USD/CHF * CHF/YEN * YEN/USD < 1.0 Représentation graphique Pour automatiser ces processus, nous pouvons utiliser des graphiques. Les tableaux mentionnés précédemment peuvent être naturellement transformés en une représentation matricielle d'un graphique, où les nœuds représentent les devises et les bords représentent les échanges bidirectionnels. Par conséquent, il est simple de représenter l’échange de deux paires dans une matrice comme ceci : EUR USD 1 1 EUR 1 1 USD En fonction du nombre de paires impliquées, notre matrice peut s'étendre : EUR USD YEN CHF 1 1 1 1 EUR 1 1 1 1 USD 1 1 1 1 YEN 1 1 1 1 CHF Par conséquent, notre tableau peut devenir considérablement plus grand, même pour deux monnaies seulement, si nous prenons en compte davantage de plateformes et de ressources d’échange. Pour résoudre les problèmes réels d’arbitrage de devises, un graphique complet englobant toutes les relations pour les cotations de devises est souvent utilisé. Un tableau de change à trois devises pourrait ressembler à ceci : USD CHF YEN { 1.0, 1.10, 0.0067 } USD { 0.91, 1.0, 0.0061 } CHF { 148.84, 163.16, 1.0 } YEN Nous pouvons utiliser une simple pour représenter nos paires de devises en mémoire : structure de données graphique class GraphNode { public: string Name; }; class Graph { public: vector > Matrix; vector Nodes; }; Il ne reste plus qu’à découvrir comment parcourir ce graphique et trouver le cercle le plus rentable. Mais il reste encore un problème... Les mathématiques nous sauvent encore une fois Les algorithmes de graphes classiques ne sont pas bien adaptés pour travailler avec le car ils sont conçus pour trouver des chemins définis comme (voir les implémentations de tous les algorithmes de recherche de chemin classiques bien connus ). produit des longueurs d'arêtes la somme de ces longueurs BFS, DFS, Dijkstra ou même Une étoile Cependant, pour contourner cette limitation, il existe un moyen mathématique de passer d'un produit à une somme : les logarithmes. Si un produit apparaît sous un logarithme, il peut être converti en une somme de logarithmes. Du côté droit de cette équation, le nombre souhaité est inférieur à un, indiquant que le logarithme de ce nombre doit être inférieur à zéro : LogE(USD/CHF) * LogE(CHF/YEN) * LogE(YEN/USD) < 0.0 Cette astuce mathématique simple nous permet de passer de la recherche d'un cycle avec un de longueur d'arête inférieur à un à . produit la recherche d'un cycle où la somme des longueurs d'arête est inférieure à zéro Nos valeurs matricielles converties en LogE(x) et arrondies avec 2 chiffres après le point ressemblent maintenant à ceci : USD CHF YEN { 0.0, 0.1, -5.01 } USD { -0.09, 0.0, -5.1 } CHF { 5.0, 5.09, 0.0 } YEN Ce problème devient désormais plus résoluble en utilisant des algorithmes graphiques classiques. Ce dont nous avons besoin, c'est de parcourir le graphique à la recherche du chemin d'échange le plus rentable. Algorithmes graphiques Chaque algorithme a ses limites. J'en ai mentionné certains dans . mon article précédent Nous ne pouvons pas appliquer ici les classiques BFS, DFS ou même Dijkstra car notre graphique peut contenir des poids négatifs, ce qui peut conduire à lorsqu'il parcourt le graphique. Les cycles négatifs posent un défi à l’algorithme car il trouve continuellement de meilleures solutions à chaque itération. des cycles négatifs Pour résoudre ce problème, l'algorithme de Bellman-Ford limite simplement le nombre d'itérations. Il parcourt chaque bord du graphique dans un cycle et applique une relaxation à tous les bords pas plus de V-1 fois (où V est un nombre de nœuds). A ce titre, l'algorithme de Bellman-Ford est au cœur de ce système d'arbitrage, car il permet de découvrir des chemins entre deux nœuds du graphe qui répondent à deux critères essentiels : ils contiennent des poids négatifs et ne font pas partie de cycles négatifs. Bien que cet algorithme soit théoriquement simple (et que vous puissiez trouver des milliards de vidéos à ce sujet), sa mise en œuvre pratique pour nos besoins nécessite un certain effort. Examinons cela. Implémentation de l'algorithme Bellman-Ford L’objectif de cet article étant l’informatique, j’utiliserai des taux de change imaginaires qui n’ont rien à voir avec les taux de change réels. Pour une introduction plus fluide à l'algorithme, utilisons un graphique qui ne contient pas du tout de cycles négatifs : graph.Nodes.push_back({ "USD" }); graph.Nodes.push_back({ "CHF" }); graph.Nodes.push_back({ "YEN" }); graph.Nodes.push_back({ "GBP" }); graph.Nodes.push_back({ "CNY" }); graph.Nodes.push_back({ "EUR" }); // Define exchange rates for pairs of currencies below // USD CHF YEN GBP CNY EUR graph.Matrix = { { 0.0, 0.41, INF, INF, INF, 0.29 }, // USD { INF, 0.0, 0.51, INF, 0.32, INF }, // CHF { INF, INF, 0.0, 0.50, INF, INF }, // YEN { 0.45, INF, INF, 0.0, INF, -0.38 }, // GBP { INF, INF, 0.32, 0.36, 0.0, INF }, // CNY { INF, -0.29, INF, INF, 0.21, 0.0 } }; // EUR L'exemple de code ci-dessous trouve un chemin entre deux nœuds à l'aide de l'algorithme de Bellman-Ford lorsque le graphique manque de cycles négatifs : vector _shortestPath; vector _previousVertex; void FindPath(Graph& graph, int start) { int verticesNumber = graph.Nodes.size(); _shortestPath.resize(verticesNumber, INF); _previousVertex.resize(verticesNumber, -1); _shortestPath[start] = 0; // For each vertex, apply relaxation for all the edges V - 1 times. for (int k = 0; k _shortestPath[from] + graph.Matrix[from][to]) { _shortestPath[to] = _shortestPath[from] + graph.Matrix[from][to]; _previousVertex[to] = from; } } L'exécution de ce code pour le yuan chinois remplit le tableau et donne des résultats comme celui-ci : _previousVertex Path from 4 to 0 is : 4(CNY) 3(GBP) 0(USD) Path from 4 to 1 is : 4(CNY) 3(GBP) 5(EUR) 1(CHF) Path from 4 to 2 is : 4(CNY) 3(GBP) 5(EUR) 1(CHF) 2(YEN) Path from 4 to 3 is : 4(CNY) 3(GBP) Path from 4 to 4 is : 4(CNY) Path from 4 to 5 is : 4(CNY) 3(GBP) 5(EUR) Comme vous pouvez le constater, il identifie les chemins optimaux entre le CNY et diverses autres devises. Et encore une fois, je ne me concentrerai pas sur la recherche d’un seul meilleur, car il s’agit d’une tâche relativement simple et ce n’est pas le but de l’article. L'implémentation ci-dessus fonctionne bien dans des cas idéaux, mais ne suffit pas lorsqu'il s'agit de graphiques contenant des cycles négatifs. Détection des cycles négatifs Ce dont nous avons réellement besoin, c’est de pouvoir identifier si un graphique contient des cycles négatifs et, si c’est le cas, d’identifier les segments problématiques. Cette connaissance nous permet d'atténuer ces problèmes et, à terme, de découvrir des chaînes rentables. Le nombre d'itérations ne doit pas toujours atteindre précisément V - 1. Une solution est réputée trouvée si, au (N+1)-ème cycle, aucun chemin meilleur que celui du N-ème cycle n'est découvert. Il y a donc place à une légère optimisation. Le code mentionné précédemment peut être amélioré non seulement pour trouver des chemins, mais également pour détecter si le graphique contient des cycles négatifs, y compris l'optimisation que j'ai mentionnée : vector _shortestPath; vector _previousVertex; bool ContainsNegativeCycles(Graph& graph, int start) { int verticesNumber = graph.Nodes.size(); _shortestPath.resize(verticesNumber, INF); _previousVertex.resize(verticesNumber, -1); _shortestPath[start] = 0; // For each vertex, apply relaxation for all the edges V - 1 times. for (int k = 0; k _shortestPath[from] + graph.Matrix[from][to]) { _shortestPath[to] = _shortestPath[from] + graph.Matrix[from][to]; _previousVertex[to] = from; updated = true; } } } if (!updated) // No changes in paths, means we can finish earlier. break; } // Run one more relaxation step to detect which nodes are part of a negative cycle. if (updated) for (int from = 0; from _shortestPath[from] + graph.Matrix[from][to]) // A negative cycle has occurred if we can find a better path beyond the optimal solution. return true; return false; } Et maintenant, nous jouons avec un graphique plus complexe qui inclut des cycles négatifs : graph.Nodes.push_back({ "USD" }); // 1 (Index = 0) graph.Nodes.push_back({ "CHF" }); graph.Nodes.push_back({ "YEN" }); graph.Nodes.push_back({ "GBP" }); graph.Nodes.push_back({ "CNY" }); graph.Nodes.push_back({ "EUR" }); graph.Nodes.push_back({ "XXX" }); graph.Nodes.push_back({ "YYY" }); // 8 (Index = 7) // USD CHF YEN GBP CNY EUR XXX YYY graph.Matrix = { { 0.0, 1.0, INF, INF, INF, INF, INF, INF }, // USD { INF, 0.0, 1.0, INF, INF, 4.0, 4.0, INF }, // CHF { INF, INF, 0.0, INF, 1.0, INF, INF, INF }, // YEN { INF, INF, 1.0, 0.0, INF, INF, INF, INF }, // GBP { INF, INF, INF, -3.0, 0.0, INF, INF, INF }, // CNY { INF, INF, INF, INF, INF, 0.0, 5.0, 3.0 }, // EUR { INF, INF, INF, INF, INF, INF, 0.0, 4.0 }, // XXX { INF, INF, INF, INF, INF, INF, INF, 0.0 } }; // YYY Notre programme s'arrête simplement et affiche un message : Graph contains negative cycle. Nous avons pu indiquer le problème, mais nous devons naviguer autour des segments problématiques du graphique. Éviter les cycles négatifs Pour ce faire, nous marquerons les sommets qui font partie de cycles négatifs avec une valeur constante, NEG_INF : bool FindPathsAndNegativeCycles(Graph& graph, int start) { int verticesNumber = graph.Nodes.size(); _shortestPath.resize(verticesNumber, INF); _previousVertex.resize(verticesNumber, -1); _shortestPath[start] = 0; for (int k = 0; k _shortestPath[from] + graph.Matrix[from][to]) { _shortestPath[to] = _shortestPath[from] + graph.Matrix[from][to]; _previousVertex[to] = from; } } bool negativeCycles = false; for (int k = 0; k _shortestPath[from] + graph.Matrix[from][to]) { _shortestPath[to] = NEG_INF; _previousVertex[to] = -2; negativeCycles = true; } } return negativeCycles; } Désormais, si nous rencontrons NEG_INF dans le tableau _shortestPath, nous pouvons afficher un message et ignorer ce segment tout en identifiant les solutions optimales pour les autres devises. Par exemple, avec le nœud 0 (représentant USD) : Graph contains negative cycle. Path from 0 to 0 is : 0(USD) Path from 0 to 1 is : 0(USD) 1(CHF) Path from 0 to 2 is : Infinite number of shortest paths (negative cycle). Path from 0 to 3 is : Infinite number of shortest paths (negative cycle). Path from 0 to 4 is : Infinite number of shortest paths (negative cycle). Path from 0 to 5 is : 0(USD) 1(CHF) 5(EUR) Path from 0 to 6 is : 0(USD) 1(CHF) 6(XXX) Path from 0 to 7 is : 0(USD) 1(CHF) 5(EUR) 7(YYY) Whoala ! Notre code a pu identifier un certain nombre de chaînes rentables malgré le fait que nos données étaient « un peu sales ». Tous les exemples de code mentionnés ci-dessus, y compris les données de test, sont partagés avec vous sur . mon GitHub Même les petites fluctuations comptent Consolidons maintenant ce que nous avons appris. Étant donné une liste de taux de change pour trois devises, nous pouvons facilement détecter des cycles négatifs : graph.Nodes.push_back({ "USD" }); // 1 (Index = 0) graph.Nodes.push_back({ "CHF" }); graph.Nodes.push_back({ "YEN" }); // 3 (Index = 2) // LogE(x) table: USD CHF YEN graph.Matrix = { { 0.0, 0.489, -0.402 }, // USD { -0.489, 0.0, -0.891 }, // CHF { 0.402, 0.89, 0.0 } }; // YEN from = 0; FindPathsAndNegativeCycles(graph, from); Résultat: Graph contains negative cycle. Path from 0 to 0 is: Infinite number of shortest paths (negative cycle). Path from 0 to 1 is: Infinite number of shortest paths (negative cycle). Path from 0 to 2 is: Infinite number of shortest paths (negative cycle). Cependant, même de légères modifications des taux de change (c'est-à-dire des ajustements de la matrice) peuvent entraîner des différences significatives : // LogE(x) table: USD CHF YEN graph.Matrix = { { 0.0, 0.490, -0.402 }, // USD { -0.489, 0.0, -0.891 }, // CHF { 0.403, 0.891, 0.0 } }; // YEN from = 0; FindPathsAndNegativeCycles(graph, from); Regardez, nous avons trouvé une chaîne rentable : Path from 0 to 0 is : 0(USD) Path from 0 to 1 is : 0(USD) 2(YEN) 1(CHF) Path from 0 to 2 is : 0(USD) 2(YEN) Nous pouvons appliquer ces concepts à des graphiques beaucoup plus grands, impliquant plusieurs devises : graph.Nodes.push_back({ "USD" }); // 1 (Index = 0) graph.Nodes.push_back({ "CHF" }); graph.Nodes.push_back({ "YEN" }); graph.Nodes.push_back({ "GBP" }); graph.Nodes.push_back({ "CNY" }); // 5 (Index = 4) // LogE(x) table: USD CHF YEN GBP CNY graph.Matrix = { { 0.0, 0.490, -0.402, 0.7, 0.413 }, // USD { -0.489, 0.0, -0.891, 0.89, 0.360 }, // CHF { 0.403, 0.891, 0.0, 0.91, 0.581 }, // YEN { 0.340, 0.405, 0.607, 0.0, 0.72 }, // GBP { 0.403, 0.350, 0.571, 0.71, 0.0 } }; // CNY from = 0; runDetectNegativeCycles(graph, from); En conséquence, nous pourrions trouver plusieurs candidats pour réaliser des bénéfices : Path from 0 to 0 is : 0(USD) Path from 0 to 1 is : 0(USD) 2(YEN) 1(CHF) Path from 0 to 2 is : 0(USD) 2(YEN) Path from 0 to 3 is : 0(USD) 2(YEN) 3(GBP) Path from 0 to 4 is : 0(USD) 2(YEN) 4(CNY) Il y a cependant deux facteurs importants : Le temps est un facteur critique dans la mise en œuvre des processus d’arbitrage, principalement en raison des fluctuations rapides des prix des devises. De ce fait, la durée de vie d’un pari sûr est extrêmement brève. Les plateformes prélèvent des commissions pour chaque transaction. Il est donc primordial et , en limitant la durée du pari sûr. de minimiser les coûts de temps de réduire les commissions L'expérience empirique suggère qu'une longueur acceptable de pari sûr se situe généralement entre 2 et 3 paires. Au-delà de cela, les exigences informatiques augmentent et les plateformes de trading imposent des commissions plus importantes. Ainsi, pour gagner un revenu, il ne suffit pas de disposer de telles technologies, mais il faut également avoir accès à des commissions de faible niveau. Habituellement, seules les grandes institutions financières disposent d’une telle ressource. Automatisation à l'aide de contrats intelligents J'ai approfondi la logique des opérations de change et la manière d'en tirer des bénéfices, mais je n'ai pas abordé les technologies utilisées pour exécuter ces opérations. Bien que ce sujet s'écarte légèrement de sa trajectoire, je ne pouvais pas omettre de mentionner les contrats intelligents. L’utilisation de contrats intelligents est aujourd’hui l’un des moyens les plus innovants de mener des opérations de change. Les contrats intelligents permettent des opérations de change en temps réel sans retards ni intervention humaine (sauf pour la création du contrat intelligent). Solidity est le langage de programmation spécialisé pour créer des contrats intelligents qui automatisent les opérations financières impliquant des crypto-monnaies. Le monde des contrats intelligents est dynamique et soumis à des changements technologiques rapides et à des réglementations évolutives. Il s'agit d'un domaine très médiatisé et comportant des risques importants liés aux portefeuilles et à la conformité légale. S'il existe sans aucun doute des individus et des équipes talentueuses qui profitent de ce domaine, il existe également des organismes de réglementation qui s'efforcent de garantir le respect des règles du marché. Pourquoi examinons-nous cela ? Malgré la complexité, l’obscurité et l’imprévisibilité de l’économie mondiale, les changes restent une force motrice cachée dans le monde financier. Il s'agit d'un élément crucial qui permet à des milliers d'entreprises et à des millions d'individus dans le monde de collaborer, de fournir des services et de s'enrichir mutuellement de manière pacifique, au-delà des frontières. Bien entendu, divers facteurs, tels que la politique, la réglementation et les banques centrales, influencent les taux de change et l’efficacité des changes. Ces complexités rendent le paysage financier complexe. Pourtant, il est essentiel de croire que ces complexités servent un objectif plus important en faveur du bien commun. De nombreux articles scientifiques se penchent sur l’existence et la détermination des taux de change dans l’économie mondiale, pour n’en citer que quelques-uns : Importateurs, exportateurs et déconnexion du taux de change Choix des devises et répercussion du taux de change Énigmes et politiques en matière de taux de change Ces articles mettent en lumière certains mécanismes fondamentaux des changes, qui sont encore difficiles à comprendre et à intégrer dans un seul modèle. Cependant, jouer avec le code et essayer de trouver une solution à un problème pratique m'a aidé à en savoir un peu plus. J’espère que vous avez apprécié ce petit voyage d’exploration autant que moi. Restez à l'écoute! Liens Code source avec tous ces exemples Sedgewick R. - Algorithmes en C, Partie 5 : Algorithmes graphiques Implémentation du code de l'algorithme Bellman Ford Exemples GitHub de William Fiset - Bellman Ford sur la matrice de contiguïté Exemples GitHub de William Fiset - Bellman Ford On Edge List Également publié . ici

Magie algorithmique : exploiter la théorie des graphes dans le domaine des changes

About Author

COMMENTAIRES

ÉTIQUETTES

CET ARTICLE A ÉTÉ PARU DANS

Related Stories

Libérer la puissance de l’IA. Une revue systématique des techniques de pointe : résumé et introduction

Valhalla de Floki se joint en tant que sponsor associé de la tournée indienne au Sri Lanka

Guide de l'architecte pour créer une architecture de référence pour un datalake IA/ML

HackerNoon Decoded: The Top 10 Countries Where HackerNoon Is the Most Active

Libérer la puissance de l’IA. Une revue systématique des techniques de pointe : résumé et introduction

Valhalla de Floki se joint en tant que sponsor associé de la tournée indienne au Sri Lanka

Guide de l'architecte pour créer une architecture de référence pour un datalake IA/ML

HackerNoon Decoded: The Top 10 Countries Where HackerNoon Is the Most Active

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps