How to Optimize Trading Parameters with Ollama: Genetic Algorithm Implementation Guide

# Install Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# Install Python dependencies
pip install ollama pandas numpy scipy matplotlib yfinance ta-lib

# Pull required model
ollama pull llama2:7b

import ollama
import pandas as pd
import numpy as np
from typing import List, Dict, Tuple

class OllamaTradingOptimizer:
    def __init__(self, model_name: str = "llama2:7b"):
        """
        Initialize Ollama trading parameter optimizer
        
        Args:
            model_name: Ollama model for strategy analysis
        """
        self.model_name = model_name
        self.client = ollama.Client()
        
    def validate_strategy_logic(self, parameters: Dict) -> bool:
        """
        Use Ollama to validate trading strategy logic
        """
        prompt = f"""
        Analyze this trading strategy configuration:
        Parameters: {parameters}
        
        Is this a valid trading strategy? Return only TRUE or FALSE.
        """
        
        response = self.client.generate(
            model=self.model_name,
            prompt=prompt
        )
        
        return "TRUE" in response['response'].upper()

import random
from dataclasses import dataclass
from typing import List, Dict, Any, Callable

@dataclass
class TradingIndividual:
    """Represents one set of trading parameters"""
    parameters: Dict[str, Any]
    fitness: float = 0.0
    age: int = 0
    
class GeneticTradingOptimizer:
    def __init__(self, 
                 parameter_bounds: Dict[str, Tuple],
                 fitness_function: Callable,
                 population_size: int = 100,
                 mutation_rate: float = 0.1,
                 crossover_rate: float = 0.8):
        """
        Initialize genetic algorithm for trading optimization
        
        Args:
            parameter_bounds: Dict with parameter names and (min, max) bounds
            fitness_function: Function that evaluates strategy performance
            population_size: Number of individuals in each generation
            mutation_rate: Probability of parameter mutation
            crossover_rate: Probability of parameter crossover
        """
        self.parameter_bounds = parameter_bounds
        self.fitness_function = fitness_function
        self.population_size = population_size
        self.mutation_rate = mutation_rate
        self.crossover_rate = crossover_rate
        self.population: List[TradingIndividual] = []
        self.generation = 0
        self.best_individual = None
        self.fitness_history = []

def initialize_population(self) -> None:
    """Create initial population with random parameters"""
    self.population = []
    
    for _ in range(self.population_size):
        parameters = {}
        
        for param_name, (min_val, max_val) in self.parameter_bounds.items():
            if isinstance(min_val, int) and isinstance(max_val, int):
                # Integer parameter
                parameters[param_name] = random.randint(min_val, max_val)
            else:
                # Float parameter
                parameters[param_name] = random.uniform(min_val, max_val)
        
        individual = TradingIndividual(parameters=parameters)
        self.population.append(individual)
    
    print(f"Initialized population of {self.population_size} individuals")

def evaluate_population(self, market_data: pd.DataFrame) -> None:
    """
    Evaluate fitness for entire population
    Uses Ollama for strategy validation and risk assessment
    """
    ollama_optimizer = OllamaTradingOptimizer()
    
    for individual in self.population:
        # Validate strategy logic with Ollama
        if not ollama_optimizer.validate_strategy_logic(individual.parameters):
            individual.fitness = -1000  # Penalty for invalid strategies
            continue
            
        # Calculate strategy performance
        individual.fitness = self.fitness_function(
            individual.parameters, 
            market_data
        )
        
        # Age tracking for diversity
        individual.age += 1
    
    # Update best individual
    best_current = max(self.population, key=lambda x: x.fitness)
    if self.best_individual is None or best_current.fitness > self.best_individual.fitness:
        self.best_individual = best_current
        
    # Track fitness history
    avg_fitness = sum(ind.fitness for ind in self.population) / len(self.population)
    self.fitness_history.append({
        'generation': self.generation,
        'best_fitness': self.best_individual.fitness,
        'avg_fitness': avg_fitness
    })

def tournament_selection(self, tournament_size: int = 5) -> TradingIndividual:
    """
    Select individual using tournament selection
    
    Args:
        tournament_size: Number of individuals in each tournament
        
    Returns:
        Selected individual for reproduction
    """
    tournament_pool = random.sample(self.population, tournament_size)
    
    # Add age penalty to prevent stagnation
    for individual in tournament_pool:
        age_penalty = individual.age * 0.01  # 1% penalty per generation
        adjusted_fitness = individual.fitness - age_penalty
        individual.adjusted_fitness = adjusted_fitness
    
    winner = max(tournament_pool, key=lambda x: x.adjusted_fitness)
    return winner

