scirs2-metrics 0.4.2

//! Neural components for adaptive streaming metrics
//!
//! This module provides neural network-based components for parameter optimization,
//! feature extraction, and adaptive learning in streaming environments.

#![allow(clippy::too_many_arguments)]
#![allow(dead_code)]

use crate::error::Result;
use scirs2_core::ndarray::{Array1, Array2};
use scirs2_core::numeric::Float;
use scirs2_core::random::{Rng, RngExt};
use serde::{Deserialize, Serialize};
use std::time::Duration;

/// Neural network configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NetworkConfig {
    /// Hidden layer sizes for parameter optimizer
    pub optimizer_hidden_layers: Vec<usize>,
    /// Hidden layer sizes for performance predictor
    pub predictor_hidden_layers: Vec<usize>,
    /// Activation function type
    pub activation: ActivationFunction,
    /// Dropout rate for regularization
    pub dropout_rate: f64,
    /// Batch normalization enabled
    pub batch_norm: bool,
    /// Learning rate for neural networks
    pub learning_rate: f64,
    /// Weight decay for regularization
    pub weight_decay: f64,
}

impl Default for NetworkConfig {
    fn default() -> Self {
        Self {
            optimizer_hidden_layers: vec![128, 64, 32],
            predictor_hidden_layers: vec![64, 32, 16],
            activation: ActivationFunction::ReLU,
            dropout_rate: 0.1,
            batch_norm: true,
            learning_rate: 0.001,
            weight_decay: 0.0001,
        }
    }
}

/// Activation functions for neural networks
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ActivationFunction {
    ReLU,
    LeakyReLU { alpha: f64 },
    ELU { alpha: f64 },
    Swish,
    GELU,
    Tanh,
    Sigmoid,
}

/// Feature extraction configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FeatureConfig {
    /// Feature extraction method
    pub extraction_method: FeatureExtractionMethod,
    /// Number of features to extract
    pub num_features: usize,
    /// Time window for feature extraction
    pub time_window: Duration,
    /// Enable automatic feature selection
    pub auto_feature_selection: bool,
    /// Feature normalization method
    pub normalization: FeatureNormalization,
}

/// Feature extraction methods
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum FeatureExtractionMethod {
    /// Statistical features (mean, std, skewness, etc.)
    Statistical,
    /// Time-series features (trends, seasonality, etc.)
    TimeSeries,
    /// Frequency domain features (FFT-based)
    FrequencyDomain,
    /// Wavelet-based features
    Wavelet { wavelet_type: String },
    /// Neural autoencoder features
    NeuralAutoencoder { encoding_dim: usize },
    /// Ensemble of multiple methods
    Ensemble {
        methods: Vec<FeatureExtractionMethod>,
    },
}

/// Feature normalization methods
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum FeatureNormalization {
    None,
    StandardScore,
    MinMax,
    Robust,
    Quantile,
}

/// Multi-armed bandit for parameter exploration
#[derive(Debug)]
pub struct MultiArmedBandit<F: Float + std::fmt::Debug> {
    /// Available actions (parameter configurations)
    actions: Vec<ParameterConfiguration<F>>,
    /// Bandit algorithm
    algorithm: BanditAlgorithm<F>,
    /// Action rewards history
    rewards: Vec<Vec<F>>,
    /// Action selection counts
    counts: Vec<usize>,
    /// Current exploration rate
    exploration_rate: f64,
    /// Regret tracking
    regret_tracker: RegretTracker<F>,
}

/// Parameter configuration for bandit actions
#[derive(Debug, Clone)]
pub struct ParameterConfiguration<F: Float + std::fmt::Debug> {
    /// Parameter name
    pub name: String,
    /// Parameter value
    pub value: F,
    /// Parameter bounds
    pub bounds: (F, F),
    /// Parameter type
    pub param_type: ParameterType,
}

/// Parameter types for optimization
#[derive(Debug, Clone)]
pub enum ParameterType {
    Continuous,
    Discrete,
    Integer,
    Boolean,
    Categorical(Vec<String>),
}

/// Bandit algorithms
#[derive(Debug)]
pub enum BanditAlgorithm<F: Float> {
    /// Epsilon-greedy exploration
    EpsilonGreedy { epsilon: f64 },
    /// Upper Confidence Bound
    UCB { confidence_level: f64 },
    /// Thompson Sampling
    ThompsonSampling,
    /// Exponential-weight algorithm
    Exp3 { learning_rate: F },
}

