401 lines
17 KiB
Python
401 lines
17 KiB
Python
"""
|
||
RSI Indicators Comparison Test
|
||
|
||
Focused testing for RSI and Simple RSI implementations.
|
||
"""
|
||
|
||
import pandas as pd
|
||
import numpy as np
|
||
import matplotlib.pyplot as plt
|
||
import matplotlib.dates as mdates
|
||
from datetime import datetime
|
||
import sys
|
||
from pathlib import Path
|
||
|
||
# Add project root to path
|
||
project_root = Path(__file__).parent.parent
|
||
sys.path.insert(0, str(project_root))
|
||
|
||
# Import original indicators
|
||
from cycles.IncStrategies.indicators import (
|
||
RSIState as OriginalRSI,
|
||
SimpleRSIState as OriginalSimpleRSI
|
||
)
|
||
|
||
# Import new indicators
|
||
from IncrementalTrader.strategies.indicators import (
|
||
RSIState as NewRSI,
|
||
SimpleRSIState as NewSimpleRSI
|
||
)
|
||
|
||
|
||
class RSIComparisonTest:
|
||
"""Test framework for comparing RSI implementations."""
|
||
|
||
def __init__(self, data_file: str = "data/btcusd_1-min_data.csv", sample_size: int = 5000):
|
||
self.data_file = data_file
|
||
self.sample_size = sample_size
|
||
self.data = None
|
||
self.results = {}
|
||
|
||
# Create results directory
|
||
self.results_dir = Path("test/results/rsi_indicators")
|
||
self.results_dir.mkdir(parents=True, exist_ok=True)
|
||
|
||
def load_data(self):
|
||
"""Load and prepare the data for testing."""
|
||
print(f"Loading data from {self.data_file}...")
|
||
|
||
df = pd.read_csv(self.data_file)
|
||
df['datetime'] = pd.to_datetime(df['Timestamp'], unit='s')
|
||
|
||
if self.sample_size and len(df) > self.sample_size:
|
||
df = df.tail(self.sample_size).reset_index(drop=True)
|
||
|
||
self.data = df
|
||
print(f"Loaded {len(df)} data points from {df['datetime'].iloc[0]} to {df['datetime'].iloc[-1]}")
|
||
|
||
def test_rsi(self, periods=[7, 14, 21, 28]):
|
||
"""Test RSI implementations (Wilder's smoothing)."""
|
||
print("\n=== Testing RSI (Wilder's Smoothing) ===")
|
||
|
||
for period in periods:
|
||
print(f"Testing RSI({period})...")
|
||
|
||
# Initialize indicators
|
||
original_rsi = OriginalRSI(period)
|
||
new_rsi = NewRSI(period)
|
||
|
||
original_values = []
|
||
new_values = []
|
||
prices = []
|
||
price_changes = []
|
||
|
||
# Process data
|
||
prev_price = None
|
||
for _, row in self.data.iterrows():
|
||
price = row['Close']
|
||
prices.append(price)
|
||
|
||
if prev_price is not None:
|
||
price_changes.append(price - prev_price)
|
||
else:
|
||
price_changes.append(0)
|
||
|
||
original_rsi.update(price)
|
||
new_rsi.update(price)
|
||
|
||
original_values.append(original_rsi.get_current_value() if original_rsi.is_warmed_up() else np.nan)
|
||
new_values.append(new_rsi.get_current_value() if new_rsi.is_warmed_up() else np.nan)
|
||
|
||
prev_price = price
|
||
|
||
# Store results
|
||
self.results[f'RSI_{period}'] = {
|
||
'original': original_values,
|
||
'new': new_values,
|
||
'prices': prices,
|
||
'price_changes': price_changes,
|
||
'dates': self.data['datetime'].tolist(),
|
||
'period': period
|
||
}
|
||
|
||
# Calculate differences
|
||
diff = np.array(new_values) - np.array(original_values)
|
||
valid_diff = diff[~np.isnan(diff)]
|
||
|
||
if len(valid_diff) > 0:
|
||
max_diff = np.max(np.abs(valid_diff))
|
||
mean_diff = np.mean(np.abs(valid_diff))
|
||
std_diff = np.std(valid_diff)
|
||
|
||
print(f" Max difference: {max_diff:.12f}")
|
||
print(f" Mean difference: {mean_diff:.12f}")
|
||
print(f" Std difference: {std_diff:.12f}")
|
||
|
||
# Status check
|
||
if max_diff < 1e-10:
|
||
print(f" ✅ PASSED: Mathematically equivalent")
|
||
elif max_diff < 1e-6:
|
||
print(f" ⚠️ WARNING: Small differences (floating point precision)")
|
||
else:
|
||
print(f" ❌ FAILED: Significant differences detected")
|
||
else:
|
||
print(f" ❌ ERROR: No valid data points")
|
||
|
||
def test_simple_rsi(self, periods=[7, 14, 21, 28]):
|
||
"""Test Simple RSI implementations (Simple moving average)."""
|
||
print("\n=== Testing Simple RSI (Simple Moving Average) ===")
|
||
|
||
for period in periods:
|
||
print(f"Testing SimpleRSI({period})...")
|
||
|
||
# Initialize indicators
|
||
original_rsi = OriginalSimpleRSI(period)
|
||
new_rsi = NewSimpleRSI(period)
|
||
|
||
original_values = []
|
||
new_values = []
|
||
prices = []
|
||
price_changes = []
|
||
|
||
# Process data
|
||
prev_price = None
|
||
for _, row in self.data.iterrows():
|
||
price = row['Close']
|
||
prices.append(price)
|
||
|
||
if prev_price is not None:
|
||
price_changes.append(price - prev_price)
|
||
else:
|
||
price_changes.append(0)
|
||
|
||
original_rsi.update(price)
|
||
new_rsi.update(price)
|
||
|
||
original_values.append(original_rsi.get_current_value() if original_rsi.is_warmed_up() else np.nan)
|
||
new_values.append(new_rsi.get_current_value() if new_rsi.is_warmed_up() else np.nan)
|
||
|
||
prev_price = price
|
||
|
||
# Store results
|
||
self.results[f'SimpleRSI_{period}'] = {
|
||
'original': original_values,
|
||
'new': new_values,
|
||
'prices': prices,
|
||
'price_changes': price_changes,
|
||
'dates': self.data['datetime'].tolist(),
|
||
'period': period
|
||
}
|
||
|
||
# Calculate differences
|
||
diff = np.array(new_values) - np.array(original_values)
|
||
valid_diff = diff[~np.isnan(diff)]
|
||
|
||
if len(valid_diff) > 0:
|
||
max_diff = np.max(np.abs(valid_diff))
|
||
mean_diff = np.mean(np.abs(valid_diff))
|
||
std_diff = np.std(valid_diff)
|
||
|
||
print(f" Max difference: {max_diff:.12f}")
|
||
print(f" Mean difference: {mean_diff:.12f}")
|
||
print(f" Std difference: {std_diff:.12f}")
|
||
|
||
# Status check
|
||
if max_diff < 1e-10:
|
||
print(f" ✅ PASSED: Mathematically equivalent")
|
||
elif max_diff < 1e-6:
|
||
print(f" ⚠️ WARNING: Small differences (floating point precision)")
|
||
else:
|
||
print(f" ❌ FAILED: Significant differences detected")
|
||
else:
|
||
print(f" ❌ ERROR: No valid data points")
|
||
|
||
def plot_comparison(self, indicator_name: str):
|
||
"""Plot detailed comparison for a specific indicator."""
|
||
if indicator_name not in self.results:
|
||
print(f"No results found for {indicator_name}")
|
||
return
|
||
|
||
result = self.results[indicator_name]
|
||
dates = pd.to_datetime(result['dates'])
|
||
|
||
# Create figure with subplots
|
||
fig, axes = plt.subplots(4, 1, figsize=(15, 16))
|
||
fig.suptitle(f'{indicator_name} - Detailed Comparison Analysis', fontsize=16)
|
||
|
||
# Plot 1: Price data
|
||
ax1 = axes[0]
|
||
ax1.plot(dates, result['prices'], label='Close Price', alpha=0.8, color='black', linewidth=1)
|
||
ax1.set_title('Price Data')
|
||
ax1.legend()
|
||
ax1.grid(True, alpha=0.3)
|
||
|
||
# Plot 2: RSI comparison with levels
|
||
ax2 = axes[1]
|
||
ax2.plot(dates, result['original'], label='Original', alpha=0.8, linewidth=2, color='blue')
|
||
ax2.plot(dates, result['new'], label='New', alpha=0.8, linewidth=2, linestyle='--', color='red')
|
||
ax2.axhline(y=70, color='red', linestyle=':', alpha=0.7, label='Overbought (70)')
|
||
ax2.axhline(y=30, color='green', linestyle=':', alpha=0.7, label='Oversold (30)')
|
||
ax2.axhline(y=50, color='gray', linestyle='-', alpha=0.5, label='Midline (50)')
|
||
ax2.set_title(f'{indicator_name} Values Comparison')
|
||
ax2.set_ylim(0, 100)
|
||
ax2.legend()
|
||
ax2.grid(True, alpha=0.3)
|
||
|
||
# Plot 3: Price changes
|
||
ax3 = axes[2]
|
||
positive_changes = [max(0, change) for change in result['price_changes']]
|
||
negative_changes = [abs(min(0, change)) for change in result['price_changes']]
|
||
ax3.plot(dates, positive_changes, label='Positive Changes', alpha=0.7, color='green')
|
||
ax3.plot(dates, negative_changes, label='Negative Changes', alpha=0.7, color='red')
|
||
ax3.set_title('Price Changes (Gains and Losses)')
|
||
ax3.legend()
|
||
ax3.grid(True, alpha=0.3)
|
||
|
||
# Plot 4: Difference analysis
|
||
ax4 = axes[3]
|
||
diff = np.array(result['new']) - np.array(result['original'])
|
||
ax4.plot(dates, diff, color='red', alpha=0.7, linewidth=1)
|
||
ax4.set_title(f'{indicator_name} Difference (New - Original)')
|
||
ax4.axhline(y=0, color='black', linestyle='-', alpha=0.5)
|
||
ax4.grid(True, alpha=0.3)
|
||
|
||
# Add statistics text
|
||
valid_diff = diff[~np.isnan(diff)]
|
||
if len(valid_diff) > 0:
|
||
stats_text = f'Max: {np.max(np.abs(valid_diff)):.2e}\n'
|
||
stats_text += f'Mean: {np.mean(np.abs(valid_diff)):.2e}\n'
|
||
stats_text += f'Std: {np.std(valid_diff):.2e}'
|
||
ax4.text(0.02, 0.98, stats_text, transform=ax4.transAxes,
|
||
verticalalignment='top', bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.8))
|
||
|
||
# Format x-axis
|
||
for ax in axes:
|
||
ax.xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d'))
|
||
ax.xaxis.set_major_locator(mdates.DayLocator(interval=max(1, len(dates)//10)))
|
||
plt.setp(ax.xaxis.get_majorticklabels(), rotation=45)
|
||
|
||
plt.tight_layout()
|
||
|
||
# Save plot
|
||
plot_path = self.results_dir / f"{indicator_name}_detailed_comparison.png"
|
||
plt.savefig(plot_path, dpi=300, bbox_inches='tight')
|
||
print(f"Plot saved to {plot_path}")
|
||
|
||
plt.show()
|
||
|
||
def plot_all_comparisons(self):
|
||
"""Plot comparisons for all tested indicators."""
|
||
print("\n=== Generating Detailed Comparison Plots ===")
|
||
|
||
for indicator_name in self.results.keys():
|
||
print(f"Plotting {indicator_name}...")
|
||
self.plot_comparison(indicator_name)
|
||
plt.close('all')
|
||
|
||
def generate_report(self):
|
||
"""Generate detailed report for RSI indicators."""
|
||
print("\n=== Generating RSI Report ===")
|
||
|
||
report_lines = []
|
||
report_lines.append("# RSI Indicators Comparison Report")
|
||
report_lines.append(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
|
||
report_lines.append(f"Data file: {self.data_file}")
|
||
report_lines.append(f"Sample size: {len(self.data)} data points")
|
||
report_lines.append("")
|
||
|
||
# Summary table
|
||
report_lines.append("## Summary Table")
|
||
report_lines.append("| Indicator | Period | Max Diff | Mean Diff | Status |")
|
||
report_lines.append("|-----------|--------|----------|-----------|--------|")
|
||
|
||
for indicator_name, result in self.results.items():
|
||
diff = np.array(result['new']) - np.array(result['original'])
|
||
valid_diff = diff[~np.isnan(diff)]
|
||
|
||
if len(valid_diff) > 0:
|
||
max_diff = np.max(np.abs(valid_diff))
|
||
mean_diff = np.mean(np.abs(valid_diff))
|
||
|
||
if max_diff < 1e-10:
|
||
status = "✅ PASSED"
|
||
elif max_diff < 1e-6:
|
||
status = "⚠️ WARNING"
|
||
else:
|
||
status = "❌ FAILED"
|
||
|
||
report_lines.append(f"| {indicator_name} | {result['period']} | {max_diff:.2e} | {mean_diff:.2e} | {status} |")
|
||
else:
|
||
report_lines.append(f"| {indicator_name} | {result['period']} | N/A | N/A | ❌ ERROR |")
|
||
|
||
report_lines.append("")
|
||
|
||
# Methodology explanation
|
||
report_lines.append("## Methodology")
|
||
report_lines.append("### RSI (Relative Strength Index)")
|
||
report_lines.append("- Uses Wilder's smoothing for average gains and losses")
|
||
report_lines.append("- Average Gain = (Previous Average Gain × (n-1) + Current Gain) / n")
|
||
report_lines.append("- Average Loss = (Previous Average Loss × (n-1) + Current Loss) / n")
|
||
report_lines.append("- RS = Average Gain / Average Loss")
|
||
report_lines.append("- RSI = 100 - (100 / (1 + RS))")
|
||
report_lines.append("")
|
||
report_lines.append("### Simple RSI")
|
||
report_lines.append("- Uses simple moving average for average gains and losses")
|
||
report_lines.append("- More responsive to recent price changes than Wilder's method")
|
||
report_lines.append("")
|
||
|
||
# Detailed analysis
|
||
report_lines.append("## Detailed Analysis")
|
||
|
||
for indicator_name, result in self.results.items():
|
||
report_lines.append(f"### {indicator_name}")
|
||
|
||
diff = np.array(result['new']) - np.array(result['original'])
|
||
valid_diff = diff[~np.isnan(diff)]
|
||
|
||
if len(valid_diff) > 0:
|
||
report_lines.append(f"- **Period**: {result['period']}")
|
||
report_lines.append(f"- **Valid data points**: {len(valid_diff)}")
|
||
report_lines.append(f"- **Max absolute difference**: {np.max(np.abs(valid_diff)):.12f}")
|
||
report_lines.append(f"- **Mean absolute difference**: {np.mean(np.abs(valid_diff)):.12f}")
|
||
report_lines.append(f"- **Standard deviation**: {np.std(valid_diff):.12f}")
|
||
|
||
# RSI-specific metrics
|
||
valid_original = np.array(result['original'])[~np.isnan(result['original'])]
|
||
if len(valid_original) > 0:
|
||
mean_rsi = np.mean(valid_original)
|
||
overbought_count = np.sum(valid_original > 70)
|
||
oversold_count = np.sum(valid_original < 30)
|
||
|
||
report_lines.append(f"- **Mean RSI value**: {mean_rsi:.2f}")
|
||
report_lines.append(f"- **Overbought periods (>70)**: {overbought_count} ({overbought_count/len(valid_original)*100:.1f}%)")
|
||
report_lines.append(f"- **Oversold periods (<30)**: {oversold_count} ({oversold_count/len(valid_original)*100:.1f}%)")
|
||
|
||
# Price change analysis
|
||
positive_changes = [max(0, change) for change in result['price_changes']]
|
||
negative_changes = [abs(min(0, change)) for change in result['price_changes']]
|
||
avg_gain = np.mean([change for change in positive_changes if change > 0]) if any(change > 0 for change in positive_changes) else 0
|
||
avg_loss = np.mean([change for change in negative_changes if change > 0]) if any(change > 0 for change in negative_changes) else 0
|
||
|
||
report_lines.append(f"- **Average gain**: {avg_gain:.6f}")
|
||
report_lines.append(f"- **Average loss**: {avg_loss:.6f}")
|
||
if avg_loss > 0:
|
||
report_lines.append(f"- **Gain/Loss ratio**: {avg_gain/avg_loss:.3f}")
|
||
|
||
# Percentile analysis
|
||
percentiles = [1, 5, 25, 50, 75, 95, 99]
|
||
perc_values = np.percentile(np.abs(valid_diff), percentiles)
|
||
perc_str = ", ".join([f"P{p}: {v:.2e}" for p, v in zip(percentiles, perc_values)])
|
||
report_lines.append(f"- **Percentiles**: {perc_str}")
|
||
|
||
report_lines.append("")
|
||
|
||
# Save report
|
||
report_path = self.results_dir / "rsi_indicators_report.md"
|
||
with open(report_path, 'w', encoding='utf-8') as f:
|
||
f.write('\n'.join(report_lines))
|
||
|
||
print(f"Report saved to {report_path}")
|
||
|
||
def run_tests(self):
|
||
"""Run all RSI tests."""
|
||
print("Starting RSI Comparison Tests...")
|
||
|
||
# Load data
|
||
self.load_data()
|
||
|
||
# Run tests
|
||
self.test_rsi()
|
||
self.test_simple_rsi()
|
||
|
||
# Generate outputs
|
||
self.plot_all_comparisons()
|
||
self.generate_report()
|
||
|
||
print("\n✅ RSI tests completed!")
|
||
|
||
|
||
if __name__ == "__main__":
|
||
tester = RSIComparisonTest(sample_size=3000)
|
||
tester.run_tests() |