optirs-learned 0.3.1

// Curriculum learning strategies for transformer optimization
//
// This module implements various curriculum learning approaches that progressively
// introduce optimization challenges of increasing difficulty to improve learning.

#[allow(dead_code)]
use scirs2_core::ndarray::{Array1, Array2};
use scirs2_core::numeric::Float;
use std::collections::{HashMap, VecDeque};
use std::fmt::Debug;

use crate::error::{OptimError, Result};

/// Curriculum learning strategies
#[derive(Debug, Clone, Copy)]
pub enum CurriculumStrategy {
    /// No curriculum learning
    None,
    /// Difficulty-based progression
    DifficultyProgression,
    /// Diversity-based curriculum
    DiversityBased,
    /// Self-paced learning
    SelfPaced,
    /// Teacher-student curriculum
    TeacherStudent,
    /// Adversarial curriculum
    Adversarial,
    /// Multi-task curriculum
    MultiTask,
    /// Adaptive curriculum
    Adaptive,
}

/// Curriculum learning manager
#[derive(Debug, Clone)]
pub struct CurriculumLearner<T: Float + Debug + Send + Sync + 'static> {
    /// Curriculum strategy
    strategy: CurriculumStrategy,

    /// Curriculum parameters
    curriculum_params: CurriculumParams<T>,

    /// Task difficulty estimator
    difficulty_estimator: TaskDifficultyEstimator<T>,

    /// Learning progress tracker
    progress_tracker: LearningProgressTracker<T>,

    /// Current curriculum state
    curriculum_state: CurriculumState<T>,

    /// Task scheduling policy
    task_scheduler: TaskScheduler<T>,

    /// Performance history
    performance_history: VecDeque<PerformanceRecord<T>>,
}

/// Curriculum parameters
#[derive(Debug, Clone)]
pub struct CurriculumParams<T: Float + Debug + Send + Sync + 'static> {
    /// Initial difficulty threshold
    initial_difficulty: T,

    /// Maximum difficulty threshold
    max_difficulty: T,

    /// Difficulty increment per epoch
    difficulty_increment: T,

    /// Performance threshold for progression
    progression_threshold: T,

    /// Patience for difficulty increases
    patience: usize,

    /// Self-pacing factor
    self_pacing_factor: T,

    /// Diversity weight in curriculum
    diversity_weight: T,

    /// Teacher model confidence threshold
    teacher_confidence: T,
}

/// Task difficulty estimator
#[derive(Debug, Clone)]
pub struct TaskDifficultyEstimator<T: Float + Debug + Send + Sync + 'static> {
    /// Learned difficulty predictor
    difficulty_predictor: DifficultyPredictor<T>,

    /// Feature extractors for tasks
    task_features: HashMap<String, Array1<T>>,

    /// Historical difficulty measurements
    difficulty_history: HashMap<String, Vec<T>>,

    /// Difficulty estimation method
    estimation_method: DifficultyEstimationMethod,
}

/// Learning progress tracker
#[derive(Debug, Clone)]
pub struct LearningProgressTracker<T: Float + Debug + Send + Sync + 'static> {
    /// Performance metrics over time
    performance_timeline: VecDeque<T>,

    /// Learning rate estimates
    learning_rates: VecDeque<T>,

    /// Competency levels for different task types
    competency_levels: HashMap<String, T>,

    /// Progress milestones
    milestones: Vec<ProgressMilestone<T>>,
}

/// Current curriculum state
#[derive(Debug, Clone)]
pub struct CurriculumState<T: Float + Debug + Send + Sync + 'static> {
    /// Current difficulty level
    current_difficulty: T,

    /// Active task types
    active_tasks: Vec<String>,

    /// Recent performance
    recent_performance: T,

    /// Epochs since last difficulty increase
    epochs_since_increase: usize,

    /// Current learning phase
    learning_phase: LearningPhase,

    /// Adaptive parameters
    adaptive_params: HashMap<String, T>,
}

/// Task scheduler for curriculum
#[derive(Debug, Clone)]
pub struct TaskScheduler<T: Float + Debug + Send + Sync + 'static> {
    /// Task queue with priorities
    task_queue: VecDeque<ScheduledTask<T>>,

    /// Scheduling policy
    scheduling_policy: SchedulingPolicy,

    /// Task weights for sampling
    task_weights: HashMap<String, T>,

    /// Load balancing factors
    load_balancing: HashMap<String, T>,
}

