Python pour le trading

algorithmique
TheQuants GmbH <trde ining@tpq.io>
Table des matières
Copyright.............................................................................................................................................1
Préface.................................................................................................................................................2
Biographie de l'auteur........................................................................................................................6
1. Python et le trading algorithmique.............................................................................................7
1.1. Introduction..........................................................................................................................7
1.2. Python pour la finance.......................................................................................................7
1.3. Trading algorithmique........................................................................................................14
1.4. Python pour le trading algorithmique..........................................................................18
1.5. Objectif et conditions préalables....................................................................................19
1.6. Stratégies de trading.........................................................................................................21
1.7. Aperçu.................................................................................................................................22
1.8. Conclusions........................................................................................................................25
1.9. Plus loin Ressources.........................................................................................................25
2. Python Infrastructure................................................................................................................27
2.1. Introduction........................................................................................................................27
2.2. Conda en tant que gestionnaire de paquets................................................................29
2.3. Conda en tant que gestionnaire d'environnement virtuel.......................................36
2.4. Utilisation des conteneurs Docker....................................................................................41
2.5. Utilisation d'instances cloud..............................................................................................48
2.6. Conclusions........................................................................................................................55
2.7. Plus loin Ressources.........................................................................................................56
3. Utilisation des données financières........................................................................................58
3.1. Introduction........................................................................................................................58
3.2. Lecture de données financières provenant de différentes sources.........................59
3.3. Utilisation de sources de données ouvertes.....................................................................66
3.4. API de données Eikon.........................................................................................................70
3.5. Stocker efficacement les données financières..............................................................79
3.6. Conclusions........................................................................................................................94
3.7. Plus loin Ressources.........................................................................................................94
3.8. Python Scripts....................................................................................................................95
4. Maîtriser le backtesting vectorisé...........................................................................................97
4.1. Introduction........................................................................................................................97
4.2. Utilisation de la vectorisation............................................................................................98
4.3. Stratégies basées sur des moyennes mobiles simples..................................................105
 4.4. Stratégies basées sur le momentum............................................................................116
4.5. Stratégies basées sur le retour à la moyenne.............................................................125
4.6. Conclusions......................................................................................................................131
4.7. Plus loin Ressources.......................................................................................................131
4.8. Python Scripts..................................................................................................................133
5. Prédire les mouvements du marché grâce à l'apprentissage automatique.................140
5.1. Introduction......................................................................................................................140
5.2. Utilisation de la régression linéaire pour la prédiction des mouvements du
marché................................................................................................................................141
5.3. Utilisation de l'apprentissage automatique pour la prédiction des mouvements
du marché..........................................................................................................................157
5.4. Utilisation de l'apprentissage profond pour la prédiction des mouvements du marché
172
5.5. Conclusions......................................................................................................................186
5.6. Plus loin Ressources.......................................................................................................187
5.7. Python Scripts..................................................................................................................188
6. Création de classes pour le backtesting basé sur les événements.......................................194
6.1. Introduction......................................................................................................................194
6.2. Classe de base de backtesting.......................................................................................195
6.3. Classe de backtesting longue uniquement.....................................................................201
6.4. Cours de backtesting long short......................................................................................205
6.5. Conclusions......................................................................................................................209
6.6. Plus loin Ressources.......................................................................................................210
6.7. Python Scripts..................................................................................................................211
7. Utilisation des données et des sockets en temps réel............................................................219
7.1. Introduction......................................................................................................................219
7.2. Exécution d'un serveur de données de tick simple.................................................221
7.3. Connexion d'un client de données de tick simple........................................................224
7.4. Génération de signaux en temps réel..........................................................................226
7.5. Visualisation de données de streaming avec Plotly.....................................................229
7.6. Conclusions......................................................................................................................243
7.7. Plus loin Ressources.......................................................................................................244
7.8. Python Scripts..................................................................................................................244
8. Trading FX avec FXCM.............................................................................................................258
8.1. Introduction......................................................................................................................258
8.2. Obtention Commencé.....................................................................................................260
8.3. Récupération Données...................................................................................................261
 8.4. Utilisation de l'API............................................................................................................267
8.5. Conclusions......................................................................................................................274

8.6. Plus loin Ressources.......................................................................................................275

9. Trading de CFD avec Oanda....................................................................................................276
9.1. Introduction......................................................................................................................276
9.2. Configuration d'un compte..............................................................................................278
9.3. L'API Oanda.......................................................................................................................280
9.4. Récupération des données historiques.......................................................................282
9.5. Utilisation des données de streaming.........................................................................289
9.6. Passer des ordres au marché.........................................................................................290
9.7. Mise en œuvre de stratégies de trading en temps réel...........................................292
9.8. Récupération des informations de compte................................................................296
9.9. Conclusions......................................................................................................................298
9.10. Plus loin Ressources.....................................................................................................299
9.11. Python Scripts................................................................................................................299
10. Trading d'actions avec Interactive Brokers......................................................................301
10.1. Introduction...................................................................................................................301
10.2. Configuration d'un compte............................................................................................302
10.3. Python et l'API de l'IB.....................................................................................................304
10.4. Une classe wrapper pour l'API de l'IB......................................................................306
10.5. Récupération des données historiques de l'IB........................................................307
10.6. Utilisation des données de diffusion en continu à partir de l'API IB................312
10.7. Mise en œuvre de stratégies de trading en temps réel.........................................314
10.8. Récupération des informations de compte..............................................................318
10.9. Conclusions....................................................................................................................320
10.10. Plus loin Ressources...................................................................................................321
10.11. Python Scripts..............................................................................................................321
11. Trader les crypto-monnaies avec Gemini.........................................................................331
11.1. Introduction...................................................................................................................331
11.2. Gémeaux Plateforme....................................................................................................334
11.3. Configuration d'un compte............................................................................................337
11.4. Une classe wrapper pour l'API Gemini........................................................................338
11.5. Récupération des données historiques.....................................................................340
11.6. Passer et gérer les commandes via l'API......................................................................344
11.7. Historique des transactions les plus récentes.........................................................351
11.8. Mise en œuvre de stratégies de trading en temps réel.........................................353
 11.9. Récupération des informations de compte..............................................................358
11.10. Conclusions..................................................................................................................360

11.11. Plus loin Ressources...................................................................................................360

