sklears_model_selection/

automl_algorithm_selection.rs

//! Automated Algorithm Selection for AutoML
//!
//! This module provides intelligent algorithm selection based on dataset characteristics,
//! computational constraints, and performance requirements. It automatically selects
//! and configures the best algorithms for classification and regression tasks.

use crate::scoring::TaskType;
use scirs2_core::ndarray::{Array1, Array2};
use sklears_core::error::{Result, SklearsError};
use std::collections::HashMap;
use std::fmt;
// use serde::{Deserialize, Serialize};

/// Algorithm family categories for classification and regression
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum AlgorithmFamily {
    /// Linear models (LogisticRegression, LinearRegression, etc.)
    Linear,
    /// Tree-based models (DecisionTree, RandomForest, etc.)
    TreeBased,
    /// Ensemble methods (AdaBoost, Stacking, etc.)
    Ensemble,
    /// Neighbor-based models (KNN, etc.)
    NeighborBased,
    /// Support Vector Machines
    SVM,
    /// Naive Bayes classifiers
    NaiveBayes,
    /// Neural networks
    NeuralNetwork,
    /// Gaussian processes
    GaussianProcess,
    /// Discriminant analysis
    DiscriminantAnalysis,
    /// Dummy/baseline models
    Dummy,
}

impl fmt::Display for AlgorithmFamily {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            AlgorithmFamily::Linear => write!(f, "Linear"),
            AlgorithmFamily::TreeBased => write!(f, "Tree-based"),
            AlgorithmFamily::Ensemble => write!(f, "Ensemble"),
            AlgorithmFamily::NeighborBased => write!(f, "Neighbor-based"),
            AlgorithmFamily::SVM => write!(f, "Support Vector Machine"),
            AlgorithmFamily::NaiveBayes => write!(f, "Naive Bayes"),
            AlgorithmFamily::NeuralNetwork => write!(f, "Neural Network"),
            AlgorithmFamily::GaussianProcess => write!(f, "Gaussian Process"),
            AlgorithmFamily::DiscriminantAnalysis => write!(f, "Discriminant Analysis"),
            AlgorithmFamily::Dummy => write!(f, "Dummy/Baseline"),
        }
    }
}

/// Specific algorithm within a family
#[derive(Debug, Clone, PartialEq)]
pub struct AlgorithmSpec {
    /// Algorithm family
    pub family: AlgorithmFamily,
    /// Specific algorithm name
    pub name: String,
    /// Default hyperparameters
    pub default_params: HashMap<String, String>,
    /// Hyperparameter search space
    pub param_space: HashMap<String, Vec<String>>,
    /// Computational complexity (relative scale)
    pub complexity: f64,
    /// Memory requirements (relative scale)
    pub memory_requirement: f64,
    /// Supports probability prediction
    pub supports_proba: bool,
    /// Handles missing values
    pub handles_missing: bool,
    /// Handles categorical features
    pub handles_categorical: bool,
    /// Supports incremental learning
    pub supports_incremental: bool,
}

/// Dataset characteristics for algorithm selection
#[derive(Debug, Clone)]
pub struct DatasetCharacteristics {
    /// Number of samples
    pub n_samples: usize,
    /// Number of features
    pub n_features: usize,
    /// Number of classes (for classification)
    pub n_classes: Option<usize>,
    /// Class distribution (for classification)
    pub class_distribution: Option<Vec<f64>>,
    /// Target distribution (for regression)
    pub target_stats: Option<TargetStatistics>,
    /// Missing value ratio
    pub missing_ratio: f64,
    /// Categorical feature ratio
    pub categorical_ratio: f64,
    /// Feature correlation matrix condition number
    pub correlation_condition_number: f64,
    /// Dataset sparsity
    pub sparsity: f64,
    /// Effective dimensionality (based on PCA)
    pub effective_dimensionality: Option<usize>,
    /// Estimated noise level
    pub noise_level: f64,
    /// Linearity score (0-1, higher means more linear)
    pub linearity_score: f64,
}

/// Target statistics for regression tasks
#[derive(Debug, Clone)]
pub struct TargetStatistics {
    /// Mean of target values
    pub mean: f64,
    /// Standard deviation of target values
    pub std: f64,
    /// Skewness of target distribution
    pub skewness: f64,
    /// Kurtosis of target distribution
    pub kurtosis: f64,
    /// Number of outliers
    pub n_outliers: usize,
}

/// Computational constraints for algorithm selection
#[derive(Debug, Clone, Default)]
pub struct ComputationalConstraints {
    /// Maximum training time in seconds
    pub max_training_time: Option<f64>,
    /// Maximum memory usage in GB
    pub max_memory_gb: Option<f64>,
    /// Maximum model size in MB
    pub max_model_size_mb: Option<f64>,
    /// Maximum inference time per sample in milliseconds
    pub max_inference_time_ms: Option<f64>,
    /// Available CPU cores
    pub n_cores: Option<usize>,
    /// GPU availability
    pub has_gpu: bool,
}

/// Configuration for automated algorithm selection
#[derive(Debug, Clone)]
pub struct AutoMLConfig {
    /// Task type (classification or regression)
    pub task_type: TaskType,
    /// Computational constraints
    pub constraints: ComputationalConstraints,
    /// Algorithm families to consider (None means all)
    pub allowed_families: Option<Vec<AlgorithmFamily>>,
    /// Algorithm families to exclude
    pub excluded_families: Vec<AlgorithmFamily>,
    /// Maximum number of algorithms to evaluate
    pub max_algorithms: usize,
    /// Cross-validation strategy
    pub cv_folds: usize,
    /// Scoring metric
    pub scoring_metric: String,
    /// Time budget for hyperparameter optimization per algorithm
    pub hyperopt_time_budget: f64,
    /// Random seed for reproducibility
    pub random_seed: Option<u64>,
    /// Whether to use ensemble methods
    pub enable_ensembles: bool,
    /// Whether to perform feature engineering
    pub enable_feature_engineering: bool,
}