/// Performance record for curriculum tracking
#[derive(Debug, Clone)]
pub struct PerformanceRecord<T: Float + Debug + Send + Sync + 'static> {
    /// Task identifier
    task_id: String,

    /// Performance score
    performance: T,

    /// Difficulty level when task was attempted
    difficulty_level: T,

    /// Number of training steps
    training_steps: usize,

    /// Timestamp
    timestamp: usize,

    /// Additional metrics
    metrics: HashMap<String, T>,
}

/// Difficulty predictor network
#[derive(Debug, Clone)]
pub struct DifficultyPredictor<T: Float + Debug + Send + Sync + 'static> {
    /// Input features dimension
    input_dim: usize,

    /// Hidden layers
    hidden_layers: Vec<Array2<T>>,

    /// Output layer
    output_layer: Array1<T>,

    /// Training history
    training_history: Vec<(Array1<T>, T)>,
}

/// Progress milestone
#[derive(Debug, Clone)]
pub struct ProgressMilestone<T: Float + Debug + Send + Sync + 'static> {
    /// Milestone name
    name: String,

    /// Performance threshold
    threshold: T,

    /// Whether milestone is achieved
    achieved: bool,

    /// Achievement timestamp
    achieved_at: Option<usize>,
}

/// Scheduled task with priority
#[derive(Debug, Clone)]
pub struct ScheduledTask<T: Float + Debug + Send + Sync + 'static> {
    /// Task identifier
    task_id: String,

    /// Task priority
    priority: T,

    /// Estimated difficulty
    difficulty: T,

    /// Required competency level
    required_competency: T,

    /// Task parameters
    parameters: HashMap<String, T>,
}

/// Learning phases in curriculum
#[derive(Debug, Clone, Copy)]
pub enum LearningPhase {
    /// Initial exploration phase
    Exploration,
    /// Skill building phase
    SkillBuilding,
    /// Mastery phase
    Mastery,
    /// Transfer phase
    Transfer,
    /// Generalization phase
    Generalization,
}

/// Difficulty estimation methods
#[derive(Debug, Clone, Copy)]
pub enum DifficultyEstimationMethod {
    /// Performance-based estimation
    PerformanceBased,
    /// Feature-based prediction
    FeatureBased,
    /// Gradient-based estimation
    GradientBased,
    /// Uncertainty-based estimation
    UncertaintyBased,
    /// Multi-modal estimation
    MultiModal,
}

/// Scheduling policies
#[derive(Debug, Clone, Copy)]
pub enum SchedulingPolicy {
    /// First-in-first-out
    FIFO,
    /// Priority-based scheduling
    Priority,
    /// Weighted random sampling
    WeightedRandom,
    /// Balanced sampling
    Balanced,
    /// Adaptive scheduling
    Adaptive,
}

impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> CurriculumLearner<T> {
    /// Create new curriculum learner
    pub fn new(strategy: CurriculumStrategy) -> Result<Self> {
        Ok(Self {
            strategy,
            curriculum_params: CurriculumParams::default(),
            difficulty_estimator: TaskDifficultyEstimator::new()?,
            progress_tracker: LearningProgressTracker::new(),
            curriculum_state: CurriculumState::new()?,
            task_scheduler: TaskScheduler::new()?,
            performance_history: VecDeque::new(),
        })
    }

    /// Update curriculum based on performance
    pub fn update_curriculum(
        &mut self,
        task_id: &str,
        performance: T,
        training_steps: usize,
    ) -> Result<()> {
        // Record performance
        let record = PerformanceRecord {
            task_id: task_id.to_string(),
            performance,
            difficulty_level: self.curriculum_state.current_difficulty,
            training_steps,
            timestamp: self.performance_history.len(),
            metrics: HashMap::new(),
        };

        self.performance_history.push_back(record);
        if self.performance_history.len() > 1000 {
            self.performance_history.pop_front();
        }

        // Update progress tracker
        self.progress_tracker.update_performance(performance);

        // Update curriculum state based on strategy
        match self.strategy {
            CurriculumStrategy::None => Ok(()),
            CurriculumStrategy::DifficultyProgression => {
                self.update_difficulty_progression(performance)
            }
            CurriculumStrategy::SelfPaced => self.update_self_paced_curriculum(performance),
            CurriculumStrategy::Adaptive => self.update_adaptive_curriculum(task_id, performance),
            _ => self.update_generic_curriculum(performance),
        }
    }

    /// Get next task according to curriculum
    pub fn get_next_task(&mut self) -> Result<Option<String>> {
        match self.strategy {
            CurriculumStrategy::None => Ok(None),
            _ => Ok(self.task_scheduler.schedule_next_task()),
        }
    }

    /// Update difficulty progression curriculum
    fn update_difficulty_progression(&mut self, performance: T) -> Result<()> {
        self.curriculum_state.recent_performance = performance;

        if performance > self.curriculum_params.progression_threshold {
            self.curriculum_state.epochs_since_increase += 1;

            if self.curriculum_state.epochs_since_increase >= self.curriculum_params.patience {
                // Increase difficulty
                let new_difficulty = (self.curriculum_state.current_difficulty
                    + self.curriculum_params.difficulty_increment)
                    .min(self.curriculum_params.max_difficulty);

                self.curriculum_state.current_difficulty = new_difficulty;
                self.curriculum_state.epochs_since_increase = 0;

                // Update learning phase
                self.update_learning_phase();
            }
        } else {
            self.curriculum_state.epochs_since_increase = 0;
        }

        Ok(())
    }

    /// Update self-paced curriculum
    fn update_self_paced_curriculum(&mut self, performance: T) -> Result<()> {
        let pacing_factor = self.curriculum_params.self_pacing_factor;

        // Adjust difficulty based on performance
        let performance_ratio = performance / self.get_expected_performance();
        let difficulty_adjustment = (performance_ratio - T::one()) * pacing_factor;

        let new_difficulty = (self.curriculum_state.current_difficulty + difficulty_adjustment)
            .max(self.curriculum_params.initial_difficulty)
            .min(self.curriculum_params.max_difficulty);

        self.curriculum_state.current_difficulty = new_difficulty;

        Ok(())
    }

    /// Update adaptive curriculum
    fn update_adaptive_curriculum(&mut self, task_id: &str, performance: T) -> Result<()> {
        // Update task-specific competency
        let competency = self
            .progress_tracker
            .competency_levels
            .get(task_id)
            .copied()
            .unwrap_or(T::zero());

        let alpha = scirs2_core::numeric::NumCast::from(0.1).unwrap_or_else(|| T::zero());
        let new_competency = competency * (T::one() - alpha) + performance * alpha;

        self.progress_tracker
            .competency_levels
            .insert(task_id.to_string(), new_competency);

        // Adapt curriculum parameters
        self.adapt_curriculum_parameters(task_id, performance)?;

        Ok(())
    }

    /// Generic curriculum update
    fn update_generic_curriculum(&mut self, performance: T) -> Result<()> {
        // Simple linear progression based on performance
        if performance > scirs2_core::numeric::NumCast::from(0.8).unwrap_or_else(|| T::zero()) {
            let increment = self.curriculum_params.difficulty_increment
                * scirs2_core::numeric::NumCast::from(0.5).unwrap_or_else(|| T::zero());
            self.curriculum_state.current_difficulty = (self.curriculum_state.current_difficulty
                + increment)
                .min(self.curriculum_params.max_difficulty);
        }

        Ok(())
    }

    /// Update learning phase
    fn update_learning_phase(&mut self) {
        let difficulty_ratio =
            self.curriculum_state.current_difficulty / self.curriculum_params.max_difficulty;

        self.curriculum_state.learning_phase = match difficulty_ratio {
            x if x < scirs2_core::numeric::NumCast::from(0.2).unwrap_or_else(|| T::zero()) => {
                LearningPhase::Exploration
            }
            x if x < scirs2_core::numeric::NumCast::from(0.4).unwrap_or_else(|| T::zero()) => {
                LearningPhase::SkillBuilding
            }
            x if x < scirs2_core::numeric::NumCast::from(0.7).unwrap_or_else(|| T::zero()) => {
                LearningPhase::Mastery
            }
            x if x < scirs2_core::numeric::NumCast::from(0.9).unwrap_or_else(|| T::zero()) => {
                LearningPhase::Transfer
            }
            _ => LearningPhase::Generalization,
        };
    }

    /// Adapt curriculum parameters based on performance
    fn adapt_curriculum_parameters(&mut self, task_id: &str, performance: T) -> Result<()> {
        // Adapt patience based on task performance variance
        let performance_variance = self.calculate_performance_variance(task_id);
        if performance_variance
            > scirs2_core::numeric::NumCast::from(0.1).unwrap_or_else(|| T::zero())
        {
            self.curriculum_params.patience = self.curriculum_params.patience.max(5);
        } else {
            self.curriculum_params.patience =
                (self.curriculum_params.patience.saturating_sub(1)).max(1);
        }

        // Adapt progression threshold based on recent performance trend
        let trend = self.calculate_performance_trend();
        if trend > T::zero() {
            // Performance is improving, can be more aggressive
            self.curriculum_params.progression_threshold =
                (self.curriculum_params.progression_threshold
                    * scirs2_core::numeric::NumCast::from(0.95).unwrap_or_else(|| T::zero()))
                .max(scirs2_core::numeric::NumCast::from(0.5).unwrap_or_else(|| T::zero()));
        } else {
            // Performance declining, be more conservative
            self.curriculum_params.progression_threshold =
                (self.curriculum_params.progression_threshold
                    * scirs2_core::numeric::NumCast::from(1.05).unwrap_or_else(|| T::zero()))
                .min(scirs2_core::numeric::NumCast::from(0.95).unwrap_or_else(|| T::zero()));
        }

        Ok(())
    }

    /// Calculate performance variance for a task
    fn calculate_performance_variance(&self, task_id: &str) -> T {
        let task_performances: Vec<T> = self
            .performance_history
            .iter()
            .filter(|record| record.task_id == task_id)
            .map(|record| record.performance)
            .collect();

        if task_performances.len() < 2 {
            return T::zero();
        }

        let mean = task_performances
            .iter()
            .cloned()
            .fold(T::zero(), |a, b| a + b)
            / T::from(task_performances.len() as f64).expect("unwrap failed");

        let variance = task_performances
            .iter()
            .map(|&x| (x - mean) * (x - mean))
            .fold(T::zero(), |a, b| a + b)
            / T::from((task_performances.len() - 1) as f64).expect("unwrap failed");

        variance
    }

    /// Calculate recent performance trend
    fn calculate_performance_trend(&self) -> T {
        if self.performance_history.len() < 10 {
            return T::zero();
        }

        let recent: Vec<T> = self
            .performance_history
            .iter()
            .rev()
            .take(10)
            .map(|record| record.performance)
            .collect();

        let first_half_avg = recent[5..].iter().cloned().fold(T::zero(), |a, b| a + b)
            / scirs2_core::numeric::NumCast::from(5.0).unwrap_or_else(|| T::zero());
        let second_half_avg = recent[..5].iter().cloned().fold(T::zero(), |a, b| a + b)
            / scirs2_core::numeric::NumCast::from(5.0).unwrap_or_else(|| T::zero());

        second_half_avg - first_half_avg
    }

    /// Get expected performance for current difficulty
    fn get_expected_performance(&self) -> T {
        // Simple model: expected performance decreases with difficulty
        let difficulty_factor =
            self.curriculum_state.current_difficulty / self.curriculum_params.max_difficulty;
        T::one()
            - difficulty_factor
                * scirs2_core::numeric::NumCast::from(0.5).unwrap_or_else(|| T::zero())
    }

    /// Add task to curriculum
    pub fn add_task(
        &mut self,
        task_id: String,
        estimated_difficulty: T,
        required_competency: T,
    ) -> Result<()> {
        let scheduled_task = ScheduledTask {
            task_id: task_id.clone(),
            priority: T::one() / estimated_difficulty, // Higher priority for easier tasks initially
            difficulty: estimated_difficulty,
            required_competency,
            parameters: HashMap::new(),
        };

        self.task_scheduler.add_task(scheduled_task);

        // Initialize competency tracking
        self.progress_tracker
            .competency_levels
            .insert(task_id, T::zero());

        Ok(())
    }

    /// Get curriculum statistics
    pub fn get_curriculum_statistics(&self) -> HashMap<String, T> {
        let mut stats = HashMap::new();

        stats.insert(
            "current_difficulty".to_string(),
            self.curriculum_state.current_difficulty,
        );
        stats.insert(
            "recent_performance".to_string(),
            self.curriculum_state.recent_performance,
        );
        stats.insert(
            "epochs_since_increase".to_string(),
            scirs2_core::numeric::NumCast::from(self.curriculum_state.epochs_since_increase as f64)
                .unwrap_or_else(|| T::zero()),
        );
        stats.insert(
            "active_tasks_count".to_string(),
            T::from(self.curriculum_state.active_tasks.len() as f64).expect("unwrap failed"),
        );

        // Average competency across all tasks
        if !self.progress_tracker.competency_levels.is_empty() {
            let avg_competency = self
                .progress_tracker
                .competency_levels
                .values()
                .cloned()
                .fold(T::zero(), |a, b| a + b)
                / T::from(self.progress_tracker.competency_levels.len() as f64)
                    .expect("unwrap failed");
            stats.insert("average_competency".to_string(), avg_competency);
        }

        stats
    }

    /// Reset curriculum state
    pub fn reset(&mut self) {
        self.curriculum_state = CurriculumState::new().expect("unwrap failed");
        self.progress_tracker.reset();
        self.performance_history.clear();
        self.task_scheduler.reset();
    }
}