11.12. Python Scripts..............................................................................................................360
12. Automatisation des opérations de trading...........................................................................383
12.1. Introduction...................................................................................................................383
12.2. Capital Gestion...............................................................................................................384
12.3. Stratégie de trading basée sur le ML............................................................................395
12.4. Algorithme en ligne........................................................................................................409
12.5. Infrastructure et déploiement....................................................................................413
12.6. Journalisation et surveillance.........................................................................................414
12.7. Vue d'ensemble visuelle étape par étape.....................................................................417
12.8. Conclusions....................................................................................................................423
12.9. Plus loin Ressources.....................................................................................................424
12.10. Python Script................................................................................................................424
Annexe A : Python, NumPy, matplotlib, pandas.......................................................................428
Introduction.............................................................................................................................428
Python Notions de base........................................................................................................429
NumPy........................................................................................................................................438
matplotlib.................................................................................................................................446
Pandas.......................................................................................................................................451
Étude de cas...............................................................................................................................463
Conclusions..............................................................................................................................470
Plus loin Ressources...............................................................................................................470
Copyright
Ce document, ainsi que tous les codes, blocs-notes Jupyter et autres documents
connexes sur la plate-forme Quant (http://pyalgo.pqp.io) sont protégés par le droit
d'auteur et uniquement destinés à un usage personnel dans le cadre d'une licence
d'utilisateur unique pour le cours Python for Algorithmic Trading
(http://pyalgo.tpq.io). Toute forme de partage, de distribution, de duplication, etc. sans
l'autorisation écrite de The Python Quants GmbH est interdite. Le contenu, les codes
Python, les blocs-notes Jupyter et d'autres documents sont fournis sans garantie ni
représentation, dans la mesure permise par la loi applicable.

Notez que ce document est toujours en cours de développement et que des ajouts,
des modifications, des mises à jour, etc. substantiels auront lieu dans un proche
avenir. Il est conseillé de vérifier régulièrement les nouvelles versions du
document.

(c) Dr Yves J. Hilpisch, octobre 2018

1
Préface
Le dataïsme dit que l'univers est constitué de flux de données, et que la valeur de tout
phénomène ou entité est déterminée par sa contribution au traitement des données. ...
Le dataïsme fait ainsi tomber la barrière entre les animaux [les humains] et les
machines, et s'attend à ce que les algorithmes électroniques finissent par déchiffrer et
surpasser les algorithmes biochimiques.

— Yuval Noah Harari (Homo Deus)

Trouver le bon algorithme pour trader automatiquement et avec succès sur les
marchés financiers est le Saint Graal de la finance. Il n'y a pas si longtemps, le
trading algorithmique n'était disponible que pour les acteurs institutionnels aux
poches profondes et avec beaucoup d'actifs sous gestion. Les développements
récents dans les domaines de l'open source, des données ouvertes, du cloud
computing et du stockage ainsi que des plateformes de trading en ligne ont
uniformisé les règles du jeu pour les petites institutions et les traders individuels,
ce qui permet de se lancer dans cette discipline fascinante en étant équipé d'un
ordinateur portable moderne et d'une connexion Internet uniquement.

De nos jours, Python et son écosystème de packages puissants est la plate-

forme technologique de choix pour le trading algorithmique. Python permet entre
autres de faire de l'analyse de données efficace (avec par exemple pandas),
d'appliquer l'apprentissage automatique à la prédiction boursière (avec par
exemple scikit-learn) ou même d'utiliser la technologie d'apprentissage profond
de Google (avec tensorflow).

Il s'agit d'un cours sur Python pour le trading algorithmique. Un tel cours, à
l'intersection de deux domaines vastes et passionnants, peut difficilement couvrir
tous les sujets pertinents. Cependant, il peut couvrir en profondeur une série de
méta-sujets importants :

• Données financières : Les données financières sont au cœur de tout projet de

trading algorithmique ; Python et les progiciels comme NumPy et pandas font un
excellent travail dans la gestion et le travail avec des données financières structurées de
tout type (fin de journée, intraday, haute fréquence)

• Backtesting : pas de trading algorithmique automatisé sans un test rigoureux de

la stratégie de trading à déployer ; le cours couvre, entre autres, les stratégies de
trading basées sur des moyennes mobiles simples, le momentum, le retour à la

2
moyenne et la prédiction basée sur le machine learning

3
 • données en temps réel : le trading algorithmique nécessite de traiter des
données en temps réel, des algorithmes en ligne basés sur celles-ci et une
visualisation en temps réel ; le cours initie à la programmation de sockets avec
ZeroMQ et à la visualisation en streaming avec Plotly

• Plates-formes en ligne : pas de trading sans plate-forme de trading ; le cours

couvre trois plates-formes de trading électronique populaires : Oanda
(trading de CFD), InteractiveBrokers (trading d'actions et d'options) et
Gemini (trading de crypto-monnaies) ; il fournit également des classes
wrapper pratiques en Python pour être opérationnel en quelques minutes

• Automatisation : la beauté ainsi que certains défis majeurs du trading

algorithmique résultent de l'automatisation de l'opération de trading ; le cours
montre comment déployer Python dans le cloud et comment mettre en place
un environnement approprié pour le trading algorithmique automatisé

Le cours offre une expérience d'apprentissage unique avec les caractéristiques et

avantages suivants.

Couverture de sujets pertinents

C'est le seul cours couvrant une telle ampleur et profondeur en ce qui concerne les
sujets pertinents en Python pour le trading algorithmique.

Base de code autonome

Le cours est accompagné d'un dépôt Git avec tous les codes sous une forme
autonome et exécutable (3 000+ lignes de code) ; le référentiel est disponible sur
la Plateforme Quant.

version du livre au format PDF

En plus de la version en ligne, il existe également une version livre au format

PDF (450+ pages).

Formation en ligne/vidéo (facultatif)

Les Quants Python proposent un cours de formation en ligne et vidéo ( non inclus)
basé sur ce cours/livre qui offre une expérience d'apprentissage interactive (par
exemple, pour voir le code exécuté en direct, poser des questions individuelles)
ainsi qu'un regard sur des sujets supplémentaires ou sur des sujets sous un angle
différent.

4
Le vrai trading comme objectif

La couverture de trois plateformes de trading en ligne différentes permet à

l'étudiant de commencer efficacement le trading papier et en direct. Ce cours
permet à l'étudiant d'acquérir des connaissances de base pertinentes, pratiques
et précieuses.

Approche à faire soi-même et à son propre rythme

Étant donné que le matériel et les codes sont autonomes et ne s'appuient que sur
des packages Python standard, l'étudiant a une connaissance et un contrôle
complets sur ce qui se passe, comment utiliser les exemples de code, comment les
modifier, etc. Il n'est pas nécessaire de s'appuyer sur des plateformes tierces, par
exemple, pour effectuer le backtesting ou pour se connecter aux plateformes de
trading. L'étudiant peut faire tout cela par lui-même avec ce cours - au rythme qui
lui convient le mieux - et dispose de chaque ligne de code pour le faire.

Forum des utilisateurs

Bien que vous soyez censé être capable de tout faire par vous-même, nous
sommes là pour vous aider. Vous pouvez poser des questions et des
commentaires sur notre forum d'utilisateurs à tout moment. Nous visons à
revenir dans les 24 heures.

Le cours suppose que l'étudiant possède, au moins à un niveau fondamental, des

connaissances de base à la fois en programmation Python et en trading financier. Le
matériel de cours comprend l'annexe A : Python, NumPy, matplotlib, pandas qui
présente des sujets importants sur Python, NumPy, matplotlib et 'pandas. De bonnes
références pour bien comprendre les sujets Python importants pour le cours sont :

• Hilpisch, Yves (2018) : Python pour la finance. 2e éd., O'Reilly, Beijing et al.

• McKinney, Wes (2017) : Python pour l'analyse des données. 2e éd., O'Reilly, Beijing et al.

• Ramalho, Luciano (2016): Fluent Python. O’Reilly, Beijing et al.

• VanderPlas, Jake (2016) : Manuel de science des données Python. O'Reilly, Beijing et
coll.

Des informations générales sur le trading algorithmique peuvent être trouvées, par
exemple, dans ces livres :

• Chan, Ernest (2009): Quantitative Trading. John Wiley & Sons, Hoboken et al.

5
 • Chan, Ernest (2013) : Trading algorithmique. John Wiley & Sons, Hoboken et al.

6
 • Kissel, Robert (2013) : Trading algorithmique et gestion de portefeuille.
Elsevier/Academic Press, Amsterdam et al.

• Narang, Rishi (2013) : À l'intérieur de la boîte noire. John Wiley & Sons, Hoboken et
al.

Profitez de votre voyage dans le monde du trading algorithmique avec Python et

contactez-nous sous training@tpq.io si vous avez des questions ou des
commentaires.

7
Biographie de l'auteur
Le Dr Yves J. Hilpisch est fondateur et associé directeur de The Python Quants, un
groupe qui se concentre sur l'utilisation de technologies open source pour la science
des données financières, l'intelligence artificielle, le trading algorithmique et la finance
computationnelle. Yves est également fondateur et PDG de The AI Machine.

Il est l'auteur des livres

• Python for Finance (2e éd., O'Reilly, 2018),

• Analyse des dérivés avec Python (Wiley, 2015) et

• Dérivés de volatilité et de variance cotés (Wiley, 2017).

Yves enseigne la finance computationnelle au CQF Program, le trading algorithmique

à l'EPAT Progrm et est le directeur des programmes de formation en ligne menant
aux premiers certificats universitaires en Python pour la finance et Python pour le
trading algorithmique (décernés par htw saar).

Yves est l'auteur de la bibliothèque d'analyse financière DX Analytics et organise

des meetups et des conférences sur Python pour le trading algorithmique,
l'intelligence artificielle et la finance quantitative à Francfort, Berlin, Paris, Londres
et New York. Il a également donné de nombreuses conférences et discours
liminaires lors de conférences technologiques aux États-Unis, en Europe et en Asie.

8
Chapitre 1. Python et le trading
algorithmique
Chez Goldman Sachs, le nombre de personnes engagées dans le trading d'actions est passé
d'un pic de 600 en 2000 à seulement deux aujourd'hui. [2 : « Trop calamar pour échouer. »
L'Économiste, p. 29. Octobre 2016.]

— L'économiste

1.1. Introduction
Ce chapitre fournit des informations générales et un aperçu des sujets abordés
dans ce livre (cours). Bien que Python pour le trading algorithmique soit un
créneau à l'intersection de la programmation Python et de la finance, il s'agit d'un
créneau en pleine croissance qui touche à des sujets aussi divers que le
déploiement de Python, l'analyse financière interactive, l'apprentissage
automatique et profond, la programmation orientée objet, la communication
socket, la visualisation de données en streaming et les plateformes de trading.

Pour un rappel rapide sur les sujets importants liés à Python, lisez d'abord l'Annexe A
: Python, NumPy, matplotlib, pandas .

1.2. Python pour la finance

Le langage de programmation Python est né en 1991 avec la première publication par
Guido van Rossum d'une version étiquetée 0.9.0. En 1994, la version 1.0 a suivi.
Cependant, il a fallu près de deux décennies à Python pour s'imposer comme un
langage de programmation et une plate-forme technologique majeurs dans le secteur
financier. Bien sûr, il y a eu des adopteurs précoces, principalement des fonds
spéculatifs, mais l'adoption généralisée n'a probablement commencé que vers 2011.

L'un des principaux obstacles à l'adoption de Python dans le secteur financier a été
le fait que la version par défaut de Python, appelée CPython, est un langage
interprété de haut niveau. Les algorithmes numériques en général et les
algorithmes financiers en particulier sont assez souvent implémentés sur la base de
structures de boucles (imbriquées). Alors que les langages compilés et de bas
niveau comme C ou C++ sont très rapides pour exécuter de telles boucles, Python –
qui s'appuie sur l'interprétation plutôt que sur la compilation – est généralement

9
assez lent à le faire.

10
En conséquence, Python pur s'est avéré trop lent pour de nombreuses applications
financières du monde réel, telles que la tarification des options ou la gestion des
risques.

Bien que Python n'ait jamais été spécifiquement destiné aux communautés
scientifiques et financières, de nombreuses personnes issues de ces domaines ont
néanmoins apprécié la beauté et la concision de sa syntaxe. Il n'y a pas si
longtemps, il était généralement considéré comme une bonne tradition d'expliquer
un algorithme (financier) et en même temps de présenter un pseudo-code comme
une étape intermédiaire vers sa mise en œuvre technologique correcte. Beaucoup
pensaient qu'avec Python, l'étape de pseudo-code ne serait plus nécessaire. Et ils se
sont avérés pour la plupart corrects.

Considérons, par exemple, la discrétisation d'Euler du mouvement brownien

géométrique comme dans la discrétisation d'Euler du mouvement brownien
géométrique.

Discrétisation d'Euler du mouvement brownien géométrique

Pendant des décennies, le langage de balisage et le compilateur Latex ont été la

référence en matière de création de documents scientifiques contenant des
formules mathématiques. À bien des égards, la syntaxe Latex est similaire ou déjà
similaire au pseudo-code lorsque, par exemple, la mise en page d'équations
comme dans la discrétisation d'Euler du mouvement brownien géométrique. Dans
ce cas particulier, la version Latex ressemble à ceci :

S_T = S_0 \exp((r - 0.5 \sigma^2) T + \sigma z \sqrt{T})

En Python, cela se traduit par un code exécutable — compte tenu des définitions
de variables respectives — qui est également très proche de la formule financière
ainsi que de la représentation Latex :

S_T = S_0 * exp((r - 0.5 * sigma ** 2) * T + sigma * z * sqrt(T))

Cependant, le problème de la vitesse demeure. Une telle équation différentielle, en

tant qu'approximation numérique de l'équation différentielle stochastique
respective, est généralement utilisée pour fixer le prix des dérivés par simulation

11
de Monte-Carlo ou pour effectuer une analyse et une gestion des risques basées
sur la simulation. Ces tâches, à leur tour, peuvent nécessiter des millions de
simulations qui doivent être terminées en temps voulu, souvent presque en temps
réel ou du moins en temps quasi réel.

12
Le Python interprété en soi n'a jamais été conçu pour être assez rapide pour
s'attaquer à des tâches aussi exigeantes en termes de calcul.

En 2006, la version 1.0 du package Python NumPy a été publiée par Travis Oliphant.
NumPy est l'abréviation de Python numérique, ce qui suggère qu'il cible des scénarios
qui sont numériquement exigeants. L'interpréteur Python de base essaie d'être
aussi général que possible dans de nombreux domaines, ce qui entraîne souvent
une surcharge au moment de l'exécution. [3 : Par exemple, les objets de liste ne
sont pas seulement mutables, c'est-à-dire qu'ils peuvent être modifiés
en taille, ils peuvent aussi contenir presque n'importe quel autre type
d'objet Python, comme les objets int, float, tuple ou les objets de liste eux-
mêmes.] NumPy, quant à lui, utilise la spécialisation comme approche principale
pour éviter les frais généraux et être aussi bon et rapide que possible dans certains
scénarios d'application.

La classe principale de NumPy est l'objet tableau régulier, appelé objet ndarray pour
tableau à n dimensions. Il est immuable, c'est-à-dire qu'il ne peut pas être modifié en
taille, et ne peut accueillir qu'un seul type de données, appelé dtype. Cette
spécialisation permet la mise en œuvre d'un code concis et rapide. Une approche
centrale dans ce contexte est la vectorisation. Fondamentalement, cette approche
évite le bouclage au niveau Python et délègue le bouclage à du code NumPy
spécialisé, implémenté en général en C et donc assez rapide.

Considérons la simulation de 1 000 000 de valeurs de fin de période selon la

discrétisation d'Euler du mouvement brownien géométrique avec Python pur. La
majeure partie du code ci-dessous est une boucle for avec 1 000 000 d'itérations.

In [1]: %%time
import random
from math import exp, sqrt

S0 = 100 ①
r = 0.05 ②
T = 1.0 ③
sigma = 0.2 ④

values = [] ⑤

for _ in range(1000000): ⑥
ST = S0 * exp((r - 0.5 * sigma ** 2) * T +
sigma * random.gauss(0, 1) * sqrt(T)) ⑦
values.append(ST) ⑧
CPU times: user 1.14 s, sys: 17.2 ms, total: 1.15 s
Wall time: 1.15 s

13
(1) Le niveau initial de l'indice.

(2) Le taux court constant.

(3) L'horizon temporel en fractions d'années.

(4) Le facteur de volatilité constante.

(5) Un objet de liste vide pour collecter des valeurs simulées.

(6) La boucle for principale .

(7) La simulation d'une valeur unique de fin de période.

(8) Ajoute la valeur simulée à l' objet list.

Avec NumPy, vous pouvez éviter complètement les boucles au niveau Python par
l'utilisation de la vectorisation. Le code est beaucoup plus concis, plus lisible et
plus rapide d'un facteur d'environ 25.

In [2]: %%time
import numpy as np

S0 = 100
r = 0.05
T = 1.0
sigma = 0.2

ST = S0 * np.exp((r - 0.5 * sigma ** 2) * T +

sigma * np.random.standard_normal(1000000) * np.sqrt(T)) ①
CPU times: user 193 ms, sys: 52.4 ms, total: 245 ms
Wall time: 253 ms

(1) Cette seule ligne de code NumPy simule toutes les valeurs et les stocke dans un
ndarray .

La vectorisation est un concept puissant pour écrire du code

concis, facile à lire et facile à maintenir dans le domaine de la


finance et du trading algorithmique. Avec NumPy, le code
vectorisé ne rend pas seulement le code plus concis, il peut
également accélérer considérablement l'exécution du code,
comme dans l'exemple de simulation de Monte-Carlo d'un
facteur d'environ 25.

On peut dire sans risque de se tromper que NumPy a contribué de manière significative
au succès de Python dans

14
la science et la finance. De nombreux autres paquets Python populaires de la pile
Python dite scientifique s'appuient sur NumPy en tant que structure de données efficace
et performante pour stocker et gérer des données numériques. En fait, NumPy est une
excroissance du projet de package SciPy, qui fournit une multitude de fonctionnalités
fréquemment nécessaires en science. Le projet SciPy a reconnu le besoin d'une
structure de données numériques plus puissante et a consolidé des projets plus
anciens comme Numeric et NumArray dans ce domaine en une nouvelle structure
unificatrice sous la forme de NumPy.

Dans le trading algorithmique, la simulation de Monte-Carlo n'est peut-être pas le cas

d'utilisation le plus important d'un langage de programmation. Cependant, si vous
entrez dans l'espace de trading algorithmique, la gestion d'ensembles de données de
séries chronologiques financières plus importants, voire volumineux, est, par exemple,
un cas d'utilisation très important. Il suffit de penser au backtesting des stratégies de
trading (intraday) ou au traitement des flux de données de ticks pendant les heures de
trading. C'est là qu'intervient le package d'analyse de données pandas (page d'accueil
pandas).

Le développement des pandas a commencé en 2008 par Wes McKinney, qui travaillait à
l'époque chez AQR Capital Management, un grand fonds spéculatif opérant à
Greenwich, dans le Connecticut. Comme pour tout autre hedge fund, travailler
avec des données de séries chronologiques est d'une importance capitale pour
AQR Capital Management, mais à l'époque, Python ne fournissait aucun support
attrayant pour ce type de données. L'idée de Wes était de créer un package qui
imite les capacités du langage statistique R (http://r-project.org ) dans ce domaine.
Cela se reflète, par exemple, dans la dénomination de la classe majeure DataFrame,
dont l'homologue en R est appelé data.frame. N'étant pas considéré comme assez
proche du cœur de métier de la gestion de fonds, AQR Capital Management a
ouvert le projet pandas en 2009, ce qui marque le début d'une success story
majeure dans le domaine de l'open source data et de l'analyse financière.

En partie grâce aux pandas, Python est devenu une force majeure dans l'analyse
des données et des finances. De nombreuses personnes qui adoptent Python, provenant
de divers autres langages, citent les pandas comme une raison majeure de leur
décision. En combinaison avec des sources de données ouvertes comme Quandl,
pandas permet même aux étudiants d'effectuer des analyses financières
sophistiquées avec les barrières à l'entrée les plus faibles qui soient : un ordinateur
portable ordinaire avec une connexion Internet suffit.

15
Supposons qu'un trader algorithmique soit intéressé par le trading de Bitcoins, la
crypto-monnaie ayant la plus grande capitalisation boursière. Une première étape
pourrait consister à récupérer des données sur l'historique du taux de change en USD.
À l'aide des données Quandl et des pandas, une telle tâche est

16
accompli en moins d'une minute. L'historique du taux de change Bitcoin en USD
du début de 2013 jusqu'en septembre 2018 montre le graphique qui résulte du
code Python ci-dessous, qui n'est (en omettant certains paramétrisations liées au
style de traçage) que quatre lignes. Bien que pandas ne soit pas explicitement
importé, le package wrapper Python Quandl renvoie par défaut un objet
DataFrame qui est ensuite utilisé pour ajouter une moyenne mobile simple (SMA)
de 100 jours, ainsi que pour visualiser les données brutes à côté du SMA.

In [3]: %matplotlib inline ①

from pylab import mpl, plt ①
plt.style.use('seaborn') ①
mpl.rcParams['font.family'] = 'serif' ①

In [4]: import configparser ②

c = configparser.ConfigParser() ②
c.read('../pyalgo.cfg') ②
Out[4]: ['../pyalgo.cfg']

In [5]: import quandl as q ③

q.ApiConfig.api_key = c['quandl']['api_key'] ③
d = q.get('BCHAIN/MKPRU') ④
d['SMA'] = d['Value'].rolling(100).mean() ⑤
d.loc['2013-1-1':].plot(title='BTC/USD exchange rate',
figsize=(10, 6)); ⑥
plt.savefig('../../images/ch01/bitcoin_xr.png')

(1) Importe et configure le package de traçage.

(2) Importe le module configparser et lit les informations d'identification.

(3) Importe le package wrapper Python Quandl et fournit la clé API.

(4) Récupère les données quotidiennes du taux de change Bitcoin et renvoie un

DataFrame pandas
avec une seule colonne.

(5) Calcule la SMA pour 100 jours de manière vectorisée.

(6) Sélectionne les données à partir du 1er janvier 2013 et les trace.

17
Graphique 1. Historique du taux de change Bitcoin en USD de début 2013 à septembre 2018

De toute évidence, NumPy et pandas contribuent de manière mesurable au

succès de Python dans la finance. Cependant, l'écosystème Python a beaucoup
plus à offrir sous la forme de paquets Python supplémentaires qui résolvent des
problèmes plutôt fondamentaux et parfois aussi des problèmes spécialisés. Dans
ce livre (cours), nous utiliserons, entre autres, des packages pour la
récupération et le stockage de données (par exemple, PyTables, TsTables, SQLite)
et pour l'apprentissage automatique et profond (par exemple, scikit-learn,
tensorflow) - pour ne citer que deux catégories. En cours de route, nous
mettrons également en œuvre des classes et des modules qui rendront tout
projet de trading algorithmique plus efficace. Mais les principaux paquets
utilisés seront NumPy et pandas.