/// Regret tracking for bandit performance
#[derive(Debug, Clone)]
pub struct RegretTracker<F: Float + std::fmt::Debug> {
    /// Cumulative regret
    cumulative_regret: F,
    /// Instantaneous regret history
    regret_history: Vec<F>,
    /// Best possible reward (oracle)
    best_reward: F,
    /// Total rounds played
    total_rounds: usize,
}

impl<F: Float + std::fmt::Debug> Default for RegretTracker<F> {
    fn default() -> Self {
        Self {
            cumulative_regret: F::zero(),
            regret_history: Vec::new(),
            best_reward: F::zero(),
            total_rounds: 0,
        }
    }
}

impl<F: Float + std::fmt::Debug> RegretTracker<F> {
    pub fn update(&mut self, reward: F, optimal_reward: F) {
        let regret = optimal_reward - reward;
        self.cumulative_regret = self.cumulative_regret + regret;
        self.regret_history.push(regret);
        self.best_reward = F::max(self.best_reward, optimal_reward);
        self.total_rounds += 1;
    }

    pub fn get_average_regret(&self) -> F {
        if self.total_rounds > 0 {
            self.cumulative_regret / F::from(self.total_rounds).expect("Failed to convert to float")
        } else {
            F::zero()
        }
    }
}

impl<F: Float + std::fmt::Debug + std::ops::AddAssign + std::iter::Sum> MultiArmedBandit<F> {
    pub fn new(actions: Vec<ParameterConfiguration<F>>, algorithm: BanditAlgorithm<F>) -> Self {
        let num_actions = actions.len();
        Self {
            actions,
            algorithm,
            rewards: vec![Vec::new(); num_actions],
            counts: vec![0; num_actions],
            exploration_rate: 0.1,
            regret_tracker: RegretTracker::default(),
        }
    }

    pub fn select_action(&mut self) -> Result<usize> {
        match &self.algorithm {
            BanditAlgorithm::EpsilonGreedy { epsilon } => {
                let mut rng = scirs2_core::random::thread_rng();
                if rng.random::<f64>() < *epsilon {
                    // Explore: random action
                    Ok(rng.random_range(0..self.actions.len()))
                } else {
                    // Exploit: best action so far
                    self.get_best_action()
                }
            }
            BanditAlgorithm::UCB { confidence_level } => self.get_ucb_action(*confidence_level),
            _ => {
                // Default to epsilon-greedy
                self.get_best_action()
            }
        }
    }

    fn get_best_action(&self) -> Result<usize> {
        let mut best_action = 0;
        let mut best_average = F::neg_infinity();

        for (i, rewards) in self.rewards.iter().enumerate() {
            if !rewards.is_empty() {
                let average = rewards.iter().cloned().sum::<F>()
                    / F::from(rewards.len()).expect("Operation failed");
                if average > best_average {
                    best_average = average;
                    best_action = i;
                }
            }
        }

        Ok(best_action)
    }

    fn get_ucb_action(&self, confidence_level: f64) -> Result<usize> {
        let total_counts: usize = self.counts.iter().sum();
        let mut best_action = 0;
        let mut best_ucb = F::neg_infinity();

        for (i, rewards) in self.rewards.iter().enumerate() {
            let ucb = if rewards.is_empty() {
                F::infinity() // Unplayed actions have infinite UCB
            } else {
                let average = rewards.iter().cloned().sum::<F>()
                    / F::from(rewards.len()).expect("Operation failed");
                let confidence_bonus =
                    F::from(confidence_level * (total_counts as f64 / self.counts[i] as f64).ln())
                        .expect("Operation failed")
                        .sqrt();
                average + confidence_bonus
            };

            if ucb > best_ucb {
                best_ucb = ucb;
                best_action = i;
            }
        }

        Ok(best_action)
    }

    pub fn update_reward(&mut self, action: usize, reward: F) -> Result<()> {
        if action >= self.actions.len() {
            return Err(crate::error::MetricsError::InvalidInput(
                "Invalid action index".to_string(),
            ));
        }

        self.rewards[action].push(reward);
        self.counts[action] += 1;

        // Update regret tracking
        let optimal_reward = self
            .rewards
            .iter()
            .filter_map(|r| {
                if r.is_empty() {
                    None
                } else {
                    Some(r.iter().cloned().sum::<F>() / F::from(r.len()).expect("Operation failed"))
                }
            })
            .fold(F::neg_infinity(), F::max);

        self.regret_tracker.update(reward, optimal_reward);

        Ok(())
    }