impl Default for AutoMLConfig {
    fn default() -> Self {
        Self {
            task_type: TaskType::Classification,
            constraints: ComputationalConstraints::default(),
            allowed_families: None,
            excluded_families: Vec::new(),
            max_algorithms: 10,
            cv_folds: 5,
            scoring_metric: "accuracy".to_string(),
            hyperopt_time_budget: 300.0, // 5 minutes per algorithm
            random_seed: None,
            enable_ensembles: true,
            enable_feature_engineering: true,
        }
    }
}

/// Result of algorithm selection process
#[derive(Debug, Clone)]
pub struct AlgorithmSelectionResult {
    /// Selected algorithm specifications
    pub selected_algorithms: Vec<RankedAlgorithm>,
    /// Dataset characteristics used for selection
    pub dataset_characteristics: DatasetCharacteristics,
    /// Total evaluation time
    pub total_evaluation_time: f64,
    /// Number of algorithms evaluated
    pub n_algorithms_evaluated: usize,
    /// Best performing algorithm
    pub best_algorithm: RankedAlgorithm,
    /// Performance improvement over baseline
    pub improvement_over_baseline: f64,
    /// Recommendation explanation
    pub explanation: String,
}

/// Algorithm with performance ranking
#[derive(Debug, Clone)]
pub struct RankedAlgorithm {
    /// Algorithm specification
    pub algorithm: AlgorithmSpec,
    /// Cross-validation score
    pub cv_score: f64,
    /// Standard deviation of CV scores
    pub cv_std: f64,
    /// Training time in seconds
    pub training_time: f64,
    /// Memory usage in MB
    pub memory_usage: f64,
    /// Optimized hyperparameters
    pub best_params: HashMap<String, String>,
    /// Rank among all algorithms (1 = best)
    pub rank: usize,
    /// Selection probability based on performance
    pub selection_probability: f64,
}

impl fmt::Display for AlgorithmSelectionResult {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        writeln!(f, "AutoML Algorithm Selection Results")?;
        writeln!(f, "==================================")?;
        writeln!(
            f,
            "Dataset: {} samples, {} features",
            self.dataset_characteristics.n_samples, self.dataset_characteristics.n_features
        )?;
        writeln!(f, "Algorithms evaluated: {}", self.n_algorithms_evaluated)?;
        writeln!(
            f,
            "Total evaluation time: {:.2}s",
            self.total_evaluation_time
        )?;
        writeln!(f)?;
        writeln!(
            f,
            "Best Algorithm: {} ({})",
            self.best_algorithm.algorithm.name, self.best_algorithm.algorithm.family
        )?;
        writeln!(
            f,
            "Score: {:.4} ± {:.4}",
            self.best_algorithm.cv_score, self.best_algorithm.cv_std
        )?;
        writeln!(
            f,
            "Training time: {:.2}s",
            self.best_algorithm.training_time
        )?;
        writeln!(
            f,
            "Improvement over baseline: {:.4}",
            self.improvement_over_baseline
        )?;
        writeln!(f)?;
        writeln!(f, "Explanation: {}", self.explanation)?;
        writeln!(f)?;
        writeln!(
            f,
            "Top {} Algorithms:",
            self.selected_algorithms.len().min(5)
        )?;
        for (i, alg) in self.selected_algorithms.iter().take(5).enumerate() {
            writeln!(
                f,
                "{}. {} ({}) - Score: {:.4} ± {:.4}",
                i + 1,
                alg.algorithm.name,
                alg.algorithm.family,
                alg.cv_score,
                alg.cv_std
            )?;
        }
        Ok(())
    }
}

/// Automated algorithm selector
pub struct AutoMLAlgorithmSelector {
    config: AutoMLConfig,
    algorithm_catalog: HashMap<TaskType, Vec<AlgorithmSpec>>,
}

impl Default for AutoMLAlgorithmSelector {
    fn default() -> Self {
        Self::new(AutoMLConfig::default())
    }
}

impl AutoMLAlgorithmSelector {
    /// Create a new AutoML algorithm selector
    pub fn new(config: AutoMLConfig) -> Self {
        let algorithm_catalog = Self::build_algorithm_catalog();
        Self {
            config,
            algorithm_catalog,
        }
    }

    /// Analyze dataset characteristics
    pub fn analyze_dataset(&self, X: &Array2<f64>, y: &Array1<f64>) -> DatasetCharacteristics {
        let n_samples = X.nrows();
        let n_features = X.ncols();

        // Basic statistics
        let missing_ratio = self.calculate_missing_ratio(X);
        let sparsity = self.calculate_sparsity(X);
        let correlation_condition_number = self.calculate_correlation_condition_number(X);

        // Task-specific characteristics
        let (n_classes, class_distribution, target_stats) = match self.config.task_type {
            TaskType::Classification => {
                let classes = self.get_unique_classes(y);
                let class_dist = self.calculate_class_distribution(y, &classes);
                (Some(classes.len()), Some(class_dist), None)
            }
            TaskType::Regression => {
                let stats = self.calculate_target_statistics(y);
                (None, None, Some(stats))
            }
        };

        // Advanced characteristics
        let linearity_score = self.estimate_linearity_score(X, y);
        let noise_level = self.estimate_noise_level(X, y);
        let effective_dimensionality = self.estimate_effective_dimensionality(X);
        let categorical_ratio = self.calculate_categorical_ratio(X);

        DatasetCharacteristics {
            n_samples,
            n_features,
            n_classes,
            class_distribution,
            target_stats,
            missing_ratio,
            categorical_ratio,
            correlation_condition_number,
            sparsity,
            effective_dimensionality,
            noise_level,
            linearity_score,
        }
    }

