Backtesting Trading Strategies with Ollama: Historical Performance Analysis Guide

# Install Ollama (macOS/Linux)
curl -fsSL https://ollama.ai/install.sh | sh

# Pull the recommended model for financial analysis
ollama pull llama2:13b

# Verify installation
ollama list

import pandas as pd
import yfinance as yf

# Download historical data for backtesting
def prepare_market_data(symbol, period="2y"):
    """
    Download and prepare market data for Ollama analysis
    Returns clean OHLCV data with technical indicators
    """
    # Fetch data from Yahoo Finance
    ticker = yf.Ticker(symbol)
    data = ticker.history(period=period)
    
    # Add basic technical indicators
    data['SMA_20'] = data['Close'].rolling(window=20).mean()
    data['SMA_50'] = data['Close'].rolling(window=50).mean()
    data['RSI'] = calculate_rsi(data['Close'])
    
    # Clean data for analysis
    data = data.dropna()
    
    return data

# Example usage
spy_data = prepare_market_data("SPY", "5y")
print(f"Prepared {len(spy_data)} days of market data")

def create_backtesting_prompt(strategy_description, data_summary):
    """
    Generate comprehensive backtesting prompt for Ollama
    Includes strategy rules and data context
    """
    prompt = f"""
    Analyze this trading strategy using the provided historical data:
    
    Strategy: {strategy_description}
    
    Data Summary:
    - Period: {data_summary['start']} to {data_summary['end']}
    - Total trading days: {data_summary['days']}
    - Volatility: {data_summary['volatility']:.2%}
    - Market trend: {data_summary['trend']}
    
    Perform backtesting analysis including:
    1. Entry and exit signals based on strategy rules
    2. Risk-adjusted returns calculation
    3. Maximum drawdown periods
    4. Win rate and average trade duration
    5. Performance comparison to buy-and-hold
    
    Provide specific recommendations for strategy optimization.
    """
    return prompt

# Example strategy testing
strategy = "Buy when RSI drops below 30, sell when RSI exceeds 70"
data_summary = {
    'start': '2020-01-01',
    'end': '2025-01-01', 
    'days': 1826,
    'volatility': 0.18,
    'trend': 'Bullish with high volatility periods'
}

prompt = create_backtesting_prompt(strategy, data_summary)

def generate_trading_signals(data, strategy_params):
    """
    Generate buy/sell signals based on strategy parameters
    Returns DataFrame with signal timestamps and reasoning
    """
    signals = pd.DataFrame(index=data.index)
    signals['price'] = data['Close']
    signals['signal'] = 0  # 0 = hold, 1 = buy, -1 = sell
    
    # RSI-based signals (example)
    oversold_threshold = strategy_params.get('oversold', 30)
    overbought_threshold = strategy_params.get('overbought', 70)
    
    # Buy signals when RSI oversold
    buy_condition = data['RSI'] < oversold_threshold
    signals.loc[buy_condition, 'signal'] = 1
    
    # Sell signals when RSI overbought  
    sell_condition = data['RSI'] > overbought_threshold
    signals.loc[sell_condition, 'signal'] = -1
    
    # Add signal reasoning for Ollama analysis
    signals['reason'] = ''
    signals.loc[buy_condition, 'reason'] = f'RSI below {oversold_threshold}'
    signals.loc[sell_condition, 'reason'] = f'RSI above {overbought_threshold}'
    
    return signals[signals['signal'] != 0]

# Generate signals for analysis
strategy_params = {'oversold': 25, 'overbought': 75}
signals = generate_trading_signals(spy_data, strategy_params)
print(f"Generated {len(signals)} trading signals")

def calculate_performance_metrics(returns, benchmark_returns):
    """
    Calculate comprehensive performance metrics for Ollama analysis
    Returns dictionary with risk-adjusted performance data
    """
    import numpy as np
    
    metrics = {}
    
    # Basic returns
    metrics['total_return'] = (1 + returns).prod() - 1
    metrics['annualized_return'] = (1 + returns.mean()) ** 252 - 1
    
    # Risk metrics
    metrics['volatility'] = returns.std() * np.sqrt(252)
    metrics['sharpe_ratio'] = (metrics['annualized_return'] - 0.02) / metrics['volatility']
    
    # Drawdown analysis
    cumulative = (1 + returns).cumprod()
    running_max = cumulative.expanding().max()
    drawdown = (cumulative - running_max) / running_max
    metrics['max_drawdown'] = drawdown.min()
    
    # Benchmark comparison
    if benchmark_returns is not None:
        benchmark_total = (1 + benchmark_returns).prod() - 1
        metrics['alpha'] = metrics['total_return'] - benchmark_total
        
        # Beta calculation
        covariance = np.cov(returns.dropna(), benchmark_returns.dropna())[0][1]
        benchmark_variance = np.var(benchmark_returns.dropna())
        metrics['beta'] = covariance / benchmark_variance
    
    return metrics

# Calculate metrics for Ollama analysis
strategy_returns = calculate_strategy_returns(signals, spy_data)
benchmark_returns = spy_data['Close'].pct_change()
performance = calculate_performance_metrics(strategy_returns, benchmark_returns)

print("Performance Summary:")
for metric, value in performance.items():
    print(f"{metric}: {value:.4f}")

