Trading de Crypto automatisé avec FreqTrade

FreqTrade ? Trading automatisé ? Quand j’ai commencé à m’intéresser aux cryptomonnaies et plus particulièrement au trading, j’ai découvert qu’il existait deux manières d’analyser les cours pour prévoir le futur et donc gagner de l’argent. N’hésitez pas à vous former sur Investopedia.

La première consiste à comprendre ce qui se cache derrière un jeton (token), son fonctionnement, et pourquoi certains investisseurs sont intéressés par cette monnaie. Est-ce qu’elle est prometteuse dans l’économie et la société actuelle ? Cette approche est appelée Analyse fondamentale.

La seconde est beaucoup plus mathématique puisqu’elle se base sur des analyses techniques de graphe pour prévoir le futur. L’idée est de trouver des formes graphiques déclencheurs ou des indicateurs combinés qui indiquent la tendance. Cela forme l’Analyse Technique.

Donc si on part sur cette seconde approche, on a un peu l’impression d’être un robot à étudier tous les jours les mêmes graphiques et indicateurs. Et c’est là que rentre en jeu le trading automatisé avec des robots (bots). Après quelques essais, je vais vous présenter ici FreqTrade que j’ai pu installer et configurer facilement. Attention, il va falloir maîtriser un peu l’anglais et un peu le Python.

Cet article étant assez complexe, j’ai décidé de le séparer en deux parties.

FreqTrade

FreqTrade présente les avantages d’être facile à installer/configurer, de pouvoir développer des stratégies personnelles en Python, de connecter votre bot à Télégram pour le piloter et enfin de pouvoir grapher les résultats (trade, profit, …)

Disclaimer : le trading (et surtout le trading automatisé) est une pratique à risque. Vous devez comprendre ce que vous faites et risquer uniquement ce que vous pouvez perdre. Ni FreqTrade, ni moi ne serons responsables de vos gains/pertes.

Installation et Configuration

Je vous conseille d’essayer en local avec Docker, c’est la manière la plus simple de démarrer sans passer 1 heure à installer toutes les dépendances.

Suivez donc les instructions ici : https://www.freqtrade.io/en/latest/docker/#docker-quick-start

Cela consiste principalement à télécharger un fichier docker-compose et à lancer la machine freqtrade. Juste une petite modification ; pour pouvoir utiliser les fonctions de graphes, j’ai créé une image Docker contenant les dépendances nécessaires.

Modifiez donc le fichier par celui-ci : https://github.com/cicoub13/freqtrade-plot-docker/blob/master/docker-compose.yml

Lors de la dernière commande, le système de configuration va vous poser quelques questions. Je vous conseille de répondre comme suit (sauf si vous maitrisez 😉 ) :

• Do you want to enable Dry-run ? => Y
• Please insert your stake currency => BTC
• Please insert your stake amount => 0.001
• Please insert max_open_trades => 3
• Please insert your timeframe => 5m
• Please insert your display Currency => EUR
• Select exchange => binance
• Do you want to enable Telegram ? => N (Nous verrons en fin d’article comment configurer Télégram)

Démarrez ensuite la machine docker avec la commande docker-compose up -d

Toutes les commandes que nous allons lancer dans la suite commenceront par docker-compose run --rm freqtrade <command>.

Avant tout, il faut télécharger les données du tracker (plateforme de trading) pour la paire de cryptomonnaies sur laquelle on va travailler (ETH/BTC par exemple) pour pouvoir faire les calculs :

docker-compose run --rm freqtrade download-data --pairs ETH/BTC --exchange binance

Si vous êtes plus courageux, lancez vous dans l’installation native : https://www.freqtrade.io/en/latest/installation/

Stratégie

Le principe d’une stratégie est assez simple : vous définissez quand acheter, quand vendre et certains paramètres classiques en trading.

Créer un fichier MaSuperStrategie.py dans user_data/strategies/

Je vous conseille de copier ce template de stratégie pour démarrer :

from freqtrade.strategy.interface import IStrategy
from pandas import DataFrame
import talib.abstract as ta
import freqtrade.vendor.qtpylib.indicators as qtpylib

class MaSuperStrategie(IStrategy):
   
    # Parameters

    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:

        return dataframe

    def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
       
        return dataframe

    def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        
        return dataframe

Quelle stratégie ? Partons sur une stratégie classique à base de RSI et de Bandes de Bollinger. Nous allons acheter quand le cours est sous la bande inférieure et le RSI inférieur à 30.

