465 lines
19 KiB
Python
465 lines
19 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Simple Strategy Comparison for 2025 Data
|
|
|
|
This script runs both the original and incremental strategies on the same 2025 timeframe
|
|
and creates side-by-side comparison plots.
|
|
"""
|
|
|
|
import pandas as pd
|
|
import numpy as np
|
|
import matplotlib.pyplot as plt
|
|
import matplotlib.dates as mdates
|
|
import logging
|
|
from typing import Dict, List, Tuple
|
|
import os
|
|
import sys
|
|
from datetime import datetime
|
|
import json
|
|
|
|
# Add project root to path
|
|
sys.path.insert(0, os.path.abspath('..'))
|
|
|
|
from cycles.IncStrategies.metatrend_strategy import IncMetaTrendStrategy
|
|
from cycles.IncStrategies.inc_backtester import IncBacktester, BacktestConfig
|
|
from cycles.utils.storage import Storage
|
|
|
|
# Configure logging
|
|
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class SimpleStrategyComparison:
|
|
"""Simple comparison between original and incremental strategies for 2025 data."""
|
|
|
|
def __init__(self, start_date: str = "2025-01-01", end_date: str = "2025-05-01"):
|
|
"""Initialize the comparison."""
|
|
self.start_date = start_date
|
|
self.end_date = end_date
|
|
self.storage = Storage(logging=logger)
|
|
|
|
# Results storage
|
|
self.original_results = None
|
|
self.incremental_results = None
|
|
self.test_data = None
|
|
|
|
def load_data(self) -> pd.DataFrame:
|
|
"""Load test data for the specified date range."""
|
|
logger.info(f"Loading data from {self.start_date} to {self.end_date}")
|
|
|
|
try:
|
|
# Load data directly from CSV file
|
|
data_file = "../data/btcusd_1-min_data.csv"
|
|
logger.info(f"Loading data from: {data_file}")
|
|
|
|
# Read CSV file
|
|
df = pd.read_csv(data_file)
|
|
|
|
# Convert timestamp column
|
|
df['timestamp'] = pd.to_datetime(df['Timestamp'], unit='s')
|
|
|
|
# Rename columns to match expected format
|
|
df = df.rename(columns={
|
|
'Open': 'open',
|
|
'High': 'high',
|
|
'Low': 'low',
|
|
'Close': 'close',
|
|
'Volume': 'volume'
|
|
})
|
|
|
|
# Filter by date range
|
|
start_dt = pd.to_datetime(self.start_date)
|
|
end_dt = pd.to_datetime(self.end_date)
|
|
|
|
df = df[(df['timestamp'] >= start_dt) & (df['timestamp'] < end_dt)]
|
|
|
|
if df.empty:
|
|
raise ValueError(f"No data found for the specified date range: {self.start_date} to {self.end_date}")
|
|
|
|
# Keep only required columns
|
|
df = df[['timestamp', 'open', 'high', 'low', 'close', 'volume']]
|
|
|
|
self.test_data = df
|
|
|
|
logger.info(f"Loaded {len(df)} data points")
|
|
logger.info(f"Date range: {df['timestamp'].min()} to {df['timestamp'].max()}")
|
|
logger.info(f"Price range: ${df['close'].min():.0f} - ${df['close'].max():.0f}")
|
|
|
|
return df
|
|
|
|
except Exception as e:
|
|
logger.error(f"Failed to load test data: {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
raise
|
|
|
|
def load_original_results(self) -> Dict:
|
|
"""Load original strategy results from existing CSV file."""
|
|
logger.info("📂 Loading Original Strategy results from CSV...")
|
|
|
|
try:
|
|
# Load the original trades file
|
|
original_file = "../results/trades_15min(15min)_ST3pct.csv"
|
|
|
|
if not os.path.exists(original_file):
|
|
logger.warning(f"Original trades file not found: {original_file}")
|
|
return None
|
|
|
|
df = pd.read_csv(original_file)
|
|
df['entry_time'] = pd.to_datetime(df['entry_time'])
|
|
df['exit_time'] = pd.to_datetime(df['exit_time'], errors='coerce')
|
|
|
|
# Calculate performance metrics
|
|
buy_signals = df[df['type'] == 'BUY']
|
|
sell_signals = df[df['type'] != 'BUY']
|
|
|
|
# Calculate final value using compounding logic
|
|
initial_usd = 10000
|
|
final_usd = initial_usd
|
|
|
|
for _, trade in sell_signals.iterrows():
|
|
profit_pct = trade['profit_pct']
|
|
final_usd *= (1 + profit_pct)
|
|
|
|
total_return = (final_usd - initial_usd) / initial_usd * 100
|
|
|
|
# Convert to standardized format
|
|
trades = []
|
|
for _, row in df.iterrows():
|
|
trades.append({
|
|
'timestamp': row['entry_time'],
|
|
'type': row['type'],
|
|
'price': row.get('entry_price', row.get('exit_price')),
|
|
'exit_time': row['exit_time'],
|
|
'exit_price': row.get('exit_price'),
|
|
'profit_pct': row.get('profit_pct', 0),
|
|
'source': 'original'
|
|
})
|
|
|
|
performance = {
|
|
'strategy_name': 'Original Strategy',
|
|
'initial_value': initial_usd,
|
|
'final_value': final_usd,
|
|
'total_return': total_return,
|
|
'num_trades': len(sell_signals),
|
|
'trades': trades
|
|
}
|
|
|
|
logger.info(f"✅ Original strategy loaded: {len(sell_signals)} trades, {total_return:.2f}% return")
|
|
|
|
self.original_results = performance
|
|
return performance
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Error loading original strategy: {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
return None
|
|
|
|
def run_incremental_strategy(self, initial_usd: float = 10000) -> Dict:
|
|
"""Run the incremental strategy using the backtester."""
|
|
logger.info("🔄 Running Incremental Strategy...")
|
|
|
|
try:
|
|
# Create strategy instance
|
|
strategy = IncMetaTrendStrategy("metatrend", weight=1.0, params={
|
|
"timeframe": "1min",
|
|
"enable_logging": False
|
|
})
|
|
|
|
# Save our data to a temporary CSV file for the backtester
|
|
temp_data_file = "../data/temp_2025_data.csv"
|
|
|
|
# Prepare data in the format expected by Storage class
|
|
temp_df = self.test_data.copy()
|
|
temp_df['Timestamp'] = temp_df['timestamp'].astype('int64') // 10**9 # Convert to Unix timestamp
|
|
temp_df = temp_df.rename(columns={
|
|
'open': 'Open',
|
|
'high': 'High',
|
|
'low': 'Low',
|
|
'close': 'Close',
|
|
'volume': 'Volume'
|
|
})
|
|
temp_df = temp_df[['Timestamp', 'Open', 'High', 'Low', 'Close', 'Volume']]
|
|
temp_df.to_csv(temp_data_file, index=False)
|
|
|
|
# Create backtest configuration with correct parameters
|
|
config = BacktestConfig(
|
|
data_file="temp_2025_data.csv",
|
|
start_date=self.start_date,
|
|
end_date=self.end_date,
|
|
initial_usd=initial_usd,
|
|
stop_loss_pct=0.03,
|
|
take_profit_pct=0.0
|
|
)
|
|
|
|
# Create backtester
|
|
backtester = IncBacktester(config)
|
|
|
|
# Run backtest
|
|
results = backtester.run_single_strategy(strategy)
|
|
|
|
# Clean up temporary file
|
|
if os.path.exists(temp_data_file):
|
|
os.remove(temp_data_file)
|
|
|
|
# Extract results
|
|
trades = results.get('trades', [])
|
|
|
|
# Convert trades to standardized format
|
|
standardized_trades = []
|
|
for trade in trades:
|
|
standardized_trades.append({
|
|
'timestamp': trade.entry_time,
|
|
'type': 'BUY',
|
|
'price': trade.entry_price,
|
|
'exit_time': trade.exit_time,
|
|
'exit_price': trade.exit_price,
|
|
'profit_pct': trade.profit_pct,
|
|
'source': 'incremental'
|
|
})
|
|
|
|
# Add sell signal
|
|
if trade.exit_time:
|
|
standardized_trades.append({
|
|
'timestamp': trade.exit_time,
|
|
'type': 'SELL',
|
|
'price': trade.exit_price,
|
|
'exit_time': trade.exit_time,
|
|
'exit_price': trade.exit_price,
|
|
'profit_pct': trade.profit_pct,
|
|
'source': 'incremental'
|
|
})
|
|
|
|
# Calculate performance metrics
|
|
final_value = results.get('final_usd', initial_usd)
|
|
total_return = (final_value - initial_usd) / initial_usd * 100
|
|
|
|
performance = {
|
|
'strategy_name': 'Incremental MetaTrend',
|
|
'initial_value': initial_usd,
|
|
'final_value': final_value,
|
|
'total_return': total_return,
|
|
'num_trades': results.get('n_trades', 0),
|
|
'trades': standardized_trades
|
|
}
|
|
|
|
logger.info(f"✅ Incremental strategy completed: {results.get('n_trades', 0)} trades, {total_return:.2f}% return")
|
|
|
|
self.incremental_results = performance
|
|
return performance
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Error running incremental strategy: {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
return None
|
|
|
|
def create_side_by_side_comparison(self, save_path: str = "../results/strategy_comparison_2025_simple.png"):
|
|
"""Create side-by-side comparison plots."""
|
|
logger.info("📊 Creating side-by-side comparison plots...")
|
|
|
|
# Create figure with subplots
|
|
fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(20, 16))
|
|
|
|
# Plot 1: Original Strategy Signals
|
|
self._plot_strategy_signals(ax1, self.original_results, "Original Strategy", 'blue')
|
|
|
|
# Plot 2: Incremental Strategy Signals
|
|
self._plot_strategy_signals(ax2, self.incremental_results, "Incremental Strategy", 'red')
|
|
|
|
# Plot 3: Performance Comparison
|
|
self._plot_performance_comparison(ax3)
|
|
|
|
# Plot 4: Trade Statistics
|
|
self._plot_trade_statistics(ax4)
|
|
|
|
# Overall title
|
|
fig.suptitle(f'Strategy Comparison: {self.start_date} to {self.end_date}',
|
|
fontsize=20, fontweight='bold', y=0.98)
|
|
|
|
# Adjust layout and save
|
|
plt.tight_layout()
|
|
plt.savefig(save_path, dpi=300, bbox_inches='tight')
|
|
plt.show()
|
|
|
|
logger.info(f"📈 Comparison plot saved to: {save_path}")
|
|
|
|
def _plot_strategy_signals(self, ax, results: Dict, title: str, color: str):
|
|
"""Plot price data with trading signals for a single strategy."""
|
|
if not results:
|
|
ax.text(0.5, 0.5, f"No data for {title}", ha='center', va='center', transform=ax.transAxes)
|
|
return
|
|
|
|
# Plot price data
|
|
ax.plot(self.test_data['timestamp'], self.test_data['close'],
|
|
color='black', linewidth=1, alpha=0.7, label='BTC Price')
|
|
|
|
# Plot trading signals
|
|
trades = results['trades']
|
|
buy_signals = [t for t in trades if t['type'] == 'BUY']
|
|
sell_signals = [t for t in trades if t['type'] == 'SELL' or t['type'] != 'BUY']
|
|
|
|
if buy_signals:
|
|
buy_times = [t['timestamp'] for t in buy_signals]
|
|
buy_prices = [t['price'] for t in buy_signals]
|
|
ax.scatter(buy_times, buy_prices, color='green', marker='^',
|
|
s=80, label=f'Buy ({len(buy_signals)})', zorder=5, alpha=0.8)
|
|
|
|
if sell_signals:
|
|
# Separate profitable and losing sells
|
|
profitable_sells = [t for t in sell_signals if t.get('profit_pct', 0) > 0]
|
|
losing_sells = [t for t in sell_signals if t.get('profit_pct', 0) <= 0]
|
|
|
|
if profitable_sells:
|
|
profit_times = [t['timestamp'] for t in profitable_sells]
|
|
profit_prices = [t['price'] for t in profitable_sells]
|
|
ax.scatter(profit_times, profit_prices, color='blue', marker='v',
|
|
s=80, label=f'Profitable Sell ({len(profitable_sells)})', zorder=5, alpha=0.8)
|
|
|
|
if losing_sells:
|
|
loss_times = [t['timestamp'] for t in losing_sells]
|
|
loss_prices = [t['price'] for t in losing_sells]
|
|
ax.scatter(loss_times, loss_prices, color='red', marker='v',
|
|
s=80, label=f'Loss Sell ({len(losing_sells)})', zorder=5, alpha=0.8)
|
|
|
|
ax.set_title(title, fontsize=14, fontweight='bold')
|
|
ax.set_ylabel('Price (USD)', fontsize=12)
|
|
ax.legend(loc='upper left', fontsize=10)
|
|
ax.grid(True, alpha=0.3)
|
|
ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'${x:,.0f}'))
|
|
|
|
# Format x-axis
|
|
ax.xaxis.set_major_locator(mdates.DayLocator(interval=7))
|
|
ax.xaxis.set_major_formatter(mdates.DateFormatter('%m-%d'))
|
|
plt.setp(ax.xaxis.get_majorticklabels(), rotation=45)
|
|
|
|
def _plot_performance_comparison(self, ax):
|
|
"""Plot performance comparison bar chart."""
|
|
if not self.original_results or not self.incremental_results:
|
|
ax.text(0.5, 0.5, "Performance data not available", ha='center', va='center',
|
|
transform=ax.transAxes, fontsize=14)
|
|
return
|
|
|
|
strategies = ['Original', 'Incremental']
|
|
returns = [self.original_results['total_return'], self.incremental_results['total_return']]
|
|
colors = ['blue', 'red']
|
|
|
|
bars = ax.bar(strategies, returns, color=colors, alpha=0.7)
|
|
|
|
# Add value labels on bars
|
|
for bar, return_val in zip(bars, returns):
|
|
height = bar.get_height()
|
|
ax.text(bar.get_x() + bar.get_width()/2., height + (1 if height >= 0 else -3),
|
|
f'{return_val:.1f}%', ha='center', va='bottom' if height >= 0 else 'top',
|
|
fontweight='bold', fontsize=12)
|
|
|
|
ax.set_title('Total Return Comparison', fontsize=14, fontweight='bold')
|
|
ax.set_ylabel('Return (%)', fontsize=12)
|
|
ax.grid(True, alpha=0.3, axis='y')
|
|
ax.axhline(y=0, color='black', linestyle='-', alpha=0.5)
|
|
|
|
def _plot_trade_statistics(self, ax):
|
|
"""Create trade statistics table."""
|
|
ax.axis('off')
|
|
|
|
if not self.original_results or not self.incremental_results:
|
|
ax.text(0.5, 0.5, "Trade data not available", ha='center', va='center',
|
|
transform=ax.transAxes, fontsize=14)
|
|
return
|
|
|
|
# Create comparison table
|
|
orig = self.original_results
|
|
incr = self.incremental_results
|
|
|
|
comparison_text = f"""
|
|
STRATEGY COMPARISON SUMMARY
|
|
{'='*50}
|
|
|
|
{'Metric':<20} {'Original':<15} {'Incremental':<15} {'Difference':<15}
|
|
{'-'*65}
|
|
{'Initial Value':<20} ${orig['initial_value']:>10,.0f} ${incr['initial_value']:>12,.0f} ${incr['initial_value'] - orig['initial_value']:>12,.0f}
|
|
{'Final Value':<20} ${orig['final_value']:>10,.0f} ${incr['final_value']:>12,.0f} ${incr['final_value'] - orig['final_value']:>12,.0f}
|
|
{'Total Return':<20} {orig['total_return']:>10.1f}% {incr['total_return']:>12.1f}% {incr['total_return'] - orig['total_return']:>12.1f}%
|
|
{'Number of Trades':<20} {orig['num_trades']:>10} {incr['num_trades']:>12} {incr['num_trades'] - orig['num_trades']:>12}
|
|
|
|
TIMEFRAME: {self.start_date} to {self.end_date}
|
|
DATA POINTS: {len(self.test_data):,} minute bars
|
|
PRICE RANGE: ${self.test_data['close'].min():,.0f} - ${self.test_data['close'].max():,.0f}
|
|
|
|
Both strategies use MetaTrend logic with 3% stop loss.
|
|
Differences indicate implementation variations.
|
|
"""
|
|
|
|
ax.text(0.05, 0.95, comparison_text, transform=ax.transAxes, fontsize=10,
|
|
verticalalignment='top', fontfamily='monospace',
|
|
bbox=dict(boxstyle="round,pad=0.5", facecolor="lightgray", alpha=0.9))
|
|
|
|
def save_results(self, output_dir: str = "../results"):
|
|
"""Save detailed results to files."""
|
|
logger.info("💾 Saving detailed results...")
|
|
|
|
os.makedirs(output_dir, exist_ok=True)
|
|
|
|
# Save performance summary
|
|
summary = {
|
|
'timeframe': f"{self.start_date} to {self.end_date}",
|
|
'data_points': len(self.test_data) if self.test_data is not None else 0,
|
|
'original_strategy': self.original_results,
|
|
'incremental_strategy': self.incremental_results,
|
|
'comparison_timestamp': datetime.now().isoformat()
|
|
}
|
|
|
|
summary_file = f"{output_dir}/strategy_comparison_2025_simple.json"
|
|
with open(summary_file, 'w') as f:
|
|
json.dump(summary, f, indent=2, default=str)
|
|
logger.info(f"Performance summary saved to: {summary_file}")
|
|
|
|
def run_full_comparison(self, initial_usd: float = 10000):
|
|
"""Run the complete comparison workflow."""
|
|
logger.info("🚀 Starting Simple Strategy Comparison for 2025")
|
|
logger.info("=" * 60)
|
|
|
|
try:
|
|
# Load data
|
|
self.load_data()
|
|
|
|
# Load original results and run incremental strategy
|
|
self.load_original_results()
|
|
self.run_incremental_strategy(initial_usd)
|
|
|
|
# Create comparison plots
|
|
self.create_side_by_side_comparison()
|
|
|
|
# Save results
|
|
self.save_results()
|
|
|
|
# Print summary
|
|
if self.original_results and self.incremental_results:
|
|
logger.info("\n📊 COMPARISON SUMMARY:")
|
|
logger.info(f"Original Strategy: ${self.original_results['final_value']:,.0f} ({self.original_results['total_return']:+.2f}%)")
|
|
logger.info(f"Incremental Strategy: ${self.incremental_results['final_value']:,.0f} ({self.incremental_results['total_return']:+.2f}%)")
|
|
logger.info(f"Difference: ${self.incremental_results['final_value'] - self.original_results['final_value']:,.0f} ({self.incremental_results['total_return'] - self.original_results['total_return']:+.2f}%)")
|
|
|
|
logger.info("✅ Simple comparison completed successfully!")
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Error during comparison: {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
|
|
|
|
def main():
|
|
"""Main function to run the strategy comparison."""
|
|
# Create comparison instance
|
|
comparison = SimpleStrategyComparison(
|
|
start_date="2025-01-01",
|
|
end_date="2025-05-01"
|
|
)
|
|
|
|
# Run full comparison
|
|
comparison.run_full_comparison(initial_usd=10000)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main() |