findest du hier einen fehler? Calculate rolling variance and plot results…
- 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.") - 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:
-
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 -
Fenster in der
getStrategyPortfolioWeightsFunktion:- Der Zugriff auf Werte von
rolling_betamitfixed_beta = rolling_beta[smoothing_window].valueskönnte zu einem Indexfehler führen, wenn dersmoothing_windowWert zu hoch ist, für den Zeitraum, denrolling_betaabdeckt. - Überprüfen Sie sicher, dass
rolling_betalang genug ist, umsmoothing_windowzu unterstützen.
- Der Zugriff auf Werte von
-
NaN-Werte in
smoothed_signal:- In der Methode
getStrategyPortfolioWeights, stellen Sie sicher, dass nach der Berechnungsmoothed_signalgenügend Werte vorhanden sind, um Unterschiede mitd_smoothed_signal = smoothed_signal.diff()zu bilden.
- In der Methode
-
mean_drawdownundmax_drawdown:- Stellen Sie sicher, dass
mean_drawdownundmax_drawdownrichtig berechnet werden. Sie setzen diese Werte möglicherweise auf NaN, wenn sie nie aktualisiert werden, und dies könnte zu unerwartetem Verhalten incalculate_performance_metricsführen.
- Stellen Sie sicher, dass
-
Fehlende Behandlungen bei
NaN-Werten:- In einigen Berechnungen, insbesondere bei der Berechnung von
sharpe_ratio, solltenNaN-Werte behandelt werden (z. B. durch Verwendung vonnp.nanmeanundnp.nanstd), um Fehler oder inkorrekte Werte zu vermeiden.
- In einigen Berechnungen, insbesondere bei der Berechnung von
-
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.
-
Rückgabewerte in der
backtest-Funktion:- Stellen Sie sicher, dass alle Berechnungen in der Backtest-Funktion korrekt sind, insbesondere bei
target_shares. Wenntrading_allowedvieleNaNs enthält, kann dies das Ergebnis beeinflussen.
- Stellen Sie sicher, dass alle Berechnungen in der Backtest-Funktion korrekt sind, insbesondere bei
-
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.
-
Symbol-Namen und Verzeichnis:- Stellen Sie sicher, dass
symbol_one,symbol_twoundpair_directoryinitialisiert und im Kontext gesetzt sind, bevor Sie sie verwenden.
- Stellen Sie sicher, dass
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.
-