    pub fn get_action_statistics(&self) -> Vec<(usize, F, F)> {
        self.rewards
            .iter()
            .enumerate()
            .map(|(i, rewards)| {
                if rewards.is_empty() {
                    (0, F::zero(), F::zero())
                } else {
                    let count = rewards.len();
                    let mean = rewards.iter().cloned().sum::<F>()
                        / F::from(count).expect("Failed to convert to float");
                    let variance = rewards.iter().map(|&x| (x - mean) * (x - mean)).sum::<F>()
                        / F::from(count.max(1)).expect("Operation failed");
                    (count, mean, variance)
                }
            })
            .collect()
    }
}

/// Neural feature extractor
#[derive(Debug)]
pub struct NeuralFeatureExtractor<F: Float + std::fmt::Debug> {
    /// Input dimension
    input_dim: usize,
    /// Output dimension
    output_dim: usize,
    /// Autoencoder network
    autoencoder: AutoencoderNetwork<F>,
    /// Feature selection network
    feature_selector: FeatureSelectionNetwork<F>,
    /// Attention mechanism for important features
    attention: AttentionMechanism<F>,
}

/// Autoencoder network for feature extraction
#[derive(Debug, Clone)]
pub struct AutoencoderNetwork<F: Float + std::fmt::Debug> {
    /// Encoder layers
    encoder_layers: Vec<usize>,
    /// Decoder layers
    decoder_layers: Vec<usize>,
    /// Bottleneck dimension
    encoding_dim: usize,
    /// Network weights (simplified)
    weights: Vec<Array2<F>>,
}

/// Feature selection network
#[derive(Debug, Clone)]
pub struct FeatureSelectionNetwork<F: Float + std::fmt::Debug> {
    /// Selection threshold
    threshold: F,
    /// Importance scores
    importance_scores: Array1<F>,
    /// Selected feature indices
    selected_features: Vec<usize>,
}

/// Attention mechanism for feature importance
#[derive(Debug, Clone)]
pub struct AttentionMechanism<F: Float + std::fmt::Debug> {
    /// Attention type
    attention_type: AttentionType,
    /// Attention weights
    attention_weights: Array1<F>,
    /// Key dimension
    key_dim: usize,
    /// Value dimension
    value_dim: usize,
}

/// Types of attention mechanisms
#[derive(Debug, Clone)]
pub enum AttentionType {
    SelfAttention,
    MultiHead { num_heads: usize },
    CrossAttention,
}

/// Adaptive learning rate scheduler
#[derive(Debug)]
pub struct AdaptiveLearningScheduler<F: Float + std::fmt::Debug> {
    /// Initial learning rate
    initial_lr: F,
    /// Current learning rate
    current_lr: F,
    /// Scheduler type
    scheduler_type: SchedulerType<F>,
    /// Performance history for adaptation
    performance_history: Vec<F>,
    /// Adaptation parameters
    adaptation_params: SchedulerAdaptationParams<F>,
}

impl<F: Float + std::fmt::Debug> AdaptiveLearningScheduler<F> {
    pub fn new(initial_lr: F, scheduler_type: SchedulerType<F>) -> Self {
        Self {
            initial_lr,
            current_lr: initial_lr,
            scheduler_type,
            performance_history: Vec::new(),
            adaptation_params: SchedulerAdaptationParams::default(),
        }
    }

    pub fn update(&mut self, performance: F) -> F {
        self.performance_history.push(performance);

        // Keep only recent history for memory efficiency
        if self.performance_history.len() > 100 {
            self.performance_history.remove(0);
        }

        match &self.scheduler_type {
            SchedulerType::StepLR { step_size, gamma } => {
                if self.performance_history.len().is_multiple_of(*step_size) {
                    self.current_lr = self.current_lr * *gamma;
                }
            }
            SchedulerType::ReduceLROnPlateau {
                factor, patience, ..
            } => {
                if self.performance_history.len() > *patience {
                    let recent_performance =
                        &self.performance_history[self.performance_history.len() - patience..];
                    let is_plateau = recent_performance.windows(2).all(|w| {
                        (w[1] - w[0]).abs()
                            < F::from(0.001).expect("Failed to convert constant to float")
                    });
                    if is_plateau {
                        self.current_lr = self.current_lr * *factor;
                    }
                }
            }
            _ => {}
        }

        self.current_lr
    }

