Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

ajoute un GUI a ca : Importer les bibliothèques nécessaires import yfinance as yf import…

  1. User

    ajoute un GUI a ca :

    Importer les bibliothèques nécessaires

    import yfinance as yf import pandas as pd import numpy as np import matplotlib.pyplot as plt import seaborn as sns import ta from datetime import datetime

    Configurer les options de visualisation

    sns.set_style('darkgrid') plt.rcParams['figure.figsize'] = (14, 7)

    Étape 1 : Récupérer les Données depuis Yahoo Finance

    def get_data(ticker, start_date, end_date): """ Télécharge les données historiques pour un ticker donné entre start_date et end_date. """ data = yf.download(ticker, start=start_date, end=end_date)

    if 'Close' not in data.columns:
        raise ValueError("Les données téléchargées ne contiennent pas de colonne 'Close'.")
    
    # Vérifier si 'Close' est une DataFrame (cas multi-ticker) ou une Series
    if isinstance(data['Close'], pd.DataFrame):
        if data['Close'].shape[1] > 1:
            raise ValueError("Plusieurs tickers téléchargés. Veuillez utiliser un seul ticker.")
        else:
            # Convertir en Series si une seule colonne
            data['Close'] = data['Close'].iloc[:,0]
    
    data.dropna(inplace=True)
    return data
    

    Étape 2 : Préparer et Nettoyer les Données

    def prepare_data(data): """ Calcule les indicateurs techniques nécessaires. """ # Moyennes Mobiles data['MA50'] = data['Close'].rolling(window=50).mean() data['MA200'] = data['Close'].rolling(window=200).mean()

    # Indicateurs Techniques Supplémentaires (Optionnel)
    data['RSI'] = ta.momentum.RSIIndicator(close=data['Close'], window=14).rsi()
    data['MACD'] = ta.trend.MACD(close=data['Close']).macd()
    
    # Supprimer les premières lignes avec des valeurs NaN après le calcul des indicateurs
    data.dropna(inplace=True)
    return data
    

    Étape 3 : Implémenter les Stratégies de Trading

    def implement_strategies(data): """ Implémente les stratégies Trend Following et Moving Average Crossover. """ # Stratégie Trend Following data['Position_Trend'] = np.where(data['Close'] > data['MA50'], 1, -1) data['Position_Trend'] = pd.Series(data['Position_Trend'], index=data.index).astype(float) # Assurer qu'est une Series 1D

    # Stratégie Moving Average Crossover
    data['MA50_Crossover'] = np.where(data['MA50'] > data['MA200'], 1, 0)
    data['Signal'] = pd.Series(data['MA50_Crossover'], index=data.index).diff()
    
    # Initialiser la colonne Position_MA avec des valeurs 0
    data['Position_MA'] = 0
    data.loc[data['Signal'] == 1, 'Position_MA'] = 1
    data.loc[data['Signal'] == -1, 'Position_MA'] = -1
    
    # S'assurer que Position_MA est une Series 1D
    data['Position_MA'] = pd.Series(data['Position_MA'], index=data.index).astype(float)
    
    return data
    

    Étape 4 : Définir le Cadre de Backtesting

    def backtest_strategy(data, position_column, initial_capital=100000): """ Effectue le backtest d'une stratégie donnée. """ # Calculer les rendements quotidiens data['Daily_Return'] = data['Close'].pct_change()

    # S'assurer que la colonne de position est une Series 1D
    position = data[position_column]
    if isinstance(position, pd.DataFrame):
        # Si position est DataFrame, extraire la première colonne
        position = position.iloc[:,0]
    
    elif isinstance(position, pd.Series):
        pass  # Rien à faire
    
    else:
        raise TypeError(f"La colonne de position {position_column} doit être une Series ou un DataFrame.")
    
    # Vérifier la forme de position
    print(f"Shape de {position_column}: {position.shape}, Type: {type(position)}")
    
    # Calculer les rendements de la stratégie
    data['Strategy_Return'] = position.shift(1) * data['Daily_Return']
    
    # Calculer le capital cumulé
    data['Capital'] = initial_capital * (1 + data['Strategy_Return'].cumsum())
    
    return data
    

    Étape 5 : Calculer les Indicateurs de Performance

    def calculate_performance(data, capital_column, initial_capital=100000): """ Calcule les indicateurs de performance de la stratégie. """ # Calculer le rendement total total_return = (data[capital_column].iloc[-1] / initial_capital) - 1

    # Calculer les rendements quotidiens de la stratégie
    daily_returns = data['Strategy_Return'].dropna()
    
    # Calculer le ratio de Sharpe (en supposant un taux sans risque de 0%)
    sharpe_ratio = (daily_returns.mean() / daily_returns.std()) * np.sqrt(252)
    
    # Calculer le maximum drawdown
    rolling_max = data[capital_column].cummax()
    drawdown = (data[capital_column] - rolling_max) / rolling_max
    max_drawdown = drawdown.min()
    
    return {
        'Total Return': total_return,
        'Sharpe Ratio': sharpe_ratio,
        'Max Drawdown': max_drawdown
    }
    

    Étape 6 : Visualiser les Résultats du Backtest

    def plot_capital(data_trend, data_ma, ticker): """ Plot la performance du capital pour les deux stratégies. """ plt.figure(figsize=(14, 7)) plt.plot(data_trend['Capital'], label='Trend Following') plt.plot(data_ma['Capital'], label='MA Crossover') plt.title(f'Performance des Stratégies de Trading pour {ticker}') plt.xlabel('Date') plt.ylabel('Capital en USD') plt.legend() plt.show()

    Fonction supplémentaire pour visualiser les signaux sur les prix

    def plot_signals(data, data_ma, ticker): """ Visualise les signaux d'achat et de vente sur le graphique des prix. """ plt.figure(figsize=(14, 7)) plt.plot(data['Close'], label='Prix de Clôture', alpha=0.5) plt.plot(data['MA50'], label='MA 50 jours', alpha=0.9) plt.plot(data['MA200'], label='MA 200 jours', alpha=0.9)

    # Signaux d'achat/vente pour MA Crossover
    buy_signals = data_ma[data_ma['Position_MA'] == 1]
    sell_signals = data_ma[data_ma['Position_MA'] == -1]
    
    plt.scatter(buy_signals.index, buy_signals['Close'], marker='^', color='g', label='Achat', alpha=1)
    plt.scatter(sell_signals.index, sell_signals['Close'], marker='v', color='r', label='Vente', alpha=1)
    
    plt.title(f'Signaux de MA Crossover pour {ticker}')
    plt.xlabel('Date')
    plt.ylabel('Prix en USD')
    plt.legend()
    plt.show()
    

    Étape 7 : Exécuter le Backtest et Afficher les Résultats

    def main(): try: # Paramètres ticker = 'AAPL' # Exemple avec Apple start_date = '2015-01-01' end_date = datetime.today().strftime('%Y-%m-%d') initial_capital = 100000 # Capital initial en USD

        # Récupérer et préparer les données
        data = get_data(ticker, start_date, end_date)
        print(f"\nShape de data avant préparation: {data.shape}")
        print(data.head())
        
        data = prepare_data(data)
        print(f"\nShape après préparation: {data.shape}")
        
        # Implémenter les stratégies
        data = implement_strategies(data)
        print(f"\nShape après implémentation des stratégies: {data.shape}")
        print(data[['Position_Trend', 'Position_MA']].head())
        
        # Vérification des formes des colonnes de position
        print("\nVérification des colonnes de position:")
        print(f"Position_Trend: Type={type(data['Position_Trend'])}, Shape={data['Position_Trend'].shape}")
        print(f"Position_MA: Type={type(data['Position_MA'])}, Shape={data['Position_MA'].shape}")
        
        # Backtester les stratégies
        data_trend = backtest_strategy(data.copy(), 'Position_Trend', initial_capital)
        data_ma = backtest_strategy(data.copy(), 'Position_MA', initial_capital)
        
        # Calculer les performances
        performance_trend = calculate_performance(data_trend, 'Capital', initial_capital)
        performance_ma = calculate_performance(data_ma, 'Capital', initial_capital)
        
        # Afficher les performances
        print("\nPerformance Trend Following:")
        for key, value in performance_trend.items():
            if key == 'Max Drawdown':
                print(f"{key}: {value:.2%}")
            elif key == 'Sharpe Ratio':
                print(f"{key}: {value:.2f}")
            else:
                print(f"{key}: {value:.2%}")
        
        print("\nPerformance MA Crossover:")
        for key, value in performance_ma.items():
            if key == 'Max Drawdown':
                print(f"{key}: {value:.2%}")
            elif key == 'Sharpe Ratio':
                print(f"{key}: {value:.2f}")
            else:
                print(f"{key}: {value:.2%}")
        
        # Visualiser les résultats
        plot_capital(data_trend, data_ma, ticker)
        
        # Visualiser les signaux sur les prix
        plot_signals(data, data_ma, ticker)
    
    except Exception as e:
        print("Une erreur s'est produite :", e)
    

    if name == "main": main()

  2. Assistant

    Ajouter une interface graphique utilisateur (GUI) à votre script de backtesting améliorera l'expérience utilisateur en rendant l'application plus interactive et accessible. Nous utiliserons Tkinter, la bibliothèque GUI standard de Python, pour créer cette interface. Tkinter est bien adapté pour des applications simples et permet d'intégrer facilement des éléments tels que des champs de saisie, des boutons et des affichages de résultats.

    Structure de l'Interface Graphique

    1. Champs de saisie :

      • Ticker : Entrée pour le symbole boursier (ex. : AAPL).
      • Date de début : Sélection de la date de début des données.
      • Date de fin : Sélection de la date de fin des données.
      • Capital initial : Entrée pour le capital de départ (optionnel, par défaut 100 000 USD).
    2. Bouton d'exécution :

      • Un bouton "Exécuter le Backtest" pour lancer le processus.
    3. Affichage des résultats :

      • Affichage des indicateurs de performance pour les deux stratégies.
      • Affichage des graphiques dans des fenêtres séparées ou intégrés dans l'interface.

    Mise en Œuvre avec Tkinter

    Voici le code complet intégrant votre script existant avec une interface Tkinter :

    # Importer les bibliothèques nécessaires
    import yfinance as yf
    import pandas as pd
    import numpy as np
    import matplotlib.pyplot as plt
    import seaborn as sns
    import ta
    from datetime import datetime
    import tkinter as tk
    from tkinter import ttk, messagebox
    from tkcalendar import DateEntry
    
    # Configurer les options de visualisation
    sns.set_style('darkgrid')
    plt.rcParams['figure.figsize'] = (14, 7)
    
    # Étape 1 : Récupérer les Données depuis Yahoo Finance
    def get_data(ticker, start_date, end_date):
        """
        Télécharge les données historiques pour un ticker donné entre start_date et end_date.
        """
        data = yf.download(ticker, start=start_date, end=end_date)
        
        if 'Close' not in data.columns:
            raise ValueError("Les données téléchargées ne contiennent pas de colonne 'Close'.")
        
        # Vérifier si 'Close' est une DataFrame (cas multi-ticker) ou une Series
        if isinstance(data['Close'], pd.DataFrame):
            if data['Close'].shape[1] > 1:
                raise ValueError("Plusieurs tickers téléchargés. Veuillez utiliser un seul ticker.")
            else:
                # Convertir en Series si une seule colonne
                data['Close'] = data['Close'].iloc[:,0]
        
        data.dropna(inplace=True)
        return data
    
    # Étape 2 : Préparer et Nettoyer les Données
    def prepare_data(data):
        """
        Calcule les indicateurs techniques nécessaires.
        """
        # Moyennes Mobiles
        data['MA50'] = data['Close'].rolling(window=50).mean()
        data['MA200'] = data['Close'].rolling(window=200).mean()
        
        # Indicateurs Techniques Supplémentaires (Optionnel)
        data['RSI'] = ta.momentum.RSIIndicator(close=data['Close'], window=14).rsi()
        data['MACD'] = ta.trend.MACD(close=data['Close']).macd()
        
        # Supprimer les premières lignes avec des valeurs NaN après le calcul des indicateurs
        data.dropna(inplace=True)
        return data
    
    # Étape 3 : Implémenter les Stratégies de Trading
    def implement_strategies(data):
        """
        Implémente les stratégies Trend Following et Moving Average Crossover.
        """
        # Stratégie Trend Following
        data['Position_Trend'] = np.where(data['Close'] > data['MA50'], 1, -1)
        data['Position_Trend'] = pd.Series(data['Position_Trend'], index=data.index).astype(float)  # Assurer qu'est une Series 1D
        
        # Stratégie Moving Average Crossover
        data['MA50_Crossover'] = np.where(data['MA50'] > data['MA200'], 1, 0)
        data['Signal'] = pd.Series(data['MA50_Crossover'], index=data.index).diff()
        
        # Initialiser la colonne Position_MA avec des valeurs 0
        data['Position_MA'] = 0
        data.loc[data['Signal'] == 1, 'Position_MA'] = 1
        data.loc[data['Signal'] == -1, 'Position_MA'] = -1
        
        # S'assurer que Position_MA est une Series 1D
        data['Position_MA'] = pd.Series(data['Position_MA'], index=data.index).astype(float)
        
        return data
    
    # Étape 4 : Définir le Cadre de Backtesting
    def backtest_strategy(data, position_column, initial_capital=100000):
        """
        Effectue le backtest d'une stratégie donnée.
        """
        # Calculer les rendements quotidiens
        data['Daily_Return'] = data['Close'].pct_change()
        
        # S'assurer que la colonne de position est une Series 1D
        position = data[position_column]
        if isinstance(position, pd.DataFrame):
            # Si position est DataFrame, extraire la première colonne
            position = position.iloc[:,0]
        
        elif isinstance(position, pd.Series):
            pass  # Rien à faire
        
        else:
            raise TypeError(f"La colonne de position {position_column} doit être une Series ou un DataFrame.")
        
        # Calculer les rendements de la stratégie
        data['Strategy_Return'] = position.shift(1) * data['Daily_Return']
        
        # Calculer le capital cumulé
        data['Capital'] = initial_capital * (1 + data['Strategy_Return'].cumsum())
        
        return data
    
    # Étape 5 : Calculer les Indicateurs de Performance
    def calculate_performance(data, capital_column, initial_capital=100000):
        """
        Calcule les indicateurs de performance de la stratégie.
        """
        # Calculer le rendement total
        total_return = (data[capital_column].iloc[-1] / initial_capital) - 1
    
        # Calculer les rendements quotidiens de la stratégie
        daily_returns = data['Strategy_Return'].dropna()
    
        # Calculer le ratio de Sharpe (en supposant un taux sans risque de 0%)
        sharpe_ratio = (daily_returns.mean() / daily_returns.std()) * np.sqrt(252)
    
        # Calculer le maximum drawdown
        rolling_max = data[capital_column].cummax()
        drawdown = (data[capital_column] - rolling_max) / rolling_max
        max_drawdown = drawdown.min()
    
        return {
            'Total Return': total_return,
            'Sharpe Ratio': sharpe_ratio,
            'Max Drawdown': max_drawdown
        }
    
    # Étape 6 : Visualiser les Résultats du Backtest
    def plot_capital(data_trend, data_ma, ticker):
        """
        Plot la performance du capital pour les deux stratégies.
        """
        plt.figure(figsize=(14, 7))
        plt.plot(data_trend['Capital'], label='Trend Following')
        plt.plot(data_ma['Capital'], label='MA Crossover')
        plt.title(f'Performance des Stratégies de Trading pour {ticker}')
        plt.xlabel('Date')
        plt.ylabel('Capital en USD')
        plt.legend()
        plt.show()
    
    # Fonction supplémentaire pour visualiser les signaux sur les prix
    def plot_signals(data, data_ma, ticker):
        """
        Visualise les signaux d'achat et de vente sur le graphique des prix.
        """
        plt.figure(figsize=(14, 7))
        plt.plot(data['Close'], label='Prix de Clôture', alpha=0.5)
        plt.plot(data['MA50'], label='MA 50 jours', alpha=0.9)
        plt.plot(data['MA200'], label='MA 200 jours', alpha=0.9)
    
        # Signaux d'achat/vente pour MA Crossover
        buy_signals = data_ma[data_ma['Position_MA'] == 1]
        sell_signals = data_ma[data_ma['Position_MA'] == -1]
        
        plt.scatter(buy_signals.index, buy_signals['Close'], marker='^', color='g', label='Achat', alpha=1)
        plt.scatter(sell_signals.index, sell_signals['Close'], marker='v', color='r', label='Vente', alpha=1)
        
        plt.title(f'Signaux de MA Crossover pour {ticker}')
        plt.xlabel('Date')
        plt.ylabel('Prix en USD')
        plt.legend()
        plt.show()
    
    # Étape 7 : Exécuter le Backtest et Afficher les Résultats
    def run_backtest(ticker, start_date, end_date, initial_capital, output_text):
        try:
            # Récupérer et préparer les données
            data = get_data(ticker, start_date, end_date)
            
            data = prepare_data(data)
            
            # Implémenter les stratégies
            data = implement_strategies(data)
            
            # Backtester les stratégies
            data_trend = backtest_strategy(data.copy(), 'Position_Trend', initial_capital)
            data_ma = backtest_strategy(data.copy(), 'Position_MA', initial_capital)
            
            # Calculer les performances
            performance_trend = calculate_performance(data_trend, 'Capital', initial_capital)
            performance_ma = calculate_performance(data_ma, 'Capital', initial_capital)
            
            # Préparer les résultats à afficher
            result = "\nPerformance Trend Following:\n"
            for key, value in performance_trend.items():
                if key == 'Max Drawdown':
                    result += f"{key}: {value:.2%}\n"
                elif key == 'Sharpe Ratio':
                    result += f"{key}: {value:.2f}\n"
                else:
                    result += f"{key}: {value:.2%}\n"
            
            result += "\nPerformance MA Crossover:\n"
            for key, value in performance_ma.items():
                if key == 'Max Drawdown':
                    result += f"{key}: {value:.2%}\n"
                elif key == 'Sharpe Ratio':
                    result += f"{key}: {value:.2f}\n"
                else:
                    result += f"{key}: {value:.2%}\n"
            
            # Afficher les résultats dans le widget texte
            output_text.config(state='normal')
            output_text.delete(1.0, tk.END)
            output_text.insert(tk.END, result)
            output_text.config(state='disabled')
            
            # Visualiser les résultats
            plot_capital(data_trend, data_ma, ticker)
            plot_signals(data, data_ma, ticker)
        
        except Exception as e:
            messagebox.showerror("Erreur", f"Une erreur s'est produite : {e}")
    
    # Création de l'interface graphique
    def create_gui():
        root = tk.Tk()
        root.title("Backtest de Stratégies de Trading")
        root.geometry("600x500")
        
        # Style
        style = ttk.Style(root)
        style.theme_use('clam')
        
        # Ticker
        ttk.Label(root, text="Ticker:").grid(column=0, row=0, padx=10, pady=10, sticky='W')
        ticker_entry = ttk.Entry(root, width=20)
        ticker_entry.grid(column=1, row=0, padx=10, pady=10, sticky='W')
        ticker_entry.insert(0, 'AAPL')  # Valeur par défaut
        
        # Date de début
        ttk.Label(root, text="Date de début:").grid(column=0, row=1, padx=10, pady=10, sticky='W')
        start_date_entry = DateEntry(root, width=18, background='darkblue',
                        foreground='white', borderwidth=2, year=2015, month=1, day=1, date_pattern='yyyy-mm-dd')
        start_date_entry.grid(column=1, row=1, padx=10, pady=10, sticky='W')
        
        # Date de fin
        ttk.Label(root, text="Date de fin:").grid(column=0, row=2, padx=10, pady=10, sticky='W')
        end_date_entry = DateEntry(root, width=18, background='darkblue',
                        foreground='white', borderwidth=2, date_pattern='yyyy-mm-dd')
        end_date_entry.grid(column=1, row=2, padx=10, pady=10, sticky='W')
        end_date_entry.set_date(datetime.today())
        
        # Capital initial
        ttk.Label(root, text="Capital initial (USD):").grid(column=0, row=3, padx=10, pady=10, sticky='W')
        capital_entry = ttk.Entry(root, width=20)
        capital_entry.grid(column=1, row=3, padx=10, pady=10, sticky='W')
        capital_entry.insert(0, '100000')  # Valeur par défaut
        
        # Bouton pour exécuter le backtest
        run_button = ttk.Button(root, text="Exécuter le Backtest", 
                                command=lambda: run_backtest(
                                    ticker_entry.get(),
                                    start_date_entry.get(),
                                    end_date_entry.get(),
                                    float(capital_entry.get()),
                                    output_text
                                ))
        run_button.grid(column=0, row=4, columnspan=2, padx=10, pady=20)
        
        # Zone de texte pour afficher les résultats
        output_text = tk.Text(root, height=15, width=70, state='disabled', wrap='word')
        output_text.grid(column=0, row=5, columnspan=2, padx=10, pady=10)
        
        # Ajouter une barre de défilement
        scrollbar = ttk.Scrollbar(root, command=output_text.yview)
        scrollbar.grid(column=2, row=5, sticky='ns')
        output_text['yscrollcommand'] = scrollbar.set
        
        root.mainloop()
    
    if __name__ == "__main__":
        # Vérifier si tkcalendar est installé
        try:
            import tkcalendar
        except ImportError:
            import sys
            message = (
                "Le module 'tkcalendar' n'est pas installé.\n"
                "Veuillez l'installer en exécutant :\n"
                "pip install tkcalendar"
            )
            messagebox.showerror("Module manquant", message)
            sys.exit(1)
        
        create_gui()
    

    Explications des Nouvelles Parties du Code

    1. Importation de Tkinter et tkcalendar :

      • tkinter : Pour créer l'interface graphique.
      • tkcalendar.DateEntry : Pour permettre aux utilisateurs de sélectionner les dates via un calendrier visuel.

      Installation de tkcalendar : Pour utiliser tkcalendar, vous devez l'installer via pip si ce n'est pas déjà fait :

      pip install tkcalendar
      
    2. Fonction run_backtest :

      • Cette fonction récupère les entrées de l'utilisateur, exécute le backtest en appelant les fonctions définies précédemment, et affiche les résultats dans un widget texte.
      • Elle gère également les erreurs en affichant des messages d'erreur via des boîtes de dialogue.
    3. Fonction create_gui :

      • Crée la fenêtre principale de l'application.
      • Ajoute des champs de saisie pour le ticker, les dates de début et de fin, et le capital initial.
      • Ajoute un bouton pour exécuter le backtest.
      • Ajoute une zone de texte pour afficher les résultats des performances.
      • Intègre des sélecteurs de date conviviaux via DateEntry.
    4. Gestion des Modules Manquants :

      • Avant de lancer l'interface, le script vérifie si tkcalendar est installé. Si ce n'est pas le cas, il affiche un message d'erreur et demande à l'utilisateur d'installer le module.

    Instructions pour Utiliser l'Application

    1. Installer les Dépendances : Assurez-vous d'avoir installé toutes les bibliothèques nécessaires. Vous pouvez utiliser pip pour installer les modules manquants :

      pip install yfinance pandas numpy matplotlib seaborn ta tkcalendar
      
    2. Exécuter le Script : Sauvegardez le code dans un fichier Python, par exemple backtest_gui.py, et exécutez-le :

      python backtest_gui.py
      
    3. Utiliser l'Interface :

      • Entrez le Ticker que vous souhaitez analyser.
      • Sélectionnez les Dates de début et de fin à l'aide des sélecteurs de date.
      • Entrez le Capital initial (par défaut 100 000 USD).
      • Cliquez sur "Exécuter le Backtest".
      • Les résultats des performances seront affichés dans la zone de texte, et les graphiques s'ouvriront dans des fenêtres séparées.

    Améliorations Futures

    • Intégration des Graphiques dans l'Interface : Pour une expérience plus fluide, les graphiques peuvent être intégrés directement dans l'interface Tkinter en utilisant des bibliothèques comme matplotlib.backends.backend_tkagg.

    • Ajouter Plus de Stratégies : Vous pouvez élargir l'application en ajoutant plus de stratégies de trading et en permettant à l'utilisateur de sélectionner celles qu'il souhaite tester.

    • Options de Personnalisation : Permettre à l'utilisateur de personnaliser les paramètres des indicateurs techniques (par exemple, les fenêtres de MA, RSI).

    • Exportation des Résultats : Ajouter des options pour exporter les résultats et les graphiques sous forme de fichiers (CSV, PNG).

    Conclusion

    En ajoutant une interface graphique avec Tkinter, votre application de backtesting devient beaucoup plus accessible et conviviale. Les utilisateurs peuvent facilement saisir les paramètres, exécuter le backtest et visualiser les résultats sans avoir à modifier le code source.