Risk Parity Implementierung: gleiche Risikobeiträge im Portfolio.

Klassische 60/40-Portfolios klingen ausgewogen, sind es aber nicht. Die Aktienseite trägt typischerweise 90 % des Risikos. Risk Parity dreht die Logik um: nicht das Kapital wird gleich verteilt, sondern der Risikobeitrag. Was das technisch bedeutet, wie Sie es in Python umsetzen — und wo die Methode an Grenzen stößt.

Warum Kapitalgewichtung in die Irre führt.

Ein 60/40-Portfolio aus Aktien und Staatsanleihen ist nicht „60 % aggressiv, 40 % defensiv". Es ist meistens „90 % Aktienrisiko, 10 % Zinsrisiko". Aktien haben historisch eine annualisierte Volatilität von rund 16 %, Staatsanleihen liegen zwischen 4 und 7 %. Multipliziert mit den Gewichten kippt die Risikobilanz dramatisch in Richtung Equity.

Bridgewater hat in den 1990er Jahren mit dem All Weather-Fonds gezeigt, was passiert, wenn man Portfolios statt nach Kapital nach Risiko strukturiert: stabilere Drawdowns, geringere Abhängigkeit von einer einzigen Asset-Klasse, sauberere Diversifikation. Die Idee ist alt, die saubere mathematische Formulierung verhältnismäßig jung — und in Python heute in wenigen Zeilen umsetzbar.

Die mathematische Grundlage.

Sei w der Vektor der Portfoliogewichte und Σ die Kovarianzmatrix der Renditen. Die Portfoliovolatilität ist σ_p = √(wᵀ Σ w). Der marginale Risikobeitrag eines Assets i ist die partielle Ableitung dieser Volatilität nach w_i:

MRC_i = (Σw)_i / σ_p

Der absolute Risikobeitrag ist RC_i = w_i · MRC_i, und es gilt Σ RC_i = σ_p. Bei einem Risk-Parity-Portfolio fordern Sie: RC_i = σ_p / N für alle i. Jedes Asset trägt exakt den gleichen Anteil zum Gesamtrisiko bei.

Das ist keine geschlossene Lösung wie bei Mean-Variance. Sie müssen ein nichtlineares Optimierungsproblem lösen — typischerweise mit einem iterativen Verfahren oder einem SLSQP-Optimizer.

Implementierung in Python.

Die folgende Funktion löst das Risk-Parity-Problem für eine beliebige Kovarianzmatrix. Verwendet wird scipy.optimize.minimize mit einer quadratischen Zielfunktion, die die Abweichung zwischen den Risikobeiträgen minimiert.

import numpy as np
from scipy.optimize import minimize

def risk_contributions(weights, cov):
    weights = np.asarray(weights)
    port_var = weights @ cov @ weights
    marginal = cov @ weights
    rc = weights * marginal / np.sqrt(port_var)
    return rc

def risk_parity_objective(weights, cov):
    rc = risk_contributions(weights, cov)
    target = rc.mean()
    return np.sum((rc - target) ** 2)

def solve_risk_parity(cov):
    n = cov.shape[0]
    x0 = np.ones(n) / n
    constraints = [{'type': 'eq', 'fun': lambda w: np.sum(w) - 1}]
    bounds = [(1e-6, 1.0) for _ in range(n)]
    result = minimize(
        risk_parity_objective, x0, args=(cov,),
        method='SLSQP', bounds=bounds, constraints=constraints,
        options={'ftol': 1e-12, 'maxiter': 500}
    )
    return result.x

Wichtig ist die Wahl der Startwerte. Bei stark unterschiedlichen Volatilitäten funktioniert eine inverse-Volatility-Initialisierung deutlich besser als Gleichgewichtung — der Optimierer findet schneller das Minimum und stürzt seltener in lokale Lösungen.

Die Kovarianzmatrix ist der eigentliche Hebel.

Die naive Schätzung der Kovarianz über einen rollierenden Sample-Estimator führt regelmäßig zu instabilen Portfolios. Die Eigenwerte der empirischen Matrix sind verrauscht, vor allem bei kurzen Stichproben und vielen Assets. Drei Verbesserungen, die in der Praxis erheblich helfen:

• Ledoit-Wolf-Shrinkage: zieht die empirische Matrix in Richtung einer strukturierten Ziel-Matrix (z. B. konstante Korrelation). Reduziert Schätzfehler ohne dass Sie selbst Hyperparameter tunen müssen.
• Exponentiell gewichtete Kovarianz: ältere Beobachtungen bekommen weniger Gewicht. Hilft bei Regime-Wechseln, kostet aber Stabilität.
• Faktor-basierte Modelle: anstatt N×N Parameter zu schätzen, modellieren Sie wenige systematische Faktoren plus idiosynkratisches Rauschen.