// Supporting type implementations
impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> TaskDifficultyEstimator<T> {
    fn new() -> Result<Self> {
        Ok(Self {
            difficulty_predictor: DifficultyPredictor::new(10)?, // Default 10-dim input
            task_features: HashMap::new(),
            difficulty_history: HashMap::new(),
            estimation_method: DifficultyEstimationMethod::PerformanceBased,
        })
    }
}

impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> LearningProgressTracker<T> {
    fn new() -> Self {
        Self {
            performance_timeline: VecDeque::new(),
            learning_rates: VecDeque::new(),
            competency_levels: HashMap::new(),
            milestones: Vec::new(),
        }
    }

    fn update_performance(&mut self, performance: T) {
        self.performance_timeline.push_back(performance);
        if self.performance_timeline.len() > 1000 {
            self.performance_timeline.pop_front();
        }
    }

    fn reset(&mut self) {
        self.performance_timeline.clear();
        self.learning_rates.clear();
        self.competency_levels.clear();
        self.milestones.clear();
    }
}

impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> CurriculumState<T> {
    fn new() -> Result<Self> {
        Ok(Self {
            current_difficulty: scirs2_core::numeric::NumCast::from(0.1)
                .unwrap_or_else(|| T::zero()),
            active_tasks: Vec::new(),
            recent_performance: T::zero(),
            epochs_since_increase: 0,
            learning_phase: LearningPhase::Exploration,
            adaptive_params: HashMap::new(),
        })
    }
}

impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> TaskScheduler<T> {
    fn new() -> Result<Self> {
        Ok(Self {
            task_queue: VecDeque::new(),
            scheduling_policy: SchedulingPolicy::Priority,
            task_weights: HashMap::new(),
            load_balancing: HashMap::new(),
        })
    }

    fn add_task(&mut self, task: ScheduledTask<T>) {
        self.task_queue.push_back(task);
    }

    fn schedule_next_task(&mut self) -> Option<String> {
        if let Some(task) = self.task_queue.pop_front() {
            Some(task.task_id)
        } else {
            None
        }
    }

    fn reset(&mut self) {
        self.task_queue.clear();
        self.task_weights.clear();
        self.load_balancing.clear();
    }
}

impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> DifficultyPredictor<T> {
    fn new(input_dim: usize) -> Result<Self> {
        Ok(Self {
            input_dim,
            hidden_layers: vec![Array2::eye(input_dim)],
            output_layer: Array1::ones(input_dim),
            training_history: Vec::new(),
        })
    }
}

impl<T: Float + Debug + Send + Sync + 'static + Default + Clone> Default for CurriculumParams<T> {
    fn default() -> Self {
        Self {
            initial_difficulty: scirs2_core::numeric::NumCast::from(0.1)
                .unwrap_or_else(|| T::zero()),
            max_difficulty: scirs2_core::numeric::NumCast::from(1.0).unwrap_or_else(|| T::zero()),
            difficulty_increment: scirs2_core::numeric::NumCast::from(0.05)
                .unwrap_or_else(|| T::zero()),
            progression_threshold: scirs2_core::numeric::NumCast::from(0.8)
                .unwrap_or_else(|| T::zero()),
            patience: 5,
            self_pacing_factor: scirs2_core::numeric::NumCast::from(0.1)
                .unwrap_or_else(|| T::zero()),
            diversity_weight: scirs2_core::numeric::NumCast::from(0.2).unwrap_or_else(|| T::zero()),
            teacher_confidence: scirs2_core::numeric::NumCast::from(0.9)
                .unwrap_or_else(|| T::zero()),
        }
    }
}