    /// Select best algorithms for the dataset
    pub fn select_algorithms(
        &self,
        X: &Array2<f64>,
        y: &Array1<f64>,
    ) -> Result<AlgorithmSelectionResult> {
        let start_time = std::time::Instant::now();

        // Analyze dataset characteristics
        let dataset_chars = self.analyze_dataset(X, y);

        // Get candidate algorithms
        let candidate_algorithms = self.get_candidate_algorithms(&dataset_chars)?;

        // Filter by constraints
        let filtered_algorithms = self.filter_by_constraints(&candidate_algorithms, &dataset_chars);

        // Evaluate algorithms
        let mut evaluated_algorithms = self.evaluate_algorithms(&filtered_algorithms, X, y)?;

        // Rank algorithms by performance
        evaluated_algorithms.sort_by(|a, b| {
            b.cv_score
                .partial_cmp(&a.cv_score)
                .expect("operation should succeed")
        });

        // Assign ranks and selection probabilities
        let algorithms_copy = evaluated_algorithms.clone();
        for (i, alg) in evaluated_algorithms.iter_mut().enumerate() {
            alg.rank = i + 1;
            alg.selection_probability = self.calculate_selection_probability(alg, &algorithms_copy);
        }

        let best_algorithm = evaluated_algorithms[0].clone();
        let baseline_score = self.get_baseline_score(X, y)?;
        let improvement = best_algorithm.cv_score - baseline_score;

        let explanation = self.generate_explanation(&best_algorithm, &dataset_chars);

        let total_time = start_time.elapsed().as_secs_f64();

        Ok(AlgorithmSelectionResult {
            selected_algorithms: evaluated_algorithms,
            dataset_characteristics: dataset_chars,
            total_evaluation_time: total_time,
            n_algorithms_evaluated: filtered_algorithms.len(),
            best_algorithm,
            improvement_over_baseline: improvement,
            explanation,
        })
    }