def crossover(self, parent1: TradingIndividual, parent2: TradingIndividual) -> TradingIndividual:
    """
    Create offspring by combining parent parameters
    Uses uniform crossover for better parameter mixing
    """
    if random.random() > self.crossover_rate:
        return parent1  # No crossover, return parent
    
    child_parameters = {}
    
    for param_name in self.parameter_bounds.keys():
        # Uniform crossover: randomly choose parent for each parameter
        if random.random() < 0.5:
            child_parameters[param_name] = parent1.parameters[param_name]
        else:
            child_parameters[param_name] = parent2.parameters[param_name]
    
    return TradingIndividual(parameters=child_parameters)

def mutate(self, individual: TradingIndividual) -> TradingIndividual:
    """
    Apply mutation to individual parameters
    Uses adaptive mutation rate based on population diversity
    """
    # Calculate population diversity
    diversity = self.calculate_population_diversity()
    
    # Adaptive mutation rate: higher when diversity is low
    adaptive_rate = self.mutation_rate * (2.0 - diversity)
    
    mutated_parameters = individual.parameters.copy()
    
    for param_name, (min_val, max_val) in self.parameter_bounds.items():
        if random.random() < adaptive_rate:
            if isinstance(min_val, int) and isinstance(max_val, int):
                # Integer mutation with normal distribution
                current_val = mutated_parameters[param_name]
                mutation_range = (max_val - min_val) * 0.1  # 10% of range
                new_val = current_val + random.gauss(0, mutation_range)
                new_val = max(min_val, min(max_val, int(new_val)))
                mutated_parameters[param_name] = new_val
            else:
                # Float mutation with normal distribution
                current_val = mutated_parameters[param_name]
                mutation_range = (max_val - min_val) * 0.1
                new_val = current_val + random.gauss(0, mutation_range)
                new_val = max(min_val, min(max_val, new_val))
                mutated_parameters[param_name] = new_val
    
    return TradingIndividual(parameters=mutated_parameters)

def calculate_population_diversity(self) -> float:
    """Calculate normalized population diversity (0-1 scale)"""
    if len(self.population) < 2:
        return 1.0
    
    total_distance = 0
    comparisons = 0
    
    for i in range(len(self.population)):
        for j in range(i + 1, len(self.population)):
            distance = self.parameter_distance(
                self.population[i].parameters,
                self.population[j].parameters
            )
            total_distance += distance
            comparisons += 1
    
    avg_distance = total_distance / comparisons
    max_possible_distance = self.calculate_max_distance()
    
    return min(1.0, avg_distance / max_possible_distance)

def advanced_fitness_function(parameters: Dict, market_data: pd.DataFrame) -> float:
    """
    Advanced fitness function combining multiple trading metrics
    
    Args:
        parameters: Trading strategy parameters
        market_data: Historical price data
        
    Returns:
        Fitness score (higher is better)
    """
    # Extract parameters
    fast_ma = parameters.get('fast_ma', 10)
    slow_ma = parameters.get('slow_ma', 20)
    rsi_period = parameters.get('rsi_period', 14)
    rsi_oversold = parameters.get('rsi_oversold', 30)
    rsi_overbought = parameters.get('rsi_overbought', 70)
    stop_loss = parameters.get('stop_loss', 0.02)
    take_profit = parameters.get('take_profit', 0.04)
    
    # Calculate technical indicators
    market_data['fast_ma'] = market_data['close'].rolling(fast_ma).mean()
    market_data['slow_ma'] = market_data['close'].rolling(slow_ma).mean()
    market_data['rsi'] = calculate_rsi(market_data['close'], rsi_period)
    
    # Generate trading signals
    signals = generate_trading_signals(
        market_data, rsi_oversold, rsi_overbought
    )
    
    # Backtest strategy
    results = backtest_strategy(
        market_data, signals, stop_loss, take_profit
    )
    
    # Calculate fitness components
    total_return = results['total_return']
    sharpe_ratio = results['sharpe_ratio']
    max_drawdown = results['max_drawdown']
    win_rate = results['win_rate']
    num_trades = results['num_trades']
    
    # Penalty for insufficient trades
    if num_trades < 10:
        return -1000
    
    # Multi-objective fitness calculation
    fitness = (
        total_return * 0.3 +           # 30% weight on returns
        sharpe_ratio * 0.25 +          # 25% weight on risk-adjusted returns
        (1 - max_drawdown) * 0.2 +     # 20% weight on drawdown control
        win_rate * 0.15 +              # 15% weight on win rate
        min(num_trades / 100, 1) * 0.1 # 10% weight on trade frequency
    )
    
    return fitness

