Was ist das Black-Scholes-Modell?
Das Black-Scholes-Modell ist das wichtigste Modell in der Finanzwirtschaft, um Optionspreise zu berechnen.
Wir verwenden es, um den Ölpreis (z. B. Brent-Oil) als stochastischen Prozess zu modellieren und dann eine Option (z. B. „Kauf einer Öl-Option“) zu bewerten.
Was ist die geometrische Brownian-Motion (GBM)?
Die geometrische Brownian-Motion (GBM) beschreibt, wie ein Ölpreis im Laufe der Zeit zufällig wächst – ein realistischer Ansatz für Finanzmärkte.
dS(t) = μS(t)dt + σS(t)dW(t)
- S(t): Ölpreis zum Zeitpunkt t
- μ: durchschnittliche Wachstumsrate (z. B. 0.01 = 1% pro Monat)
- σ: Volatilität (z. B. 0.2 = 20% pro Monat)
- dW(t): Zufallsweg (Wiener-Prozess)
Die GBM ist ein stochastischer Prozess, der den zufälligen Charakter von Märkten widerspiegelt.
Warum ist das ein stochastischer Prozess?
Der Ölpreis folgt der GBM → ein stochastischer Prozess.
Die Option hängt von dieser zufälligen Entwicklung ab. Es gibt keine exakte Vorhersage – nur erwartete Preise mit Wahrscheinlichkeiten.
Beispiel: Ein Ölpreis kann steigen oder fallen – das Modell zeigt nur die erwartete Entwicklung unter Berücksichtigung von Risiken.
Python-Code: Black-Scholes-Modell für Ölpreis (Brent-Oil)
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm
import datetime
# ----------------------------------------
# Parameter für das Modell
# ----------------------------------------
S0 = 85.0 # Startpreis (in USD/barrel) – z. B. Brent-Oil
K = 80.0 # Ausübungspreis (z. B. 80€/Barrel)
T = 1.0 # Zeit bis Ausübung (in Jahren) – z. B. 1 Jahr
r = 0.02 # Zinssatz (2% pro Jahr)
sigma = 0.20 # Volatilität (20% pro Jahr) – typisch für Öl
# ----------------------------------------
# Funktion: Black-Scholes-Call-Option
# ----------------------------------------
def black_scholes_call(S0, K, T, r, sigma):
d1 = (np.log(S0 / K) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
# Optionsscheinpreis
C = S0 * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
return C
# ----------------------------------------
# Simuliere den Ölpreis über Zeit (mit GBM)
# ----------------------------------------
n_days = 252 # 1 Jahr (252 Trading-Tage)
dt = 1 / 252
time = np.arange(0, T + 0.01, dt)
# Simuliere den Preis mit GBM (zufällige Entwicklung)
np.random.seed(42)
S = [S0]
for i in range(1, n_days):
# GBM-Schritt: Zufallsweg
dz = np.random.normal(0, sigma * np.sqrt(dt))
S_next = S[-1] * np.exp((r - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * dz)
S.append(S_next)
# ----------------------------------------
# Berechne Optionsscheinpreis (Black-Scholes)
# ----------------------------------------
option_price = black_scholes_call(S0, K, T, r, sigma)
# ----------------------------------------
# Visualisierung
# ----------------------------------------
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 7))
# Ax1: Ölpreis über Zeit (GBM-Simulation)
ax1.plot(time, S, marker='o', linestyle='-', color='blue', linewidth=2, markersize=4)
ax1.axhline(y=S0, color='red', linestyle='--', alpha=0.7, label="Startpreis (85€)")
ax1.axhline(y=K, color='orange', linestyle='--', alpha=0.7, label="Ausübungspreis (80€)")
ax1.set_title("Ölpreis (Brent-Oil) über Zeit (GBM-Simulation)")
ax1.set_xlabel("Zeit (in Jahren)")
ax1.set_ylabel("Preis (USD/barrel)")
ax1.grid(True, alpha=0.3)
ax1.legend()
ax1.set_ylim(60, 110)
# Ax2: Black-Scholes-Optionsscheinpreis
ax2.text(0.5, 0.5,
f"Call-Optionsscheinpreis:\n{option_price:.2f} €/Barrel\n\n"
f"Preis: {S0:.1f}€ → Ausübungspreis: {K:.1f}€\n"
f"Zinssatz: {r*100:.1f}%\n"
f"Volatilität: {sigma*100:.1f}%\n"
f"Zeit: {T:.1f} Jahre",
fontsize=12, ha='center', va='center',
bbox=dict(boxstyle="round", facecolor="lightblue", alpha=0.9))
ax2.set_title("Black-Scholes-Modell: Call-Option für Ölpreis")
ax2.axis('off') # Keine Achsen
plt.tight_layout()
plt.show()
# Ausgabe: Ergebnisse
print("=" * 60)
print("BLACK-SCHOLES-ÖL-OPTIONSSCHEIN (BRENT-OIL)")
print("=" * 60)
print(f"Startpreis (S₀): {S0:.1f} €/Barrel")
print(f"Ausübungspreis (K): {K:.1f} €/Barrel")
print(f"Zinssatz (r): {r*100:.1f}% pro Jahr")
print(f"Volatilität (σ): {sigma*100:.1f}% pro Jahr")
print(f"Zeit bis Ausübung (T): {T:.1f} Jahr")
print(f"Call-Optionsscheinpreis: {option_price:.2f} €/Barrel")
print(f"Erwartete Preisentwicklung: {np.mean(S):.1f} € → {np.max(S):.1f} € (Max)")
print(f"Erwartete Mindestpreis: {np.min(S):.1f} €")
Fazit: Mit diesem Python-Code hast du das Fundament eines echten finanzmathematischen Modells gelernt – mit stochastischen Prozessen (GBM) und einem realitätsnahen Finanzinstrument (Call-Option).
Das ist genau das, was moderne Finanzanalysten und Unternehmen nutzen – um zufällige, komplexe Märkte zu modellieren.