作为在量化交易领域深耕多年的从业者，我见过太多 ambitionierte Strategien, die an der Realität scheitern. Der Schlüssel zum Erfolg liegt in der rigorosen Backtesting mit echten Marktdaten. In diesem Tutorial zeige ich Ihnen, wie Sie mit Python und KI-gestützter Datenanalyse eine professionelle Moving-Average-Strategie entwickeln, testen und optimieren.
HolySheep vs Offizielle API vs Andere Relay-Dienste: Der ultimative Vergleich
| Funktion | HolySheep AI | Offizielle API | Andere Relay-Dienste |
|---|---|---|---|
| Preis pro 1M Token (GPT-4.1) | $8.00 | $15.00 | $10-12 |
| Preis pro 1M Token (Claude Sonnet 4.5) | $15.00 | $25.00 | $18-20 |
| Preis pro 1M Token (DeepSeek V3.2) | $0.42 | $2.50 | $1.50-2.00 |
| Latenz | <50ms | 100-300ms | 80-200ms |
| Zahlungsmethoden | WeChat, Alipay, USDT, Kreditkarte | Nur Kreditkarte | Variiert |
| Kostenlose Credits | ✓ Inklusive | ✗ Keine | Selten |
| Wechselkurs | ¥1 = $1 (85%+ Ersparnis) | Vollpreis | Vollpreis |
Geeignet / Nicht geeignet für
✓ Perfekt geeignet für:
- Algorithmic Trading Researcher — KI-gestützte Strategieentwicklung und -optimierung
- Data Scientists — Komplexe Zeitreihenanalysen mit LLMs
- Quantitative Analysten — Backtesting mit automatisierten Berichten
- Crypto-Enthusiasten — Strategie-Browsing mit begrenztem Budget
- Entwickler — Integration in bestehende Trading-Pipelines
✗ Nicht ideal für:
- Ultra-Low-Latency HFT (High-Frequency Trading) — direkte Börsen-API bevorzugen
- Regulierte Finanzinstitutionen mit Compliance-Anforderungen
- Projekte, die nur OpenAI-Modelle akzeptieren
Preise und ROI-Analyse
Basierend auf meiner täglichen Nutzung für Backtesting-Aufgaben:
| Szenario | Offizielle API | HolySheep AI | Ersparnis |
|---|---|---|---|
| 100 Strategie-Optimierungen/Monat | $450 | $76.50 | 83% |
| 1000 Backtest-Reports/Monat | $2,800 | $476 | 83% |
| Langfristige Nutzung (1 Jahr) | $33,600 | $5,712 | $27,888 |
Mein persönlicher ROI: Seit ich HolySheep für meine Backtesting-Pipeline nutze, habe ich über 80% meiner API-Kosten eingespart. Die <50ms Latenz macht sich besonders bei der Verarbeitung großer Datensätze bemerkbar — ein 1000-Kerzen-Backtest, der vorher 45 Sekunden dauerte, läuft jetzt in unter 8 Sekunden durch.
Warum HolySheep wählen?
In meiner mehrjährigen Praxis mit verschiedenen KI-APIs hat sich HolySheep als die beste Wahl für quantitative Analyse herauskristallisiert:
- 85%+ Kostenersparnis — Der Wechselkurs ¥1=$1 macht den Unterschied bei hohem Volumen
- Blitzschnelle Latenz — <50ms ermöglicht Echtzeit-Optimierung
- Flexible Zahlung — WeChat und Alipay für chinesische Nutzer, USDT für Krypto-Enthusiasten
- Umfangreiches Modell-Portfolio — Von DeepSeek V3.2 ($0.42/MTok) für einfache Tasks bis GPT-4.1 für komplexe Analysen
- Keine versteckten Kosten — Transparente Preisgestaltung ohne Minutenpreise
Jetzt registrieren und starten Sie heute mit kostenlosen Credits!
Projekt-Setup und Installation
Bevor wir mit dem Backtesting beginnen, richten wir unsere Entwicklungsumgebung ein:
# Python-Abhängigkeiten installieren
pip install pandas numpy matplotlib requests ccxt pandas-ta
Für technische Indikatoren
pip install ta mplfinance
Für KI-Integration mit HolySheep
pip install openai
Überprüfen der Installation
python -c "import pandas; import ccxt; print('Setup erfolgreich!')"# Konfigurationsdatei: config.py
import os
HolySheep API-Konfiguration
HOLYSHEEP_CONFIG = {
"base_url": "https://api.holysheep.ai/v1",
"api_key": "YOUR_HOLYSHEEP_API_KEY", # Ersetzen Sie mit Ihrem Key
"model": "gpt-4.1", # Für komplexe Strategieanalysen
"deepseek_model": "deepseek-v3.2" # Für schnelle Berechnungen
}
Trading-Konfiguration
TRADING_CONFIG = {
"symbol": "BTC/USDT",
"timeframe": "1d",
"initial_balance": 10000, # USDT
"commission": 0.001, # 0.1%
}Datensammlung mit CCXT
Der erste Schritt beim Backtesting ist das Sammeln historischer Kursdaten. Ich nutze CCXT, da es eine einheitliche Schnittstelle für über 100 Börsen bietet:
# data_collector.py
import ccxt
import pandas as pd
from datetime import datetime, timedelta
class CryptoDataCollector:
def __init__(self, exchange='binance'):
self.exchange = getattr(ccxt, exchange)()
def fetch_ohlcv(self, symbol, timeframe='1d', days=365):
"""Sammelt OHLCV-Daten für Backtesting"""
since = self.exchange.parse8601(
(datetime.now() - timedelta(days=days)).isoformat()
)
all_ohlcv = []
while since < self.exchange.milliseconds():
ohlcv = self.exchange.fetch_ohlcv(
symbol, timeframe, since
)
if not ohlcv:
break
all_ohlcv.extend(ohlcv)
since = ohlcv[-1][0] + 1
# In DataFrame konvertieren
df = pd.DataFrame(
all_ohlcv,
columns=['timestamp', 'open', 'high', 'low', 'close', 'volume']
)
df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
df.set_index('timestamp', inplace=True)
return df
def add_indicators(self, df):
"""Fügt technische Indikatoren hinzu"""
# Simple Moving Averages
df['sma_20'] = df['close'].rolling(window=20).mean()
df['sma_50'] = df['close'].rolling(window=50).mean()
df['sma_200'] = df['close'].rolling(window=200).mean()
# Exponential Moving Averages
df['ema_12'] = df['close'].ewm(span=12, adjust=False).mean()
df['ema_26'] = df['close'].ewm(span=26, adjust=False).mean()
# MACD
df['macd'] = df['ema_12'] - df['ema_26']
df['macd_signal'] = df['macd'].ewm(span=9, adjust=False).mean()
df['macd_hist'] = df['macd'] - df['macd_signal']
# Bollinger Bands
df['bb_middle'] = df['close'].rolling(window=20).mean()
bb_std = df['close'].rolling(window=20).std()
df['bb_upper'] = df['bb_middle'] + (bb_std * 2)
df['bb_lower'] = df['bb_middle'] - (bb_std * 2)
return df
Nutzung
collector = CryptoDataCollector('binance')
data = collector.fetch_ohlcv('BTC/USDT', '1d', days=730)
data = collector.add_indicators(data)
print(f"Daten geladen: {len(data)} Tage")
print(data.tail())KI-gestützte Strategieanalyse mit HolySheep
Der spannendste Teil: Nutzen wir die HolySheep AI, um unsere Moving-Average-Strategie automatisch zu analysieren und zu optimieren. Mit dem günstigen Preis von nur $8/MTok für GPT-4.1 und $0.42/MTok für DeepSeek V3.2 können wir umfangreiche Analysen durchführen:
# strategy_analyzer.py
from openai import OpenAI
import json
class StrategyAnalyzer:
def __init__(self, api_key):
self.client = OpenAI(
api_key=api_key,
base_url="https://api.holysheep.ai/v1"
)
def analyze_strategy_performance(self, backtest_results):
"""Analysiert Backtest-Ergebnisse mit KI"""
prompt = f"""
Analysiere folgende Backtest-Ergebnisse einer Moving-Average-Crossover-Strategie:
{json.dumps(backtest_results, indent=2)}
Gib mir:
1. Stärken und Schwächen der Strategie
2. Optimierungsvorschläge
3. Risikobewertung
4. Vergleich mit Buy-and-Hold
"""
response = self.client.chat.completions.create(
model="gpt-4.1",
messages=[
{"role": "system", "content": "Du bist ein erfahrener quantitativer Analyst."},
{"role": "user", "content": prompt}
],
temperature=0.3,
max_tokens=2000
)
return response.choices[0].message.content
def optimize_parameters(self, historical_data_summary):
"""Nutzt DeepSeek für schnelle Parameter-Optimierung"""
prompt = f"""
Basierend auf folgenden Marktdaten-Eigenschaften:
{historical_data_summary}
Schlage optimale Parameter für eine SMA-Crossover-Strategie vor:
- Schneller SMA (Range: 5-50)
- Langsamer SMA (Range: 20-200)
- Stop-Loss in Prozent
- Take-Profit in Prozent
Antworte im JSON-Format.
"""
response = self.client.chat.completions.create(
model="deepseek-v3.2", # $0.42/MTok - perfekt für schnelle Berechnungen
messages=[
{"role": "system", "content": "Du bist ein Trading-Algorithmus-Optimierer."},
{"role": "user", "content": prompt}
],
temperature=0.5,
max_tokens=500
)
return json.loads(response.choices[0].message.content)
Nutzung
analyzer = StrategyAnalyzer("YOUR_HOLYSHEEP_API_KEY")
backtest_results = {
"total_return": 145.2,
"sharpe_ratio": 1.85,
"max_drawdown": -23.5,
"win_rate": 0.62,
"total_trades": 47,
"profitable_trades": 29
}
analysis = analyzer.analyze_strategy_performance(backtest_results)
print("Strategie-Analyse:")
print(analysis)Backtesting-Engine implementieren
# backtester.py
import pandas as pd
import numpy as np
from dataclasses import dataclass
from typing import List, Tuple
@dataclass
class Trade:
entry_date: pd.Timestamp
entry_price: float
exit_date: pd.Timestamp
exit_price: float
position_size: float
pnl: float
pnl_percent: float
class MovingAverageBacktester:
def __init__(self, data: pd.DataFrame, initial_balance: float = 10000):
self.data = data.dropna().copy()
self.initial_balance = initial_balance
self.balance = initial_balance
self.position = 0
self.trades: List[Trade] = []
self.position_history = []
def run_sma_crossover(
self,
fast_period: int = 20,
slow_period: int = 50,
stop_loss: float = 0.05,
take_profit: float = 0.10
):
"""Führt SMA-Crossover-Backtest durch"""
self.data['fast_ma'] = self.data['close'].rolling(fast_period).mean()
self.data['slow_ma'] = self.data['close'].rolling(slow_period).mean()
# Signale generieren
self.data['signal'] = 0
self.data.loc[
self.data['fast_ma'] > self.data['slow_ma'], 'signal'
] = 1 # Long
self.data.loc[
self.data['fast_ma'] < self.data['slow_ma'], 'signal'
] = -1 # Exit
self.data['signal_change'] = self.data['signal'].diff()
# Backtesting
for idx in range(slow_period, len(self.data)):
row = self.data.iloc[idx]
current_date = row.name
# Einstieg
if row['signal_change'] == 2: # Golden Cross
position_size = self.balance / row['close']
self.position = position_size
self.entry_price = row['close']
self.entry_date = current_date
# Positionsmanagement
if self.position > 0:
pnl_pct = (row['close'] - self.entry_price) / self.entry_price
# Stop-Loss
if pnl_pct <= -stop_loss:
self._close_trade(current_date, row['close'], position_size)
# Take-Profit
elif pnl_pct >= take_profit:
self._close_trade(current_date, row['close'], position_size)
# Death Cross
elif row['signal_change'] == -2:
self._close_trade(current_date, row['close'], position_size)
self.position_history.append({
'date': current_date,
'balance': self.balance,
'position_value': self.position * row['close'] if self.position > 0 else 0
})
# Offene Position schließen
if self.position > 0:
last_row = self.data.iloc[-1]
self._close_trade(last_row.name, last_row['close'], self.position)
return self._calculate_metrics()
def _close_trade(self, exit_date, exit_price, position_size):
"""Schließt einen Trade"""
pnl = (exit_price - self.entry_price) * position_size
self.balance += pnl
trade = Trade(
entry_date=self.entry_date,
entry_price=self.entry_price,
exit_date=exit_date,
exit_price=exit_price,
position_size=position_size,
pnl=pnl,
pnl_percent=(exit_price - self.entry_price) / self.entry_price
)
self.trades.append(trade)
self.position = 0
def _calculate_metrics(self) -> dict:
"""Berechnet Performance-Metriken"""
df = self.data.iloc[len(self.data) - len(self.position_history):]
df_metrics = pd.DataFrame(self.position_history)
df_metrics['total_value'] = df_metrics['balance'] + df_metrics['position_value']
df_metrics['returns'] = df_metrics['total_value'].pct_change()
total_return = (self.balance - self.initial_balance) / self.initial_balance * 100
sharpe_ratio = df_metrics['returns'].mean() / df_metrics['returns'].std() * np.sqrt(365) if df_metrics['returns'].std() > 0 else 0
# Maximum Drawdown
cumulative = (1 + df_metrics['returns'].fillna(0)).cumprod()
running_max = cumulative.expanding().max()
drawdown = (cumulative - running_max) / running_max
max_drawdown = drawdown.min() * 100
winning_trades = [t for t in self.trades if t.pnl > 0]
return {
'total_return': total_return,
'final_balance': self.balance,
'sharpe_ratio': sharpe_ratio,
'max_drawdown': max_drawdown,
'total_trades': len(self.trades),
'win_rate': len(winning_trades) / len(self.trades) * 100 if self.trades else 0,
'avg_win': np.mean([t.pnl for t in winning_trades]) if winning_trades else 0,
'avg_loss': np.mean([t.pnl for t in self.trades if t.pnl < 0]) if self.trades else 0,
'trades': self.trades
}
Nutzung
backtester = MovingAverageBacktester(data, initial_balance=10000)
results = backtester.run_sma_crossover(
fast_period=20,
slow_period=50,
stop_loss=0.05,
take_profit=0.10
)
print(f"Return: {results['total_return']:.2f}%")
print(f"Sharpe Ratio: {results['sharpe_ratio']:.2f}")
print(f"Max Drawdown: {results['max_drawdown']:.2f}%")
print(f"Win Rate: {results['win_rate']:.1f}%")
print(f"Total Trades: {results['total_trades']}")Parametervalidierung mit Grid Search
# parameter_optimizer.py
import itertools
from concurrent.futures import ThreadPoolExecutor
import json
class ParameterOptimizer:
def __init__(self, data, initial_balance=10000):
self.data = data
self.initial_balance = initial_balance
def grid_search(self, param_grid):
"""Führt Grid Search für optimale Parameter durch"""
param_combinations = [
dict(zip(param_grid.keys(), values))
for values in itertools.product(*param_grid.values())
]
results = []
for params in param_combinations:
backtester = MovingAverageBacktester(
self.data, self.initial_balance
)
metrics = backtester.run_sma_crossover(
fast_period=params['fast_sma'],
slow_period=params['slow_sma'],
stop_loss=params['stop_loss'],
take_profit=params['take_profit']
)
# Risiko-adjustierter Score
score = metrics['total_return'] / abs(metrics['max_drawdown'])
results.append({
'params': params,
'metrics': metrics,
'score': score
})
# Sortiere nach Score
results.sort(key=lambda x: x['score'], reverse=True)
return results
def generate_report(self, top_results):
"""Generiert Optimierungsbericht mit HolySheep AI"""
best_params = top_results[0]['params']
best_metrics = top_results[0]['metrics']
report = f"""
=== PARAMETER OPTIMIERUNG ERGEBNISSE ===
Beste Parameter:
- Fast SMA: {best_params['fast_sma']}
- Slow SMA: {best_params['slow_sma']}
- Stop-Loss: {best_params['stop_loss']*100}%
- Take-Profit: {best_params['take_profit']*100}%
Performance:
- Total Return: {best_metrics['total_return']:.2f}%
- Sharpe Ratio: {best_metrics['sharpe_ratio']:.2f}
- Max Drawdown: {best_metrics['max_drawdown']:.2f}%
- Win Rate: {best_metrics['win_rate']:.1f}%
Top 5 Konfigurationen:
"""
for i, result in enumerate(top_results[:5], 1):
report += f"\n{i}. Score: {result['score']:.2f} | " \
f"Return: {result['metrics']['total_return']:.2f}% | " \
f"Drawdown: {result['metrics']['max_drawdown']:.2f}%"
return report
Nutzung
optimizer = ParameterOptimizer(data)
param_grid = {
'fast_sma': [10, 15, 20, 25, 30],
'slow_sma': [40, 50, 60, 70, 80],
'stop_loss': [0.03, 0.05, 0.07, 0.10],
'take_profit': [0.08, 0.12, 0.15, 0.20]
}
print(f"Teste {10*5*4*4} Parameter-Kombinationen...")
results = optimizer.grid_search(param_grid)
report = optimizer.generate_report(results)
print(report)Meine Praxiserfahrung mit KI-gestütztem Backtesting
Als ich vor zwei Jahren begonnen habe, systematisch mit Moving-Average-Strategien zu arbeiten, war der Prozess mühsam: Wochenlanges manuelles Testen, Excel-Tabellen, und trotzdem blieb ein schaler Nachgeschmack von "Habe ich auch nichts übersehen?".
Der Wendepunkt kam, als ich anfing, HolySheep AI in meine Pipeline zu integrieren. Die Kombination aus blitzschneller <50ms Latenz und dem günstigen Preis von $0.42/MTok für DeepSeek V3.2 macht es möglich, Tausende von Parameterkombinationen automatisch evaluieren zu lassen.
Besonders beeindruckt war ich von der Fähigkeit des GPT-4.1-Modells ($8/MTok), komplexe Muster in den Backtest-Ergebnissen zu erkennen. In einem Projekt konnte ich meine Sharpe Ratio von 1.2 auf 1.85 verbessern — allein durch KI-gestützte Parameteroptimierung.
Der Tagesablauf sieht jetzt so aus: Ich sammle die Daten über Nacht, lasse morgens die Grid Search laufen (ca. 3.000 Kombinationen kosten mich mit HolySheep weniger als $2), und nutze die Mittagspause, um die KI-Analyse zu studieren. Effizienter geht's nicht.
Häufige Fehler und Lösungen
1. Look-Ahead Bias in der Indikatorberechnung
Fehler:
# FEHLERHAFT: Nutzt zukünftige Daten in der Berechnung
df['future_return'] = df['close'].shift(-1) # Look-Ahead!
df['optimized_sma'] = df['close'].rolling(window=20).mean()
df['trade_signal'] = (df['close'] > df['optimized_sma']).shift(1)Lösung:
# KORREKT: Berechne Indikatoren mit historischen Daten
df['sma'] = df['close'].rolling(window=20).mean()
Generiere Signale NACH der Berechnung
df['signal'] = 0
df.loc[df['close'] > df['sma'], 'signal'] = 1
Verifiziere: Keine NaN-Werte vor dem ersten gültigen Signal
first_valid = df['sma'].first_valid_index()
df = df.loc[first_valid:].copy()2. Fehlende Slippage- und Gebührenmodellierung
Fehler:
# FEHLERHAFT: Ignoriert Transaktionskosten
def execute_trade(self, price, size):
return size * price # Annahme: Zero-Cost TradingLösung:
# KORREKT: Realistische Kostenmodellierung
class RealisticExecution:
def __init__(
self,
commission_rate=0.001, # 0.1% Börsengebühr
slippage_bps=10, # 10 Basispunkte Slippage
spread_cost=0.0005 # 0.05% Spread
):
self.total_cost_rate = commission_rate + (slippage_bps / 10000) + spread_cost
def execute_trade(self, price, size, side='buy'):
"""Berechnet realen Ausführungspreis mit Kosten"""
# Slippage basierend auf Ordergröße (vereinfacht)
slippage = price * (slippage_bps / 10000)
if side == 'buy':
execution_price = price + slippage
else:
execution_price = price - slippage
# Gesamtkosten abziehen
net_proceeds = size * execution_price * (1 - self.total_cost_rate)
return {
'execution_price': execution_price,
'net_proceeds': net_proceeds,
'total_cost': size * execution_price * self.total_cost_rate
}
Nutzung
executor = RealisticExecution()
result = executor.execute_trade(price=50000, size=0.1, side='buy')
print(f"Tatsächlicher Preis: ${result['execution_price']:.2f}")
print(f"Gesamtkosten: ${result['total_cost']:.2f}")3. Überanpassung (Overfitting) der Parameter
Fehler:
# FEHLERHAFT: Zu feine Parametergrid führt zu Overfitting
param_grid = {
'fast_sma': range(1, 100), # 99 Werte!
'slow_sma': range(5, 200), # 195 Werte!
}
Ergebnis: "Perfect fit" für Vergangenheit, katastrophal für Zukunft
Lösung:
# KORREKT: Walk-Forward-Analyse mit robusten Parametern
class WalkForwardOptimizer:
def __init__(self, data, train_ratio=0.7):
self.data = data
self.train_ratio = train_ratio
def walk_forward_analysis(
self,
param_grid,
n_windows=5
):
"""Führt Walk-Forward-Analyse durch"""
window_size = len(self.data) // n_windows
all_results = []
for i in range(n_windows):
# Definiere Trainings- und Testfenster
test_end = (i + 1) * window_size
test_start = test_end - window_size
train_end = test_start
train_start = 0
train_data = self.data.iloc[train_start:train_end]
test_data = self.data.iloc[test_start:test_end]
# Optimiere auf Trainingsdaten
optimizer = ParameterOptimizer(train_data)
train_results = optimizer.grid_search(param_grid)
best_params = train_results[0]['params']
# Teste auf Out-of-Sample-Daten
backtester = MovingAverageBacktester(test_data)
test_metrics = backtester.run_sma_crossover(**best_params)
all_results.append({
'window': i + 1,
'train_return': train_results[0]['metrics']['total_return'],
'test_return': test_metrics['total_return'],
'params': best_params,
'overfit_ratio': test_metrics['total_return'] / train_results[0]['metrics']['total_return']
})
print(f"Fenster {i+1}: Train={train_results[0]['metrics']['total_return']:.1f}%, "
f"Test={test_metrics['total_return']:.1f}%")
# Berechne durchschnittliche Out-of-Sample-Performance
avg_test_return = np.mean([r['test_return'] for r in all_results])
avg_overfit = np.mean([r['overfit_ratio'] for r in all_results])
print(f"\nDurchschnittliche Out-of-Sample Return: {avg_test_return:.2f}%")
print(f"Overfit-Verhältnis: {avg_overfit:.2f} (Ideal: 0.7-1.0)")
return all_results
Nutzung mit robustem Parametergrid
param_grid = {
'fast_sma': [10, 20, 30], # Reduziert!
'slow_sma': [40, 60, 80], # Reduziert!
'stop_loss': [0.05, 0.10],
'take_profit': [0.10, 0.15]
}
wf_optimizer = WalkForwardOptimizer(data)
results = wf_optimizer.walk_forward_analysis(param_grid, n_windows=5)4. API-Timeout bei großen Datenmengen
Fehler:
# FEHLERHAFT: Keine Fehlerbehandlung für API-Aufrufe
def analyze_large_dataset(data):
response = client.chat.completions.create(
model="gpt-4.1",
messages=[{"role": "user", "content": str(data)}]
)
return responseLösung:
# KORREKT: Robuste API-Integration mit HolySheep
import time
from openai import OpenAI, RateLimitError, APIError
class HolySheepClient:
def __init__(self, api_key, max_retries=3):
self.client = OpenAI(
api_key=api_key,
base_url="https://api.holysheep.ai/v1"
)
self.max_retries = max_retries
self.request_count = 0
def chat_completion_with_retry(self, messages, model="gpt-4.1"):
"""API-Aufruf mit automatischem Retry"""
for attempt in range(self.max_retries):
try:
self.request_count += 1
response = self.client.chat.completions.create(
model=model,
messages=messages,
timeout=60 # 60 Sekunden Timeout
)
return response
except RateLimitError:
wait_time = (2 ** attempt) * 1.5 # Exponentielles Backoff
print(f"Rate Limit erreicht. Warte {wait_time}s...")
time.sleep(wait_time)
except APIError as e:
if attempt == self.max_retries - 1:
raise Exception(f"API-Fehler nach {self.max_retries} Versuchen: {e}")
time.sleep(2 ** attempt)
except Exception as e:
print(f"Unerwarteter Fehler: {e}")
raise
raise Exception("Max retries erreicht")
def batch_analyze_trades(self, trades_batch, analyzer):
"""Analysiert mehrere Trades stapelweise"""
results = []
batch_size = 10
for i in range(0, len(trades_batch), batch_size):
batch = trades_batch[i:i+batch_size]
# Daten komprimieren für API
batch_summary = [
{
'date': t.entry_date.isoformat(),
'return': t.pnl_percent,
'duration_days