def calculate_rsi(prices: pd.Series, period: int) -> pd.Series:
    """Calculate RSI indicator"""
    delta = prices.diff()
    gain = delta.where(delta > 0, 0)
    loss = -delta.where(delta < 0, 0)
    
    avg_gain = gain.rolling(period).mean()
    avg_loss = loss.rolling(period).mean()
    
    rs = avg_gain / avg_loss
    rsi = 100 - (100 / (1 + rs))
    
    return rsi

def backtest_strategy(data: pd.DataFrame, 
                     signals: pd.Series, 
                     stop_loss: float, 
                     take_profit: float) -> Dict:
    """
    Backtest trading strategy with risk management
    
    Returns:
        Dictionary with performance metrics
    """
    portfolio_value = 10000  # Starting capital
    position = 0  # 0 = no position, 1 = long, -1 = short
    entry_price = 0
    trades = []
    equity_curve = [portfolio_value]
    
    for i in range(1, len(data)):
        current_price = data.iloc[i]['close']
        signal = signals.iloc[i]
        
        # Exit conditions
        if position != 0:
            # Stop loss check
            if position == 1 and (current_price <= entry_price * (1 - stop_loss)):
                # Long stop loss
                pnl = (current_price - entry_price) / entry_price
                portfolio_value *= (1 + pnl)
                trades.append(pnl)
                position = 0
                
            elif position == -1 and (current_price >= entry_price * (1 + stop_loss)):
                # Short stop loss
                pnl = (entry_price - current_price) / entry_price
                portfolio_value *= (1 + pnl)
                trades.append(pnl)
                position = 0
                
            # Take profit check
            elif position == 1 and (current_price >= entry_price * (1 + take_profit)):
                # Long take profit
                pnl = (current_price - entry_price) / entry_price
                portfolio_value *= (1 + pnl)
                trades.append(pnl)
                position = 0
                
            elif position == -1 and (current_price <= entry_price * (1 - take_profit)):
                # Short take profit
                pnl = (entry_price - current_price) / entry_price
                portfolio_value *= (1 + pnl)
                trades.append(pnl)
                position = 0
        
        # Entry conditions
        if position == 0:
            if signal == 1:  # Long signal
                position = 1
                entry_price = current_price
            elif signal == -1:  # Short signal
                position = -1
                entry_price = current_price
        
        equity_curve.append(portfolio_value)
    
    # Calculate performance metrics
    total_return = (portfolio_value - 10000) / 10000
    
    if len(trades) == 0:
        return {
            'total_return': -0.5,
            'sharpe_ratio': -2,
            'max_drawdown': 1,
            'win_rate': 0,
            'num_trades': 0
        }
    
    returns = pd.Series(trades)
    sharpe_ratio = returns.mean() / returns.std() if returns.std() > 0 else 0
    
    # Calculate max drawdown
    equity_series = pd.Series(equity_curve)
    rolling_max = equity_series.expanding().max()
    drawdown = (equity_series - rolling_max) / rolling_max
    max_drawdown = abs(drawdown.min())
    
    win_rate = len([t for t in trades if t > 0]) / len(trades)
    
    return {
        'total_return': total_return,
        'sharpe_ratio': sharpe_ratio,
        'max_drawdown': max_drawdown,
        'win_rate': win_rate,
        'num_trades': len(trades)
    }

import yfinance as yf
import pandas as pd
import matplotlib.pyplot as plt
from datetime import datetime, timedelta

