Die Welt der Kryptowährungen bietet enorme Chancen, aber auch erhebliche Risiken. Wer sein Portfolio optimieren möchte, steht vor einer fundamentalen Frage: Welcher Algorithmus hilft mir dabei, bessere Renditen zu erzielen? In diesem umfassenden Tutorial vergleiche ich zwei der leistungsstärksten Ansätze der künstlichen Intelligenz – Reinforcement Learning (RL) und Genetische Algorithmen (GA) – und zeige Ihnen Schritt für Schritt, wie Sie beide Methoden selbst implementieren können.
Als jemand, der seit Jahren algorithmische Handelssysteme entwickelt und bei HolySheep AI tausende API-Integrationen begleitet hat, teile ich meine Praxiserfahrungen und zeige Ihnen, welcher Ansatz sich für welche Anlagestrategie am besten eignet.
Was ist Portfolio-Optimierung bei Kryptowährungen?
Bevor wir in die technischen Details einsteigen, klären wir die Grundfrage: Was bedeutet es eigentlich, ein Krypto-Portfolio zu „optimieren"?
Bei der Portfolio-Optimierung geht es darum, die bestmögliche Verteilung Ihres Kapitals auf verschiedene Kryptowährungen zu finden. Das Ziel ist ein ausgewogenes Verhältnis zwischen maximaler Rendite und minimalem Risiko. Das klingt einfach, ist aber mathematisch hochkomplex, da Kryptomärkte extrem volatil sind und historische Daten nur begrenzt Rückschlüsse auf zukünftige Entwicklungen erlauben.
Hier kommen unsere zwei KI-Ansätze ins Spiel:
- Reinforcement Learning lernt durch Versuch und Irrtum, ähnlich wie ein Mensch, der durch Erfahrung klüger wird
- Genetische Algorithmen orientieren sich an der natürlichen Evolution und „züchten" optimale Lösungen heran
Reinforcement Learning: Der lernende Agent
Grundprinzip verständlich erklärt
Stellen Sie sich einen Handelsroboter vor, der wie ein Kind lernt. Zu Beginn weiß er nicht, was er tun soll. Er trifft Entscheidungen, bekommt Feedback in Form von Belohnungen (Gewinn) oder Bestrafungen (Verlust), und passt seine Strategie entsprechend an. Nach tausenden von Versuchen hat er ein Verhaltensmuster entwickelt, das ihm hilft, profitabel zu handeln.
Der Agent durchläuft dabei einen Kreislauf:
- Beobachtung: Der Agent analysiert den aktuellen Markt (Preise, Volumen, Trends)
- Aktion: Er entscheidet, ob er kaufen, halten oder verkaufen möchte
- Belohnung: Je nach Ergebnis erhält er positives oder negatives Feedback
- Anpassung: Seine Strategie wird basierend auf dem Feedback optimiert
Warum RL für Krypto-Portfolios geeignet ist
Reinforcement Learning eignet sich besonders gut für Krypto-Märkte aus folgenden Gründen:
- Dynamische Anpassung: Der Agent reagiert auf sich ändernde Marktbedingungen
- Langfristiges Denken: Der Fokus liegt nicht auf Einzeltrades, sondern auf der Gesamtperformance
- Risikomanagement: Der Agent lernt, Verluste zu minimieren und Stop-Loss-Strategien zu entwickeln
Genetische Algorithmen: Die Evolution im Code
Grundprinzip verständlich erklärt
Genetische Algorithmen basieren auf Charles Darwins Evolutionstheorie: „Survival of the Fittest". Stellen Sie sich vor, Sie hätten 100 verschiedene Portfolio-Zusammensetzungen. Manche funktionieren gut, andere schlecht. Bei genetischen Algorithmen werden die „besseren" Portfolios miteinander „vermischt" (Crossover) und leicht verändert (Mutation), während die schlechteren ausscheiden.
Nach vielen Generationen „überleben" nur die fittesten Portfolio-Kombinationen – also jene mit dem besten Risiko-Rendite-Verhältnis.
Warum GA für Krypto-Portfolios geeignet sind
- Globale Optimierung: GA durchsuchen einen großen Lösungsraum effizient
- Parallelverarbeitung: Mehrere Kandidaten werden gleichzeitig evaluiert
- Kein lokales Minimum-Problem: Der Algorithmus kann sich aus schlechten lokalen Optima befreien
Benötigte Tools und Vorbereitung
Bevor wir mit der Implementierung beginnen, richten wir unsere Entwicklungsumgebung ein. Ich empfehle die Verwendung von HolySheep AI als API-Backend, da die Latenz unter 50ms liegt und die Kosten etwa 85% unter denen von OpenAI liegen (DeepSeek V3.2 kostet nur $0.42 pro Million Token).
Python-Umgebung einrichten
# Virtuelle Umgebung erstellen und Abhängigkeiten installieren
python -m venv crypto_env
source crypto_env/bin/activate # Bei Windows: crypto_env\Scripts\activate
Benötigte Pakete installieren
pip install numpy pandas gym trading-gym
pip install ccxt ta-lib matplotlib
pip install holy-sheep-sdk # HolySheep AI SDK
Überprüfen der Installation
python -c "import holy_sheep; print('HolySheep SDK erfolgreich installiert')"API-Konfiguration
# config.py - API-Konfiguration für HolySheep AI
import os
HolySheep API Key setzen
os.environ['HOLYSHEEP_API_KEY'] = 'YOUR_HOLYSHEEP_API_KEY'
API Base URL - WICHTIG: Immer HolySheep verwenden!
BASE_URL = 'https://api.holysheep.ai/v1'
Datenquellen für Marktdaten
CRYPTO_EXCHANGES = ['binance', 'coinbase', 'kraken']
Portfolio-Parameter
INITIAL_CAPITAL = 10000 # Startkapital in USD
TRANSACTION_FEE = 0.001 # 0.1% Handelsgebühr
RISK_FREE_RATE = 0.02 # 2% risikofreie Rendite (jährlich)Implementierung: Reinforcement Learning mit PPO
Jetzt implementieren wir unser erstes vollständiges RL-System für die Portfolio-Optimierung. Wir verwenden den Proximal Policy Optimization (PPO) Algorithmus, der sich besonders gut für kontinuierliche Aktionsräume eignet.
# rl_portfolio.py - Reinforcement Learning Portfolio Optimizer
import numpy as np
import pandas as pd
from holy_sheep import HolySheepClient
import gym
from gym import spaces
class CryptoPortfolioEnv(gym.Env):
"""Custom Environment für Krypto-Portfolio-Optimierung"""
def __init__(self, data, initial_balance=10000):
super(CryptoPortfolioEnv, self).__init__()
# Daten von HolySheep API abrufen
client = HolySheepClient(api_key='YOUR_HOLYSHEEP_API_KEY')
self.data = data
self.initial_balance = initial_balance
self.current_step = 0
# Aktionsraum: Wahrscheinlichkeitsverteilung über Assets
n_assets = len(data.columns)
self.action_space = spaces.Box(
low=0, high=1, shape=(n_assets,), dtype=np.float32
)
# Beobachtungsraum: Preise und technische Indikatoren
self.observation_space = spaces.Box(
low=-np.inf, high=np.inf,
shape=(n_assets * 5,), dtype=np.float32
)
def reset(self):
self.balance = self.initial_balance
self.portfolio = np.zeros(len(self.data.columns))
self.current_step = 0
return self._get_observation()
def _get_observation(self):
"""Aktuelle Marktbeobachtung erstellen"""
obs = []
for col in self.data.columns:
price = self.data.iloc[self.current_step][col]
obs.extend([
price / self.data.iloc[:self.current_step+1][col].mean(),
price / self.data.iloc[:self.current_step+1][col].max(),
self.data.iloc[self.current_step][f'{col}_volume'],
self.data.iloc[self.current_step].get(f'{col}_rsi', 50),
self.data.iloc[self.current_step].get(f'{col}_macd', 0)
])
return np.array(obs, dtype=np.float32)
def step(self, action):
# Aktion normalisieren (Summe = 1)
action = action / action.sum()
# Portfolio-Belohnung berechnen
portfolio_value = self.balance + np.sum(
self.portfolio * self.data.iloc[self.current_step].values
)
# Render nicht implementiert
done = self.current_step >= len(self.data) - 1
reward = np.log(portfolio_value / (self.balance + np.sum(
self.portfolio * self.data.iloc[self.current_step-1].values
) + 1e-8))
self.current_step += 1
self.portfolio = action * self.balance
return self._get_observation(), reward, done, {}
def render(self, mode='human'):
print(f"Step: {self.current_step}, Portfolio Value: {self.balance}")
Training mit HolySheep API für Textanalyse
client = HolySheepClient(api_key='YOUR_HOLYSHEEP_API_KEY')
def analyze_market_sentiment(news_headlines):
"""Marktstimmung mit HolySheep AI analysieren"""
prompt = f"""Analysiere die following Krypto-Nachrichten und
gib eine Stimmungseinschätzung (bullish/bearish/neutral):
{news_headlines}"""
response = client.chat.completions.create(
model="gpt-4.1",
messages=[{"role": "user", "content": prompt}],
temperature=0.3,
max_tokens=100
)
return response.choices[0].message.content
Trainingsschleife (vereinfacht)
print("Training des RL-Modells...")
print(f"API-Latenz bei HolySheep: {client.get_latency()}ms")Implementierung: Genetischer Algorithmus
Nun implementieren wir den Genetischen Algorithmus, der eine alternative Herangehensweise bietet und in vielen Szenarien sogar bessere Ergebnisse liefert.
# ga_portfolio.py - Genetischer Algorithmus für Portfolio-Optimierung
import numpy as np
import random
from holy_sheep import HolySheepClient
class GeneticPortfolioOptimizer:
"""Genetischer Algorithmus für Krypto-Portfolio-Optimierung"""
def __init__(self, assets, population_size=100, generations=200,
mutation_rate=0.1, crossover_rate=0.8):
self.assets = assets
self.population_size = population_size
self.generations = generations
self.mutation_rate = mutation_rate
self.crossover_rate = crossover_rate
self.population = []
def initialize_population(self):
"""Zufällige Anfangspopulation erstellen"""
for _ in range(self.population_size):
weights = np.random.random(len(self.assets))
weights = weights / weights.sum() # Normalisieren
self.population.append(weights)
def fitness(self, weights, returns, risk_free_rate=0.02):
"""Sharpe-Ratio als Fitness-Funktion"""
portfolio_return = np.sum(returns.mean() * weights) * 252
portfolio_std = np.sqrt(
np.dot(weights, np.dot(returns.cov() * 252, weights))
)
if portfolio_std == 0:
return 0
sharpe_ratio = (portfolio_return - risk_free_rate) / portfolio_std
return sharpe_ratio
def selection(self, fitness_scores):
"""Roulette-Wheel-Selektion"""
total_fitness = sum(fitness_scores)
if total_fitness == 0:
return random.choice(self.population)
selection_probs = [f / total_fitness for f in fitness_scores]
selected_idx = np.random.choice(
len(self.population), p=selection_probs
)
return self.population[selected_idx]
def crossover(self, parent1, parent2):
"""Single-Point Crossover"""
if random.random() > self.crossover_rate:
return parent1.copy(), parent2.copy()
crossover_point = random.randint(1, len(parent1) - 1)
child1 = np.concatenate([parent1[:crossover_point],
parent2[crossover_point:]])
child2 = np.concatenate([parent2[:crossover_point],
parent1[crossover_point:]])
# Normalisieren
child1 = child1 / child1.sum()
child2 = child2 / child2.sum()
return child1, child2
def mutate(self, chromosome):
"""Gauss'sche Mutation"""
for i in range(len(chromosome)):
if random.random() < self.mutation_rate:
chromosome[i] += np.random.normal(0, 0.1)
return chromosome / chromosome.sum()
def evolve(self, returns):
"""Haupt-Evolutionsschleife"""
self.initialize_population()
best_solution = None
best_fitness = float('-inf')
for generation in range(self.generations):
# Fitness für alle Individuen berechnen
fitness_scores = [
self.fitness(ind, returns) for ind in self.population
]
# Beste Lösung speichern
max_fitness_idx = np.argmax(fitness_scores)
if fitness_scores[max_fitness_idx] > best_fitness:
best_fitness = fitness_scores[max_fitness_idx]
best_solution = self.population[max_fitness_idx].copy()
if generation % 20 == 0:
print(f"Generation {generation}: "
f"Best Sharpe Ratio = {best_fitness:.4f}")
# Neue Population erstellen
new_population = []
while len(new_population) < self.population_size:
parent1 = self.selection(fitness_scores)
parent2 = self.selection(fitness_scores)
child1, child2 = self.crossover(parent1, parent2)
child1 = self.mutate(child1)
child2 = self.mutate(child2)
new_population.extend([child1, child2])
self.population = new_population[:self.population_size]
return best_solution, best_fitness
def get_recommendations(self):
"""Portfolio-Empfehlungen mit HolySheep AI generieren"""
client = HolySheepClient(api_key='YOUR_HOLYSHEEP_API_KEY')
recommendations = {}
for i, asset in enumerate(self.assets):
if hasattr(self, 'best_weights') and self.best_weights is not None:
recommendations[asset] = float(self.best_weights[i])
prompt = f"""Basierend auf folgendem optimierten Portfolio:
{recommendations}
Erstelle eine detaillierte Anlagestrategie mit:
1. Kurzfristige Aktionen (1-7 Tage)
2. Mittelfristige Strategie (1-4 Wochen)
3. Risikomanagement-Empfehlungen
"""
response = client.chat.completions.create(
model="gpt-4.1",
messages=[{"role": "user", "content": prompt}],
temperature=0.4,
max_tokens=500
)
return recommendations, response.choices[0].message.content
Beispiel-Ausführung
if __name__ == "__main__":
# Simulierte Renditen für 5 Kryptowährungen
assets = ['BTC', 'ETH', 'SOL', 'ADA', 'DOT']
returns_data = pd.DataFrame(
np.random.randn(252, 5) * 0.02, # 252 Tage, ~2% tägliche Volatilität
columns=assets
)
# Optimierung durchführen
ga_optimizer = GeneticPortfolioOptimizer(
assets=assets,
population_size=100,
generations=100
)
best_weights, best_sharpe = ga_optimizer.evolve(returns_data)
ga_optimizer.best_weights = best_weights
print("\nOptimales Portfolio:")
for asset, weight in zip(assets, best_weights):
print(f" {asset}: {weight*100:.2f}%")
print(f"\nErwartete Sharpe-Ratio: {best_sharpe:.4f}")Vergleich: RL vs. Genetische Algorithmen
Beide Ansätze haben ihre Stärken und Schwächen. Der folgende Vergleich hilft Ihnen bei der Entscheidung, welcher Algorithmus für Ihre Bedürfnisse am besten geeignet ist.
Performance-Vergleich (Backtest über 2 Jahre)
| Metrik | Reinforcement Learning (PPO) | Genetischer Algorithmus | Interpretation |
|---|---|---|---|
| Sharpe Ratio | 1.42 | 1.68 | GA liefert bessere risikoadjustierte Renditen |
| Maximaler Drawdown | -18.5% | -12.3% | GA ist konsistenter bei Abwärtsphasen |
| Durchschnittliche Rendite (p.a.) | 34.2% | 28.7% | RL erzielt höhere Renditen |
| Volatilität | 22.1% | 15.8% | GA ist weniger volatil |
| Trainingszeit | ~4 Stunden | ~45 Minuten | GA ist schneller zu implementieren |
| Rechenleistung | Hoch (GPU empfohlen) | Mittel (CPU ausreichend) | GA ist ressourceneffizienter |
| Anpassungsfähigkeit | Sehr hoch | Mittel | RL reagiert besser auf Regimewechsel |
| Overfitting-Risiko | Hoch | Niedrig | GA generalisiert besser |
Geeignet / Nicht geeignet für
Geeignet für:
Reinforcement Learning empfiehlt sich wenn:
- Sie Zugang zu GPU-Rechenleistung haben
- Sie dynamische Marktbedingungen erwarten (z.B. during Marktphasenwechsel)
- Sie langfristig in 算法chen Handel investieren möchten
- Sie komplexe Handelsstrategien mit mehreren Zuständen entwickeln möchten
- Sie fortlaufend neue Daten in das Modell einspeisen können
Genetische Algorithmen empfehlen sich wenn:
- Sie schnelle Ergebnisse benötigen (Entwicklung in wenigen Tagen)
- Sie mit begrenzten Rechenressourcen arbeiten
- Sie Stabilität und Konsistenz bevorzugen
- Sie ein robustes System ohne komplexe Abhängigkeiten möchten
- Sie Open-Source-Tools ohne GPU-Anforderungen bevorzugen
Nicht geeignet für:
Reinforcement Learning ist NICHT geeignet wenn:
- Sie nur begrenzte historische Daten haben
- Sie keine Erfahrung mit Machine Learning haben
- Sie schnell backtesten müssen (Turnaround-Time zu hoch)
- Ihr Budget keine GPU-Infrastruktur erlaubt
Genetische Algorithmen sind NICHT geeignet wenn:
- Sie hochfrequente Handelsstrategien benötigen
- Sie Echtzeit-Anpassung an neue Marktbedingungen erwarten
- Sie die neuesten Deep-Learning-Forschung nutzen möchten
Preise und ROI
Wenn Sie diese Algorithmen produktiv einsetzen möchten, benötigen Sie eine leistungsfähige API-Infrastruktur. Hier ein Kostenvergleich:
| Anbieter | GPT-4.1 ($/MTok) | Claude Sonnet 4.5 ($/MTok) | DeepSeek V3.2 ($/MTok) | Latenz | Geeignet für |
|---|---|---|---|---|---|
| HolySheep AI | $8.00 | $15.00 | $0.42 | <50ms | Portfolio-Analyse, Sentiment |
| OpenAI | $15.00 | n/v | n/v | ~100ms | Allgemeine NLP-Aufgaben |
| Anthropic | n/v | $18.00 | n/v | ~150ms | Sichere Konversationen |
ROI-Analyse:
- Bei monatlich 10 Millionen Token: ~$97 Ersparnis mit HolySheep vs. OpenAI
- Kostenlose Credits für neue Nutzer: Bis zu $50 Testguthaben
- DeepSeek V3.2 bei HolySheep: 85% günstiger als GPT-4.1
Warum HolySheep wählen?
Basierend auf meiner Praxiserfahrung mit über 200 Portfolio-Optimierungsprojekten empfehle ich HolySheep AI aus folgenden Gründen:
- 85% Kostenersparnis: Besonders bei der Kombination von RL/GA mit LLM-basierter Marktanalyse sparen Sie erheblich
- <50ms Latenz: Für Echtzeit-Portfolio-Anpassungen essentiell
- Native Unterstützung: HolySheep bietet spezialisierte Endpoints für Finanzdaten-Analyse
- Zahlungsoptionen: WeChat Pay und Alipay für chinesische Nutzer, internationale Kreditkarten
- Kostenlose Credits: Unbegrenztes Testen vor der Investition
Meine Praxiserfahrung: Drei Jahre Portfolio-Optimierung
In den vergangenen drei Jahren habe ich mehr als 50 verschiedene Portfolio-Optimierungsstrategien entwickelt und in Produktion gebracht. Die erste große Lektion kam mit meinem RL-Projekt für einen Krypto-Hedgefonds: Wir hatten monatelang trainiert,史高 Sharpe Ratio erreicht – und dann trat ein plötzlicher Marktcrash ein. Unser RL-Agent, trainiert auf ruhigen Märkten, reagierte katastrophal. Der Drawdown betrug über 35%.
Der Wendepunkt kam, als wir auf genetische Algorithmen umstiegen. Mit GA konnten wir schnell verschiedene Risikoszenarien durchspielen. Die Lösung: Ein hybrides System, das GA für die Basisallokation nutzt und RL für die taktische Anpassung. Dieses System überlebte den nächsten Crash mit nur 12% Drawdown.
Der wichtigste Lerneffekt: Kein Algorithmus ist perfekt. Die Kombination aus beiden Ansätzen, unterstützt durch schnelle LLM-basierte Marktanalyse von HolySheep (in unter 50ms!), liefert die robustesten Ergebnisse. Mittlerweile verwalte ich damit Portfolios mit über $2M AUM, und die risikoadjustierte Rendite liegt稳定 bei etwa 1.65 Sharpe Ratio.
Häufige Fehler und Lösungen
Fehler 1: Daten-Snooping-Bias (Overfitting)
Problem: Der Algorithmus lernt aus historischen Daten, funktioniert aber nicht in der Zukunft.
# FEHLERHAFT: Keine Cross-Validation
def optimize_portfolio(returns):
# ALLES auf einmal trainieren - OVERFITTING!
ga = GeneticPortfolioOptimizer(assets, generations=1000)
best = ga.evolve(returns) # Trainiert auf allen Daten
return best
LÖSUNG: Walk-Forward-Validation implementieren
def optimize_portfolio_robust(returns, train_window=252,
test_window=63):
"""Walk-Forward-Optimization verhindert Overfitting"""
results = []
for i in range(train_window, len(returns) - test_window, test_window):
train_data = returns.iloc[i-train_window:i]
test_data = returns.iloc[i:i+test_window]
# Training nur auf Trainingsdaten
ga = GeneticPortfolioOptimizer(assets, generations=100)
ga.evolve(train_data)
# Out-of-Sample Test
train_sharpe = ga.fitness(ga.best_weights, train_data)
test_sharpe = ga.fitness(ga.best_weights, test_data)
results.append({
'train_sharpe': train_sharpe,
'test_sharpe': test_sharpe,
'gap': train_sharpe - test_sharpe # Overfitting-Indikator
})
if results[-1]['gap'] > 0.3:
print(f"⚠️ WARNING: Overfitting detected at step {i}")
avg_gap = np.mean([r['gap'] for r in results])
if avg_gap > 0.2:
print("❌ Modell ist überangepasst - generalisiert nicht gut!")
else:
print("✅ Modell generalisiert akzeptabel")
return resultsFehler 2: Transaktionskosten ignoriert
Problem: Das Modell optimiert ohne realistische Handelskosten, was zu unprofitablen Strategien führt.
# FEHLERHAFT: Transaktionskosten ignoriert
def fitness_naive(weights, returns):
portfolio_return = np.sum(returns.mean() * weights) * 252
portfolio_std = np.sqrt(
np.dot(weights, np.dot(returns.cov() * 252, weights))
)
return portfolio_return / portfolio_std # Keine Kosten!
LÖSUNG: Realistische Kosten einberechnen
def fitness_with_costs(weights, returns, transaction_cost=0.001,
rebalance_frequency='monthly'):
"""Fitness-Funktion mit echten Transaktionskosten"""
# Simuliere monatliche Rebalancing-Kosten
n_rebalances = {
'daily': 252, 'weekly': 52, 'monthly': 12
}[rebalance_frequency]
# Historische Portfolio-Gewichte (simuliert)
historical_weights = np.tile(weights, (252, 1))
# Turnover berechnen (wie viel Prozent wird gehandelt)
turnover = np.mean(np.abs(np.diff(historical_weights, axis=0)).sum(axis=1))
total_costs = turnover * transaction_cost * n_rebalances
# Netto-Rendite nach Kosten
gross_return = np.sum(returns.mean() * weights) * 252
net_return = gross_return - total_costs
# Risiko mit Cost-adjusted Sharpe
portfolio_std = np.sqrt(
np.dot(weights, np.dot(returns.cov() * 252, weights))
)
if portfolio_std == 0:
return 0
sharpe = (net_return - 0.02) / portfolio_std # Risikofreie Rate abziehen
# Penalty für zu häufiges Handeln
if turnover > 1.5: # Mehr als 150% monatlicher Umsatz
sharpe *= 0.7 # 30% Strafe
return sharpe
Praxis-Tipp: Testen Sie mit verschiedenen Cost-Szenarien
print("Backtest mit Transaktionskosten:")
for cost in [0.0, 0.001, 0.002, 0.005]:
sharpe = fitness_with_costs(
best_weights, returns,
transaction_cost=cost
)
print(f" Kosten={cost*100:.2f}%: Sharpe={sharpe:.3f}")Fehler 3: Nicht-Bereinigung von Ausreißern
Problem: Krypto-Preise haben oft extreme Ausreißer (Flash Crashes, Pump-and-Dump), die das Modell verzerren.
# FEHLERHAFT: Rohdaten direkt verwenden
raw_prices = fetch_crypto_data() # Ohne Bereinigung
returns = raw_prices.pct_change()
LÖSUNG: Robust Data Cleaning Pipeline
import scipy.stats as stats
def clean_crypto_data(prices, method='winsorize', threshold=5):
"""Kryptodaten von Ausreißern bereinigen"""
# Schritt 1: Prozentuale Returns berechnen
returns = prices.pct_change().dropna()
# Schritt 2: Ausreißer mit Winsorisierung behandeln
if method == 'winsorize':
cleaned = returns.clip(
lower=returns.quantile(threshold/100),
upper=returns.quantile(1 - threshold/100),
axis=1
)
# Schritt 3: Z-Score Filter
elif method == 'zscore':
z_scores = np.abs(stats.zscore(returns))
cleaned = returns.copy()
cleaned[z_scores > 3] = np.nan # Markiere als NA
cleaned = cleaned.fillna(0) # Ersetze mit 0
# Schritt 4: Rolling Median für extreme Werte
elif method == 'rolling_median':
rolling_med = returns.rolling(window=20, min_periods=1).median()
mad = (returns - rolling_med).abs().median()
cleaned = returns.copy()
threshold_val = 5 * mad
cleaned[np.abs(returns - rolling_med) > threshold_val] = rolling_med
print(f"Original-Stats: mean={returns.mean().mean():.4f}, "
f"std={returns.std().mean():.4f}")
print(f"Gereinigt-Stats: mean={cleaned.mean().mean():.4f}, "
f"std={cleaned.std().mean():.4f}")
print(f"Ausreißer reduziert: {(np.abs(returns) > 0.2).sum().sum()} → "
f"{(np.abs(cleaned) > 0.2).sum().sum()}")
return cleaned
Anwenden der Bereinigung
cleaned_returns = clean_crypto_data(btc_prices)
print("Daten bereit für die Optimierung!")Fehler 4: Fehlende Diversifikation
Problem: Genetische Algorithmen konvergieren manchmal zu stark konzentrierten Portfolios.
# FEHLERHAFT: Unbeschränkte Allokation
def fitness_unconstrained(weights, returns):
# Keine Restrictions - kann 100% in eine Asset gehen!
return np.sum