Quand vendre ? Premièrement, nous allons préciser quelques paramètres qui décrivent quand fermer automatiquement l’ordre (à partir d’un gain ou d’une perte définis) et sur quel ticker (durée de chandelier) nous allons appliquer notre statégie :

# Fermeture de l'ordre si gain de 1%
minimal_roi = {
        "0": 0.01
    }
# Fermeture de l'ordre si perte de 1%
 stoploss = -0.01
# Nous jouons avec les chandeliers de 5 minutes
 ticker_interval = '5m'

Quels indicateurs ? Il faut ensuite renseigner quels indicateurs nous allons utiliser dans la fonction populate_indicators :

def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        
        # Ajout du RSI
        dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)

        # Définition de l'indicateur Bollinger
        bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=2)
        # Ajout de la bande supérieure
        dataframe['bb_lowerband'] = bollinger['lower'] 

        return dataframe

Quand acheter ? Puis nous allons renseigner la fonction populate_buy_trend pour indiquer au bot à quel moment placer un ordre de type achat :

def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        dataframe.loc[
            (
                # Lorsque le RSI est inférieur à 30
                (dataframe['rsi'] < 30) &
                # Lorsque la clôture du cours est sous la bande inférieure
                (dataframe['close'] < dataframe['bb_lowerband'])
            ),
            'buy'] = 1
        return dataframe

Quand vendre ? Il est obligatoire de fournir en plus des paramètres de sortie automatique une fonction populate_sell_trend qui indique au bot une stratégie de sortie en fonction des indicateurs. Je vous propose une configuration simple :

    def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        dataframe.loc[
            (
                # Sortie lorsque le RSI est supérieur à 70
                (dataframe['rsi'] > 70)
            ),
            'sell'] = 1
        return dataframe

Vous pouvez trouver tout un ensemble de stratégies dans ce répertoire GitHub : https://github.com/freqtrade/freqtrade-strategies/tree/master/user_data/strategies/berlinguyinca

Backtesting

Nous allons maintenant tester notre stratégie sur les données des 30 derniers jours (par défaut) de la paire ETH/BTC. Cela est possible grâce à la commande que nous avons lancée précédemment qui a téléchargé l’historique de stocks pour cette paire.

Lancez la commande suivante :

docker-compose run --rm freqtrade backtesting -s MaSuperStrategie

S’il n’y a aucun erreur dans votre stratégie, vous devriez obtenir un tableau comme celui-ci. Notre stratégie a passé 71 ordres, 37 ont été gagnants et 34 perdants. La profit total est de -0.00008553, ce qui représente -2.85%. Pas fameux :

Le deuxième tableau vous donne plus de renseignements sur les raisons de fermeture d’ordre, ce qui permet d’adapter les paramètres (stoploss, minimum_roi) de votre stratégie. Ici, notre stop_loss est peut-être mal positionné :

En jouant un peu avec les paramètres (vente quand RSI > 50 et stop_loss à 4%), j’arrive à obtenir un profit de 1.77% 😀

Vous pouvez commencer à jouer avec cette commande et adapter votre stratégie pour qu’elle soit gagnante. Si vous voulez visualiser graphiquement ce qu’il se passe, il faut ajouter --export trades à la commande backtesting :

docker-compose run --rm freqtrade backtesting -s MaSuperStrategie --export trades

Puis, générer le graphe :

docker-compose run freqtrade plot-dataframe -s MaSuperStrategie

Cette commande génère un graphe dans le dossier freqtrade/user_data/plot/ qui devrait ressembler à quelque chose comme ça :

Les ronds bleus correspondent aux ordres d’achat selon votre stratégie. Les carrés rouge sont les ventes perdantes 😕 et les carrés verts représentent les ventes gagnantes 😛

Vous pouvez donc analyser plus finement votre stratégie et l’adapter pour éviter les cas perdants. Vous pouvez aussi ajouter les indicateurs que vous avez utilisé dans votre stratégie pour avoir une analyse plus fine : https://www.freqtrade.io/en/latest/plotting/#plot-price-and-indicators

Il y a de nombreuses options de backtesting (période, paires, durée des chandeliers, liste de stratégies, …) et je vous conseille de bien explorer cette page : https://www.freqtrade.io/en/latest/backtesting/

C’est fini pour cette première partie. La prochaine fois (semaine prochaine), nous verrons comment configurer Télégram et lancer le Bot pour opérer notre stratégie sur les cours avec de vrais ordres d’achat.

J’espère que cet article vous a plu, qu’il vous a permis d’apprendre le trading automatique et peut-être d’avoir gagné vos premiers Bitcoins. N’hésitez pas à poser vos questions en commentaire, je compléterai l’article si des parties sont manquantes.