def run_trading_optimization():
    """Complete example of trading parameter optimization"""
    
    # Download market data
    end_date = datetime.now()
    start_date = end_date - timedelta(days=365 * 2)  # 2 years of data
    
    ticker = "AAPL"
    data = yf.download(ticker, start=start_date, end=end_date)
    data.columns = data.columns.str.lower()
    
    # Define parameter bounds for momentum strategy
    parameter_bounds = {
        'fast_ma': (5, 20),           # Fast moving average period
        'slow_ma': (20, 100),         # Slow moving average period
        'rsi_period': (10, 30),       # RSI calculation period
        'rsi_oversold': (20, 35),     # RSI oversold threshold
        'rsi_overbought': (65, 80),   # RSI overbought threshold
        'stop_loss': (0.01, 0.05),    # Stop loss percentage
        'take_profit': (0.02, 0.08)   # Take profit percentage
    }
    
    # Initialize genetic algorithm
    optimizer = GeneticTradingOptimizer(
        parameter_bounds=parameter_bounds,
        fitness_function=advanced_fitness_function,
        population_size=50,
        mutation_rate=0.15,
        crossover_rate=0.8
    )
    
    # Run optimization
    optimizer.initialize_population()
    
    print(f"Starting optimization for {ticker}")
    print(f"Data period: {start_date.date()} to {end_date.date()}")
    print(f"Population size: {optimizer.population_size}")
    
    for generation in range(50):  # Run for 50 generations
        optimizer.generation = generation
        
        # Evaluate current population
        optimizer.evaluate_population(data)
        
        # Print progress
        if generation % 10 == 0:
            best_fitness = optimizer.best_individual.fitness
            avg_fitness = sum(ind.fitness for ind in optimizer.population) / len(optimizer.population)
            print(f"Generation {generation}: Best={best_fitness:.4f}, Avg={avg_fitness:.4f}")
        
        # Create next generation
        new_population = []
        
        # Elitism: keep top 10% of population
        elite_size = int(0.1 * optimizer.population_size)
        elite = sorted(optimizer.population, key=lambda x: x.fitness, reverse=True)[:elite_size]
        new_population.extend(elite)
        
        # Generate rest of population through selection and breeding
        while len(new_population) < optimizer.population_size:
            parent1 = optimizer.tournament_selection()
            parent2 = optimizer.tournament_selection()
            
            child = optimizer.crossover(parent1, parent2)
            child = optimizer.mutate(child)
            
            new_population.append(child)
        
        optimizer.population = new_population
    
    # Final evaluation
    optimizer.evaluate_population(data)
    
    # Display results
    print("\n" + "="*50)
    print("OPTIMIZATION COMPLETE")
    print("="*50)
    print(f"Best Parameters: {optimizer.best_individual.parameters}")
    print(f"Best Fitness: {optimizer.best_individual.fitness:.4f}")
    
    # Plot fitness evolution
    plot_optimization_results(optimizer.fitness_history)
    
    return optimizer.best_individual

def plot_optimization_results(fitness_history: List[Dict]):
    """Plot optimization progress"""
    generations = [h['generation'] for h in fitness_history]
    best_fitness = [h['best_fitness'] for h in fitness_history]
    avg_fitness = [h['avg_fitness'] for h in fitness_history]
    
    plt.figure(figsize=(12, 6))
    
    plt.subplot(1, 2, 1)
    plt.plot(generations, best_fitness, 'b-', label='Best Fitness', linewidth=2)
    plt.plot(generations, avg_fitness, 'r--', label='Average Fitness', linewidth=1)
    plt.xlabel('Generation')
    plt.ylabel('Fitness Score')
    plt.title('Genetic Algorithm Progress')
    plt.legend()
    plt.grid(True, alpha=0.3)
    
    plt.subplot(1, 2, 2)
    improvement = [(best_fitness[i] - best_fitness[0]) / abs(best_fitness[0]) * 100 
                   for i in range(len(best_fitness))]
    plt.plot(generations, improvement, 'g-', linewidth=2)
    plt.xlabel('Generation')
    plt.ylabel('Improvement (%)')
    plt.title('Performance Improvement Over Time')
    plt.grid(True, alpha=0.3)
    
    plt.tight_layout()
    plt.show()

# Run the optimization
if __name__ == "__main__":
    best_solution = run_trading_optimization()