Alors que NumPy fournit la structure de données de base pour

stocker des données numériques et les utiliser, pandas apporte de
puissantes capacités de gestion des séries chronologiques. Il fait
également un excellent travail d'emballage des fonctionnalités
d'autres packages dans un logiciel facile à utiliser


seul
API. L'exemple Bitcoin que nous venons de décrire montre qu'un

sur un objet DataFrame est suffisant pour générer un tracé

avec deux séries chronologiques financières visualisées. Comme
NumPy, pandas permet un code vectorisé plutôt concis qui est

18
généralement exécuté assez rapidement en raison de l'utilisation
intensive de code compilé sous le capot.

19
1.3. Trading algorithmique
Le terme de trading algorithmique n'est ni unique ni universel. À un niveau assez
basique, il s'agit de la négociation d'instruments financiers basés sur un algorithme
formel. Un algorithme est un ensemble d'opérations (mathématiques, techniques) à
mener dans un certain ordre pour atteindre un certain objectif. Par exemple, il
existe des algorithmes mathématiques pour résoudre un Rubik's cube. [4 : Voir Les
mathématiques du Rubik's Cube ou Algorithmes pour résoudre le Rubik's Cube.]
Un tel algorithme peut résoudre le problème à résoudre par le biais d'une
procédure étape par étape, souvent parfaitement. Un autre exemple est celui des
algorithmes permettant de trouver la ou les racines d'une équation si elle existe. En
ce sens, l'objectif d'un algorithme mathématique est souvent bien spécifié et une
solution optimale est souvent attendue.

