Function make_blobs_auto_gpu 

pub fn make_blobs_auto_gpu(
    n_samples: usize,
    n_features: usize,
    n_centers: usize,
    cluster_std: f64,
    random_state: Option<u64>,
) -> Result<Dataset>

Generate blobs dataset with automatic GPU detection

Examples found in repository

examples/gpu_acceleration.rs (line 394)

fn demonstrate_large_scale_generation() -> Result<(), Box<dyn std::error::Error>> {
    println!("  🎯 Goal: Generate 1M samples across multiple datasets");
    println!("  📊 Using GPU acceleration for maximum throughput");

    let total_samples = 1_000_000;
    let features = 100;

    // Track generation times
    let mut generation_times = Vec::new();
    let start_total = Instant::now();

    // Classification dataset
    let start = Instant::now();
    let classification =
        make_classification_auto_gpu(total_samples, features, 10, 2, 50, Some(42))?;
    let class_time = start.elapsed();
    generation_times.push(("Classification", class_time, classification.n_samples()));

    // Regression dataset
    let start = Instant::now();
    let regression = make_regression_auto_gpu(total_samples, features, 60, 0.1, Some(43))?;
    let reg_time = start.elapsed();
    generation_times.push(("Regression", reg_time, regression.n_samples()));

    // Clustering dataset
    let start = Instant::now();
    let clustering = make_blobs_auto_gpu(total_samples, 50, 20, 1.5, Some(44))?;
    let cluster_time = start.elapsed();
    generation_times.push(("Clustering", cluster_time, clustering.n_samples()));

    let total_time = start_total.elapsed();

    println!("  ✅ Generation Results:");
    for (name, time, samples) in generation_times {
        let throughput = samples as f64 / time.as_secs_f64();
        println!(
            "    {}: {:.1}s ({:.1}K samples/s)",
            name,
            time.as_secs_f64(),
            throughput / 1000.0
        );
    }

    let total_samples_generated =
        classification.n_samples() + regression.n_samples() + clustering.n_samples();
    let overall_throughput = total_samples_generated as f64 / total_time.as_secs_f64();

    println!(
        "  📈 Overall: {} samples in {:.1}s ({:.1}K samples/s)",
        total_samples_generated,
        total_time.as_secs_f64(),
        overall_throughput / 1000.0
    );

    Ok(())
}

#[allow(dead_code)]
fn demonstrate_rapid_prototyping() -> Result<(), Box<dyn std::error::Error>> {
    println!("  🎯 Goal: Quickly test different dataset configurations");
    println!("  ⚡ Using GPU for instant feedback");

    let configurations = vec![
        ("Small Dense", 1_000, 20, 5),
        ("Medium Sparse", 10_000, 100, 20),
        ("Large High-Dim", 100_000, 500, 100),
    ];

    for (name, samples, features, informative) in configurations {
        let start = Instant::now();

        let dataset = make_classification_auto_gpu(samples, features, 5, 2, informative, Some(42))?;
        let duration = start.elapsed();

        // Quick analysis
        let memory_usage = dataset.n_samples() * dataset.n_features() * 8; // bytes
        let density = informative as f64 / features as f64;

        println!(
            "    {}: {} in {:.1}ms",
            name,
            format_number(dataset.n_samples()),
            duration.as_millis()
        );
        println!(
            "      Features: {} (density: {:.1}%)",
            features,
            density * 100.0
        );
        println!(
            "      Memory: {:.1} MB",
            memory_usage as f64 / (1024.0 * 1024.0)
        );
    }

    Ok(())
}

#[allow(dead_code)]
fn demonstrate_batch_processing() -> Result<(), Box<dyn std::error::Error>> {
    println!("  🎯 Goal: Process multiple dataset requests in parallel");
    println!("  🔄 Simulating production workload");

    // Simulate batch requests
    let requests = vec![
        ("User A - Classification", 5_000, 30, "classification"),
        ("User B - Regression", 8_000, 25, "regression"),
        ("User C - Clustering", 3_000, 15, "clustering"),
        ("User D - Classification", 12_000, 40, "classification"),
        ("User E - Regression", 6_000, 35, "regression"),
    ];

    let batch_start = Instant::now();
    let mut total_samples = 0;

    for (requestname, samples, features, dataset_type) in requests {
        let start = Instant::now();

        let dataset = match dataset_type {
            "classification" => {
                make_classification_auto_gpu(samples, features, 5, 2, features / 2, Some(42))?
            }
            "regression" => {
                make_regression_auto_gpu(samples, features, features / 2, 0.1, Some(42))?
            }
            "clustering" => make_blobs_auto_gpu(samples, features, 8, 1.0, Some(42))?,
            _ => unreachable!(),
        };

        let duration = start.elapsed();
        total_samples += dataset.n_samples();

        println!(
            "    {}: {} samples in {:.1}ms",
            requestname,
            dataset.n_samples(),
            duration.as_millis()
        );
    }

    let batch_duration = batch_start.elapsed();
    let batch_throughput = total_samples as f64 / batch_duration.as_secs_f64();

    println!("  📊 Batch Summary:");
    println!("    Total Requests: 5");
    println!("    Total Samples: {}", format_number(total_samples));
    println!("    Batch Time: {:.2}s", batch_duration.as_secs_f64());
    println!(
        "    Throughput: {:.1}K samples/s",
        batch_throughput / 1000.0
    );

    Ok(())
}