def walk_forward_analysis(parameter_bounds: Dict, 
                         data: pd.DataFrame, 
                         window_months: int = 6,
                         step_months: int = 1) -> pd.DataFrame:
    """
    Perform walk-forward analysis to validate optimization robustness
    
    Args:
        parameter_bounds: Parameter search space
        data: Complete dataset
        window_months: Training window size in months
        step_months: Step size for moving window
        
    Returns:
        DataFrame with walk-forward test results
    """
    results = []
    
    # Convert months to approximate days
    window_days = window_months * 30
    step_days = step_months * 30
    
    start_idx = window_days
    
    while start_idx + step_days < len(data):
        # Define training and testing periods
        train_end = start_idx
        train_start = train_end - window_days
        test_start = train_end
        test_end = min(test_start + step_days, len(data))
        
        train_data = data.iloc[train_start:train_end]
        test_data = data.iloc[test_start:test_end]
        
        print(f"Training: {train_data.index[0].date()} to {train_data.index[-1].date()}")
        print(f"Testing: {test_data.index[0].date()} to {test_data.index[-1].date()}")
        
        # Optimize on training data
        optimizer = GeneticTradingOptimizer(
            parameter_bounds=parameter_bounds,
            fitness_function=advanced_fitness_function,
            population_size=30,  # Smaller for faster computation
            mutation_rate=0.15,
            crossover_rate=0.8
        )
        
        optimizer.initialize_population()
        
        # Run optimization (fewer generations for walk-forward)
        for generation in range(20):
            optimizer.generation = generation
            optimizer.evaluate_population(train_data)
            
            # Create next generation
            new_population = []
            elite_size = int(0.1 * optimizer.population_size)
            elite = sorted(optimizer.population, key=lambda x: x.fitness, reverse=True)[:elite_size]
            new_population.extend(elite)
            
            while len(new_population) < optimizer.population_size:
                parent1 = optimizer.tournament_selection()
                parent2 = optimizer.tournament_selection()
                child = optimizer.crossover(parent1, parent2)
                child = optimizer.mutate(child)
                new_population.append(child)
            
            optimizer.population = new_population
        
        # Get best parameters from training
        optimizer.evaluate_population(train_data)
        best_params = optimizer.best_individual.parameters
        
        # Test on out-of-sample data
        test_fitness = advanced_fitness_function(best_params, test_data)
        
        results.append({
            'train_start': train_data.index[0],
            'train_end': train_data.index[-1],
            'test_start': test_data.index[0],
            'test_end': test_data.index[-1],
            'train_fitness': optimizer.best_individual.fitness,
            'test_fitness': test_fitness,
            'parameters': best_params
        })
        
        start_idx += step_days
    
    return pd.DataFrame(results)

def analyze_parameter_stability(optimization_results: pd.DataFrame) -> Dict:
    """
    Analyze stability of optimized parameters across time periods
    
    Returns:
        Dictionary with stability metrics
    """
    # Extract parameter values across periods
    param_evolution = {}
    for param_name in optimization_results.iloc[0]['parameters'].keys():
        param_evolution[param_name] = [
            result['parameters'][param_name] 
            for result in optimization_results['parameters']
        ]
    
    # Calculate stability metrics
    stability_metrics = {}
    
    for param_name, values in param_evolution.items():
        series = pd.Series(values)
        
        stability_metrics[param_name] = {
            'mean': series.mean(),
            'std': series.std(),
            'coefficient_of_variation': series.std() / series.mean() if series.mean() != 0 else float('inf'),
            'min': series.min(),
            'max': series.max(),
            'range_ratio': (series.max() - series.min()) / series.mean() if series.mean() != 0 else float('inf')
        }
    
    # Overall performance stability
    train_performance = optimization_results['train_fitness']
    test_performance = optimization_results['test_fitness']
    
    performance_correlation = train_performance.corr(test_performance)
    
    stability_metrics['performance'] = {
        'train_test_correlation': performance_correlation,
        'avg_train_fitness': train_performance.mean(),
        'avg_test_fitness': test_performance.mean(),
        'performance_degradation': (train_performance.mean() - test_performance.mean()) / train_performance.mean()
    }
    
    return stability_metrics

import logging
from datetime import datetime
import json