Mais qu'en est-il de l'objectif de l'algorithme de trading financier ? Il n'est pas si

facile de répondre à cette question en général. Il peut être utile de prendre un peu
de recul et d'examiner les motivations du trading en général. Dans Dorn et al.
(2008), ils écrivent :

Le trading sur les marchés financiers est une activité économique importante. Les
transactions sont nécessaires pour entrer et sortir du marché, pour mettre de l'argent
inutile sur le marché et pour le reconvertir en espèces lorsque l'argent est nécessaire. Ils
sont également nécessaires pour déplacer de l'argent sur le marché, pour échanger un
actif contre un autre, pour gérer les risques et pour exploiter les informations sur les
mouvements de prix futurs.

Le point de vue exprimé ici est de nature plus technique qu'économique, se

concentrant principalement sur le processus lui-même et seulement en partie sur
les raisons pour lesquelles les gens initient des transactions en premier lieu. Pour nos
besoins, une liste non exhaustive des motivations de trading financier des
personnes et des institutions financières gérant de l'argent pour leur propre
compte ou pour d'autres comprend :

• Trading bêta : gagner des primes de risque de marché en investissant, par

exemple, dans des fonds négociés en bourse (ETF) qui reproduisent la
performance du S&P 500

• génération d'alpha : gagner des primes de risque indépendantes du marché,