    pub fn get_learning_rate(&self) -> F {
        self.current_lr
    }

    pub fn reset(&mut self) {
        self.current_lr = self.initial_lr;
        self.performance_history.clear();
    }
}

/// Learning rate scheduler types
#[derive(Debug, Clone)]
pub enum SchedulerType<F: Float> {
    /// Constant learning rate
    Constant,
    /// Step-wise decay
    StepLR { step_size: usize, gamma: F },
    /// Exponential decay
    ExponentialLR { gamma: F },
    /// Reduce on plateau
    ReduceLROnPlateau {
        factor: F,
        patience: usize,
        threshold: F,
    },
    /// Cosine annealing
    CosineAnnealingLR { t_max: usize },
}

/// Scheduler adaptation parameters
#[derive(Debug, Clone)]
pub struct SchedulerAdaptationParams<F: Float + std::fmt::Debug> {
    /// Minimum learning rate
    pub min_lr: F,
    /// Maximum learning rate
    pub max_lr: F,
    /// Adaptation sensitivity
    pub sensitivity: F,
}

impl<F: Float + std::fmt::Debug> Default for SchedulerAdaptationParams<F> {
    fn default() -> Self {
        Self {
            min_lr: F::from(1e-6).expect("Failed to convert constant to float"),
            max_lr: F::from(1e-1).expect("Failed to convert constant to float"),
            sensitivity: F::from(0.1).expect("Failed to convert constant to float"),
        }
    }
}

// Simplified implementations for the other neural components
impl<F: Float + std::fmt::Debug + Send + Sync + scirs2_core::ndarray::ScalarOperand>
    AutoencoderNetwork<F>
{
    pub fn new(input_dim: usize, encoding_dim: usize) -> Self {
        Self {
            encoder_layers: vec![input_dim, encoding_dim * 2, encoding_dim],
            decoder_layers: vec![encoding_dim, encoding_dim * 2, input_dim],
            encoding_dim,
            weights: Vec::new(), // Would be properly initialized in real implementation
        }
    }

    pub fn encode(&self, _input: &Array1<F>) -> Result<Array1<F>> {
        // Simplified encoding - would implement actual forward pass
        Ok(Array1::zeros(self.encoding_dim))
    }
}

impl<F: Float + std::fmt::Debug> AttentionMechanism<F> {
    pub fn new(key_dim: usize, value_dim: usize, attention_type: AttentionType) -> Self {
        Self {
            attention_type,
            attention_weights: Array1::zeros(key_dim),
            key_dim,
            value_dim,
        }
    }
}

impl<F: Float + std::fmt::Debug + Send + Sync + scirs2_core::ndarray::ScalarOperand>
    FeatureSelectionNetwork<F>
{
    pub fn new(num_features: usize, threshold: F) -> Self {
        Self {
            threshold,
            importance_scores: Array1::zeros(num_features),
            selected_features: Vec::new(),
        }
    }

    pub fn select_features(&mut self, scores: &Array1<F>) -> Vec<usize> {
        self.importance_scores = scores.clone();
        self.selected_features = scores
            .iter()
            .enumerate()
            .filter(|(_, &score)| score > self.threshold)
            .map(|(i, _)| i)
            .collect();
        self.selected_features.clone()
    }
}

impl<F: Float + std::fmt::Debug + Send + Sync + scirs2_core::ndarray::ScalarOperand>
    NeuralFeatureExtractor<F>
{
    pub fn new(input_dim: usize, output_dim: usize) -> Self {
        Self {
            input_dim,
            output_dim,
            autoencoder: AutoencoderNetwork::new(input_dim, output_dim),
            feature_selector: FeatureSelectionNetwork::new(
                input_dim,
                F::from(0.1).expect("Failed to convert constant to float"),
            ),
            attention: AttentionMechanism::new(input_dim, output_dim, AttentionType::SelfAttention),
        }
    }

    pub fn extract_features(&self, input: &Array1<F>) -> Result<Array1<F>> {
        // Simplified feature extraction
        self.autoencoder.encode(input)
    }
}