    /// Build catalog of available algorithms
    fn build_algorithm_catalog() -> HashMap<TaskType, Vec<AlgorithmSpec>> {
        let mut catalog = HashMap::new();

        // Classification algorithms
        let classification_algorithms = vec![
            // Linear classifiers
            AlgorithmSpec {
                family: AlgorithmFamily::Linear,
                name: "LogisticRegression".to_string(),
                default_params: [("C".to_string(), "1.0".to_string())]
                    .iter()
                    .cloned()
                    .collect(),
                param_space: [(
                    "C".to_string(),
                    vec![
                        "0.001".to_string(),
                        "0.01".to_string(),
                        "0.1".to_string(),
                        "1.0".to_string(),
                        "10.0".to_string(),
                        "100.0".to_string(),
                    ],
                )]
                .iter()
                .cloned()
                .collect(),
                complexity: 1.0,
                memory_requirement: 1.0,
                supports_proba: true,
                handles_missing: false,
                handles_categorical: false,
                supports_incremental: false,
            },
            AlgorithmSpec {
                family: AlgorithmFamily::Linear,
                name: "RidgeClassifier".to_string(),
                default_params: [("alpha".to_string(), "1.0".to_string())]
                    .iter()
                    .cloned()
                    .collect(),
                param_space: [(
                    "alpha".to_string(),
                    vec![
                        "0.1".to_string(),
                        "1.0".to_string(),
                        "10.0".to_string(),
                        "100.0".to_string(),
                    ],
                )]
                .iter()
                .cloned()
                .collect(),
                complexity: 1.0,
                memory_requirement: 1.0,
                supports_proba: false,
                handles_missing: false,
                handles_categorical: false,
                supports_incremental: false,
            },
            // Tree-based classifiers
            AlgorithmSpec {
                family: AlgorithmFamily::TreeBased,
                name: "DecisionTreeClassifier".to_string(),
                default_params: [("max_depth".to_string(), "None".to_string())]
                    .iter()
                    .cloned()
                    .collect(),
                param_space: [
                    (
                        "max_depth".to_string(),
                        vec![
                            "3".to_string(),
                            "5".to_string(),
                            "10".to_string(),
                            "None".to_string(),
                        ],
                    ),
                    (
                        "min_samples_split".to_string(),
                        vec!["2".to_string(), "5".to_string(), "10".to_string()],
                    ),
                ]
                .iter()
                .cloned()
                .collect(),
                complexity: 2.0,
                memory_requirement: 2.0,
                supports_proba: true,
                handles_missing: false,
                handles_categorical: true,
                supports_incremental: false,
            },
            AlgorithmSpec {
                family: AlgorithmFamily::TreeBased,
                name: "RandomForestClassifier".to_string(),
                default_params: [("n_estimators".to_string(), "100".to_string())]
                    .iter()
                    .cloned()
                    .collect(),
                param_space: [
                    (
                        "n_estimators".to_string(),
                        vec!["50".to_string(), "100".to_string(), "200".to_string()],
                    ),
                    (
                        "max_depth".to_string(),
                        vec![
                            "3".to_string(),
                            "5".to_string(),
                            "10".to_string(),
                            "None".to_string(),
                        ],
                    ),
                ]
                .iter()
                .cloned()
                .collect(),
                complexity: 4.0,
                memory_requirement: 4.0,
                supports_proba: true,
                handles_missing: false,
                handles_categorical: true,
                supports_incremental: false,
            },
            // Ensemble methods
            AlgorithmSpec {
                family: AlgorithmFamily::Ensemble,
                name: "AdaBoostClassifier".to_string(),
                default_params: [("n_estimators".to_string(), "50".to_string())]
                    .iter()
                    .cloned()
                    .collect(),
                param_space: [
                    (
                        "n_estimators".to_string(),
                        vec!["25".to_string(), "50".to_string(), "100".to_string()],
                    ),
                    (
                        "learning_rate".to_string(),
                        vec!["0.1".to_string(), "0.5".to_string(), "1.0".to_string()],
                    ),
                ]
                .iter()
                .cloned()
                .collect(),
                complexity: 3.0,
                memory_requirement: 3.0,
                supports_proba: true,
                handles_missing: false,
                handles_categorical: true,
                supports_incremental: false,
            },
            // K-Nearest Neighbors
            AlgorithmSpec {
                family: AlgorithmFamily::NeighborBased,
                name: "KNeighborsClassifier".to_string(),
                default_params: [("n_neighbors".to_string(), "5".to_string())]
                    .iter()
                    .cloned()
                    .collect(),
                param_space: [
                    (
                        "n_neighbors".to_string(),
                        vec![
                            "3".to_string(),
                            "5".to_string(),
                            "7".to_string(),
                            "11".to_string(),
                        ],
                    ),
                    (
                        "weights".to_string(),
                        vec!["uniform".to_string(), "distance".to_string()],
                    ),
                ]
                .iter()
                .cloned()
                .collect(),
                complexity: 1.0,
                memory_requirement: 5.0,
                supports_proba: true,
                handles_missing: false,
                handles_categorical: false,
                supports_incremental: false,
            },
            // Naive Bayes
            AlgorithmSpec {
                family: AlgorithmFamily::NaiveBayes,
                name: "GaussianNB".to_string(),
                default_params: HashMap::new(),
                param_space: HashMap::new(),
                complexity: 1.0,
                memory_requirement: 1.0,
                supports_proba: true,
                handles_missing: false,
                handles_categorical: false,
                supports_incremental: true,
            },
            // Support Vector Machine
            AlgorithmSpec {
                family: AlgorithmFamily::SVM,
                name: "SVC".to_string(),
                default_params: [
                    ("C".to_string(), "1.0".to_string()),
                    ("kernel".to_string(), "rbf".to_string()),
                ]
                .iter()
                .cloned()
                .collect(),
                param_space: [
                    (
                        "C".to_string(),
                        vec!["0.1".to_string(), "1.0".to_string(), "10.0".to_string()],
                    ),
                    (
                        "kernel".to_string(),
                        vec!["linear".to_string(), "rbf".to_string(), "poly".to_string()],
                    ),
                ]
                .iter()
                .cloned()
                .collect(),
                complexity: 3.0,
                memory_requirement: 3.0,
                supports_proba: false,
                handles_missing: false,
                handles_categorical: false,
                supports_incremental: false,
            },
            // Dummy classifier for baseline
            AlgorithmSpec {
                family: AlgorithmFamily::Dummy,
                name: "DummyClassifier".to_string(),
                default_params: [("strategy".to_string(), "stratified".to_string())]
                    .iter()
                    .cloned()
                    .collect(),
                param_space: [(
                    "strategy".to_string(),
                    vec![
                        "stratified".to_string(),
                        "most_frequent".to_string(),
                        "uniform".to_string(),
                    ],
                )]
                .iter()
                .cloned()
                .collect(),
                complexity: 0.1,
                memory_requirement: 0.1,
                supports_proba: true,
                handles_missing: true,
                handles_categorical: true,
                supports_incremental: true,
            },
        ];

        // Regression algorithms
        let regression_algorithms = vec![
            // Linear regressors
            AlgorithmSpec {
                family: AlgorithmFamily::Linear,
                name: "LinearRegression".to_string(),
                default_params: HashMap::new(),
                param_space: HashMap::new(),
                complexity: 1.0,
                memory_requirement: 1.0,
                supports_proba: false,
                handles_missing: false,
                handles_categorical: false,
                supports_incremental: false,
            },
            AlgorithmSpec {
                family: AlgorithmFamily::Linear,
                name: "Ridge".to_string(),
                default_params: [("alpha".to_string(), "1.0".to_string())]
                    .iter()
                    .cloned()
                    .collect(),
                param_space: [(
                    "alpha".to_string(),
                    vec![
                        "0.1".to_string(),
                        "1.0".to_string(),
                        "10.0".to_string(),
                        "100.0".to_string(),
                    ],
                )]
                .iter()
                .cloned()
                .collect(),
                complexity: 1.0,
                memory_requirement: 1.0,
                supports_proba: false,
                handles_missing: false,
                handles_categorical: false,
                supports_incremental: false,
            },
            AlgorithmSpec {
                family: AlgorithmFamily::Linear,
                name: "Lasso".to_string(),
                default_params: [("alpha".to_string(), "1.0".to_string())]
                    .iter()
                    .cloned()
                    .collect(),
                param_space: [(
                    "alpha".to_string(),
                    vec![
                        "0.001".to_string(),
                        "0.01".to_string(),
                        "0.1".to_string(),
                        "1.0".to_string(),
                    ],
                )]
                .iter()
                .cloned()
                .collect(),
                complexity: 1.5,
                memory_requirement: 1.0,
                supports_proba: false,
                handles_missing: false,
                handles_categorical: false,
                supports_incremental: false,
            },
            // Tree-based regressors
            AlgorithmSpec {
                family: AlgorithmFamily::TreeBased,
                name: "DecisionTreeRegressor".to_string(),
                default_params: [("max_depth".to_string(), "None".to_string())]
                    .iter()
                    .cloned()
                    .collect(),
                param_space: [
                    (
                        "max_depth".to_string(),
                        vec![
                            "3".to_string(),
                            "5".to_string(),
                            "10".to_string(),
                            "None".to_string(),
                        ],
                    ),
                    (
                        "min_samples_split".to_string(),
                        vec!["2".to_string(), "5".to_string(), "10".to_string()],
                    ),
                ]
                .iter()
                .cloned()
                .collect(),
                complexity: 2.0,
                memory_requirement: 2.0,
                supports_proba: false,
                handles_missing: false,
                handles_categorical: true,
                supports_incremental: false,
            },
            AlgorithmSpec {
                family: AlgorithmFamily::TreeBased,
                name: "RandomForestRegressor".to_string(),
                default_params: [("n_estimators".to_string(), "100".to_string())]
                    .iter()
                    .cloned()
                    .collect(),
                param_space: [
                    (
                        "n_estimators".to_string(),
                        vec!["50".to_string(), "100".to_string(), "200".to_string()],
                    ),
                    (
                        "max_depth".to_string(),
                        vec![
                            "3".to_string(),
                            "5".to_string(),
                            "10".to_string(),
                            "None".to_string(),
                        ],
                    ),
                ]
                .iter()
                .cloned()
                .collect(),
                complexity: 4.0,
                memory_requirement: 4.0,
                supports_proba: false,
                handles_missing: false,
                handles_categorical: true,
                supports_incremental: false,
            },
            // K-Nearest Neighbors
            AlgorithmSpec {
                family: AlgorithmFamily::NeighborBased,
                name: "KNeighborsRegressor".to_string(),
                default_params: [("n_neighbors".to_string(), "5".to_string())]
                    .iter()
                    .cloned()
                    .collect(),
                param_space: [
                    (
                        "n_neighbors".to_string(),
                        vec![
                            "3".to_string(),
                            "5".to_string(),
                            "7".to_string(),
                            "11".to_string(),
                        ],
                    ),
                    (
                        "weights".to_string(),
                        vec!["uniform".to_string(), "distance".to_string()],
                    ),
                ]
                .iter()
                .cloned()
                .collect(),
                complexity: 1.0,
                memory_requirement: 5.0,
                supports_proba: false,
                handles_missing: false,
                handles_categorical: false,
                supports_incremental: false,
            },
            // Support Vector Machine
            AlgorithmSpec {
                family: AlgorithmFamily::SVM,
                name: "SVR".to_string(),
                default_params: [
                    ("C".to_string(), "1.0".to_string()),
                    ("kernel".to_string(), "rbf".to_string()),
                ]
                .iter()
                .cloned()
                .collect(),
                param_space: [
                    (
                        "C".to_string(),
                        vec!["0.1".to_string(), "1.0".to_string(), "10.0".to_string()],
                    ),
                    (
                        "kernel".to_string(),
                        vec!["linear".to_string(), "rbf".to_string(), "poly".to_string()],
                    ),
                ]
                .iter()
                .cloned()
                .collect(),
                complexity: 3.0,
                memory_requirement: 3.0,
                supports_proba: false,
                handles_missing: false,
                handles_categorical: false,
                supports_incremental: false,
            },
            // Dummy regressor for baseline
            AlgorithmSpec {
                family: AlgorithmFamily::Dummy,
                name: "DummyRegressor".to_string(),
                default_params: [("strategy".to_string(), "mean".to_string())]
                    .iter()
                    .cloned()
                    .collect(),
                param_space: [(
                    "strategy".to_string(),
                    vec![
                        "mean".to_string(),
                        "median".to_string(),
                        "constant".to_string(),
                    ],
                )]
                .iter()
                .cloned()
                .collect(),
                complexity: 0.1,
                memory_requirement: 0.1,
                supports_proba: false,
                handles_missing: true,
                handles_categorical: true,
                supports_incremental: true,
            },
        ];

        catalog.insert(TaskType::Classification, classification_algorithms);
        catalog.insert(TaskType::Regression, regression_algorithms);
        catalog
    }

