Pyne est un système qui permet de créer des programmes traitant des données de marché. Ces programmes peuvent calculer et afficher des valeurs dérivées des cours ou définir les règles d’une stratégie de trading. Ce livre présente ce travail depuis l’écriture du programme jusqu’à la vérification de son résultat.

Qu’appelle-t-on Pyne code ?

Nous écrivons les programmes en Pyne code. C’est un langage à part entière, conçu pour traiter des données de marché. Le code indique ce que le système doit calculer, afficher et sous quelles conditions il doit effectuer une opération.

Un indicateur peut, par exemple, calculer le cours moyen des dix dernières bougies et en tracer une ligne sur le graphique de cours. Un graphique de cours (chart en anglais) montre l’évolution des prix dans le temps. Une stratégie définit aussi des règles d’entrée et de sortie : elle peut, par exemple, ouvrir une position acheteuse lorsqu’une condition est remplie. En l’exécutant sur des données historiques, vous pouvez examiner les transactions que ces règles auraient produites selon les conditions d’exécution choisies. C’est ce qu’on appelle un backtest.

Nous créons d’abord des indicateurs simples. Ils permettent d’apprendre à connaître les données et le langage avant d’écrire des règles de trading.

Pyne code utilise les règles d’écriture de Python. Ces règles constituent la syntaxe : elles définissent, par exemple, la place des parenthèses et la manière de regrouper les lignes. Vous n’avez pas à apprendre Python auparavant ; les exemples du livre vous feront découvrir les règles nécessaires.

Les fichiers portent donc l’extension .py, habituelle en Python. Pyne code peut aussi s’exécuter dans un environnement Python avec PyneCore installé. Python fournit l’environnement d’exécution ; PyneCore fournit le fonctionnement propre à Pyne et sa bibliothèque de fonctions.

Comment le programme traite-t-il les données ?

Dans les exemples, les données de marché se présentent sous la forme d’une suite de bougies. Une bougie résume les données d’une période, notamment ses cours d’ouverture et de clôture. Sur des données journalières, une bougie représente une journée.

PyneCore exécute les calculs du programme successivement sur ces bougies. Il peut, par exemple, recalculer une moyenne à chaque bougie avec les cours disponibles jusqu’alors. Il gère aussi les valeurs précédentes des calculs et les données qui doivent être conservées entre les bougies.

Ce fonctionnement diffère de celui d’un programme Python ordinaire. Le marqueur @pyne au début du fichier indique à PyneCore de préparer et d’exécuter le code selon ces règles. Le chapitre consacré à la lecture du code présente la forme exacte de ce marqueur et le sens du mot edge qui l’accompagne dans les exemples.

En quoi cela diffère-t-il du traitement vectorisé ?

Parmi les frameworks de trading en Python, certains fonctionnent bougie par bougie, d’autres de manière vectorisée. Le traitement vectorisé consiste à travailler sur des séries complètes de nombres : vous calculez, par exemple, les moyennes et les signaux d’achat de toutes les bougies en une seule opération. Les données sont alors souvent manipulées dans des tableaux ou des structures tabulaires.

Avec PyneCore, vous décrivez ce qu’il faut faire à la bougie actuelle. Le système exécute ces opérations, puis passe à la suivante. Il gère l’historique des calculs et l’état à conserver selon les règles propres au langage Pyne.

Décrire les étapes dans une fonction simple

Dans plusieurs frameworks fonctionnant bougie par bougie, vous devez créer une classe pour votre stratégie. Une classe regroupe des données et les opérations associées ; les fonctions définies dans cette classe s’appellent des méthodes. Vous placez alors la configuration et les règles de trading dans les méthodes imposées par le framework, et vous accédez aux cours ou à la position à travers les données de la classe.

Dans les exemples Pyne code, vous écrivez dans une fonction main() ce que vous voulez calculer et sous quelles conditions vous voulez agir. Pour chaque bougie traitée, les lignes de la fonction s’exécutent successivement : vous calculez une valeur, vérifiez une condition, puis tracez un signal ou passez un ordre. PyneCore se charge de parcourir les bougies.

Pour commencer, vous n’avez donc pas à apprendre à créer des classes, à utiliser l’héritage ou à répartir votre programme entre les méthodes d’un framework. Les exemples simples nécessitent seulement les variables, les appels de fonctions et les conditions, que vous apprendrez dans les chapitres suivants.

Suivre les règles dans l’ordre chronologique

Ce fonctionnement se rapproche de votre raisonnement lors d’une décision de trading : « J’examine le prix actuel et son évolution jusqu’ici. Si ma condition est remplie, j’entre en position. Tant que j’ai une position, je surveille la condition de sortie. » Le code permet de suivre les événements dans cet ordre, et le débogueur permet d’examiner les variables à une bougie donnée.

Réduire l’utilisation accidentelle de données futures

Dans un traitement vectorisé, la série complète peut être disponible. Un décalage dans le mauvais sens ou une moyenne mal choisie peut alors inclure un prix encore inconnu au moment de la décision. Par exemple, utiliser la moyenne de l’année entière pour prendre une décision en janvier reviendrait à utiliser aussi les prix des mois suivants. Le programme peut s’exécuter et afficher des résultats convaincants ; l’erreur peut être difficile à repérer. C’est le biais d’anticipation, ou look-ahead bias en anglais.

Les séries temporelles de Pyne donnent accès aux valeurs de la bougie actuelle et des bougies déjà traitées. Consulter l’historique ne permet pas de lire le cours de la bougie suivante. Cela réduit le risque d’utiliser accidentellement des données futures et facilite la vérification des éléments à l’origine d’une décision.

La préparation des données demande toujours de l’attention. Si des données externes contiennent déjà une information connue seulement plus tard, l’exécution bougie par bougie ne peut pas le détecter à elle seule.

Un compromis possible sur la vitesse

Pour certains programmes, une exécution bougie par bougie peut être plus lente qu’un calcul vectorisé bien écrit. Cela peut compter lorsque vous essayez de nombreuses stratégies ou combinaisons de paramètres sur un grand jeu de données. Les systèmes vectorisés accélèrent souvent ces calculs massifs grâce à des bibliothèques de calcul optimisées. L’écart réel dépend du programme et du volume de données.

Ce livre enseigne le fonctionnement bougie par bougie : formuler les règles dans l’ordre chronologique et vérifier les données qui précèdent chaque décision.

Pour découvrir d’autres approches : traitement vectorisé avec VectorBT et stratégies bougie par bougie avec Backtrader (en anglais).

À quoi servent PyneIDE et PyneCore ?

PyneIDE est une extension de l’éditeur Visual Studio Code. Vous y écrivez le programme, choisissez ses données et lancez son exécution. Vous y examinez les résultats sur le graphique et recherchez les erreurs.

PyneCore est le système qui assure l’exécution. Il charge et prépare le programme, lui fait traiter les bougies, puis produit les résultats des calculs et des transactions. PyneIDE l’utilise en arrière-plan et affiche ces résultats.

Dans le chapitre suivant, vous configurerez PyneIDE et créerez votre premier projet. Les exercices utilisent des données d’exemple : vous pourrez relancer le même programme et comparer les effets de vos modifications.