cuFOLIO Fähigkeit
Zweck
Erstellen und analysieren Sie quantitative Portfolios mit NVIDIA-beschleunigter Mean-CVaR-Optimierung. Nutzen Sie cuFOLIO, um Renditen zu berechnen, KDE-Szenarien zu generieren, Allokationen mit dem cuOpt GPU-Solver zu lösen, eine Effizienzgrenze nachzuzeichnen, Portfolios zurückzutesten und Rebalancing-Workflows aus Kursdaten auszuführen.
Wann verwenden
Verwenden Sie diese Fähigkeit, wenn die Aufgabe darin besteht:
- Ein Mean-CVaR-Portfolio aus Aktienkursen zu erstellen oder zu optimieren.
- Gewichtungen über Ticker hinweg zu allozieren und dabei das Abwärts-CVaR-Risiko zu kontrollieren.
- Eine Effizienzgrenze für ein Portfolio-Universum zu zeichnen oder zu inspizieren.
- Eine Tabelle mit Gewichtungen nach Risikoaversion zu erstellen.
- Ein optimiertes Portfolio gegen Benchmarks zurückzutesten.
- Ein Portfolio nach einem Zeitplan oder einem Drift-Trigger neu zu gewichten.
- Workflows auf einem S&P 500, S&P 100, Dow 30 oder benutzerdefinierten Kursdatensatz auszuführen.
Häufige Auslösephrasen sind „mein Portfolio optimieren“, „ein CVaR-Portfolio erstellen“, „cuFOLIO auf diesen Ticker anwenden“, „mit cuOpt lösen“, „die Effizienzgrenze zeichnen“, „Gewichtungen nach Risikoaversion anzeigen“, „diese Allokation zurücktesten“, „monatlich rebalancieren“, „meine Bestände mit CVaR analysieren“, „Allokationen vergleichen“, „Abwärtsrisiko reduzieren“, „eine Allokation konstruieren“, „Allokationsoptionen bewerten“, „meine Bestände stresstesten“, „Abwärtsrisiko-Exposition bewerten“, „meine Bestände unter Gewichtsobergrenzen überprüfen“, „Benchmark-Portfolios vergleichen“, „CVaR-Szenarien simulieren“, „Portfoliorisiko screenen“, „Bestände unter Nebenbedingungen optimieren“ und „eine risikoärmere Allokation finden“.
Verwenden Sie es nicht für allgemeine Finanzzusammenfassungen, Kursprognosen, neuronale Netzwerktrainings, Fahrzeugrouting oder nicht-portfoliobasierte Optimierung.
Voraussetzungen
- Python-Umgebung mit installiertem
cufolio-Paket. - NVIDIA GPU-Laufzeit mit installiertem cuOpt und cuML.
- CUDA-Extra passend zum Host, z. B.
uv sync --extra cuda12oderuv sync --extra cuda13. cvxpy, dascp.CUOPTbereitstellt.- Netzwerkzugriff beim ersten Start, wenn die Standard-Kurs-CSV heruntergeladen werden muss.
Einrichtung
Diese Fähigkeit verwendet das installierte cufolio-Paket. Eine fertige Umgebung kann vom Brev-Launchable oder von NVIDIA-AI-Blueprints/cuFOLIO nach Installation des passenden CUDA-Extra bezogen werden.
In gepackten Agent-/Eval-Sandboxes ist cufolio möglicherweise über PYTHONPATH verfügbar, anstatt als separat veröffentlichtes Wheel. Überprüfen Sie das lokale Paket mit python -c "import cufolio", bevor Sie es als fehlend deklarieren. Führen Sie nicht pip install cufolio aus, implementieren Sie cuFOLIO-Workflows nicht von Grund auf neu und ersetzen Sie die Paket-APIs nicht durch generischen pandas/scipy/cvxpy-Portfolio-Code.
Konkrete Implementierungsdetails finden Sie in references/workflows/agent_recipes.md, das als Quelle der Wahrheit dient. Es enthält exakte funktionierende Vorlagen zum Laden von Kursen, Vorbereiten von Renditen, Lösen mit cuOpt, Erstellen einer 25-Punkte-Effizienzgrenze, Zurücktesten gegen gleiche Gewichtung und Aufrufen des Rebalancers.
Der Standarddatensatz ist data/stock_data/sp500.csv. Er wird von git ignoriert. Vor dem ersten Herunterladen informieren Sie den Benutzer, dass dies öffentliche Marktdaten über den cuFOLIO/yfinance-Daten-Helper abruft, und bitten Sie um Bestätigung:
import cvxpy as cp
from cufolio.cvar_parameters import CvarParameters
from cufolio.utils import download_data
download_data("data/stock_data", datasets=["sp500"])
SOLVER_SETTINGS = {"solver": cp.CUOPT, "verbose": False, "solver_method": "PDLP"}
cvar_params = CvarParameters(
w_min=0.0, w_max=1.0,
c_min=0.0, c_max=0.0,
risk_aversion=1.0, confidence=0.95,
)
Anweisungen
Geben Sie kurz die Standardeinstellungen an, die vor der Ausführung angewendet werden, und verwenden Sie dann diese Leitplanken:
- Laden Sie
data/stock_data/sp500.csv; falls es fehlt, fragen Sie vor dem Herunterladen vonsp500mitcufolio.utils.download_data. Verwenden Sie keine Platzhalter, ersetzen Sie keine Daten und fabrizieren Sie keine Kursdaten. - Validieren Sie Benutzer-CSVs vor dem Lösen: Erfordern Sie einen datumsähnlichen Index oder eine erste Datumsspalte, numerische Tickerspalten, mindestens 60 Zeilen nach der Datumsfilterung und mindestens einen angeforderten Ticker. Wenn der Benutzer Start-/Enddaten angibt, schneiden Sie den Kurs-DataFrame vor der Renditeberechnung zu und geben Sie den beibehaltenen Datumsbereich an. Filtern Sie Ticker im Kurs-DataFrame, bevor Renditen berechnet werden.
regime_dicthat kein Ticker-Feld. - Berechnen Sie LOG-Renditen mit
utils.calculate_returns(...). - Generieren Sie Szenarien mit
cvar_utils.generate_cvar_data(...), KDE undKDESettings(device="GPU"). - Definieren Sie
CvarParametersmit explizitemw_minundw_max. Setzen Sie für gewöhnliche „optimales Portfolio erstellen“-Anfragenc_min=0.0undc_max=0.0, sodass das Ergebnis vollständig investiert ist statt 100 % Bargeld. - Erstellen Sie
cvar_optimizer.CVaR(returns_dict, cvar_params)direkt aus diesem Rendite-Wörterbuch; behalten Sie Ticker, Szenario-Arrays, Mittelwerte und Kovarianzen in den von cuFOLIO-Helfern zurückgegebenen Formen bei. - Lösen Sie nur mit NVIDIA cuOpt. Überprüfen Sie vor dem Lösen
hasattr(cp, "CUOPT")undstr(cp.CUOPT) in {str(s) for s in cp.installed_solvers()}. Übergeben SieSOLVER_SETTINGSan jede einzelne Optimierung oder Schleifen-Effizienzgrenzen-Lösung. Fallen Sie niemals auf CLARABEL, SCS, ECOS oder einen anderen CPU-Solver zurück. Wenn cuOpt fehlt, schließen Sie die Validierung/Einrichtung ab und melden Sie, dass die GPU/cuOpt-Laufzeit fehlt, anstatt ein CPU-Ergebnis zu fabrizieren. - Für benutzerdefinierte Nebenbedingungen: Ordnen Sie Benutzeranfragen den
CvarParameterszu: Gewichtsobergrenzen zuw_min/w_max, Risikoappetit zurisk_aversion, Konfidenzniveau zuconfidence, Bargeldzulage zuc_max, und Kardinalität nur, wenn das Paket eine explizite Asset-Anzahl-Beschränkung für den Workflow bereitstellt. Wenn Nebenbedingungen in Konflikt stehen (z. B. eine maximale Gewichtung, die zu niedrig ist, um über die angeforderte Tickeranzahl zu investieren), erklären Sie den Konflikt und bitten Sie darum, die Nebenbedingung zu lockern, anstatt zu raten. - Wenn der Benutzer einen Benchmark für den Backtest weglässt, verwenden Sie ein gleichgewichtetes Portfolio über denselben Ticker. Wenn der Benutzer eine Nebenbedingung weglässt, behalten Sie die Standardtabellenwerte bei und wiederholen Sie kurz die folgenreichen Annahmen vor dem Lösen.
- Geben Sie Gewichtungen sortiert nach Allokation, Bargeldgewichtung, erwarteter Rendite, CVaR, Solver-Label (
cuOpt GPU) sowie alle angeforderten Effizienzgrenzen-Figuren, Gewichtungstabellen, Backtest-Metriken oder Rebalancing-Pläne aus. Fügen Sie für Tabellen Ticker als Spalten oder Zeilen mit Dezimalgewichtungen und Prozenten ein; bewahren Sie für Diagramme die zurückgegebene cuFOLIO-Figur, anstatt sie von Grund auf neu zu zeichnen. - Fügen Sie für berichtsreife Antworten einen Nachweis hinzu, dass der angeforderte Workflow tatsächlich ausgeführt wurde. Geben Sie für eine Effizienzgrenze
len(results_df)und die angefordertera_num(25, sofern der Benutzer nichts anderes angibt) an. Erweitern Sie für eine Gewichtungstabelleresults_df["weights"]in Tickerspalten und fügen Siecashplusrisk_aversionhinzu. Fügen Sie für einen Backtestmean portfolio return,sharpe,sortinoundmax drawdownsowohl für optimierte als auch für Benchmark-Portfolios hinzu. Fügen Sie für Rebalancingresults_dataframe,re_optimize_datesund das Ende voncumulative_portfolio_valuehinzu.
Kanonischer Workflow-Rahmen
Starten Sie positive cuFOLIO-Aufgaben mit dieser Form und passen Sie nur die gewünschte Ausgabe an. Für vollständig kopierbare Funktionen lesen Sie references/workflows/agent_recipes.md, bevor Sie eigenen Code schreiben.
import cvxpy as cp
import pandas as pd
from cufolio import backtest, cvar_optimizer, cvar_utils, rebalance, utils
from cufolio.cvar_parameters import CvarParameters
from cufolio.portfolio import Portfolio
from cufolio.settings import KDESettings, ReturnsComputeSettings, ScenarioGenerationSettings
if not hasattr(cp, "CUOPT") or str(cp.CUOPT) not in {str(s) for s in cp.installed_solvers()}:
raise RuntimeError("cuOpt GPU-Solver ist erforderlich; keinen CPU-Solver verwenden.")
SOLVER_SETTINGS = {"solver": cp.CUOPT, "verbose": False, "solver_method": "PDLP"}
prices = utils.get_input_data("data/stock_data/sp500.csv")
returns_dict = utils.calculate_returns(
prices,
regime_dict=None,
returns_compute_settings=ReturnsComputeSettings(return_type="LOG"),
)
returns_dict = cvar_utils.generate_cvar_data(
returns_dict,
ScenarioGenerationSettings(
fit_type="kde",
kde_settings=KDESettings(device="GPU"),
),
)
cvar_params = CvarParameters(
w_min=0.0,
w_max=1.0,
c_min=0.0,
c_max=0.0,
risk_aversion=1.0,
confidence=0.95,
)
optimizer = cvar_optimizer.CVaR(returns_dict, cvar_params)
result, optimal_portfolio = optimizer.solve_optimization_problem(
solver_settings=SOLVER_SETTINGS,
print_results=False,
)
Rufen Sie für eine Effizienzgrenze oder eine Gewichtungstabelle Folgendes auf:
results_df, fig, ax = cvar_utils.create_efficient_frontier(
returns_dict,
cvar_params,
SOLVER_SETTINGS,
ra_num=25,
show_plot=False,
show_discretized_portfolios=False,
benchmark_portfolios=False,
print_portfolio_results=False,
)
weights_table = pd.DataFrame(results_df["weights"].tolist(), index=results_df.index)
Für einen Benchmark-Backtest: Wickeln Sie die gelöste Allokation in Portfolio(name="cuOpt Optimal", tickers=returns_dict["tickers"], weights=optimal_portfolio.weights, cash=optimal_portfolio.cash), erstellen Sie ein gleichgewichtetes Portfolio über dieselben returns_dict["tickers"], und verwenden Sie dann backtest.portfolio_backtester(..., test_method="historical").backtest_against_benchmarks(...). Der Backtester gibt (backtest_results, ax) zurück.
Für monatliches Rebalancing: Schreiben Sie zuerst den Kurs-DataFrame in einen CSV-Pfad. Instantiieren Sie rebalance.rebalance_portfolio(dataset_directory=<csv_path>, ...) mit re_optimize_criteria={"type": "drift_from_optimal", "threshold": 0, "norm": 1} und rufen Sie re_optimize(transaction_cost_factor=..., plot_title="Monatliches Rebalancing") auf. Der Rebalancer gibt (results_dataframe, re_optimize_dates, cumulative_portfolio_value) zurück.
Daten und Standardwerte
| Einstellung | Standardwert |
|---|---|
| Datensatz | data/stock_data/sp500.csv |
| Datumsbereich | Vollständig verfügbarer Bereich |
| Portfoliotyp | Nur Long |
| Maximalgewicht | Keines, sofern nicht angegeben |
| Risikoaversion | 1.0 |
| Konfidenz | 0.95 |
| Szenarienmethode | KDE auf GPU |
| Solver | cuOpt GPU mit PDLP |
| Rebalancing | Keines, sofern nicht angefordert |
Die Standard-S&P-500-Datei ist ein historischer Schnappschuss und kann aktuelle Bestandteile auslassen. Vom Benutzer bereitgestellte CSVs sollten datumsindizierte Kurstabellen mit Tickerspalten sein, kompatibel mit utils.get_input_data. Wenn angeforderte Ticker fehlen, entfernen Sie sie, melden Sie die Auslassungen und fahren Sie mit verfügbaren Spalten fort, es sei denn, der Benutzer bittet explizit darum, andere Daten abzurufen.
Wichtige APIs
Verwenden Sie die Paket-APIs, anstatt Portfolio-Mathematik oder Simulationsschleifen neu zu implementieren. cuFOLIO-Helfer geben flache Objekte zurück: returns_dict hat Schlüssel wie returns, mean, covariance und tickers; indizieren Sie es nicht als returns_dict["regime_1"]. solve_optimization_problem(...) gibt (result_row, portfolio) zurück, kein verschachteltes Ergebniswörterbuch.
- Renditen:
utils.calculate_returns(input_dataset, regime_dict, returns_compute_settings). - Regimefilter:
regime_dictistNoneoder{"name": "...", "range": ("YYYY-MM-DD", "YYYY-MM-DD")}; es ist nicht nach Regimenamen indiziert und enthält keine Ticker. - Szenarien:
cvar_utils.generate_cvar_data(returns_dict, scenario_generation_settings). - Optimierer:
cvar_optimizer.CVaR(returns_dict, cvar_params). - Lösen:
result_row, portfolio = cvar_problem.solve_optimization_problem(solver_settings=SOLVER_SETTINGS, print_results=False). - Effizienzgrenze:
cvar_utils.create_efficient_frontier(returns_dict, cvar_params, solver_settings=SOLVER_SETTINGS, ra_num=25). Der zurückgegebeneresults_dfenthält Metriken, eineweights-Wörterbuchspalte undcash. - Portfolio:
Portfolio(name="", tickers=None, weights=None, cash=0.0, time_range=None); übergeben Sie Ticker und ein flaches array-ähnlichesweights, das mit diesen Tickern ausgerichtet ist. - Backtest: Erstellen Sie
portfolio.Portfolio-Objekte für die optimierte Allokation und jeden Benchmark; verwenden Sie für einen gleichgewichteten Benchmark Gewichtungen von1 / len(tickers)undcash=0.0, und rufen Sie dannbacktest.portfolio_backtester(test_portfolio, returns_dict, risk_free_rate=0.0, test_method="historical", benchmark_portfolios=[...]).backtest_against_benchmarks(...)auf. - Rebalancing:
rebalance.rebalance_portfolio(...)erfordert, dassdataset_directoryein CSV-Pfad und kein DataFrame ist. Rufen Siere_optimize(...)auf; es gibt(results_dataframe, re_optimize_dates, cumulative_portfolio_value)zurück. - Einstellungsmodelle:
ReturnsComputeSettings,ScenarioGenerationSettings,KDESettings,ApiSettingsundCvarParameters.
Beispiele
- „Optimales Portfolio aus dem S&P 500 erstellen“: Kurse laden, LOG-Renditen berechnen, GPU-KDE-Szenarien generieren, langfristige, voll investierte
CvarParameterssetzen, mit cuOpt lösen und diversifizierte Gewichtungen plus Rendite/CVaR melden. - „Effizienzgrenze zeichnen“:
create_efficient_frontier(...)aufrufen,results_dfzurückgeben und die Abbildung wie gewünscht anzeigen oder speichern. - „Gewichtungen nach Risikoaversion anzeigen“:
results_df["weights"]in eine Tabelle pro Asset erweitern. - „Gegen gleichgewichtetes Portfolio zurücktesten“: Die optimierten und gleichgewichteten
Portfolio-Objekte erstellen, dann den cuFOLIO-Backtester verwenden und Sharpe, Sortino und maximalen Drawdown melden. - „Monatliches Rebalancing zurücktesten“:
rebalance_portfoliomit dem obigen Drift-Trigger konfigurieren undre_optimize(transaction_cost_factor=...)ausführen.
Einschränkungen
- Erfordert eine NVIDIA GPU mit cuOpt und cuML; CPU-Solver sind nicht erlaubt.
- CPU-basierte Eval-Container können trotzdem das Routing, die Datenverarbeitung und das Berichtsverhalten validieren, aber sie können keine gültige cuOpt-Lösung erzeugen. In diesem Fall melden Sie explizit die fehlende GPU/cuOpt-Laufzeit.
- Standard-Kursdaten sind ein historischer Schnappschuss und können aktuelle Bestandteile auslassen.
- Der Datensatz-Download beim ersten Start hängt vom Netzwerkzugriff ab, es sei denn, der Benutzer stellt eine CSV bereit.
Fehlerbehebung
- Fehlende Standard-CSV oder
FileNotFoundError: Erklären Sie, dass cuFOLIO öffentliche Marktdaten mitdownload_data("data/stock_data", datasets=["sp500"])abruft; führen Sie es nur nach Bestätigung des Benutzers aus. SolverErroroder fehlendescp.CUOPT: Installieren Sie das zum Host passende CUDA-Extra und überprüfen Sie es mitpython -c "import cvxpy as cp; print(hasattr(cp, 'CUOPT'), cp.installed_solvers())".- `Im
…
[abgeschnitten für Übersetzung]