class TradingParameterMonitor:
    def __init__(self, optimal_parameters: Dict, 
                 reoptimization_threshold: float = 0.2):
        """
        Monitor trading parameter performance in production
        
        Args:
            optimal_parameters: Current optimal parameters
            reoptimization_threshold: Performance drop threshold for reoptimization
        """
        self.optimal_parameters = optimal_parameters
        self.reoptimization_threshold = reoptimization_threshold
        self.performance_history = []
        self.setup_logging()
        
    def setup_logging(self):
        """Setup comprehensive logging for parameter monitoring"""
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('trading_monitor.log'),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger(__name__)
    
    def evaluate_current_performance(self, recent_data: pd.DataFrame) -> Dict:
        """
        Evaluate current parameter performance
        
        Returns:
            Performance metrics and reoptimization recommendation
        """
        current_fitness = advanced_fitness_function(
            self.optimal_parameters, 
            recent_data
        )
        
        # Calculate performance baseline
        baseline_fitness = self.calculate_baseline_performance()
        
        performance_ratio = current_fitness / baseline_fitness if baseline_fitness != 0 else 0
        performance_drop = 1 - performance_ratio
        
        # Log performance
        self.logger.info(f"Current fitness: {current_fitness:.4f}")
        self.logger.info(f"Baseline fitness: {baseline_fitness:.4f}")
        self.logger.info(f"Performance ratio: {performance_ratio:.4f}")
        
        # Check reoptimization trigger
        needs_reoptimization = performance_drop > self.reoptimization_threshold
        
        if needs_reoptimization:
            self.logger.warning(
                f"Performance drop of {performance_drop:.2%} exceeds threshold "
                f"of {self.reoptimization_threshold:.2%}. Reoptimization recommended."
            )
        
        # Update performance history
        self.performance_history.append({
            'timestamp': datetime.now(),
            'fitness': current_fitness,
            'performance_ratio': performance_ratio,
            'needs_reoptimization': needs_reoptimization
        })
        
        return {
            'current_fitness': current_fitness,
            'baseline_fitness': baseline_fitness,
            'performance_ratio': performance_ratio,
            'performance_drop': performance_drop,
            'needs_reoptimization': needs_reoptimization,
            'parameters': self.optimal_parameters.copy()
        }
    
    def calculate_baseline_performance(self) -> float:
        """Calculate baseline performance from recent history"""
        if len(self.performance_history) < 10:
            return 1.0  # Default baseline
        
        recent_performances = [h['fitness'] for h in self.performance_history[-10:]]
        return sum(recent_performances) / len(recent_performances)

class AutomaticReoptimizer:
    def __init__(self, parameter_bounds: Dict, 
                 reoptimization_schedule: str = "weekly"):
        """
        Automatic parameter reoptimization system
        
        Args:
            parameter_bounds: Parameter search space
            reoptimization_schedule: "daily", "weekly", or "monthly"
        """
        self.parameter_bounds = parameter_bounds
        self.reoptimization_schedule = reoptimization_schedule
        self.last_optimization = datetime.now()
        self.optimization_history = []
        
    def should_reoptimize(self, monitor_result: Dict) -> bool:
        """
        Determine if reoptimization should run
        
        Args:
            monitor_result: Result from TradingParameterMonitor
            
        Returns:
            True if reoptimization should run
        """
        # Performance-based trigger
        if monitor_result['needs_reoptimization']:
            return True
        
        # Schedule-based trigger
        days_since_optimization = (datetime.now() - self.last_optimization).days
        
        schedule_thresholds = {
            'daily': 1,
            'weekly': 7,
            'monthly': 30
        }
        
        threshold = schedule_thresholds.get(self.reoptimization_schedule, 7)
        
        return days_since_optimization >= threshold
    
    def run_reoptimization(self, recent_data: pd.DataFrame) -> Dict:
        """
        Execute parameter reoptimization
        
        Returns:
            New optimal parameters and optimization results
        """
        print("Starting automatic reoptimization...")
        
        # Use more recent data for reoptimization
        optimization_data = recent_data.tail(252)  # Last year of data
        
        # Run genetic algorithm optimization
        optimizer = GeneticTradingOptimizer(
            parameter_bounds=self.parameter_bounds,
            fitness_function=advanced_fitness_function,
            population_size=40,
            mutation_rate=0.15,
            crossover_rate=0.8
        )
        
        optimizer.initialize_population()
        
        # Shorter optimization for production reoptimization
        for generation in range(30):
            optimizer.generation = generation
            optimizer.evaluate_population(optimization_data)
            
            # Create next generation
            new_population = []
            elite_size = int(0.15 * optimizer.population_size)
            elite = sorted(optimizer.population, key=lambda x: x.fitness, reverse=True)[:elite_size]
            new_population.extend(elite)
            
            while len(new_population) < optimizer.population_size:
                parent1 = optimizer.tournament_selection()
                parent2 = optimizer.tournament_selection()
                child = optimizer.crossover(parent1, parent2)
                child = optimizer.mutate(child)
                new_population.append(child)
            
            optimizer.population = new_population
        
        # Final evaluation
        optimizer.evaluate_population(optimization_data)
        
        # Record optimization results
        optimization_result = {
            'timestamp': datetime.now(),
            'new_parameters': optimizer.best_individual.parameters,
            'new_fitness': optimizer.best_individual.fitness,
            'optimization_generations': 30,
            'data_period': f"{optimization_data.index[0].date()} to {optimization_data.index[-1].date()}"
        }
        
        self.optimization_history.append(optimization_result)
        self.last_optimization = datetime.now()
        
        print(f"Reoptimization complete. New fitness: {optimizer.best_individual.fitness:.4f}")
        
        return optimization_result

