Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-mini-2024-07-18· OpenAIAi2 WildChat-4.8M (AI2)

findest du hier einen fehler? Calculate rolling variance and plot results…

  1. User

    findest du hier einen fehler?

    # Calculate rolling variance and plot results
    rolling_beta_series = pd.Series(rolling_beta, index=orig_data.index)
    
    #rolling_beta = trace.posterior['beta'].mean(dim=('chain', 'draw'))  # Replace with your actual data
    #rolling_beta_series = pd.Series(rolling_beta, index=orig_data.index)  # Use the DateTime index
    
    def getStrategyPortfolioWeights(rolling_beta, stock_name1, stock_name2, data, smoothing_window=15):
        data1 = data[stock_name1].ffill().fillna(0).values
        data2 = data[stock_name2].ffill().fillna(0).values
    
        # initial signal rebalance
        fixed_beta = rolling_beta[smoothing_window].values  # Verwandle in ein Array
        signal = fixed_beta * data1 - data2
        smoothed_signal = pd.Series(signal).rolling(smoothing_window).mean()
        d_smoothed_signal = smoothed_signal.diff()
        trading = "not"
        trading_start = 0
    
        leverage = pd.DataFrame(0, index=data.index, columns=[stock_name1, stock_name2])  # Initialisiere das DataFrame
        
        for i in range(smoothing_window, data1.shape[0]):
            leverage.iloc[i, :] = leverage.iloc[i - 1, :]
    
            if trading == "not":
                # Dynamisch den fixed_beta aktualisieren
                fixed_beta = rolling_beta[i].values  # Verwandle in ein Array
                signal = fixed_beta * data1 - data2
                smoothed_signal = pd.Series(signal).rolling(smoothing_window).mean()
                d_smoothed_signal = smoothed_signal.diff()
    
                if smoothed_signal[i] > 0 and d_smoothed_signal[i] < 0:
                    leverage.iloc[i, 0] = -fixed_beta / (abs(fixed_beta) + 1)
                    leverage.iloc[i, 1] = 1 / (abs(fixed_beta) + 1)
                    trading = "short"
                    trading_start = smoothed_signal[i]
    
                elif smoothed_signal[i] < 0 and d_smoothed_signal[i] > 0:
                    leverage.iloc[i, 0] = fixed_beta / (abs(fixed_beta) + 1)
                    leverage.iloc[i, 1] = -1 / (abs(fixed_beta) + 1)
                    trading = "long"
                    trading_start = smoothed_signal[i]
    
                else:
                    leverage.iloc[i, 0] = 0
                    leverage.iloc[i, 1] = 0
    
            elif trading == "long":
                if smoothed_signal[i] < trading_start:  # failed trade
                    leverage.iloc[i, 0] = 0
                    leverage.iloc[i, 1] = 0
                    trading = "not"
    
                if smoothed_signal[i] > 0:  # successful trade
                    leverage.iloc[i, 0] = 0
                    leverage.iloc[i, 1] = 0
                    trading = "not"
    
            elif trading == "short":
                if smoothed_signal[i] > trading_start:  # failed trade
                    leverage.iloc[i, 0] = 0
                    leverage.iloc[i, 1] = 0
                    trading = "not"
    
                if smoothed_signal[i] < 0:  # successful trade
                    leverage.iloc[i, 0] = 0
                    leverage.iloc[i, 1] = 0
                    trading = "not"
    
        return leverage
    
    portfolioWeights = getStrategyPortfolioWeights(rolling_beta,symbol_one, symbol_two,data).fillna(0)
    
    
    def backtest(pricingDF, leverageDF, start_cash):
        """
        Backtests pricing based on some given set of leverage. Leverage works such that it happens "overnight",
        so leverage for "today" is applied to yesterday's close price. This algo can handle NaNs in pricing data
        before a stock exists, but ffill() should be used for NaNs that occur after the stock has existed, even
        if that stock ceases to exist later.
        """
        
        pricing = pricingDF.values
        leverage = leverageDF.values
        
        shares = np.zeros_like(pricing)
        cash = np.zeros(pricing.shape[0])
        cash[0] = start_cash
        curr_price = np.zeros(pricing.shape[1])
        curr_price_div = np.zeros(pricing.shape[1])
        
        num_trades = 0  # Zählvariable für die Anzahl der Trades
        
        for t in range(1, pricing.shape[0]):
            
            if np.any(leverage[t] != leverage[t - 1]):
                # handle non-existent stock values
                curr_price[:] = pricing[t - 1]  # you can multiply with this one
                curr_price[np.isnan(curr_price)] = 0
                trading_allowed = (curr_price != 0)
                curr_price_div[:] = curr_price  # you can divide with this one
                curr_price_div[~trading_allowed] = 1
                
                # determine new positions (warning: leverage to non-trading_allowed stocks is just lost)
                portfolio_value = (shares[t - 1] * curr_price).sum() + cash[t - 1]
                target_shares = trading_allowed * (portfolio_value * leverage[t]) // curr_price_div
                
                # Count trades when positions change
                for i in range(len(target_shares)):
                    if target_shares[i] != shares[t - 1, i]:  # Wenn die Anzahl der Anteile sich ändert
                        num_trades += 1
                
                # rebalance
                shares[t] = target_shares
                cash[t] = cash[t - 1] - ((shares[t] - shares[t - 1]) * curr_price).sum()
                
            else:
                # maintain positions
                shares[t] = shares[t - 1]
                cash[t] = cash[t - 1]
        
        returns = (shares * np.nan_to_num(pricing)).sum(axis=1) + cash
        pct_returns = (returns - start_cash) / start_cash
        
        print(f"Total number of trades executed: {num_trades}")  # Ausgabe der Anzahl der Trades
        
        return (
            pd.DataFrame(shares, index=pricingDF.index, columns=pricingDF.columns),
            pd.Series(cash, index=pricingDF.index),
            pd.Series(pct_returns, index=pricingDF.index)
        )
    
    
    """# Berechne den Mittelwert der Betas über die Ketten und Ziehungen (draws)
    rolling_beta = trace.posterior['beta'].mean(dim=('chain', 'draw'))
    
    plt.figure(figsize=(18, 8))
    ax = plt.gca()
    plt.title("Beta Distribution over Time")
    
    # Beta-Mittelwert plotten
    pd.Series(rolling_beta, index=orig_data.index).plot(ax=ax, color='r', zorder=1e6, linewidth=2)
    
    # Beta-Orbits plotten (alle draws für jede Zeitreihe)
    for i in range(500):  # Plotte 500 Orbits, indem du draw variierst
        orbit = trace.posterior['beta'].isel(chain=0, draw=i)
        pd.Series(orbit, index=orig_data.index).plot(ax=ax, color=sns.color_palette()[0], alpha=0.05)
    
    plt.legend(['Beta Mean', 'Beta Orbit'])
    plt.show()"""
    
    
    
    """    # Plotting
        plt.figure(figsize=(18, 8))
        ax = plt.gca()
        plt.title("Return Profile of Algorithm")
        plt.ylabel("Percent Returns")
    
        # Plot the returns
        returns.plot(ax=ax, linewidth=3)
        vals = ax.get_yticks()
        ax.set_yticklabels(['{:,.0%}'.format(x) for x in vals])
    
        # Step 2: Optionally, you can add annotations or lines if necessary
        # plt.axhline(0, color='black', linewidth=0.5, linestyle='--')  # Optional horizontal line at y=0
    
        plt.tight_layout()
        plt.savefig(pair_directory / f'equity_symbol1-{symbol_one}_symbol2-{symbol_two}.png')
        plt.close()
        # Execute strategy portfolio weights calculation
        #leverage = getStrategyPortfolioWeights(rolling_beta_series, symbol_one, symbol_two, orig_data)
    
        # Save strategy results to CSV
        #leverage.to_csv(pair_directory / f'leverage_strategy_symbolone_{symbol_one}_symboltwo_{symbol_two}.csv')
    """
    
    
    
    def calculate_performance_metrics(returns_series, start_cash):
        """
        Berechnet wichtige Kennzahlen für die Equity-Kurve, basierend auf einer prozentualen Rückgabeserie.
        """
        # Annualized Returns (CAGR)
        # returns_series enthält prozentuale Renditen, also den Endwert in % nehmen
        final_value = returns_series.iloc[-1] + 1  # Endwert in Prozent (+1, um den Endwert als Wachstumsfaktor zu nutzen)
        cagr = final_value ** (252 / len(returns_series)) - 1
    
        # Daily Returns: pct_returns Serie zeigt die täglichen prozentualen Änderungen bereits
        daily_returns = returns_series.diff().dropna()  # Differenz zu den vorherigen Tagen (relative tägliche Änderungen)
        
        # Sharpe Ratio (angenommen, risk-free rate ist 0)
        sharpe_ratio = np.mean(daily_returns) / np.std(daily_returns) * np.sqrt(252)
    
        # Max Drawdown
        cumulative_returns = (returns_series + 1).cummax()  # Umwandeln in Wachstumspfad
        drawdown = (returns_series + 1) / cumulative_returns - 1
        max_drawdown = drawdown.min()
    
        # Mean Drawdown
        mean_drawdown = drawdown.mean()
    
        # R-Squared: Hier mit einem Benchmark wie SP500 arbeiten
        benchmark = np.arange(len(returns_series))  # Einfaches Benchmark als Beispiel
        slope, intercept, r_value, p_value, std_err = stats.linregress(benchmark, returns_series)
        r_squared = r_value ** 2
    
        # Normalized Profit Factor
        profit = daily_returns[daily_returns > 0].sum()
        loss = -daily_returns[daily_returns < 0].sum()  # Negative Renditen als positive Verluste behandeln
        normalized_profit_factor = profit / loss if loss != 0 else np.nan
    
        # Pearson Correlation (mit Benchmark)
        benchmark_returns = np.random.normal(0, 1, len(daily_returns))  # Platzhalter für Benchmark-Renditen
        pearson_corr = np.corrcoef(daily_returns, benchmark_returns)[0, 1] if len(daily_returns) == len(benchmark_returns) else np.nan
    
        # CAGR in Bezug auf den Mean Drawdown
        cagr_mean_drawdown = cagr / abs(mean_drawdown) if mean_drawdown != 0 else np.nan
    
        # CAGR in Bezug auf den Max Drawdown
        cagr_max_drawdown = cagr / abs(max_drawdown) if max_drawdown != 0 else np.nan
    
        return {
            "CAGR": cagr,
            "Sharpe Ratio": sharpe_ratio,
            "Max Drawdown": max_drawdown,
            "Mean Drawdown": mean_drawdown,
            "R-Squared": r_squared,
            "Normalized Profit Factor": normalized_profit_factor,
            "Pearson Correlation": pearson_corr,
            "CAGR/Mean Drawdown": cagr_mean_drawdown,
            "CAGR/Max Drawdown": cagr_max_drawdown
        }
    
    
    
    def save_performance_to_csv(metrics_dict, pair_directory, symbol_one, symbol_two):
        """
        Speichert die berechneten Kennzahlen in einer CSV-Datei, überschreibt bestehende Paare und fügt neue hinzu.
        """
        # Gehe eine Ebene höher, um die Datei im gemeinsamen Verzeichnis zu speichern
        base_directory = os.path.dirname(pair_directory)  # Der übergeordnete Ordner für alle Paare
        performance_dir = os.path.join(base_directory, 'all_symbols_performance')  # Zielverzeichnis
    
        # Erstelle das Zielverzeichnis, falls es noch nicht existiert
        os.makedirs(performance_dir, exist_ok=True)
    
        # CSV-Datei Pfad
        csv_file = os.path.join(performance_dir, 'all_symbols_performance.csv')
    
        # Erstelle ein DataFrame für das aktuelle Paar
        pair_name = f"{symbol_one}_{symbol_two}"
        metrics_df = pd.DataFrame([metrics_dict], columns=metrics_dict.keys())
        metrics_df['pair'] = pair_name  # Fügt die Paarinformation hinzu
        
        # Setze 'pair' an den Anfang des DataFrames
        metrics_df = metrics_df[['pair'] + [col for col in metrics_dict.keys()]]
    
        # Wenn die CSV-Datei existiert, lese sie
        if os.path.exists(csv_file):
            existing_df = pd.read_csv(csv_file)
    
            # Prüfe, ob das Paar bereits in der CSV existiert
            if pair_name in existing_df['pair'].values:
                # Überschreibe die bestehende Zeile für dieses Paar
                existing_df.loc[existing_df['pair'] == pair_name] = metrics_df.values[0]
            else:
                # Füge das neue Paar hinzu
                existing_df = pd.concat([existing_df, metrics_df], ignore_index=True)
    
            # Speichere die aktualisierte DataFrame
            existing_df.to_csv(csv_file, index=False)
        else:
            # Erstelle eine neue CSV-Datei, wenn sie noch nicht existiert
            metrics_df.to_csv(csv_file, index=False)
    
    
    
    # Beispielhafte Verwendung:
    
    
    # Führe den Backtest durch
    shares, cash, returns = backtest( orig_data, portfolioWeights, 1000 )
    # Berechne wichtige Kennzahlen
    metrics = calculate_performance_metrics(returns, 1000)
    print("returns",returns)
    # Speichere die Ergebnisse
    save_performance_to_csv(metrics, pair_directory, symbol_one, symbol_two)
    
        # Plotting
    plt.figure(figsize=(18, 8))
    ax = plt.gca()
    plt.title("Return Profile of Algorithm")
    plt.ylabel("Percent Returns")
    
    # Plot the returns
    returns.plot(ax=ax, linewidth=3)
    vals = ax.get_yticks()
    ax.set_yticklabels(['{:,.0%}'.format(x) for x in vals])
    
    # Performance Metriken als Text ins Diagramm schreiben (rechts unten)
    performance_text = (
        f"CAGR: {metrics['CAGR']:.2%}\n"
        f"Sharpe Ratio: {metrics['Sharpe Ratio']:.2f}\n"
        f"Max Drawdown: {metrics['Max Drawdown']:.2%}\n"
        f"Mean Drawdown: {metrics['Mean Drawdown']:.2%}\n"
        f"R-Squared: {metrics['R-Squared']:.2f}\n"
        f"Profit Factor: {metrics['Normalized Profit Factor']:.2f}\n"
        f"Pearson Correlation: {metrics['Pearson Correlation']:.2f}\n"
        f"CAGR/Mean Drawdown: {metrics['CAGR/Mean Drawdown']:.2f}\n"
        f"CAGR/Max Drawdown: {metrics['CAGR/Max Drawdown']:.2f}"
    )
    
    # Positioniere den Text rechts unten
    ax.text(
        1, 0,  # Position (1, 0) ist die rechte untere Ecke des Plots
        performance_text,
        horizontalalignment='right',
        verticalalignment='bottom',
        transform=ax.transAxes,
        bbox=dict(facecolor='white', alpha=0.5)  # Optional: Hintergrund für besseren Kontrast
    )
    
    # Step 1: Optionally, add background shading or other annotations
    # plt.axhline(0, color='black', linewidth=0.5, linestyle='--')  # Optional horizontal line at y=0
    
    plt.tight_layout()
    plt.savefig(pair_directory / f'equity_symbol1-{symbol_one}_symbol2-{symbol_two}.png')
    plt.close()
        
    print("Kennzahlen für alle Paare erfolgreich berechnet und gespeichert.")
    
  2. Assistant

    Um den Code gründlich zu überprüfen, muss ich verschiedene Aspekte analysieren. Hier sind einige potenzielle Punkte, die Fehler oder Verbesserungsmöglichkeiten darstellen könnten:

    1. Imports: Es gibt keine Importstatements im Code. Stellen Sie sicher, dass die notwendigen Bibliotheken (wie pandas, numpy, scipy.stats, matplotlib, etc.) importiert werden. Zum Beispiel:

      import pandas as pd
      import numpy as np
      import matplotlib.pyplot as plt
      from scipy import stats
      import os
      import seaborn as sns
      
    2. Fenster in der getStrategyPortfolioWeights Funktion:

      • Der Zugriff auf Werte von rolling_beta mit fixed_beta = rolling_beta[smoothing_window].values könnte zu einem Indexfehler führen, wenn der smoothing_window Wert zu hoch ist, für den Zeitraum, den rolling_beta abdeckt.
      • Überprüfen Sie sicher, dass rolling_beta lang genug ist, um smoothing_window zu unterstützen.
    3. NaN-Werte in smoothed_signal:

      • In der Methode getStrategyPortfolioWeights, stellen Sie sicher, dass nach der Berechnung smoothed_signal genügend Werte vorhanden sind, um Unterschiede mit d_smoothed_signal = smoothed_signal.diff() zu bilden.
    4. mean_drawdown und max_drawdown:

      • Stellen Sie sicher, dass mean_drawdown und max_drawdown richtig berechnet werden. Sie setzen diese Werte möglicherweise auf NaN, wenn sie nie aktualisiert werden, und dies könnte zu unerwartetem Verhalten in calculate_performance_metrics führen.
    5. Fehlende Behandlungen bei NaN-Werten:

      • In einigen Berechnungen, insbesondere bei der Berechnung von sharpe_ratio, sollten NaN-Werte behandelt werden (z. B. durch Verwendung von np.nanmean und np.nanstd), um Fehler oder inkorrekte Werte zu vermeiden.
    6. Benchmark-Rückgaben in calculate_performance_metrics:

      • Der Benchmark wird zufällig generiert. In der Praxis haben Sie wahrscheinlich einen spezifischen Benchmark wie den SP500. Implementieren Sie eine klare Benchmark-Logik.
    7. Rückgabewerte in der backtest-Funktion:

      • Stellen Sie sicher, dass alle Berechnungen in der Backtest-Funktion korrekt sind, insbesondere bei target_shares. Wenn trading_allowed viele NaNs enthält, kann dies das Ergebnis beeinflussen.
    8. Fehlende Testfälle / Validierungen:

      • Es ist ratsam, Testfälle oder Validierungen für die Funktionalität hinzuzufügen, um zu überprüfen, ob das Programm mit verschiedenen Eingaben erwartungsgemäß funktioniert.
    9. Symbol-Namen und Verzeichnis:

      • Stellen Sie sicher, dass symbol_one, symbol_two und pair_directory initialisiert und im Kontext gesetzt sind, bevor Sie sie verwenden.

    Insgesamt würde ich empfehlen, den Code in kleinere Einheiten zu zerlegen, jede Funktion einzeln zu testen und sicherzustellen, dass Sie bei der Verwendung von Geschäften und Finanzdaten Vorsicht walten lassen, da Fehler möglicherweise schwerwiegende Folgen im finanziellen Kontext haben könnten.

    Stellen Sie sicher, dass Sie nach der Identifizierung von Fehlern (ob syntaktischer oder logischer Art) den Code schrittweise ausführen und überprüfen, ob jede Funktion die erwarteten Ergebnisse zurückgibt.