par exemple en vendant des actions courtes cotées au S&P 500 ou des ETF du
S&P 500

20
 • couverture statique : couverture contre les risques de marché en achetant, par
exemple, des options de vente hors de la monnaie sur le S&P 500

• couverture dynamique : couverture contre les risques de marché affectant les options
sur le S&P
500 en négociant dynamiquement des contrats à terme sur le S&P 500 et

21
 Instruments de trésorerie, du marché monétaire ou de taux appropriés

• gestion actif-passif : négociation d'actions et d'ETF du S&P 500 pour pouvoir

couvrir les passifs résultant, par exemple, de la souscription de polices
d'assurance-vie

• tenue de marché : fournir, par exemple, de la liquidité aux options sur le S&P 500
en achetant et en vendant des options à des prix d'achat et de vente différents.

Tous ces types de transactions peuvent être mis en œuvre par une approche
discrétionnaire, le trader humain prenant des décisions principalement par lui-
même. ainsi que sur la base d'algorithmes soutenant le trader humain ou même le
remplaçant complètement dans le processus de prise de décision. Dans ce
contexte, l'informatisation du trading financier joue bien sûr un rôle important.
Alors qu'au début du trading financier, le floor trading avec un grand groupe de
personnes se criant dessus (« cri ouvert ») était le seul moyen d'exécuter des
transactions, l'informatisation et l'avènement d'Internet et des technologies Web
ont révolutionné le trading dans le secteur financier. La citation au début de ce
chapitre l'illustre de manière impressionnante en termes de nombre de personnes
activement engagées dans la finance chez Goldman Sachs en 2000 et en 2016. C'est
une tendance qui était prévue il y a 25 ans, comme le soulignent Solomon et Corso
(1991) :

Les ordinateurs ont révolutionné le trading de valeurs mobilières et le marché boursier est
actuellement en pleine transformation. Il est clair que le marché de l'avenir ne ressemblera
pas aux marchés du passé.

La technologie a permis d'envoyer des informations sur les cours des actions dans le
monde entier en quelques secondes. À l'heure actuelle, les ordinateurs acheminent les
ordres et exécutent de petites transactions directement du terminal de la société de
courtage à la bourse. Des ordinateurs relient désormais différentes bourses, une
pratique qui contribue à la création d'un marché mondial unique pour le négoce de
valeurs mobilières. Les améliorations continues de la technologie permettront
d'exécuter des transactions à l'échelle mondiale par le biais de systèmes de négociation
électroniques.

Il est intéressant de noter que l'un des algorithmes les plus anciens et les plus utilisés
se trouve dans la couverture dynamique des options. Déjà avec la publication des
articles fondateurs sur la tarification des options européennes par Black et Scholes
(1973) et Merton (1973), l'algorithme, appelé delta hedging, a été mis à disposition – bien
avant que le trading informatisé et électronique ne commence. La couverture delta en
tant qu'algorithme de trading montre comment couvrir tous les risques de marché
22
dans un monde modèle simplifié, parfait et continu. Dans le monde réel, avec des
coûts de transaction, des transactions discrètes, des marchés imparfaitement liquides
et d'autres frictions (« imperfections »), l'algorithme a fait ses preuves – de manière
quelque peu surprenante

23
Peut-être — son utilité et sa robustesse aussi. Il ne permet peut-être pas de couvrir
parfaitement les risques de marché affectant les options, mais il est utile pour se
rapprocher de l'idéal et est donc encore utilisé à grande échelle dans l'industrie
financière. [5 : Voir Hilpisch (2015) pour une analyse détaillée des stratégies de
couverture delta pour les options européennes et américaines à l'aide de Python.]

Ce livre (cours) se concentre sur le trading algorithmique dans le contexte des

stratégies génératrices d' alpha. Bien qu'il existe des définitions plus sophistiquées
de l'alpha, pour les besoins de ce livre (cours), l'alpha est considéré comme la
différence entre le rendement d'une stratégie de trading sur une certaine période
de temps et le rendement de l'indice de référence (action unique, indice, crypto-
monnaie, etc.). Par exemple, si le S&P 500 affiche un rendement de 10 % en 2018 et
qu'une stratégie algorithmique affiche un rendement de 12 %, alors l'alpha est de
+2 points de pourcentage. Si la stratégie rapporte 7 %, alors l'alpha est de -3 points
de pourcentage. En général, ces chiffres ne sont pas ajustés en fonction du risque,
et d'autres caractéristiques de risque telles que le drawdown maximal (période)
sont généralement considérées comme d'une importance de second ordre, voire
pas du tout.

Ce livre (cours) se concentre sur les stratégies génératrices

d'alpha, c'est-à-dire les stratégies qui tentent de générer des


rendements positifs (au-dessus d'un indice de référence)
indépendamment de la performance du marché lui-même.
L'alpha est défini dans ce livre (cours) de la manière la plus
simple comme le rendement excédentaire d'une stratégie par
rapport à l'instrument financier de référence.

Il existe d'autres domaines où les algorithmes liés au trading jouent un rôle

important. L'un d'entre eux est le trading à haute fréquence (HFT), où la vitesse est
généralement la discipline dans laquelle les joueurs s'affrontent. [6 : Voir le livre de
Lewis (2015) pour une introduction non technique au THF.] Les motivations du
THF sont diverses, mais la tenue de marché et la génération d'alpha jouent
probablement un rôle prépondérant. Un autre est l'exécution des transactions, où des
algorithmes sont déployés pour exécuter de manière optimale certaines
transactions non standard. Les motifs dans ce domaine peuvent inclure l'exécution
(au meilleur prix possible) d'ordres importants ou l'exécution d'un ordre avec le
moins d'impact possible sur le marché et les prix. Un motif plus subtil pourrait être
de déguiser un ordre en l'exécutant sur un certain nombre d'échanges différents.