class OptimizationDiagnostics:
    def __init__(self, optimizer: GeneticTradingOptimizer):
        self.optimizer = optimizer
        self.convergence_threshold = 0.001  # Fitness improvement threshold
        
    def diagnose_convergence_issues(self) -> Dict:
        """
        Diagnose convergence problems in optimization
        
        Returns:
            Dictionary with diagnostic information and recommendations
        """
        fitness_history = [h['best_fitness'] for h in self.optimizer.fitness_history]
        
        if len(fitness_history) < 10:
            return {'status': 'insufficient_data', 'recommendation': 'Run more generations'}
        
        # Check for premature convergence
        recent_improvement = fitness_history[-1] - fitness_history[-10]
        improvement_rate = recent_improvement / 10
        
        diagnostics = {
            'recent_improvement': recent_improvement,
            'improvement_rate': improvement_rate,
            'population_diversity': self.optimizer.calculate_population_diversity(),
            'generation_count': len(fitness_history)
        }
        
        # Diagnose specific issues
        if improvement_rate < self.convergence_threshold:
            if diagnostics['population_diversity'] < 0.1:
                diagnostics['issue'] = 'premature_convergence'
                diagnostics['recommendation'] = 'Increase mutation rate and population diversity'
            else:
                diagnostics['issue'] = 'local_optimum'
                diagnostics['recommendation'] = 'Restart with different initial population'
        elif diagnostics['population_diversity'] > 0.8:
            diagnostics['issue'] = 'insufficient_selection_pressure'
            diagnostics['recommendation'] = 'Increase selection pressure or reduce mutation rate'
        else:
            diagnostics['issue'] = 'normal_convergence'
            diagnostics['recommendation'] = 'Continue optimization'
        
        return diagnostics
    
    def apply_adaptive_fixes(self, diagnostics: Dict) -> None:
        """
        Automatically apply fixes based on diagnostics
        """
        issue = diagnostics.get('issue', 'unknown')
        
        if issue == 'premature_convergence':
            # Increase diversity
            self.optimizer.mutation_rate = min(0.3, self.optimizer.mutation_rate * 1.5)
            
            # Add random individuals to population
            random_individuals = []
            for _ in range(int(0.2 * self.optimizer.population_size)):
                parameters = {}
                for param_name, (min_val, max_val) in self.optimizer.parameter_bounds.items():
                    if isinstance(min_val, int):
                        parameters[param_name] = random.randint(min_val, max_val)
                    else:
                        parameters[param_name] = random.uniform(min_val, max_val)
                random_individuals.append(TradingIndividual(parameters=parameters))
            
            # Replace worst performers with random individuals
            self.optimizer.population.sort(key=lambda x: x.fitness, reverse=True)
            self.optimizer.population[-len(random_individuals):] = random_individuals
            
            print(f"Applied premature convergence fix: increased mutation rate to {self.optimizer.mutation_rate:.3f}")
            
        elif issue == 'insufficient_selection_pressure':
            # Increase selection pressure
            self.optimizer.mutation_rate = max(0.05, self.optimizer.mutation_rate * 0.8)
            print(f"Applied selection pressure fix: reduced mutation rate to {self.optimizer.mutation_rate:.3f}")

def validate_parameter_constraints(parameters: Dict) -> Tuple[bool, List[str]]:
    """
    Validate parameter combinations for logical consistency
    
    Returns:
        Tuple of (is_valid, list_of_errors)
    """
    errors = []
    
    # Moving average constraint: fast_ma must be less than slow_ma
    if parameters.get('fast_ma', 0) >= parameters.get('slow_ma', 100):
        errors.append("Fast moving average must be less than slow moving average")
    
    # RSI threshold constraints
    if parameters.get('rsi_oversold', 30) >= parameters.get('rsi_overbought', 70):
        errors.append("RSI oversold threshold must be less than overbought threshold")
    
    # Risk management constraints
    if parameters.get('stop_loss', 0.02) >= parameters.get('take_profit', 0.04):
        errors.append("Stop loss should typically be less than take profit")
    
    # Reasonable value ranges
    if parameters.get('rsi_period', 14) < 5:
        errors.append("RSI period too short, may cause excessive noise")
    
    if parameters.get('stop_loss', 0.02) > 0.1:
        errors.append("Stop loss too large, may indicate poor risk management")
    
    return len(errors) == 0, errors