Für ein Multi-Asset-Risk-Parity-Portfolio mit 8 bis 12 Positionen reicht in der Regel Ledoit-Wolf auf Tagesrenditen aus einem 3- bis 5-Jahres-Fenster.

Hebel: das ungelöste Problem.

Risk Parity hat einen Haken, den viele Anbieter unter den Tisch kehren. Wenn jedes Asset gleich viel Risiko beitragen soll, bekommen volatile Anlagen wie Aktien kleine Gewichte und ruhige Anlagen wie Staatsanleihen große. Die Portfoliovolatilität sinkt entsprechend — und damit auch die erwartete Rendite. Um auf das Renditeniveau eines Aktien-Portfolios zu kommen, brauchen Sie Hebel.

Ein typisches Risk-Parity-Portfolio aus Aktien, Anleihen, Rohstoffen und Inflations-Linkers hat ohne Hebel eine Sharpe-Ratio von vielleicht 0,7 bis 0,9 — bei einer Volatilität von 6 bis 8 %. Soll das Portfolio 12 % Volatilität haben, muss es mit Faktor 1,5 bis 2 gehebelt werden. Das ist nicht trivial: Sie brauchen Finanzierungs-Linien, Sie tragen das Risiko von Margin-Calls, und in Liquiditätskrisen werden Hebelpositionen häufig zwangsweise reduziert — exakt im schlechtesten Moment.

Backtest-Vergleich: 60/40 vs. Risk Parity.

Ein einfacher historischer Vergleich auf vier Asset-Klassen (S&P 500, US Treasuries 10y, Gold, REITs) zeigt das typische Muster. Hier eine kompakte Auswertung über monatliche Renditen:

import pandas as pd
import numpy as np

def rolling_risk_parity(returns, lookback=252, rebalance=21):
    weights_history = []
    dates = []
    for t in range(lookback, len(returns), rebalance):
        window = returns.iloc[t - lookback:t]
        cov = window.cov().values * 252  # annualisiert
        w = solve_risk_parity(cov)
        weights_history.append(w)
        dates.append(returns.index[t])
    return pd.DataFrame(weights_history, index=dates, columns=returns.columns)

def evaluate(weights, returns):
    aligned = weights.reindex(returns.index, method='ffill').fillna(0)
    port_ret = (aligned.shift(1) * returns).sum(axis=1)
    sharpe = port_ret.mean() / port_ret.std() * np.sqrt(252)
    max_dd = (port_ret.add(1).cumprod() / port_ret.add(1).cumprod().cummax() - 1).min()
    return {'sharpe': sharpe, 'max_dd': max_dd, 'vol': port_ret.std() * np.sqrt(252)}

In typischen Backtests über 20 Jahre liefert das ungehebelte Risk-Parity-Portfolio einen Sharpe von 0,8 bis 0,9 gegenüber 0,55 bis 0,7 für 60/40 — bei deutlich geringeren Drawdowns. Mit Hebel auf gleiche Vola steigt die annualisierte Rendite entsprechend, der Sharpe bleibt erhalten, die Tail-Risiken nehmen zu.

Wann Risk Parity scheitert.

Drei Szenarien, in denen die Methode strukturell unter Druck gerät:

• Korrelations-Breakdown: Wenn Aktien und Anleihen gleichzeitig fallen — 2022 war ein Lehrbuchbeispiel — verliert Risk Parity seinen wichtigsten Diversifikationskanal. Das gehebelte Portfolio verliert dann überdurchschnittlich.
• Steigende Zinsen aus niedrigem Niveau: Anleihen liefern keinen Puffer mehr, sondern werden zur Verlustquelle. Die niedrige Vola der Anleihen, auf der die Allokation aufbaut, ist trügerisch.
• Liquiditätskrisen: Hebel-Positionen werden zwangsabgebaut, oft am Tief.

Praxistauglich machen: drei Regeln.

Erstens: Bauen Sie mindestens drei Asset-Klassen mit fundamental unterschiedlichen Wirtschaftssensitivitäten ein — Wachstum, Inflation, Zins. Nur dann funktioniert die Diversifikation auch im Regimewechsel.

Zweitens: Setzen Sie ein hartes Vola-Ziel und passen Sie den Hebel laufend an. Eine statische 1,5-Hebelung über alle Marktphasen hinweg ist gefährlich. Steigt die realisierte Volatilität, muss der Hebel zurückgenommen werden.

Drittens: Rebalancieren Sie nicht zu häufig. Tägliches Rebalancing erzeugt Transaktionskosten ohne Mehrwert. Monatlich oder bei größeren Abweichungen reicht. Ein Drift-Trigger von 20 % auf die einzelnen Risikobeiträge funktioniert in der Praxis besser als ein fester Kalender.

Sie wollen ein Risk-Parity-Portfolio aufsetzen oder ein bestehendes Setup prüfen lassen? Erstgespräch buchen — wir bauen die Allokation mit Ihnen, inklusive Risikomodell und Rebalancing-Logik.