24
Une question importante reste à résoudre : y a-t-il un avantage à utiliser des
algorithmes pour le trading au lieu de la recherche, de l'expérience et de la
discrétion humaines ? Il est difficile de répondre à cette question de manière
générale. C'est sûr, il y a des

25
les traders et les gestionnaires de portefeuille qui ont gagné, en moyenne, plus que
leur indice de référence pour les investisseurs sur de plus longues périodes.
L'exemple le plus frappant à cet égard est celui de Warren Buffett. D'autre part, les
analyses statistiques montrent que la majorité des gestionnaires de portefeuille
actifs battent rarement les indices de référence pertinents de manière cohérente. Se
référant à l'année 2015, Adam Shell écrit :

L'année dernière, par exemple, lorsque l'indice Standard & Poor's 500 a affiché un
rendement total dérisoire de 1,4 % dividendes inclus, 66 % des fonds d'actions de
grandes entreprises « gérés activement » ont affiché des rendements inférieurs à ceux
de l'indice. Les perspectives à long terme sont tout aussi sombres, 84 % des fonds à
grande capitalisation ayant généré des rendements inférieurs à ceux du S&P 500 au
cours des cinq dernières années et 82 % au cours des 10 dernières années, selon l'étude.
[8 : Source : « 66 % des gestionnaires de fonds ne peuvent pas égaler les résultats de
S&P. » USA Today, 14 mars 2016.]

Dans une étude empirique publiée en décembre 2016, Harvey et al. (2016) écrivent :

Nous analysons et comparons les performances des hedge funds discrétionnaires et

systématiques. Les fonds systématiques utilisent des stratégies fondées sur des règles,
avec peu ou pas d'intervention quotidienne de la part des humains... Nous constatons
que, pour la période 1996‐2014, les gérants systématiques d'actions sous‐performent
leurs homologues discrétionnaires en termes de rendements non ajustés (bruts), mais
qu'après ajustement pour tenir compte de l'exposition à des facteurs de risque bien
connus, la performance ajustée au risque est similaire. Dans le cas de la
macroéconomie, les fonds systématiques surperforment les fonds discrétionnaires, tant
sur une base non ajustée que sur une base ajustée au risque.

La performance annualisée des catégories de hedge funds reproduit les principaux

résultats quantitatifs de l'étude de Harvey et al. (2016). [9 : Performance annualisée
(au-dessus du taux d'intérêt à court terme) et mesures du risque pour les
catégories de hedge funds comprenant un total de 9 000 hedge funds sur la
période de juin 1996 à décembre 2014.] Dans le tableau, les facteurs comprennent
les facteurs traditionnels (actions, obligations, etc.), les facteurs dynamiques (valeur,
momentum, etc.) et la volatilité (achat de options de vente et d'options d'achat au cours ).
Le ratio d'évaluation du rendement ajusté divise l'alpha par la volatilité du
rendement ajusté. Pour plus de détails et de contexte, voir le document lui-même.

Les résultats de l'étude montrent que les hedge funds macro systématiques («
algorithmiques ») obtiennent les meilleurs résultats en tant que catégorie, tant en
termes non ajustés qu'en termes ajustés au risque. Ils génèrent un alpha annualisé

26
de 4,85% sur la période étudiée. Il s'agit de hedge funds qui mettent en œuvre des
stratégies qui sont généralement mondiales, multi-actifs, et qui impliquent souvent
des éléments politiques et macroéconomiques. Les hedge funds systématiques en
actions ne battent leurs homologues discrétionnaires que sur la base du ratio
d'évaluation du rendement ajusté (0,35 contre 0,25).

27
Tableau 1. Performance annualisée des catégories de hedge funds

macro Macro Équité Capitaux

systématique discrétionnai systématique propres
re discrétionnai
res
Moyen 5.01% 2.86% 2.88% 4.09%
ne de
rendem
ent
Rendement 0.15% 1.28% 1.77% 2.86%
attribué aux
facteurs

Moyenne 4.85% 1.57% 1.11% 1.22%

de
rendemen
t ajustée
(alpha)
Volatilité 10.93% 5.10% 3.18% 4.79%
ajustée des
rendements
Ratio 0.44 0.31 0.35 0.25
d'évaluati
on ajusté

Par rapport au S&P 500, la performance des hedge funds a été plutôt maigre pour
l'année 2017. Alors que l'indice S&P 500 a enregistré un rendement de 21,8 %, les fonds
spéculatifs n'ont rapporté que 8,5 % aux investisseurs (voir http://investopedia.com).
Cela illustre à quel point il est difficile, même avec des budgets de plusieurs millions
de dollars pour la recherche et la technologie, de générer de l'alpha.

1.4. Python pour le trading algorithmique

Python est utilisé dans de nombreux coins de l'industrie financière, mais est
devenu particulièrement populaire dans l'espace de trading algorithmique. Il y a
plusieurs bonnes raisons à cela :

• Capacités d'analyse de données : L'une des principales exigences de tout projet

de trading algorithmique est la capacité de gérer et de traiter efficacement les
données financières. Python, en combinaison avec des packages comme NumPy et
pandas, rend la vie plus facile à cet égard pour chaque trader algorithmique que la
plupart des autres langages de programmation.

28
• Gestion des API modernes : Les plateformes de trading en ligne modernes telles
que celles de FXCM, Oanda et Gemini offrent des interfaces de programmation
d'applications (API) RESTful et des API de socket (streaming) pour accéder aux
données historiques et en direct. Python est en général bien adapté pour interagir
efficacement avec de telles API.

29
 • Forfaits dédiés : En plus des packages d'analyse de données standard, il existe
plusieurs packages dédiés à l'espace de trading algorithmique, tels que
PyAlgoTrade et Zipline pour le backtesting des stratégies de trading, et
Pyfoliopour effectuer des analyses de portefeuille et de risque.

• De plus en plus de fournisseurs publient des packages Python open source

pour faciliter l'accès à leurs offres, notamment des plateformes de trading en
ligne comme Oanda ainsi que les principaux fournisseurs de données comme
Bloomberg et Thomson Reuters.

• Plates-formes dédiées : Quantopian, par exemple, offre un environnement de

backtesting standardisé en tant que plate-forme Web où le langage de choix
est Python et où les gens peuvent échanger des idées avec d'autres personnes
partageant les mêmes idées via différentes fonctionnalités de réseau social.
Depuis sa création jusqu'en 2018, Quantopian a attiré environ 200 000
utilisateurs.

• Adoption côté achat et côté vente : De plus en plus d'acteurs institutionnels

ont adopté Python pour rationaliser les efforts de développement dans leurs
départements de trading. Ceci, à son tour, nécessite de plus en plus de
personnel maîtrisant Python, ce qui fait de l'apprentissage de Python un
investissement rentable.

• Éducation, formation et livres : Les conditions préalables à l'adoption

généralisée d'une technologie ou d'un langage de programmation sont des
programmes d'éducation et de formation académiques et professionnelles en
combinaison avec des livres spécialisés et d'autres ressources. L'écosystème
Python a récemment connu une croissance considérable de ces offres,
éduquant et formant de plus en plus de personnes à l'utilisation de Python
pour la finance. On peut s'attendre à ce que cela renforce la tendance à
l'adoption de Python dans l'espace de trading algorithmique.

