Portfolio-Optimierung mit Marktdaten: Ein interdisziplinäres Projekt in Finanzmathematik

Einführung in die Portfolio-Optimierung mit Marktdaten

Die Optimierung von Portfolios ist ein zentrales Thema der Finanzmathematik. In diesem Tutorial zeigen wir dir, wie du mit historischen Marktdaten und statistischen Methoden optimale Anlagestrategien entwickeln kannst. Am Beispiel des interdisziplinären Projekts aus dem Kurs FMAT3888 lernst du die Schritte von der Parameterschätzung bis zur dynamischen Optimierung kennen.

Schritt 1: Parameterschätzung mit historischen Daten

Bevor du ein Portfolio optimieren kannst, musst du die Parameter schätzen, die die Renditen der Anlageklassen beschreiben. Angenommen, du hast monatliche Renditedaten für sechs Anlageklassen von Januar 2007 bis Dezember 2010 (Zeitraum A) und von Januar 2011 bis Dezember 2014 (Zeitraum B). Du nimmst an, dass die logarithmierten Renditen X_i_t = ln(1 + α_i_t) multivariat normalverteilt sind mit Mittelwertvektor a und Kovarianzmatrix B.

Um a und B zu schätzen, berechnest du den Stichprobenmittelwert und die Stichprobenkovarianzmatrix der logarithmierten monatlichen Renditen für jeden Zeitraum. In Python könntest du das so umsetzen:

import pandas as pd
import numpy as np

daten = pd.read_excel('Monatsrenditen.xlsx', index_col=0)
zeitraum_A = daten.loc['2007-01':'2010-12']
log_renditen_A = np.log(1 + zeitraum_A)
a_A = log_renditen_A.mean().values
B_A = log_renditen_A.cov().values

Wiederhole dies für Zeitraum B. Die geschätzten Parameter dienen als Grundlage für die weiteren Optimierungen.

Schritt 2: Verteilung der mehrperiodigen Renditen

Da du für die Optimierung Jahres- oder Zweijahresrenditen benötigst, musst du die Verteilung der mehrperiodigen Renditen herleiten. Wenn die monatlichen Renditen i.i.d. lognormal sind, dann ist die kumulierte Rendite über n Monate ebenfalls lognormal mit Mittelwert n*a und Kovarianzmatrix n*B. Für n=12 (Jahresrendite) oder n=24 (Zweijahresrendite) kannst du die Parameter entsprechend skalieren.

Um die Erwartungswerte und Kovarianzen der einfachen Renditen zu berechnen, verwendest du die Formeln für die Lognormalverteilung:

mu_i_k = np.exp(k * a_i + 0.5 * k * B_ii) - 1
cov_ij_k = (np.exp(k * (a_i + a_j + 0.5 * k * (B_ii + B_jj + 2*B_ij))) - np.exp(k * (a_i + a_j + 0.5 * k * (B_ii + B_jj))))

Diese Parameter benötigst du für die Portfolio-Optimierung.

Schritt 3: Statische Portfolio-Optimierung mit exponentiellem Nutzen

Bei der statischen Optimierung legst du die Gewichte für die gesamte Haltedauer fest. Der Investor maximiert den erwarteten Nutzen des Endvermögens. Bei exponentiellem Nutzen U(x) = -e^{-γx} mit γ=1 und unter der Annahme normalverteilter Renditen (Approximation) lautet das Optimierungsproblem:

Maximiere E[U(R_w)] = -exp(-γ * (w'μ - 0.5*γ*w'C w)) unter der Nebenbedingung sum(w) = 1.

Dies ist äquivalent zur Maximierung von w'μ - 0.5*γ*w'C w. Die Lösung ist der Tangentialpunkt der Kapitalmarktlinie. In Python kannst du das mit scipy.optimize lösen:

from scipy.optimize import minimize

def neg_utility(w, mu, C, gamma):
    return -(w @ mu - 0.5 * gamma * w @ C @ w)

cons = ({'type': 'eq', 'fun': lambda w: np.sum(w) - 1})
bounds = [(-1, 1) for _ in range(6)]  # Leerverkäufe erlaubt
result = minimize(neg_utility, x0=np.ones(6)/6, args=(mu, C, gamma=1),
                  constraints=cons, bounds=bounds)
opt_weights = result.x

Vergleiche die optimalen Gewichte für die beiden Zeiträume. Welche Unterschiede fallen dir auf? Oft zeigen sich in Krisenzeiten (Zeitraum A) höhere Gewichte in sicheren Anlagen wie Cash oder Anleihen.

Schritt 4: Effizienzgrenze und Minimum-Varianz-Portfolio

Die Effizienzgrenze stellt alle Portfolios dar, die bei gegebenem Risiko die maximale Rendite bieten. Du kannst sie berechnen, indem du für verschiedene Zielrenditen das Varianzminimum bestimmst:

target_returns = np.linspace(mu.min(), mu.max(), 50)
frontier_vols = []
for r in target_returns:
    cons = [{'type': 'eq', 'fun': lambda w: np.sum(w) - 1},
            {'type': 'eq', 'fun': lambda w: w @ mu - r}]
    res = minimize(lambda w: w @ C @ w, x0=np.ones(6)/6, constraints=cons)
    frontier_vols.append(np.sqrt(res.fun))

Das Minimum-Varianz-Portfolio mit einer erwarteten Rendite von mindestens 12% erhältst du, indem du die Varianz unter der Renditebedingung minimierst. Vergleiche die Ergebnisse für die beiden Zeiträume. Welches Portfolio hat das geringste Risiko? Wie unterscheiden sich die Gewichtungen?

Schritt 5: Dynamische Portfolio-Optimierung

Bei der dynamischen Optimierung kannst du die Gewichte nach dem ersten Jahr anpassen. Dies ist realistischer, da du auf neue Informationen reagieren kannst. Das Problem wird mit dynamischer Programmierung gelöst. Angenommen, du hast zwei Jahre Anlagehorizont. Im ersten Jahr wählst du Gewichte w, im zweiten Jahr u in Abhängigkeit von der erzielten Rendite im ersten Jahr.

Der erwartete Nutzen des Endvermögens ist E[U((1+ξ1'w)(1+ξ2'u)-1)]. Du löst das Problem rückwärts: Für jede mögliche Realisation von ξ1 bestimmst du das optimale u, dann das optimale w unter Berücksichtigung der zukünftigen Anpassung.

In der Praxis wird oft mit einer diskreten Zustandsraumapproximation gearbeitet. Vereinfacht kannst du annehmen, dass die Renditen im ersten Jahr nur wenige Werte annehmen (z.B. Szenarioanalyse).

Ein einfacher Ansatz: Simuliere viele Pfade für ξ1 und ξ2 und optimiere die Gewichte über alle Pfade. Dies ist rechenintensiv, aber mit Python-Bibliotheken wie numpy und scipy umsetzbar.

Fazit

Die Portfolio-Optimierung mit Marktdaten ist ein mächtiges Werkzeug, um Anlageentscheidungen zu treffen. Von der Parameterschätzung über die statische Optimierung bis zur dynamischen Anpassung – jeder Schritt erfordert ein gutes Verständnis der zugrundeliegenden Mathematik und der verwendeten Daten. Mit den gezeigten Methoden kannst du eigene Optimierungen durchführen und die Ergebnisse kritisch hinterfragen.

Denke daran: Historische Daten garantieren keine zukünftigen Renditen. Die Optimierung liefert dir jedoch eine fundierte Grundlage für deine Anlageentscheidungen.