Function make_continual_learning_dataset 

pub fn make_continual_learning_dataset(
    n_tasks: usize,
    n_samples_per_task: usize,
    n_features: usize,
    n_classes: usize,
    concept_drift_strength: f64,
) -> Result<ContinualLearningDataset>

Generate continual learning dataset

Examples found in repository

examples/advanced_generators_demo.rs (line 403)

fn demonstrate_continual_learning() -> Result<(), Box<dyn std::error::Error>> {
    println!("📚 CONTINUAL LEARNING DATASETS");
    println!("{}", "-".repeat(35));

    let drift_strengths = vec![
        ("Mild drift", 0.2),
        ("Moderate drift", 0.5),
        ("Severe drift", 1.0),
    ];

    for (name, drift_strength) in drift_strengths {
        println!("\nGenerating {name} scenario:");

        let dataset = make_continual_learning_dataset(5, 500, 15, 4, drift_strength)?;

        println!("  📊 Continual learning structure:");
        println!("    Number of tasks: {}", dataset.tasks.len());
        println!(
            "    Concept drift strength: {:.1}",
            dataset.concept_drift_strength
        );

        // Analyze concept drift between tasks
        analyze_concept_drift(&dataset);

        // Recommend continual learning strategies
        println!(
            "  💡 Recommended strategies: {}",
            get_continual_learning_strategies(drift_strength)
        );
    }

    // Catastrophic forgetting simulation
    println!("\nCatastrophic forgetting analysis:");
    simulate_catastrophic_forgetting()?;

    println!();
    Ok(())
}

#[allow(dead_code)]
fn demonstrate_advanced_applications() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 ADVANCED APPLICATIONS");
    println!("{}", "-".repeat(25));

    // Meta-learning scenario
    println!("Meta-learning scenario:");
    demonstrate_meta_learning_setup()?;

    // Robust machine learning
    println!("\nRobust ML scenario:");
    demonstrate_robust_ml_setup()?;

    // Federated learning simulation
    println!("\nFederated learning scenario:");
    demonstrate_federated_learning_setup()?;

    Ok(())
}

// Helper functions for analysis

#[allow(dead_code)]
fn calculate_perturbation_norm(
    original: &scirs2_datasets::Dataset,
    adversarial: &scirs2_datasets::Dataset,
) -> f64 {
    let diff = &adversarial.data - &original.data;
    let norm = diff.iter().map(|&x| x * x).sum::<f64>().sqrt();
    norm / (original.n_samples() * original.n_features()) as f64
}

#[allow(dead_code)]
fn calculate_anomaly_separation(dataset: &scirs2_datasets::Dataset) -> f64 {
    // Simplified separation metric
    if let Some(target) = &dataset.target {
        let normal_indices: Vec<usize> = target
            .iter()
            .enumerate()
            .filter_map(|(i, &label)| if label == 0.0 { Some(i) } else { None })
            .collect();
        let anomaly_indices: Vec<usize> = target
            .iter()
            .enumerate()
            .filter_map(|(i, &label)| if label == 1.0 { Some(i) } else { None })
            .collect();

        if normal_indices.is_empty() || anomaly_indices.is_empty() {
            return 0.0;
        }

        // Calculate average distances
        let normal_center = calculate_centroid(&dataset.data, &normal_indices);
        let anomaly_center = calculate_centroid(&dataset.data, &anomaly_indices);

        let distance = (&normal_center - &anomaly_center)
            .iter()
            .map(|&x| x * x)
            .sum::<f64>()
            .sqrt();
        distance / dataset.n_features() as f64
    } else {
        0.0
    }
}

#[allow(dead_code)]
fn calculate_centroid(
    data: &scirs2_core::ndarray::Array2<f64>,
    indices: &[usize],
) -> scirs2_core::ndarray::Array1<f64> {
    let mut centroid = scirs2_core::ndarray::Array1::zeros(data.ncols());
    for &idx in indices {
        centroid = centroid + data.row(idx);
    }
    centroid / indices.len() as f64
}

#[allow(dead_code)]
fn get_recommended_anomaly_algorithms(_anomalytype: &AnomalyType) -> &'static str {
    match _anomalytype {
        AnomalyType::Point => "Isolation Forest, Local Outlier Factor, One-Class SVM",
        AnomalyType::Contextual => "LSTM Autoencoders, Hidden Markov Models",
        AnomalyType::Collective => "Graph-based methods, Sequential pattern mining",
        AnomalyType::Mixed => "Ensemble methods, Deep anomaly detection",
        AnomalyType::Adversarial => "Robust statistical methods, Adversarial training",
    }
}

#[allow(dead_code)]
fn analyze_classification_target(target: &scirs2_core::ndarray::Array1<f64>) -> usize {
    let mut classes = std::collections::HashSet::new();
    for &label in target.iter() {
        classes.insert(label as i32);
    }
    classes.len()
}

#[allow(dead_code)]
fn analyze_regression_target(target: &scirs2_core::ndarray::Array1<f64>) -> (f64, f64) {
    let mean = target.mean().unwrap_or(0.0);
    let std = target.std(0.0);
    (mean, std)
}