En résumé, on peut dire sans risque de se tromper que Python joue déjà un rôle
important dans le trading algorithmique, et semble avoir une forte dynamique
pour devenir encore plus important dans un avenir proche. C'est donc un bon
choix pour tous ceux qui tentent d'entrer dans l'espace, que ce soit en tant que
trader « amateur » ambitieux ou en tant que professionnel employé par une
institution financière de premier plan engagée dans le trading automatisé.

1.5. Objectif et conditions préalables

30
L'objectif de ce livre (cours) est de Python en tant que langage de programmation pour
trading algorithmique. Le livre (cours) suppose que le lecteur a déjà

31
expérience avec Python et les progiciels Python populaires utilisés pour l'analyse
de données. Les bons livres d'introduction sont, par exemple, Hilpisch (2018),
McKinney (2017) et VanderPlas (2016), qui peuvent tous être consultés pour
construire une base solide en Python pour l'analyse de données et la finance. On
s'attend également à ce que le lecteur ait une certaine expérience des outils
typiques utilisés pour l'analyse interactive avec Python, tels que IPython, auquel
VanderPlas (2016) fournit également une introduction.

Ce livre (cours) présente et explique le code Python qui est appliqué aux sujets
abordés, comme le backtesting des stratégies de trading ou le travail avec des
données en streaming. Il ne peut pas fournir une introduction complète à tous les
paquets utilisés à différents endroits. Il essaie, cependant, de mettre en évidence les
capacités des paquets qui sont au cœur de l'exposition (comme la vectorisation
avec NumPy).

Le livre (cours) ne peut pas non plus fournir une introduction et un aperçu
approfondis de tous les aspects financiers et opérationnels pertinents pour le
trading algorithmique. L'approche se concentre plutôt sur l'utilisation de Python
pour construire l'infrastructure nécessaire aux systèmes de trading automatisés et
algorithmiques. Bien sûr, la majorité des exemples utilisés sont tirés de l'espace de
trading algorithmique. Cependant, lorsqu'il s'agit, par exemple, de stratégies de
momentum ou de retour à la moyenne, elles sont plus ou moins simplement
utilisées sans fournir de vérification (statistique) ou une discussion approfondie de
leurs complexités. Chaque fois que cela semble approprié, des références sont
données qui dirigent le lecteur vers des sources qui abordent des questions laissées
en suspens pendant l'exposition.

Dans l'ensemble, ce livre (cours) est écrit pour les lecteurs qui ont une certaine
expérience à la fois de Python et du trading (algorithmique). Pour un tel lecteur, le
livre (cours) est un guide pratique pour la création de systèmes de trading automatisés
à l'aide de Python et de packages supplémentaires.

Ce livre (cours) utilise un certain nombre d'approches de

programmation Python (par exemple, la programmation
orientée objet) et de packages (par exemple, scikit-learn) qui ne
peuvent pas être expliqués en détail. L'accent est mis sur les

 Application ces approches et ces packages à différentes étapes d'un

processus de trading algorithmique. Il est donc recommandé que
ceux qui n'ont pas encore assez d'expérience en Python (pour la

32
finance) consultent en outre d'autres textes d'introduction à Python.

33
1.6. Stratégies de trading
Tout au long de ce livre (cours), quatre stratégies de trading algorithmique
différentes sont utilisées à titre d'exemples. Ils sont présentés brièvement ci-
dessous et plus en détail dans Mastering Vectorized Backtesting. Toutes ces
stratégies de trading peuvent être classées comme des stratégies principalement à
la recherche d'alpha, car leur objectif principal est de générer des rendements
positifs et supérieurs à ceux du marché, indépendamment de la direction du
marché. Des exemples canoniques tout au long du livre (cours) en ce qui concerne
les instruments financiers négociés sont un indice boursier, une action unique ou une
crypto-monnaie (libellée dans une monnaie fiduciaire). Le livre (cours) ne couvre
pas les stratégies impliquant plusieurs instruments financiers en même temps
(stratégies de trading par paires, stratégies basées sur des paniers, etc.). Il ne
couvre également que les stratégies dont les signaux de trading sont dérivés de
données structurées de séries chronologiques financières et non, par exemple, de
sources de données non structurées telles que les flux d'actualités ou de médias
sociaux. Cela permet de garder les discussions et les implémentations de Python
concises et plus faciles à comprendre, conformément à l'approche (discutée
précédemment) de se concentrer sur Python pour le trading algorithmique. [10 :
Voir le livre de Kissel (2013) pour un aperçu des sujets liés au trading
algorithmique, le livre de Chan (2013) pour une discussion approfondie du
momentum et des stratégies de retour à la moyenne, ou le livre de Narang (2013)
pour une couverture du trading quantitatif et du HFT en général.]

Le reste de cette section donne un aperçu rapide des quatre stratégies de trading
utilisées dans ce livre (cours).

1.6.1. Moyennes mobiles simples

Le premier type de stratégie de trading repose sur des moyennes mobiles simples
(SMA) pour générer des signaux de trading et des positionnements de marché. Ces
stratégies de trading ont été popularisées par ce que l'on appelle les analystes
techniques ou chartistes. L'idée de base est qu'une SMA à court terme ayant une valeur
plus élevée qu'une SMA à long terme signale une position longue sur le marché et que
le scénario inverse signale une position neutre ou courte sur le marché.

1.6.2. Élan

L'idée de base qui sous-tend les stratégies de momentum est qu'un instrument

34
financier est supposé se comporter en fonction de ses performances récentes
pendant un certain temps supplémentaire. Par exemple, lorsqu'un indice boursier
a enregistré un rendement négatif en moyenne au cours des cinq derniers jours, on
suppose que sa performance sera négative demain, car

35
puits.

1.6.3. Réversion de la moyenne

Dans les stratégies de retour à la moyenne, on suppose qu'un instrument financier

revient à un niveau moyen ou tendanciel s'il est actuellement suffisamment éloigné
d'un tel niveau. Par exemple, supposons qu'une action se négocie à 10 USD en
dessous de son niveau SMA de 200 jours de 100. On s'attend alors à ce que le cours
de l'action revienne bientôt à son niveau SMA.

1.6.4. Machine Learning et Deep Learning

Avec les algorithmes d'apprentissage automatique et d'apprentissage profond, on

adopte généralement une approche plus proche de la boîte noire pour prédire les
mouvements du marché. Dans ce livre (cours), nous nous appuyons
principalement sur les observations de rendement historiques comme
caractéristiques pour entraîner des algorithmes d'apprentissage automatique et
d'apprentissage profond à prédire les mouvements des marchés boursiers.

Ce livre (cours) n'introduit pas le trading algorithmique de

manière systématique. Étant donné que l'accent est mis sur
l'application de Python dans ce domaine fascinant, les lecteurs
qui ne sont pas familiers avec le trading algorithmique devraient
consulter d'autres ressources dédiées sur le sujet, dont certaines


soyez
qui sont cités dans ce chapitre et dans les autres qui suivent. Mais

conscient du fait que le monde du trading algorithmique en général

est
secret et que presque tous ceux qui réussissent là-bas sont
naturellement réticents à partager leurs secrets afin de protéger
leurs sources de succès, c'est-à-dire l'alpha.

1.7. Aperçu
Voici un bref aperçu des sujets abordés dans chaque chapitre :

Python Infrastructure

Jette les bases de tous les chapitres suivants en ce sens qu'il montre comment

36
mettre en place un environnement Python approprié. Ce chapitre utilise
principalement conda en tant que gestionnaire de packages et
d'environnements, et illustre le déploiement de Python via des conteneurs
Docker et dans le cloud.

37
Utilisation des données financières

Les données des séries chronologiques financières sont au cœur de tout projet
de trading algorithmique. Ce chapitre vous montre comment récupérer des
données financières à partir de différentes données publiques ainsi que de
sources de données propriétaires. Il montre également comment stocker
efficacement des données de séries chronologiques financières avec Python.

