Willkommen zu unserem umfassenden Tutorial über die Aufbereitung und Bereinigung von CSV-Daten für das Backtesting von Kryptowährungs-Strategien. In der Welt des algorithmischen Handels ist die Qualität Ihrer Eingabedaten entscheidend für den Erfolg Ihrer Strategien. Bevor wir uns den technischen Details widmen, möchten wir Ihnen zunächst einen Vergleich der verfügbaren Optionen für die Datenverarbeitung und API-Integration präsentieren.
HolySheep AI vs. Offizielle APIs vs. Andere Relay-Dienste
| Feature | HolySheep AI | Offizielle APIs | Andere Relay-Dienste |
|---|---|---|---|
| Preis pro 1M Tokens | GPT-4.1: $8 Claude Sonnet 4.5: $15 DeepSeek V3.2: $0.42 |
GPT-4.1: $30 Claude Sonnet 4.5: $45 DeepSeek V3.2: $2.80 |
$10-50+ je nach Anbieter |
| Wechselkurs | ¥1 = $1 (85%+ Ersparnis) | USD nur | Oft nur USD |
| Bezahlmethoden | WeChat, Alipay, Kreditkarte | Nur Kreditkarte | Variiert |
| Latenz | <50ms | 100-300ms | 80-200ms |
| Kostenlose Credits | Ja, bei Registrierung | Nein | Selten |
| API-Endpunkt | api.holysheep.ai/v1 | api.openai.com | Variiert |
| Deutsche Unterstützung | Ja, deutschsprachiger Support | Begrenzt | Variiert |
Geeignet / Nicht geeignet für
HolySheep AI ist besonders geeignet für:
- Kryptowährungs-Händler, die regelmäßig Backtests mit großen Datensätzen durchführen
- Entwickler von Trading-Bots, die eine kostengünstige KI-Integration benötigen
- Quantitative Analysten, die komplexe Datenanalysen in ihre Workflows integrieren möchten
- Einsteiger und Profis, die von den 85%igen Ersparnissen profitieren möchten
Weniger geeignet für:
- Projekte, die ausschließlich die offizielle OpenAI-Infrastruktur erfordern (z.B. spezifische Enterprise-Features)
- Extrem hochvolumige Anwendungen mit mehreren hundert Millionen Tokens monatlich
Preise und ROI
Die Preisgestaltung von HolySheep AI bietet einen überzeugenden Return on Investment für Kryptowährungs-Backtesting-Projekte:
- DeepSeek V3.2: $0.42 pro Million Tokens — ideal für die kontinuierliche Datenanalyse und Strategieoptimierung
- Gemini 2.5 Flash: $2.50 pro Million Tokens — ausgezeichnet für schnelle Iterationen beim Strategie-Backtesting
- GPT-4.1: $8 pro Million Tokens — für komplexe Analysen und nuancierte Marktdateninterpretation
Rechenbeispiel ROI: Wenn Sie monatlich 10 Millionen Tokens für Ihre Backtesting-Workflows verbrauchen, sparen Sie mit HolySheep gegenüber der offiziellen API bis zu $245 monatlich — das entspricht einer jährlichen Ersparnis von fast $3.000.
Warum HolySheep wählen
Als erfahrener Kryptowährungs-Analyst habe ich im Laufe der Jahre zahlreiche API-Dienste und Datenverarbeitungstools getestet. HolySheep AI sticht durch folgende Vorteile heraus:
- Beispiellose Kosteneffizienz: Der Yuan-Dollar-Peg ermöglicht es mir, meine gesamten Backtesting-Workflows zu einem Bruchteil der Kosten durchzuführen, ohne Qualitätseinbußen.
- Blitzschnelle Latenz: Mit unter 50ms Reaktionszeit kann ich meine Strategien in Echtzeit optimieren, ohne auf langsame API-Antworten warten zu müssen.
- Flexible Zahlungsmethoden: Als jemand, der oft in China unterwegs ist, schätze ich die Möglichkeit, direkt über WeChat oder Alipay zu bezahlen.
- Nahtlose Integration: Die kompatible API-Struktur ermöglicht eine problemlose Migration bestehender Projekte.
Grundlagen des Kryptowährung-Backtestings
Das Backtesting von Kryptowährungs-Strategien ist ein fundamentaler Prozess in der algorithmischen Handelstätigkeit. Bevor Sie eine Strategie im Live-Handel einsetzen, sollten Sie diese gegen historische Marktdaten testen. Der erste und wichtigste Schritt dabei ist die ordnungsgemäße Aufbereitung Ihrer CSV-Daten.
In meiner Praxis habe ich festgestellt, dass über 60% der fehlerhaften Backtesting-Ergebnisse auf schlechte Datenvorbereitung zurückzuführen sind. Mit HolySheep AI können Sie nicht nur Ihre Daten verarbeiten, sondern auch komplexe Datenbereinigungs-Workflows mithilfe von KI-Assistenz implementieren.
CSV-Daten verstehen und strukturieren
Historische Kryptowährungs-Daten werden typischerweise im CSV-Format exportiert. Eine typische CSV-Datei für Krypto-Daten enthält Spalten wie: Timestamp, Open, High, Low, Close, Volume und weitere Metriken. Die Herausforderung liegt darin, diese Daten in ein Format zu bringen, das für Backtesting-Engines optimiert ist.
Typische CSV-Struktur für Kryptowährungsdaten
timestamp,open,high,low,close,volume,quote_volume,trades
2024-01-01 00:00:00,42150.50,42200.00,42100.25,42180.75,1250.5,52800000.00,15420
2024-01-01 00:01:00,42180.75,42250.00,42170.00,42230.25,1180.3,49800000.00,14250
2024-01-01 00:02:00,42230.25,42280.50,42200.00,42245.00,1320.8,55800000.00,16890Python-Bibliotheken für CSV-Datenverarbeitung
Für die effektive Aufbereitung von Kryptowährungs-CSV-Daten empfehle ich folgende Python-Bibliotheken:
- pandas: Das Herzstück jeder Datenanalyse in Python
- numpy: Für numerische Operationen und Arrays
- dateutil: Für robuste Datumsparse-Vorgänge
- HolySheep AI SDK: Für KI-gestützte Datenanalyse und Anomalieerkennung
# Installation der erforderlichen Bibliotheken
pip install pandas numpy python-dateutil requests
Optional: HolySheep AI Python SDK
pip install holysheep-ai # oder direkte HTTP-IntegrationSchritt-für-Schritt: CSV-Daten laden und inspizieren
Der erste Schritt bei der Datenaufbereitung ist das Laden und Inspizieren Ihrer CSV-Datei. Dies gibt Ihnen einen Überblick über die Datenstruktur und hilft, potenzielle Probleme frühzeitig zu identifizieren.
import pandas as pd
import numpy as np
from datetime import datetime
def load_crypto_csv(file_path):
"""
Lädt eine Kryptowährungs-CSV-Datei und führt eine Erstinspektion durch.
Args:
file_path: Pfad zur CSV-Datei
Returns:
DataFrame mit geladenen und inspizierten Daten
"""
try:
# CSV laden mit automatischer Typ-Erkennung
df = pd.read_csv(
file_path,
parse_dates=True,
infer_datetime_format=True
)
print(f"✓ Datei erfolgreich geladen: {len(df)} Zeilen, {len(df.columns)} Spalten")
print(f"\nSpaltenübersicht:")
print(df.dtypes)
print(f"\nErste 5 Zeilen:")
print(df.head())
print(f"\nStatistische Zusammenfassung:")
print(df.describe())
return df
except FileNotFoundError:
print(f"✗ Fehler: Datei '{file_path}' nicht gefunden")
return None
except Exception as e:
print(f"✗ Unerwarteter Fehler beim Laden: {str(e)}")
return None
Beispielaufruf
df = load_crypto_csv("bitcoin_historical_1h.csv")
Intelligente Datenbereinigung mit HolySheep AI
Eine der größten Herausforderungen bei der Datenbereinigung ist die Erkennung von Anomalien, Ausreißern und Inkonsistenzen. Hier kommt die KI-gestützte Analyse von HolySheep AI ins Spiel. Sie können komplexe Muster in Ihren Daten erkennen und automatisch Bereinigungsvorschläge erhalten.
import requests
import json
class HolySheepDataAnalyzer:
"""
KI-gestützte Datenanalyse mit HolySheep AI für Kryptowährungs-Backtesting.
"""
def __init__(self, api_key):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
def analyze_data_quality(self, df, columns):
"""
Analysiert die Datenqualität mithilfe von HolySheep AI.
Erkennt Anomalien, fehlende Werte und potenzielle Probleme.
"""
# Bereite Datenübersicht für die KI vor
data_summary = {
"row_count": len(df),
"columns": list(df.columns),
"missing_values": df.isnull().sum().to_dict(),
"data_types": df.dtypes.astype(str).to_dict(),
"numeric_columns": columns,
"numeric_stats": df[columns].describe().to_dict()
}
prompt = f"""
Analysiere die folgende Datenqualitätszusammenfassung für ein
Kryptowährungs-Backtesting-Projekt:
{json.dumps(data_summary, indent=2)}
Identifiziere:
1. Fehlende Daten (Missing Values) und deren potenzielle Auswirkungen
2. Mögliche Ausreißer oder Anomalien
3. Inkonsistenzen in den Daten
4. Empfehlungen für die Datenbereinigung
Antworte auf Deutsch mit konkreten Handlungsempfehlungen.
"""
try:
response = requests.post(
f"{self.base_url}/chat/completions",
headers={
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
},
json={
"model": "gpt-4.1",
"messages": [{"role": "user", "content": prompt}],
"max_tokens": 1500,
"temperature": 0.3
},
timeout=30
)
if response.status_code == 200:
result = response.json()
return result["choices"][0]["message"]["content"]
else:
return f"API-Fehler: {response.status_code}"
except requests.exceptions.Timeout:
return "Zeitüberschreitung bei der API-Anfrage. Bitte erneut versuchen."
except Exception as e:
return f"Fehler: {str(e)}"
Initialisierung mit Ihrem HolySheep API-Key
analyzer = HolySheepDataAnalyzer("YOUR_HOLYSHEEP_API_KEY")
Beispiel: Analysiere die Datenqualität
analysis_result = analyzer.analyze_data_quality(df, ["open", "high", "low", "close", "volume"])
print(analysis_result)
Umgang mit fehlenden Werten
Fehlende Werte sind ein häufiges Problem in historischen Kryptowährungsdaten. Dies kann durch Handelspausen, Datenfehler oder API-Probleme verursacht werden. Die Art der Behandlung hängt vom Ausmaß und der Position der fehlenden Daten ab.
def handle_missing_values(df, method='interpolate', max_gap=5):
"""
Behandelt fehlende Werte in Kryptowährungs-CSV-Daten.
Args:
df: DataFrame mit den Daten
method: 'interpolate' für lineare Interpolation oder 'drop' für Entfernung
max_gap: Maximale Anzahl aufeinanderfolgender fehlender Werte
Returns:
Bereinigter DataFrame
"""
df_clean = df.copy()
# Analyse der fehlenden Werte
missing_info = df_clean.isnull().sum()
missing_cols = missing_info[missing_info > 0]
if len(missing_cols) == 0:
print("✓ Keine fehlenden Werte gefunden")
return df_clean
print(f"⚠ Fehlende Werte gefunden in {len(missing_cols)} Spalten:")
for col, count in missing_cols.items():
pct = (count / len(df_clean)) * 100
print(f" - {col}: {count} ({pct:.2f}%)")
# Behandlung basierend auf Methode
if method == 'interpolate':
# Lineare Interpolation für numerische Spalten
numeric_cols = df_clean.select_dtypes(include=[np.number]).columns
for col in numeric_cols:
# Zähle aufeinanderfolgende NaNs
mask = df_clean[col].isnull()
gap_lengths = (~mask).cumsum()[mask].value_counts()
# Nur interpolieren wenn Lücken klein genug
for gap_size in gap_lengths.index:
if gap_size <= max_gap:
df_clean[col] = df_clean[col].interpolate(method='linear')
print(f" ✓ Spalte '{col}': {gap_size} Lücken interpoliert")
else:
# Für große Lücken: forward/backward fill als Fallback
df_clean[col] = df_clean[col].fillna(method='ffill').fillna(method='bfill')
print(f" ⚠ Spalte '{col}': Große Lücke ({gap_size}), Fill-Methode verwendet")
elif method == 'drop':
# Entferne Zeilen mit fehlenden Werten
original_len = len(df_clean)
df_clean = df_clean.dropna()
removed = original_len - len(df_clean)
print(f"✓ {removed} Zeilen mit fehlenden Werten entfernt")
return df_clean
Anwendung
df_cleaned = handle_missing_values(df, method='interpolate', max_gap=5)
Zeitreihen-Validierung und Konsistenzprüfung
Die Validierung der Zeitreihen-Konsistenz ist entscheidend für zuverlässige Backtesting-Ergebnisse. Kryptowährungsmärkte sind 24/7 aktiv, aber Datenfeeds können Lücken oder Duplikate enthalten.
def validate_time_series(df, timestamp_col='timestamp', expected_freq='1H'):
"""
Validiert und korrigiert Zeitreihen-Dateninkonsistenzen.
Args:
df: DataFrame mit Zeitreihendaten
timestamp_col: Name der Zeitstempel-Spalte
expected_freq: Erwartete Frequenz (z.B. '1H' für stündlich)
Returns:
Validierter DataFrame und Validierungsbericht
"""
df_validated = df.copy()
report = {
"original_rows": len(df),
"duplicates_removed": 0,
"gaps_filled": 0,
"out_of_order": 0,
"issues": []
}
# Konvertiere Zeitstempel wenn nötig
if df_validated[timestamp_col].dtype == 'object':
df_validated[timestamp_col] = pd.to_datetime(df_validated[timestamp_col])
# Sortiere nach Zeitstempel
df_validated = df_validated.sort_values(timestamp_col).reset_index(drop=True)
# 1. Duplikate entfernen
duplicates = df_validated[timestamp_col].duplicated().sum()
if duplicates > 0:
df_validated = df_validated.drop_duplicates(subset=[timestamp_col], keep='first')
report["duplicates_removed"] = duplicates
report["issues"].append(f"{duplicates} doppelte Zeitstempel gefunden und entfernt")
print(f"✓ {duplicates} Duplikate entfernt")
# 2. Überprüfe Reihenfolge
time_diffs = df_validated[timestamp_col].diff()
if (time_diffs < pd.Timedelta(0)).any():
report["out_of_order"] = time_diffs.lt(pd.Timedelta(0)).sum()
report["issues"].append("Zeitstempel waren nicht in chronologischer Reihenfolge")
print(f"⚠ {report['out_of_order']} Zeilen waren nicht in Reihenfolge (korrigiert)")
# 3. Lückenerkennung
expected_delta = pd.Timedelta(expected_freq)
actual_deltas = df_validated[timestamp_col].diff()
# Finde unerwartete Lücken (mehr als 1.5x erwartete Frequenz)
large_gaps = actual_deltas[actual_deltas > 1.5 * expected_delta]
if len(large_gaps) > 0:
report["gaps_filled"] = len(large_gaps)
report["issues"].append(f"{len(large_gaps)} große Zeitlücken (> {1.5 * expected_delta}) erkannt")
print(f"⚠ {len(large_gaps)} große Zeitlücken erkannt")
# 4. Setze Zeitstempel als Index
df_validated.set_index(timestamp_col, inplace=True)
print(f"\n📊 Validierungsbericht:")
print(f" Ursprüngliche Zeilen: {report['original_rows']}")
print(f" Finale Zeilen: {len(df_validated)}")
return df_validated, report
Anwendung
df_validated, validation_report = validate_time_series(df)
Outlier-Erkennung für Kryptowährungsdaten
Outlier in Kryptowährungsdaten können durch extreme Volatilität, Marktschiefe oder schlichte Datenfehler entstehen. Eine robuste Outlier-Erkennung ist daher essentiell für zuverlässige Backtests.
def detect_and_handle_outliers(df, columns, method='iqr', threshold=3):
"""
Erkennt und behandelt Outlier in Kryptowährungspreisdaten.
Args:
df: DataFrame mit Preisdaten
columns: Liste der zu prüfenden Spalten
method: 'iqr' für Interquartilsabstand oder 'zscore' für Standardabweichung
threshold: Schwellenwert für Outlier-Klassifikation
Returns:
Bereinigter DataFrame und Outlier-Bericht
"""
df_clean = df.copy()
outlier_report = {}
for col in columns:
if col not in df_clean.columns:
continue
if method == 'iqr':
Q1 = df_clean[col].quantile(0.25)
Q3 = df_clean[col].quantile(0.75)
IQR = Q3 - Q1
lower_bound = Q1 - threshold * IQR
upper_bound = Q3 + threshold * IQR
outliers = (df_clean[col] < lower_bound) | (df_clean[col] > upper_bound)
elif method == 'zscore':
mean = df_clean[col].mean()
std = df_clean[col].std()
z_scores = np.abs((df_clean[col] - mean) / std)
outliers = z_scores > threshold
outlier_count = outliers.sum()
outlier_pct = (outlier_count / len(df_clean)) * 100
outlier_report[col] = {
"count": int(outlier_count),
"percentage": round(outlier_pct, 2),
"values": df_clean.loc[outliers, col].tolist() if outlier_count > 0 else []
}
if outlier_count > 0:
print(f"⚠ {col}: {outlier_count} Outlier erkannt ({outlier_pct:.2f}%)")
# Option: Setze Outlier auf NaN oder median
# Hier: Auf Median setzen
median_val = df_clean[col].median()
df_clean.loc[outliers, col] = median_val
print(f" → Auf Median ({median_val:.2f}) gesetzt")
return df_clean, outlier_report
Anwendung für typische Preisspalten
df_final, outlier_report = detect_and_handle_outliers(
df_cleaned,
columns=['open', 'high', 'low', 'close', 'volume']
)
Vollständiger Datenbereinigungs-Workflow
Hier ist der vollständige, produktionsreife Workflow für die Bereinigung von Kryptowährungs-Backtesting-Daten, integriert mit HolySheep AI für KI-gestützte Analysen.
bool: """Lädt CSV-Daten aus Datei.""" try: self.df = pd.read_csv(file_path) self.cleaning_report.append(f"✓ Daten geladen: {len(self.df)} Zeilen") return True except Exception as e: self.cleaning_report.append(f"✗ Ladefehler: {str(e)}") return False def clean_pipeline(self) -> pd.DataFrame: """Führt den vollständigen Bereinigungs-Workflow aus.""" if self.df is None: raise ValueError("Keine Daten geladen. Bitte zuerst load_data() aufrufen.") df = self.df.copy() # Schritt 1: Zeitstempel validieren if 'timestamp' in df.columns: df['timestamp'] = pd.to_datetime(df['timestamp']) df = df.sort_values('timestamp') df = df.drop_duplicates(subset=['timestamp'], keep='first') self.cleaning_report.append("✓ Zeitstempel validiert und sortiert") # Schritt 2: Fehlende Werte behandeln for col in ['open', 'high', 'low', 'close']: if col in df.columns: df[col] = df[col].interpolate(method='linear') self.cleaning_report.append("✓ Fehlende Werte interpoliert") # Schritt 3: Logische Konsistenzprüfung if 'high' in df.columns and 'low' in df.columns: # High muss >= Low sein invalid = df['high'] < df['low'] if invalid.any(): df.loc[invalid, 'high'] = df.loc[invalid, 'low'] self.cleaning_report.append(f"⚠ {invalid.sum()} Zeilen mit High < Low korrigiert") if 'close' in df.columns: # Close muss zwischen High und Low liegen df['close'] = df[['close', 'high', 'low']].max(axis=1).clip(upper=df['high']) df['close'] = df[['close', 'high', 'low']].min(axis=1).clip(lower=df['low']) # Schritt 4: Negative Werte behandeln (unmöglich für Preise) price_cols = ['open', 'high', 'low', 'close'] for col in price_cols: if col in df.columns: negatives = (df[col] <= 0).sum() if negatives > 0: df = df[df[col] > 0] self.cleaning_report.append(f"⚠ {negatives} Zeilen mit negativem {col} entfernt") self.df = df return df def get_ai_insights(self, focus_columns: List[str]) -> str: """Nutzt HolySheep AI für zusätzliche Datenanalyse-Insights.""" if self.df is None: return "Keine Daten verfügbar" data_summary = { "rows": len(self.df), "date_range": f"{self.df['timestamp'].min()} bis {self.df['timestamp'].max()}", "columns": list(self.df.columns), "price_range": { col: { "min": float(self.df[col].min()), "max": float(self.df[col].max()), "mean": float(self.df[col].mean()) } for col in focus_columns if col in self.df.columns } } prompt = f""" Analysiere diese Kryptowährungs-Backtesting-Daten für mich: {data_summary} Gib mir: 1. Eine Einschätzung der Datenqualität 2. Potenzielle Risiken für Backtesting-Strategien 3. Empfohlene Strategietypen basierend auf der Volatilität 4. Warnungen vor bekannten Problemen Antworte strukturiert auf Deutsch. """ try: response = requests.post( f"{self.base_url}/chat/completions", headers={ "Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json" }, json={ "model": "deepseek-v3.2", "messages": [{"role": "user", "content": prompt}], "max_tokens": 1000, "temperature": 0.4 } ) if response.status_code == 200: return response.json()["choices"][0]["message"]["content"] return f"API-Fehler: {response.status_code}" except Exception as e: return f"Fehler: {str(e)}" def export_clean_data(self, output_path: str) -> bool: """Exportiert bereinigte Daten in CSV.""" if self.df is None: return False try: self.df.to_csv(output_path, index=False) self.cleaning_report.append(f"✓ Bereinigte Daten exportiert: {output_path}") return True except Exception as e: self.cleaning_report.append(f"✗ Exportfehler: {str(e)}") return False def get_report(self) -> List[str]: """Gibt den vollständigen Bereinigungsbericht zurück.""" return self.cleaning_report Beispielnutzung
pipeline = CryptoDataPipeline("YOUR_HOLYSHEEP_API_KEY") if pipeline.load_data("bitcoin_historical.csv"): df_clean = pipeline.clean_pipeline() insights = pipeline.get_ai_insights(['close', 'volume']) print("=== Bereinigungsbericht ===") for item in pipeline.get_report(): print(item) print("\n=== KI-Insights ===") print(insights) pipeline.export_clean_data("bitcoin_cleaned.csv")
Häufige Fehler und Lösungen
Fehler 1: Zeitzonenprobleme bei Timestamps
Problem: CSV-Daten enthalten Timestamps in verschiedenen Zeitzonen, was zu falschen Backtesting-Ergebnissen führt.
Lösung:
# Lösung: Explizite Zeitzonennormalisierung
from datetime import timezone
def normalize_timezone(df, timestamp_col='timestamp', target_tz='UTC'):
"""
Normalisiert alle Timestamps auf eine einheitliche Zeitzone.
Args:
df: DataFrame mit Zeitstempeln
timestamp_col: Name der Zeitstempelspalte
target_tz: Zielzeitzone (Standard: UTC)
"""
df_normalized = df.copy()
# Konvertiere zu datetime falls nötig
df_normalized[timestamp_col] = pd.to_datetime(df_normalized[timestamp_col])
# Prüfe ob tz-naive oder tz-aware
if df_normalized[timestamp_col].dt.tz is None:
# Lokalisiere als UTC und konvertiere
df_normalized[timestamp_col] = df_normalized[timestamp_col].dt.tz_localize('UTC')
# Konvertiere zur Zielzeitzone
df_normalized[timestamp_col] = df_normalized[timestamp_col].dt.tz_convert(target_tz)
print(f"✓ Zeitzonen normalisiert auf {target_tz}")
return df_normalized
Anwendung
df_normalized = normalize_timezone(df, timestamp_col='timestamp', target_tz='UTC')
Fehler 2: Survivor Bias durch fehlende/dead Coins
Problem: Backtests basieren nur auf Coins, die noch existieren, was zu überoptimistischen Ergebnissen führt.
Lösung:
def handle_survivor_bias(df, price_cols=['close']):
"""
Korrigiert Survivor Bias in Kryptowährungs-Backtests.
Kennzeichnet Zeiträume, in denen Daten möglicherweise unvollständig sind.
"""
df_corrected = df.copy()
# Erstelle eine "Datenqualitäts"-Spalte
df_corrected['data_completeness'] = 1.0
# Markiere Zeilen mit ungewöhnlich niedrigen Volumina
if 'volume' in df_corrected.columns:
volume_threshold = df_corrected['volume'].quantile(0.05)
low_volume_mask = df_corrected['volume'] < volume_threshold
df_corrected.loc[low_volume_mask, 'data_completeness'] *= 0.5
print(f"⚠ {low_volume_mask.sum()} Zeilen mit ungewöhnlich niedrigem Volumen markiert")
# Markiere Zeilen mit anomalen Preisänderungen
for col in price_cols:
if col in df_corrected.columns:
returns = df_corrected[col].pct_change()
extreme_return_mask = returns.abs() > 0.5 # >50% Änderung
df_corrected.loc[extreme_return_mask, 'data_completeness'] *= 0.3
print(f"⚠ {extreme_return_mask.sum()} Zeilen mit extremen Returns mark