    /// Get candidate algorithms for the given dataset characteristics
    fn get_candidate_algorithms(
        &self,
        dataset_chars: &DatasetCharacteristics,
    ) -> Result<Vec<AlgorithmSpec>> {
        let algorithms = self
            .algorithm_catalog
            .get(&self.config.task_type)
            .ok_or_else(|| SklearsError::InvalidParameter {
                name: "task_type".to_string(),
                reason: format!(
                    "No algorithms available for task type: {:?}",
                    self.config.task_type
                ),
            })?;

        let mut candidates = Vec::new();

        for algorithm in algorithms {
            // Check if family is allowed
            if let Some(ref allowed) = self.config.allowed_families {
                if !allowed.contains(&algorithm.family) {
                    continue;
                }
            }

            // Check if family is excluded
            if self.config.excluded_families.contains(&algorithm.family) {
                continue;
            }

            // Apply heuristic filters based on dataset characteristics
            if self.is_algorithm_suitable(algorithm, dataset_chars) {
                candidates.push(algorithm.clone());
            }
        }

        // Limit to max_algorithms
        candidates.truncate(self.config.max_algorithms);

        Ok(candidates)
    }

    /// Check if algorithm is suitable for the dataset
    fn is_algorithm_suitable(
        &self,
        algorithm: &AlgorithmSpec,
        dataset_chars: &DatasetCharacteristics,
    ) -> bool {
        // Skip dummy algorithms unless specifically requested
        if algorithm.family == AlgorithmFamily::Dummy && !self.config.excluded_families.is_empty() {
            return false;
        }

        // High-dimensional data heuristics
        if dataset_chars.n_features > dataset_chars.n_samples {
            // Prefer linear models for high-dimensional data
            match algorithm.family {
                AlgorithmFamily::Linear | AlgorithmFamily::NaiveBayes => return true,
                AlgorithmFamily::NeighborBased | AlgorithmFamily::SVM => return false,
                _ => {}
            }
        }

        // Small dataset heuristics
        if dataset_chars.n_samples < 100 {
            // Avoid overly complex models for small datasets
            if algorithm.complexity > 3.0 {
                return false;
            }
        }

        // Large dataset heuristics
        if dataset_chars.n_samples > 10000 {
            // Prefer scalable algorithms for large datasets
            match algorithm.family {
                AlgorithmFamily::NeighborBased => return false, // KNN doesn't scale well
                AlgorithmFamily::SVM => return dataset_chars.n_samples < 50000, // SVM has cubic complexity
                _ => {}
            }
        }

        // Linearity heuristics
        if dataset_chars.linearity_score > 0.8 {
            // Prefer linear models for linear data
            match algorithm.family {
                AlgorithmFamily::Linear => return true,
                AlgorithmFamily::TreeBased | AlgorithmFamily::Ensemble => return false,
                _ => {}
            }
        }

        // Missing value handling
        if dataset_chars.missing_ratio > 0.0 && !algorithm.handles_missing {
            return false;
        }

        true
    }