def apply_parameter_constraints(individual: TradingIndividual) -> TradingIndividual:
    """
    Apply hard constraints to parameter combinations
    """
    params = individual.parameters.copy()
    
    # Ensure fast_ma < slow_ma
    if params['fast_ma'] >= params['slow_ma']:
        params['fast_ma'] = max(1, params['slow_ma'] - 5)
    
    # Ensure RSI thresholds are properly ordered
    if params['rsi_oversold'] >= params['rsi_overbought']:
        mid_point = (params['rsi_oversold'] + params['rsi_overbought']) / 2
        params['rsi_oversold'] = max(10, mid_point - 10)
        params['rsi_overbought'] = min(90, mid_point + 10)
    
    # Ensure stop_loss < take_profit
    if params['stop_loss'] >= params['take_profit']:
        avg = (params['stop_loss'] + params['take_profit']) / 2
        params['stop_loss'] = avg * 0.8
        params['take_profit'] = avg * 1.2
    
    return TradingIndividual(parameters=params, fitness=individual.fitness)

import multiprocessing as mp
from concurrent.futures import ProcessPoolExecutor
import time

class ParallelGeneticOptimizer(GeneticTradingOptimizer):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.num_processes = mp.cpu_count() - 1  # Leave one core free
        
    def evaluate_population_parallel(self, market_data: pd.DataFrame) -> None:
        """
        Evaluate population fitness using parallel processing
        """
        # Split population into chunks for parallel processing
        chunk_size = len(self.population) // self.num_processes
        population_chunks = [
            self.population[i:i + chunk_size] 
            for i in range(0, len(self.population), chunk_size)
        ]
        
        # Process chunks in parallel
        with ProcessPoolExecutor(max_workers=self.num_processes) as executor:
            chunk_results = list(executor.map(
                self._evaluate_chunk, 
                [(chunk, market_data) for chunk in population_chunks]
            ))
        
        # Combine results
        evaluated_population = []
        for chunk_result in chunk_results:
            evaluated_population.extend(chunk_result)
        
        self.population = evaluated_population
        
        # Update best individual
        best_current = max(self.population, key=lambda x: x.fitness)
        if self.best_individual is None or best_current.fitness > self.best_individual.fitness:
            self.best_individual = best_current
    
    @staticmethod
    def _evaluate_chunk(args) -> List[TradingIndividual]:
        """
        Evaluate a chunk of individuals (static method for multiprocessing)
        """
        chunk, market_data = args
        
        for individual in chunk:
            individual.fitness = advanced_fitness_function(
                individual.parameters, 
                market_data
            )
            individual.age += 1
        
        return chunk

class MemoryEfficientOptimizer:
    def __init__(self, data_file_path: str, chunk_size: int = 1000):
        """
        Memory-efficient optimizer for large datasets
        
        Args:
            data_file_path: Path to data file
            chunk_size: Number of rows to process at once
        """
        self.data_file_path = data_file_path
        self.chunk_size = chunk_size
        
    def chunked_fitness_evaluation(self, parameters: Dict) -> float:
        """
        Evaluate fitness using data chunks to minimize memory usage
        """
        total_fitness = 0
        chunk_count = 0
        
        # Process data in chunks
        for chunk in pd.read_csv(self.data_file_path, chunksize=self.chunk_size):
            if len(chunk) < 50:  # Skip small chunks
                continue
                
            chunk_fitness = advanced_fitness_function(parameters, chunk)
            total_fitness += chunk_fitness
            chunk_count += 1
        
        return total_fitness / chunk_count if chunk_count > 0 else 0
    
    def optimize_with_streaming_data(self, parameter_bounds: Dict) -> Dict:
        """
        Run optimization with streaming data processing
        """
        best_parameters = None
        best_fitness = float('-inf')
        
        # Simple random search for memory-efficient optimization
        for iteration in range(1000):
            # Generate random parameters
            parameters = {}
            for param_name, (min_val, max_val) in parameter_bounds.items():
                if isinstance(min_val, int):
                    parameters[param_name] = random.randint(min_val, max_val)
                else:
                    parameters[param_name] = random.uniform(min_val, max_val)
            
            # Evaluate fitness with chunked data
            fitness = self.chunked_fitness_evaluation(parameters)
            
            if fitness > best_fitness:
                best_fitness = fitness
                best_parameters = parameters.copy()
                print(f"Iteration {iteration}: New best fitness {fitness:.4f}")
        
        return {
            'best_parameters': best_parameters,
            'best_fitness': best_fitness,
            'iterations': 1000
        }