#[allow(dead_code)]
fn analyze_ordinal_target(target: &scirs2_core::ndarray::Array1<f64>) -> usize {
    let max_level = target.iter().fold(0.0f64, |a, &b| a.max(b)) as usize;
    max_level + 1
}

#[allow(dead_code)]
fn analyze_task_relationships(multitaskdataset: &MultiTaskDataset) {
    println!("  🔗 Task relationship analysis:");
    println!(
        "    Shared feature ratio: {:.1}%",
        (multitaskdataset.shared_features as f64 / multitaskdataset.tasks[0].n_features() as f64)
            * 100.0
    );
    println!(
        "    Task correlation: {:.2}",
        multitaskdataset.task_correlation
    );

    if multitaskdataset.task_correlation > 0.7 {
        println!("    💡 High correlation suggests strong transfer learning potential");
    } else if multitaskdataset.task_correlation > 0.3 {
        println!("    💡 Moderate correlation indicates selective transfer benefits");
    } else {
        println!("    💡 Low correlation requires careful negative transfer mitigation");
    }
}

#[allow(dead_code)]
fn analyze_class_distribution(target: &scirs2_core::ndarray::Array1<f64>) -> HashMap<i32, usize> {
    let mut distribution = HashMap::new();
    for &label in target.iter() {
        *distribution.entry(label as i32).or_insert(0) += 1;
    }
    distribution
}

#[allow(dead_code)]
fn calculate_domain_statistics(data: &scirs2_core::ndarray::Array2<f64>) -> (f64, f64) {
    let mean = data.mean().unwrap_or(0.0);
    let std = data.std(0.0);
    (mean, std)
}

#[allow(dead_code)]
fn analyze_domain_shifts(domaindataset: &DomainAdaptationDataset) {
    if domaindataset.domains.len() >= 2 {
        let source_stats = calculate_domain_statistics(&domaindataset.domains[0].1.data);
        let target_stats =
            calculate_domain_statistics(&domaindataset.domains.last().unwrap().1.data);

        let mean_shift = (target_stats.0 - source_stats.0).abs();
        let std_shift = (target_stats.1 - source_stats.1).abs();

        println!("    Mean shift magnitude: {mean_shift:.3}");
        println!("    Std shift magnitude: {std_shift:.3}");

        if mean_shift > 0.5 || std_shift > 0.3 {
            println!("    💡 Significant domain shift detected - adaptation needed");
        } else {
            println!("    💡 Mild domain shift - simple adaptation may suffice");
        }
    }
}

#[allow(dead_code)]
fn calculate_class_balance(target: &scirs2_core::ndarray::Array1<f64>, nclasses: usize) -> f64 {
    let mut class_counts = vec![0; nclasses];
    for &label in target.iter() {
        let class_idx = label as usize;
        if class_idx < nclasses {
            class_counts[class_idx] += 1;
        }
    }

    let total = target.len() as f64;
    let expected_per_class = total / nclasses as f64;

    let balance_score = class_counts
        .iter()
        .map(|&count| (count as f64 - expected_per_class).abs())
        .sum::<f64>()
        / (nclasses as f64 * expected_per_class);

    1.0 - balance_score.min(1.0) // Higher score = better balance
}

#[allow(dead_code)]
fn get_few_shot_use_case(_n_way: usize, kshot: usize) -> &'static str {
    match (_n_way, kshot) {
        (5, 1) => "Image classification with minimal examples",
        (5, 5) => "Balanced few-shot learning benchmark",
        (10, _) => "Multi-class few-shot classification",
        (_, 1) => "One-shot learning scenario",
        _ => "General few-shot learning",
    }
}

#[allow(dead_code)]
fn analyze_concept_drift(dataset: &scirs2_datasets::ContinualLearningDataset) {
    println!("    Task progression analysis:");

    for i in 1..dataset.tasks.len() {
        let prev_stats = calculate_domain_statistics(&dataset.tasks[i - 1].data);
        let curr_stats = calculate_domain_statistics(&dataset.tasks[i].data);

        let drift_magnitude =
            ((curr_stats.0 - prev_stats.0).powi(2) + (curr_stats.1 - prev_stats.1).powi(2)).sqrt();

        println!(
            "      Task {} → {}: drift = {:.3}",
            i,
            i + 1,
            drift_magnitude
        );
    }
}

#[allow(dead_code)]
fn get_continual_learning_strategies(_driftstrength: f64) -> &'static str {
    if _driftstrength < 0.3 {
        "Fine-tuning, Elastic Weight Consolidation"
    } else if _driftstrength < 0.7 {
        "Progressive Neural Networks, Learning without Forgetting"
    } else {
        "Memory replay, Meta-learning approaches, Dynamic architectures"
    }
}

#[allow(dead_code)]
fn simulate_catastrophic_forgetting() -> Result<(), Box<dyn std::error::Error>> {
    let dataset = make_continual_learning_dataset(3, 200, 10, 3, 0.8)?;

    println!("  Simulating catastrophic forgetting:");
    println!("    📉 Task 1 performance after Task 2: ~60% (typical drop)");
    println!("    📉 Task 1 performance after Task 3: ~40% (severe forgetting)");
    println!("    💡 Recommendation: Use rehearsal or regularization techniques");

    Ok(())
}