    /// Filter algorithms by computational constraints
    fn filter_by_constraints(
        &self,
        algorithms: &[AlgorithmSpec],
        dataset_chars: &DatasetCharacteristics,
    ) -> Vec<AlgorithmSpec> {
        algorithms
            .iter()
            .filter(|alg| self.satisfies_constraints(alg, dataset_chars))
            .cloned()
            .collect()
    }

    /// Check if algorithm satisfies computational constraints
    fn satisfies_constraints(
        &self,
        algorithm: &AlgorithmSpec,
        dataset_chars: &DatasetCharacteristics,
    ) -> bool {
        // Rough complexity estimates
        let estimated_training_time = self.estimate_training_time(algorithm, dataset_chars);
        let estimated_memory_usage = self.estimate_memory_usage(algorithm, dataset_chars);

        if let Some(max_time) = self.config.constraints.max_training_time {
            if estimated_training_time > max_time {
                return false;
            }
        }

        if let Some(max_memory) = self.config.constraints.max_memory_gb {
            if estimated_memory_usage > max_memory {
                return false;
            }
        }

        true
    }

    /// Estimate training time for algorithm
    fn estimate_training_time(
        &self,
        algorithm: &AlgorithmSpec,
        dataset_chars: &DatasetCharacteristics,
    ) -> f64 {
        let n = dataset_chars.n_samples as f64;
        let p = dataset_chars.n_features as f64;

        // Base time estimates (in seconds for 1000 samples, 10 features)
        let base_time = match algorithm.family {
            AlgorithmFamily::Linear => 0.1,
            AlgorithmFamily::TreeBased => {
                if algorithm.name.contains("Random") {
                    2.0
                } else {
                    0.5
                }
            }
            AlgorithmFamily::Ensemble => 3.0,
            AlgorithmFamily::NeighborBased => 0.05, // Training is fast, prediction is slow
            AlgorithmFamily::SVM => 1.0,
            AlgorithmFamily::NaiveBayes => 0.05,
            AlgorithmFamily::NeuralNetwork => 5.0,
            AlgorithmFamily::GaussianProcess => 2.0,
            AlgorithmFamily::DiscriminantAnalysis => 0.2,
            AlgorithmFamily::Dummy => 0.01,
        };

        // Scale by complexity and data size
        base_time * algorithm.complexity * (n / 1000.0) * (p / 10.0).sqrt()
    }

    /// Estimate memory usage for algorithm
    fn estimate_memory_usage(
        &self,
        algorithm: &AlgorithmSpec,
        dataset_chars: &DatasetCharacteristics,
    ) -> f64 {
        let n = dataset_chars.n_samples as f64;
        let p = dataset_chars.n_features as f64;

        // Base memory in GB
        let base_memory_mb = match algorithm.family {
            AlgorithmFamily::Linear => 1.0,
            AlgorithmFamily::TreeBased => {
                if algorithm.name.contains("Random") {
                    50.0
                } else {
                    10.0
                }
            }
            AlgorithmFamily::Ensemble => 100.0,
            AlgorithmFamily::NeighborBased => n * p * 8.0 / 1_000_000.0, // Store all training data
            AlgorithmFamily::SVM => 20.0,
            AlgorithmFamily::NaiveBayes => 1.0,
            AlgorithmFamily::NeuralNetwork => 50.0,
            AlgorithmFamily::GaussianProcess => 10.0,
            AlgorithmFamily::DiscriminantAnalysis => 5.0,
            AlgorithmFamily::Dummy => 0.1,
        };

        (base_memory_mb * algorithm.memory_requirement) / 1000.0 // Convert to GB
    }

    /// Evaluate algorithms using cross-validation
    fn evaluate_algorithms(
        &self,
        algorithms: &[AlgorithmSpec],
        X: &Array2<f64>,
        y: &Array1<f64>,
    ) -> Result<Vec<RankedAlgorithm>> {
        let mut results = Vec::new();

        for algorithm in algorithms {
            let start_time = std::time::Instant::now();

            // Create mock cross-validation results
            // In a real implementation, this would actually train and evaluate the models
            let cv_score = self.mock_evaluate_algorithm(algorithm, X, y);
            let cv_std = cv_score * 0.05; // Mock standard deviation

            let training_time = start_time.elapsed().as_secs_f64();
            let memory_usage = self.estimate_memory_usage(algorithm, &self.analyze_dataset(X, y));

            results.push(RankedAlgorithm {
                algorithm: algorithm.clone(),
                cv_score,
                cv_std,
                training_time,
                memory_usage,
                best_params: algorithm.default_params.clone(),
                rank: 0,                    // Will be set later
                selection_probability: 0.0, // Will be set later
            });
        }

        Ok(results)
    }

    /// Mock algorithm evaluation (replace with actual implementation)
    fn mock_evaluate_algorithm(
        &self,
        algorithm: &AlgorithmSpec,
        X: &Array2<f64>,
        y: &Array1<f64>,
    ) -> f64 {
        // Generate mock scores based on algorithm characteristics and data
        let dataset_chars = self.analyze_dataset(X, y);

        let base_score = match self.config.task_type {
            TaskType::Classification => 0.7, // Mock accuracy
            TaskType::Regression => 0.8,     // Mock R²
        };

        // Adjust score based on algorithm suitability
        let mut score: f64 = base_score;

        // Linear models perform better on linear data
        if algorithm.family == AlgorithmFamily::Linear && dataset_chars.linearity_score > 0.7 {
            score += 0.1;
        }

        // Tree models perform better on non-linear data
        if matches!(
            algorithm.family,
            AlgorithmFamily::TreeBased | AlgorithmFamily::Ensemble
        ) && dataset_chars.linearity_score < 0.5
        {
            score += 0.1;
        }

        // Ensemble methods generally perform better
        if algorithm.family == AlgorithmFamily::Ensemble {
            score += 0.05;
        }

        // Add some noise
        //         use scirs2_core::random::Rng;
        let mut rng = scirs2_core::random::thread_rng();
        score += rng.gen_range(-0.05..0.05);

        score.clamp(0.0, 1.0)
    }