Maîtriser le backtesting vectorisé

La vectorisation est une approche puissante en calcul numérique en général et

pour l'analyse financière en particulier. Ce chapitre présente la vectorisation avec
NumPy et pandas, et applique cette approche au backtesting des stratégies basées sur
l'AMS, le momentum et le retour à la moyenne.

Prédire les mouvements du marché grâce à l'apprentissage automatique

Ce chapitre est consacré à la génération de prédictions de marché par

l'utilisation d'approches d'apprentissage automatique et d'apprentissage
profond. En s'appuyant principalement sur les observations de rendement
passées comme caractéristiques, des approches sont présentées pour
prédire la direction du marché de demain en utilisant des packages Python
tels que scikit-learn et tensorflow.

Création de classes pour le backtesting basé sur les événements

Bien que le backtesting vectorisé présente des avantages en termes de concision

du code et de performance, il est limité en ce qui concerne la représentation de
certaines caractéristiques du marché des stratégies de trading ; D'autre part, le
backtesting basé sur les événements, techniquement mis en œuvre par
l'utilisation de la programmation orientée objet, permet une modélisation
plutôt granulaire et plus réaliste de ces caractéristiques. Ce chapitre présente et
explique en détail une classe de base ainsi que deux classes pour le backtesting
des stratégies de trading long-only et long-short.

Utilisation des données et des sockets en temps réel

La nécessité de faire face à des données en temps réel ou en continu est une réalité,
même pour le trader algorithmique individuel ambitieux. L'outil de prédilection
est la programmation par socket, pour laquelle ce chapitre présente ZeroMQ en tant
que technologie légère et évolutive. Le chapitre illustre également comment utiliser
Plotly pour créer de jolies intrigues interactives en streaming. Il présente également
une classe wrapper qui simplifie la création de tels graphiques dans les cas où

38
plusieurs flux de données doivent être visualisés simultanément (par exemple, à la
manière d'un tableau de bord).

39
Trading FX avec FXCM

FXCM est une plateforme de trading de forex et de contrats de différence (CFD)

qui a récemment publié une API RESTful moderne pour le trading algorithmique.
Les instruments disponibles couvrent plusieurs classes d'actifs, telles que le forex,
les indices boursiers ou les matières premières. Un paquet d'encapsulation Python
est disponible, ce qui rend le trading algorithmique basé sur le code Python plutôt
pratique et efficace (http://fxcmpy.tpq.io).

Trading de CFD avec Oanda

Oanda est une autre plateforme de trading de forex et de CFD offrant un large
éventail d'instruments négociables, par exemple basés sur des paires de
devises, des indices boursiers, des matières premières ou des instruments de
taux (obligations de référence). Ce chapitre fournit des conseils sur la façon de
mettre en œuvre des stratégies de trading algorithmiques automatisées avec
Oanda.

Trading d'actions avec Interactive Brokers

Interactive Brokers est une plateforme de courtage en ligne de premier plan qui se
concentre sur le trading d'actions et d'options. Le chapitre traite de l'API
Interactive Brokers qui est technologiquement basée sur l'application Trader
Workstation. Il introduit une classe wrapper Python qui rend la vie assez pratique
et efficace dans ce contexte.

Trader les crypto-monnaies avec Gemini

Les crypto-monnaies et les technologies connexes, comme les blockchains, ont

été un sujet assez populaire dans les cercles technologiques et financiers ces
derniers temps. Le chapitre couvre Gemini comme l' une des plates-formes
modernes qui permettent le trading automatisé de crypto-monnaies, comme le
Bitcoin ou l'Ether. Le chapitre présente des classes d'encapsulation Python
pour simplifier considérablement la plupart des opérations typiques du trading
algorithmique.

[automating_trading]

Ce chapitre traite de la gestion du capital, de l'analyse et de la gestion des

risques ainsi que des tâches typiques de l'automatisation technique des
opérations de trading algorithmique. Il couvre, par exemple, le critère de Kelly
pour l'allocation du capital et l'effet de levier en détail.

40
Annexe A : Python, NumPy, matplotlib, pandas

Cette annexe fournit une introduction concise aux principes les plus importants
de Python,

41
 NumPy et les pandas dans le contexte du matériel présenté dans les chapitres
principaux. Il représente un point de départ à partir duquel on peut ajouter à ses
propres connaissances Python au fil du temps.

1.8. Conclusions
Python est déjà une force dans la finance en général, et est en passe de devenir une
force majeure dans le trading algorithmique. Il existe un certain nombre de bonnes
raisons d'utiliser Python pour le trading algorithmique, parmi lesquelles le
puissant écosystème de packages qui permettent une analyse efficace des données
ou la gestion d'API modernes. Il existe également un certain nombre de bonnes
raisons d'apprendre Python pour le trading algorithmique, notamment le fait que
certaines des plus grandes institutions d'achat et de vente font un usage intensif de
Python dans leurs opérations de trading et recherchent constamment des
professionnels chevronnés de Python.

Ce livre (cours) et ce cours en ligne se concentrent sur l'application de Python aux

différentes disciplines du trading algorithmique, comme le backtesting des
stratégies de trading ou l'interaction avec les plateformes de trading en ligne. Il ne
peut pas remplacer une introduction approfondie à Python lui-même ni au trading
en général. Cependant, il combine systématiquement ces deux mondes fascinants
pour fournir une source précieuse pour la génération d'alpha sur les marchés
financiers et crypto-monnaie concurrentiels d'aujourd'hui.

1.9. Autres ressources

Documents de recherche cités dans ce chapitre :

• Black, Fischer et Myron Scholes (1973) : « L'établissement du prix des options et

des responsabilités des entreprises ». Revue d'économie politique, vol. 81, n° 3, 638-
659.

• Harvey, Campbell, Sandy Rattray, Andrew Sinclair et Otto Van Hemert (2016) : «
L'homme contre la machine : comparaison de la performance discrétionnaire et
systématique des hedge funds ». Livre blanc, Man Group.

• Dorn, Anne, Daniel Dorn et Paul Sengmueller (2008) : « Pourquoi les gens font-ils
du commerce ? »
Journal of Applied Finance, automne/hiver, 37-50.

42
• Merton, Robert (1973) : « Théorie de la tarification rationnelle des options. »
Journal Bell des sciences économiques et de gestion, vol. 4, 141-183.

43
 • Solomon, Lewis et Louise Corso (1991) : « L'impact de la technologie sur la
négociation de valeurs mobilières : le marché mondial émergent et ses
implications pour la réglementation ». The John Marshall Law Review, vol. 24, n°
2, 299-338.

Livres cités dans ce chapitre :

• Chan, Ernest (2013) : Trading algorithmique. John Wiley & Sons, Hoboken et al.

• Kissel, Robert (2013) : Trading algorithmique et gestion de portefeuille.

Elsevier/Academic Press, Amsterdam et al.

• Lewis, Michael (2015) : Flash Boys. W.W. Norton & Company, New York et
Londres.

• Hilpisch, Yves (2018) : Python pour la finance. 2e éd., O'Reilly, Beijing et al.
Ressources sous http://pff.tpq.io.

• Hilpisch, Yves (2015) : Analyse des produits dérivés avec Python. Wiley Finance.
Ressources sous http://dawp.tpq.io.

• McKinney, Wes (2017) : Python pour l'analyse des données. 2e éd., O'Reilly, Beijing et al.

• Narang, Rishi (2013) : À l'intérieur de la boîte noire. John Wiley & Sons, Hoboken et
al.

• VanderPlas, Jake (2016) : Manuel de science des données Python. O'Reilly, Beijing et
coll.

44