Struct ProblemCharacteristics 

pub struct ProblemCharacteristics {
    pub n_samples: usize,
    pub n_features: usize,
    pub n_classes: usize,
    pub dimensionality_ratio: f64,
    pub sparsity: f64,
    pub condition_number: f64,
    pub class_imbalance: f64,
    pub task_type: TaskType,
    pub domain: ProblemDomain,
}

Problem characteristics extracted from dataset and task definition

Fields

n_samples: usize

Number of samples in the dataset

n_features: usize

Number of features per sample

n_classes: usize

Number of classes (for classification) or 1 (for regression)

dimensionality_ratio: f64

Dimensionality ratio (features/samples)

sparsity: f64

Data sparsity (fraction of zero elements)

condition_number: f64

Feature correlation matrix condition number

class_imbalance: f64

Class imbalance ratio (max_class_count / min_class_count)

task_type: TaskType

Task type

domain: ProblemDomain

Problem domain

Implementations

impl ProblemCharacteristics

pub fn from_dataset(x: &Array2<f64>, y: &Array1<usize>) -> Self

Extract problem characteristics from dataset

Examples found in repository

examples/hybrid_automl_demo.rs (line 35)

fn main() {
    println!("\n╔══════════════════════════════════════════════════════════╗");
    println!("║  Quantum-Classical Hybrid AutoML Decision Engine        ║");
    println!("║  Intelligent Algorithm Selection & Configuration        ║");
    println!("╚══════════════════════════════════════════════════════════╝\n");

    // Create the AutoML engine
    let engine = HybridAutoMLEngine::new();

    // ========================================================================
    // Scenario 1: Small Dataset - Drug Discovery
    // ========================================================================

    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("Scenario 1: Small High-Dimensional Dataset (Drug Discovery)");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    let small_dataset = generate_synthetic_dataset(200, 50, 2);
    let mut chars1 = ProblemCharacteristics::from_dataset(&small_dataset.0, &small_dataset.1);
    chars1.domain = ProblemDomain::DrugDiscovery;

    println!("Problem Characteristics:");
    println!("  Samples: {}", chars1.n_samples);
    println!("  Features: {}", chars1.n_features);
    println!("  Classes: {}", chars1.n_classes);
    println!("  Dimensionality ratio: {:.3}", chars1.dimensionality_ratio);
    println!("  Sparsity: {:.2}%", chars1.sparsity * 100.0);
    println!("  Class imbalance: {:.2}", chars1.class_imbalance);
    println!("  Domain: {:?}\n", chars1.domain);

    let constraints1 = create_quantum_available_constraints();

    match engine.analyze_and_recommend(&chars1, &constraints1) {
        Ok(recommendation) => {
            print_recommendation(&recommendation, "Scenario 1");
        }
        Err(e) => println!("Error: {e}"),
    }

    // ========================================================================
    // Scenario 2: Large Dataset - Finance
    // ========================================================================

    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("Scenario 2: Large Low-Dimensional Dataset (Finance)");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    let large_dataset = generate_synthetic_dataset(10000, 15, 2);
    let mut chars2 = ProblemCharacteristics::from_dataset(&large_dataset.0, &large_dataset.1);
    chars2.domain = ProblemDomain::Finance;

    println!("Problem Characteristics:");
    println!("  Samples: {}", chars2.n_samples);
    println!("  Features: {}", chars2.n_features);
    println!("  Classes: {}", chars2.n_classes);
    println!("  Dimensionality ratio: {:.3}", chars2.dimensionality_ratio);
    println!("  Sparsity: {:.2}%", chars2.sparsity * 100.0);
    println!("  Class imbalance: {:.2}", chars2.class_imbalance);
    println!("  Domain: {:?}\n", chars2.domain);

    let constraints2 = create_quantum_available_constraints();

    match engine.analyze_and_recommend(&chars2, &constraints2) {
        Ok(recommendation) => {
            print_recommendation(&recommendation, "Scenario 2");
        }
        Err(e) => println!("Error: {e}"),
    }

    // ========================================================================
    // Scenario 3: Multi-class Classification - Computer Vision
    // ========================================================================

    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("Scenario 3: Multi-class Classification (Computer Vision)");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    let multiclass_dataset = generate_synthetic_dataset(5000, 784, 10);
    let mut chars3 =
        ProblemCharacteristics::from_dataset(&multiclass_dataset.0, &multiclass_dataset.1);
    chars3.domain = ProblemDomain::ComputerVision;

    println!("Problem Characteristics:");
    println!("  Samples: {}", chars3.n_samples);
    println!("  Features: {} (28×28 images)", chars3.n_features);
    println!("  Classes: {}", chars3.n_classes);
    println!("  Dimensionality ratio: {:.3}", chars3.dimensionality_ratio);
    println!("  Sparsity: {:.2}%", chars3.sparsity * 100.0);
    println!("  Class imbalance: {:.2}", chars3.class_imbalance);
    println!("  Domain: {:?}\n", chars3.domain);

    let constraints3 = create_classical_only_constraints();

    match engine.analyze_and_recommend(&chars3, &constraints3) {
        Ok(recommendation) => {
            print_recommendation(&recommendation, "Scenario 3");
        }
        Err(e) => println!("Error: {e}"),
    }

    // ========================================================================
    // Scenario 4: Constrained Resources - Edge Computing
    // ========================================================================

    println!("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("Scenario 4: Resource-Constrained Environment (Edge Device)");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    let edge_dataset = generate_synthetic_dataset(1000, 30, 2);
    let mut chars4 = ProblemCharacteristics::from_dataset(&edge_dataset.0, &edge_dataset.1);
    chars4.domain = ProblemDomain::General;

    println!("Problem Characteristics:");
    println!("  Samples: {}", chars4.n_samples);
    println!("  Features: {}", chars4.n_features);
    println!("  Classes: {}", chars4.n_classes);
    println!("  Dimensionality ratio: {:.3}", chars4.dimensionality_ratio);
    println!("  Domain: {:?}\n", chars4.domain);

    let constraints4 = create_edge_device_constraints();

    println!("Resource Constraints:");
    println!("  Max latency: 10ms");
    println!("  Max cost per inference: $0.0001");
    println!("  Max training time: 60s");
    println!("  Power limit: 10W\n");

    match engine.analyze_and_recommend(&chars4, &constraints4) {
        Ok(recommendation) => {
            print_recommendation(&recommendation, "Scenario 4");
        }
        Err(e) => println!("Error: {e}"),
    }

    // ========================================================================
    // Comparison Summary
    // ========================================================================

    println!("\n\n╔══════════════════════════════════════════════════════════╗");
    println!("║  Decision Summary Across Scenarios                      ║");
    println!("╚══════════════════════════════════════════════════════════╝\n");

    println!("┌─────────────┬────────────────────┬──────────────────────────┐");
    println!("│ Scenario    │ Recommended        │ Reasoning                │");
    println!("├─────────────┼────────────────────┼──────────────────────────┤");
    println!("│ 1. Drug     │ Quantum (QSVM)     │ High-dim, small sample  │");
    println!("│ Discovery   │                    │ Quantum kernel advantage │");
    println!("├─────────────┼────────────────────┼──────────────────────────┤");
    println!("│ 2. Finance  │ Classical (XGBoost)│ Large sample, low-dim    │");
    println!("│             │                    │ Classical more efficient │");
    println!("├─────────────┼────────────────────┼──────────────────────────┤");
    println!("│ 3. Vision   │ Classical (CNN)    │ Many samples, no quantum │");
    println!("│             │                    │ devices available        │");
    println!("├─────────────┼────────────────────┼──────────────────────────┤");
    println!("│ 4. Edge     │ Classical (RF)     │ Latency & power          │");
    println!("│ Device      │                    │ constraints critical     │");
    println!("└─────────────┴────────────────────┴──────────────────────────┘");

    println!("\n\n╔══════════════════════════════════════════════════════════╗");
    println!("║  Key Insights                                            ║");
    println!("╚══════════════════════════════════════════════════════════╝\n");

    println!("1. 🔬 Quantum Advantages:");
    println!("   • High-dimensional feature spaces (features >> samples)");
    println!("   • Complex kernel functions (non-linear separability)");
    println!("   • Small to medium datasets (< 10,000 samples)");
    println!("   • Domain-specific problems (chemistry, materials)");

    println!("\n2. ⚡ Classical Advantages:");
    println!("   • Large datasets (> 10,000 samples)");
    println!("   • Low-dimensional feature spaces");
    println!("   • Strict latency requirements (< 10ms)");
    println!("   • Cost-sensitive applications");

    println!("\n3. 🤝 Hybrid Approaches:");
    println!("   • Quantum feature engineering + classical training");
    println!("   • Ensemble methods combining both paradigms");
    println!("   • Quantum-enhanced hyperparameter optimization");

    println!("\n4. 💡 Production Considerations:");
    println!("   • Always include probability calibration");
    println!("   • Monitor performance drift over time");
    println!("   • Have classical fallback for quantum unavailability");
    println!("   • Optimize batch sizes for throughput");
    println!("   • Enable caching for repeated inference patterns");

    println!("\n✨ Hybrid AutoML demonstration complete! ✨\n");
}

Trait Implementations

impl Clone for ProblemCharacteristics

fn clone(&self) -> ProblemCharacteristics

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ProblemCharacteristics

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.