    /// Calculate selection probability based on performance
    fn calculate_selection_probability(
        &self,
        algorithm: &RankedAlgorithm,
        all_algorithms: &[RankedAlgorithm],
    ) -> f64 {
        let max_score = all_algorithms
            .iter()
            .map(|a| a.cv_score)
            .fold(0.0, f64::max);
        let min_score = all_algorithms
            .iter()
            .map(|a| a.cv_score)
            .fold(1.0, f64::min);

        if max_score == min_score {
            return 1.0 / all_algorithms.len() as f64;
        }

        // Softmax-like probability
        let normalized_score = (algorithm.cv_score - min_score) / (max_score - min_score);
        let exp_score = (normalized_score * 5.0).exp();
        let total_exp: f64 = all_algorithms
            .iter()
            .map(|a| {
                let norm = (a.cv_score - min_score) / (max_score - min_score);
                (norm * 5.0).exp()
            })
            .sum();

        exp_score / total_exp
    }

    /// Get baseline score for comparison
    fn get_baseline_score(&self, _X: &Array2<f64>, y: &Array1<f64>) -> Result<f64> {
        match self.config.task_type {
            TaskType::Classification => {
                // Most frequent class accuracy
                let classes = self.get_unique_classes(y);
                let class_counts = self.calculate_class_distribution(y, &classes);
                Ok(class_counts.iter().fold(0.0, |acc, &x| acc.max(x)))
            }
            TaskType::Regression => {
                // R² of predicting mean
                let mean = y.mean().expect("operation should succeed");
                let tss: f64 = y.iter().map(|&yi| (yi - mean).powi(2)).sum();
                let rss = tss; // Predicting mean gives R² = 0
                Ok(1.0 - rss / tss)
            }
        }
    }

    /// Generate explanation for the selected algorithm
    fn generate_explanation(
        &self,
        best_algorithm: &RankedAlgorithm,
        dataset_chars: &DatasetCharacteristics,
    ) -> String {
        let mut explanation = format!(
            "{} ({}) was selected as the best algorithm with a cross-validation score of {:.4}.",
            best_algorithm.algorithm.name, best_algorithm.algorithm.family, best_algorithm.cv_score
        );

        // Add reasoning based on dataset characteristics
        if dataset_chars.n_samples < 1000 {
            explanation.push_str(" This algorithm is well-suited for small datasets.");
        } else if dataset_chars.n_samples > 10000 {
            explanation.push_str(" This algorithm scales well to large datasets.");
        }

        if dataset_chars.linearity_score > 0.7
            && best_algorithm.algorithm.family == AlgorithmFamily::Linear
        {
            explanation.push_str(
                " The linear nature of your data makes linear models particularly effective.",
            );
        }

        if dataset_chars.n_features > dataset_chars.n_samples {
            explanation.push_str(" The high-dimensional nature of your data favors this algorithm's regularization capabilities.");
        }

        if best_algorithm.algorithm.family == AlgorithmFamily::Ensemble {
            explanation.push_str(
                " Ensemble methods often provide robust performance across diverse datasets.",
            );
        }

        explanation
    }

    // Helper methods for dataset analysis
    fn calculate_missing_ratio(&self, X: &Array2<f64>) -> f64 {
        let total_values = X.len() as f64;
        let missing_count = X.iter().filter(|&&x| x.is_nan()).count() as f64;
        missing_count / total_values
    }

    fn calculate_sparsity(&self, X: &Array2<f64>) -> f64 {
        let total_values = X.len() as f64;
        let zero_count = X.iter().filter(|&&x| x == 0.0).count() as f64;
        zero_count / total_values
    }

    fn calculate_categorical_ratio(&self, X: &Array2<f64>) -> f64 {
        let n_features = X.ncols();
        if n_features == 0 {
            return 0.0;
        }

        let mut categorical_count = 0;
        for col_idx in 0..n_features {
            let column = X.column(col_idx);

            // Filter out NaN values
            let valid_values: Vec<f64> = column.iter().filter(|&&x| !x.is_nan()).copied().collect();

            if valid_values.is_empty() {
                continue;
            }

            // Count unique values
            let mut unique_values = valid_values.clone();
            unique_values.sort_by(|a, b| a.partial_cmp(b).expect("operation should succeed"));
            unique_values.dedup();

            let n_unique = unique_values.len();
            let n_total = valid_values.len();

            // Heuristic: Consider categorical if:
            // 1. Has 10 or fewer unique values, OR
            // 2. Unique ratio < 5% and all values appear to be integers
            let unique_ratio = n_unique as f64 / n_total as f64;
            let all_integers = valid_values.iter().all(|&x| (x - x.round()).abs() < 1e-10);

            if n_unique <= 10 || (unique_ratio < 0.05 && all_integers) {
                categorical_count += 1;
            }
        }

        categorical_count as f64 / n_features as f64
    }

    fn calculate_correlation_condition_number(&self, _X: &Array2<f64>) -> f64 {
        // Mock implementation - would need actual correlation matrix computation
        //         use scirs2_core::random::Rng;
        let mut rng = scirs2_core::random::thread_rng();
        rng.gen_range(1.0..100.0)
    }

    fn get_unique_classes(&self, y: &Array1<f64>) -> Vec<i32> {
        let mut classes: Vec<i32> = y.iter().map(|&x| x as i32).collect();
        classes.sort_unstable();
        classes.dedup();
        classes
    }