def create_optimization_prompt(performance_data, signal_analysis):
    """
    Create detailed optimization prompt for Ollama
    Focuses on improving risk-adjusted returns
    """
    prompt = f"""
    Analyze this trading strategy performance and suggest optimizations:
    
    Current Performance:
    - Total Return: {performance_data['total_return']:.2%}
    - Sharpe Ratio: {performance_data['sharpe_ratio']:.3f}
    - Maximum Drawdown: {performance_data['max_drawdown']:.2%}
    - Win Rate: {signal_analysis['win_rate']:.1%}
    
    Signal Analysis:
    - Total trades: {signal_analysis['total_trades']}
    - Average holding period: {signal_analysis['avg_holding_days']} days
    - Best month: {signal_analysis['best_month']}
    - Worst month: {signal_analysis['worst_month']}
    
    Market Conditions During Testing:
    - Bull market periods: {signal_analysis['bull_periods']}
    - Bear market periods: {signal_analysis['bear_periods']}
    - High volatility events: {signal_analysis['volatility_events']}
    
    Provide specific recommendations for:
    1. Improving signal timing and accuracy
    2. Reducing maximum drawdown periods
    3. Enhancing performance during different market conditions
    4. Optimal position sizing strategies
    5. Risk management improvements
    
    Include confidence levels for each recommendation.
    """
    return prompt

def backtest_mean_reversion_strategy():
    """
    Complete backtesting example for mean reversion strategy
    Demonstrates Ollama integration for strategy validation
    """
    # Strategy parameters
    lookback_period = 20
    entry_threshold = -2.0  # 2 standard deviations below mean
    exit_threshold = 0.5    # 0.5 standard deviations above mean
    
    # Calculate signals
    data = prepare_market_data("QQQ", "3y")
    data['price_zscore'] = (data['Close'] - data['Close'].rolling(lookback_period).mean()) / \
                          data['Close'].rolling(lookback_period).std()
    
    # Generate entry/exit signals
    signals = pd.DataFrame(index=data.index)
    signals['position'] = 0
    
    # Entry when significantly oversold
    signals.loc[data['price_zscore'] < entry_threshold, 'position'] = 1
    
    # Exit when price normalizes
    signals.loc[data['price_zscore'] > exit_threshold, 'position'] = 0
    
    # Calculate strategy returns
    signals['returns'] = signals['position'].shift(1) * data['Close'].pct_change()
    
    # Analyze with Ollama
    strategy_summary = {
        'name': 'Mean Reversion (QQQ)',
        'total_return': signals['returns'].sum(),
        'num_trades': len(signals[signals['position'] != signals['position'].shift()]),
        'best_trade': signals['returns'].max(),
        'worst_trade': signals['returns'].min()
    }
    
    return strategy_summary, signals

# Run backtesting analysis
results, signals = backtest_mean_reversion_strategy()
print(f"Strategy returned {results['total_return']:.2%} over testing period")

def validate_ollama_recommendations(ai_suggestions, historical_data):
    """
    Validate AI optimization suggestions against historical performance
    Returns confidence scores for each recommendation
    """
    validation_results = {}
    
    for suggestion in ai_suggestions:
        # Test suggestion on out-of-sample data
        modified_strategy = implement_suggestion(suggestion, historical_data)
        
        # Calculate performance improvement
        baseline_sharpe = calculate_baseline_sharpe(historical_data)
        improved_sharpe = calculate_sharpe(modified_strategy)
        
        # Score recommendation confidence
        improvement_ratio = improved_sharpe / baseline_sharpe
        confidence_score = min(improvement_ratio, 2.0)  # Cap at 200%
        
        validation_results[suggestion['name']] = {
            'confidence': confidence_score,
            'expected_improvement': improvement_ratio - 1,
            'implementation_complexity': suggestion['complexity']
        }
    
    return validation_results

def walk_forward_analysis(strategy_func, data, window_size=252, step_size=63):
    """
    Perform walk-forward analysis on trading strategy
    Tests strategy robustness across different time periods
    """
    results = []
    
    for start_idx in range(0, len(data) - window_size, step_size):
        # Define training and testing windows
        train_end = start_idx + window_size
        test_end = min(train_end + step_size, len(data))
        
        train_data = data.iloc[start_idx:train_end]
        test_data = data.iloc[train_end:test_end]
        
        # Optimize strategy on training data
        optimized_params = optimize_strategy_parameters(strategy_func, train_data)
        
        # Test on out-of-sample data
        test_performance = strategy_func(test_data, optimized_params)
        
        results.append({
            'period': f"{test_data.index[0]} to {test_data.index[-1]}",
            'return': test_performance['total_return'],
            'sharpe': test_performance['sharpe_ratio'],
            'max_drawdown': test_performance['max_drawdown']
        })
    
    return pd.DataFrame(results)

# Perform walk-forward analysis
wf_results = walk_forward_analysis(mean_reversion_strategy, spy_data)
print("Walk-Forward Analysis Results:")
print(wf_results.describe())

def automated_backtesting_pipeline():
    """
    Automated pipeline for daily strategy analysis
    Integrates with Ollama for continuous optimization
    """
    # Download latest market data
    latest_data = update_market_data()
    
    # Run strategy backtesting
    for strategy in active_strategies:
        results = run_backtest(strategy, latest_data)
        
        # Analyze with Ollama
        analysis_prompt = create_analysis_prompt(results, strategy)
        ollama_insights = query_ollama(analysis_prompt)
        
        # Generate alerts for significant changes
        if detect_performance_degradation(results):
            send_alert(strategy, results, ollama_insights)
        
        # Update strategy database
        save_backtest_results(strategy, results, ollama_insights)

# Schedule daily execution
schedule_backtesting_pipeline(automated_backtesting_pipeline)