    fn calculate_class_distribution(&self, y: &Array1<f64>, classes: &[i32]) -> Vec<f64> {
        let total = y.len() as f64;
        classes
            .iter()
            .map(|&class| {
                let count = y.iter().filter(|&&yi| yi as i32 == class).count() as f64;
                count / total
            })
            .collect()
    }

    fn calculate_target_statistics(&self, y: &Array1<f64>) -> TargetStatistics {
        let mean = y.mean().expect("operation should succeed");
        let std = y.std(0.0);

        // Mock calculations for advanced statistics
        TargetStatistics {
            mean,
            std,
            skewness: 0.0, // Would need actual skewness calculation
            kurtosis: 0.0, // Would need actual kurtosis calculation
            n_outliers: 0, // Would need outlier detection
        }
    }

    fn estimate_linearity_score(&self, _X: &Array2<f64>, _y: &Array1<f64>) -> f64 {
        // Mock implementation - would need actual linearity testing
        //         use scirs2_core::random::Rng;
        let mut rng = scirs2_core::random::thread_rng();
        rng.gen_range(0.0..1.0)
    }

    fn estimate_noise_level(&self, _X: &Array2<f64>, _y: &Array1<f64>) -> f64 {
        // Mock implementation - would need actual noise estimation
        //         use scirs2_core::random::Rng;
        let mut rng = scirs2_core::random::thread_rng();
        rng.gen_range(0.0..0.5)
    }

    fn estimate_effective_dimensionality(&self, X: &Array2<f64>) -> Option<usize> {
        // Mock implementation - would need PCA analysis
        Some((X.ncols() as f64 * 0.8) as usize)
    }
}

/// Convenience function for quick algorithm selection
pub fn select_best_algorithm(
    X: &Array2<f64>,
    y: &Array1<f64>,
    task_type: TaskType,
) -> Result<AlgorithmSelectionResult> {
    let config = AutoMLConfig {
        task_type,
        ..Default::default()
    };

    let selector = AutoMLAlgorithmSelector::new(config);
    selector.select_algorithms(X, y)
}

#[allow(non_snake_case)]
#[cfg(test)]
mod tests {
    use super::*;
    use scirs2_core::ndarray::{Array1, Array2};

    #[allow(non_snake_case)]
    fn create_test_classification_data() -> (Array2<f64>, Array1<f64>) {
        let X = Array2::from_shape_vec((100, 4), (0..400).map(|i| i as f64).collect())
            .expect("operation should succeed");
        let y = Array1::from_vec((0..100).map(|i| (i % 3) as f64).collect());
        (X, y)
    }

    #[allow(non_snake_case)]
    fn create_test_regression_data() -> (Array2<f64>, Array1<f64>) {
        let X = Array2::from_shape_vec((100, 4), (0..400).map(|i| i as f64).collect())
            .expect("operation should succeed");
        use scirs2_core::essentials::Uniform;
        use scirs2_core::random::{thread_rng, Distribution};
        let mut rng = thread_rng();
        let dist = Uniform::new(0.0, 1.0).expect("operation should succeed");
        let y = Array1::from_vec((0..100).map(|i| i as f64 + dist.sample(&mut rng)).collect());
        (X, y)
    }

    #[test]
    fn test_algorithm_selection_classification() {
        let (X, y) = create_test_classification_data();
        let result = select_best_algorithm(&X, &y, TaskType::Classification);
        assert!(result.is_ok());

        let result = result.expect("operation should succeed");
        assert!(!result.selected_algorithms.is_empty());
        assert!(result.best_algorithm.cv_score > 0.0);
    }

    #[test]
    fn test_algorithm_selection_regression() {
        let (X, y) = create_test_regression_data();
        let result = select_best_algorithm(&X, &y, TaskType::Regression);
        assert!(result.is_ok());

        let result = result.expect("operation should succeed");
        assert!(!result.selected_algorithms.is_empty());
        assert!(result.best_algorithm.cv_score > 0.0);
    }

    #[test]
    fn test_dataset_characteristics_analysis() {
        let (X, y) = create_test_classification_data();
        let config = AutoMLConfig::default();
        let selector = AutoMLAlgorithmSelector::new(config);

        let chars = selector.analyze_dataset(&X, &y);
        assert_eq!(chars.n_samples, 100);
        assert_eq!(chars.n_features, 4);
        assert_eq!(chars.n_classes, Some(3));
    }

    #[test]
    fn test_custom_config() {
        let (X, y) = create_test_classification_data();

        let config = AutoMLConfig {
            task_type: TaskType::Classification,
            max_algorithms: 3,
            allowed_families: Some(vec![AlgorithmFamily::Linear, AlgorithmFamily::TreeBased]),
            ..Default::default()
        };

        let selector = AutoMLAlgorithmSelector::new(config);
        let result = selector.select_algorithms(&X, &y);
        assert!(result.is_ok());

        let result = result.expect("operation should succeed");
        assert!(result.n_algorithms_evaluated <= 3);

        for alg in &result.selected_algorithms {
            assert!(matches!(
                alg.algorithm.family,
                AlgorithmFamily::Linear | AlgorithmFamily::TreeBased
            ));
        }
    }

    #[test]
    fn test_computational_constraints() {
        let (X, y) = create_test_classification_data();

        let config = AutoMLConfig {
            task_type: TaskType::Classification,
            constraints: ComputationalConstraints {
                max_training_time: Some(1.0), // Very short time limit
                max_memory_gb: Some(0.1),     // Very low memory limit
                ..Default::default()
            },
            ..Default::default()
        };

        let selector = AutoMLAlgorithmSelector::new(config);
        let result = selector.select_algorithms(&X, &y);
        assert!(result.is_ok());

        let result = result.expect("operation should succeed");
        // Should still find at least simple algorithms
        assert!(!result.selected_algorithms.is_empty());
    }
}