Struct QuantumVisionConfig 

pub struct QuantumVisionConfig {
    pub num_qubits: usize,
    pub encoding_method: ImageEncodingMethod,
    pub backbone: VisionBackbone,
    pub task_config: VisionTaskConfig,
    pub preprocessing: PreprocessingConfig,
    pub quantum_enhancement: QuantumEnhancement,
}

Quantum computer vision pipeline configuration

Fields

num_qubits: usize

Number of qubits for encoding

encoding_method: ImageEncodingMethod

Image encoding method

backbone: VisionBackbone

Vision backbone type

task_config: VisionTaskConfig

Task-specific configuration

preprocessing: PreprocessingConfig

Preprocessing configuration

quantum_enhancement: QuantumEnhancement

Quantum enhancement level

Implementations

impl QuantumVisionConfig

pub fn default() -> Self

Create default configuration

Examples found in repository

examples/computer_vision.rs (line 266)

fn classification_demo() -> Result<()> {
    println!("   Quantum image classification demo...");

    // Create classification pipeline
    let config = QuantumVisionConfig::default();
    let mut pipeline = QuantumVisionPipeline::new(config)?;

    // Create synthetic dataset
    let num_classes = 10;
    let num_samples = 20;
    let (train_data, val_data) = create_classification_dataset(num_samples, num_classes)?;

    println!(
        "   Dataset: {} training, {} validation samples",
        train_data.len(),
        val_data.len()
    );

    // Train the model (simplified)
    println!("\n   Training quantum classifier...");
    let history = pipeline.train(
        &train_data,
        &val_data,
        5, // epochs
        OptimizationMethod::Adam,
    )?;

    // Display training results
    println!("\n   Training results:");
    for (epoch, train_loss, val_loss) in history
        .epochs
        .iter()
        .zip(history.train_losses.iter())
        .zip(history.val_losses.iter())
        .map(|((e, t), v)| (e, t, v))
    {
        println!(
            "   Epoch {}: train_loss={:.4}, val_loss={:.4}",
            epoch + 1,
            train_loss,
            val_loss
        );
    }

    // Test on new images
    println!("\n   Testing on new images...");
    let test_images = create_test_image(5, 3, 224, 224)?;
    let predictions = pipeline.forward(&test_images)?;

    if let TaskOutput::Classification { probabilities, .. } = predictions {
        for (i, prob_row) in probabilities.outer_iter().enumerate() {
            let (predicted_class, confidence) = prob_row
                .iter()
                .enumerate()
                .max_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap())
                .map_or((0, 0.0), |(idx, &prob)| (idx, prob));

            println!(
                "   Image {}: Class {} (confidence: {:.2}%)",
                i + 1,
                predicted_class,
                confidence * 100.0
            );
        }
    }

    // Analyze quantum advantage
    let quantum_advantage = analyze_classification_quantum_advantage(&pipeline)?;
    println!("\n   Quantum advantage analysis:");
    println!(
        "   - Parameter efficiency: {:.2}x classical",
        quantum_advantage.param_efficiency
    );
    println!(
        "   - Feature expressiveness: {:.2}x",
        quantum_advantage.expressiveness
    );
    println!(
        "   - Training speedup: {:.2}x",
        quantum_advantage.training_speedup
    );

    Ok(())
}

pub fn object_detection(num_classes: usize) -> Self

Create configuration for object detection

Examples found in repository

examples/computer_vision.rs (line 352)

fn object_detection_demo() -> Result<()> {
    println!("   Quantum object detection demo...");

    // Create detection pipeline
    let config = QuantumVisionConfig::object_detection(80); // 80 classes (COCO-like)
    let mut pipeline = QuantumVisionPipeline::new(config)?;

    // Test image
    let test_images = create_test_image(2, 3, 416, 416)?;

    println!(
        "   Processing {} images for object detection...",
        test_images.dim().0
    );

    // Run detection
    let detections = pipeline.forward(&test_images)?;

    if let TaskOutput::Detection {
        boxes,
        scores,
        classes,
    } = detections
    {
        println!("   Detection results:");

        for batch_idx in 0..boxes.dim().0 {
            println!("\n   Image {}:", batch_idx + 1);

            // Filter detections by score threshold
            let threshold = 0.5;
            let mut num_detections = 0;

            for det_idx in 0..boxes.dim().1 {
                let score = scores[[batch_idx, det_idx]];

                if score > threshold {
                    let class_id = classes[[batch_idx, det_idx]];
                    let bbox = boxes.slice(scirs2_core::ndarray::s![batch_idx, det_idx, ..]);

                    println!(
                        "   - Object {}: Class {}, Score {:.3}, Box [{:.1}, {:.1}, {:.1}, {:.1}]",
                        num_detections + 1,
                        class_id,
                        score,
                        bbox[0],
                        bbox[1],
                        bbox[2],
                        bbox[3]
                    );

                    num_detections += 1;
                }
            }

            if num_detections == 0 {
                println!("   - No objects detected above threshold");
            } else {
                println!("   Total objects detected: {num_detections}");
            }
        }
    }

    // Analyze detection performance
    println!("\n   Detection performance analysis:");
    println!("   - Quantum anchor generation improves localization");
    println!("   - Entangled features enhance multi-scale detection");
    println!("   - Quantum NMS reduces redundant detections");

    Ok(())
}

pub fn segmentation(num_classes: usize) -> Self

Create configuration for segmentation

Examples found in repository

examples/computer_vision.rs (line 425)

fn segmentation_demo() -> Result<()> {
    println!("   Quantum semantic segmentation demo...");

    // Create segmentation pipeline
    let config = QuantumVisionConfig::segmentation(21); // 21 classes (Pascal VOC-like)
    let mut pipeline = QuantumVisionPipeline::new(config)?;

    // Test images
    let test_images = create_test_image(1, 3, 512, 512)?;

    println!("   Processing image for semantic segmentation...");

    // Run segmentation
    let segmentation = pipeline.forward(&test_images)?;

    if let TaskOutput::Segmentation {
        masks,
        class_scores,
    } = segmentation
    {
        println!("   Segmentation results:");
        println!("   - Mask shape: {:?}", masks.dim());
        println!("   - Class scores shape: {:?}", class_scores.dim());

        // Analyze segmentation quality
        let seg_metrics = analyze_segmentation_quality(&masks, &class_scores)?;
        println!("\n   Segmentation metrics:");
        println!("   - Mean IoU: {:.3}", seg_metrics.mean_iou);
        println!(
            "   - Pixel accuracy: {:.1}%",
            seg_metrics.pixel_accuracy * 100.0
        );
        println!(
            "   - Boundary precision: {:.3}",
            seg_metrics.boundary_precision
        );

        // Class distribution
        println!("\n   Predicted class distribution:");
        let class_counts = compute_class_distribution(&masks)?;
        for (class_id, count) in class_counts.iter().take(5) {
            let percentage = *count as f64 / (512.0 * 512.0) * 100.0;
            println!("   - Class {class_id}: {percentage:.1}% of pixels");
        }
    }

    // Quantum advantages for segmentation
    println!("\n   Quantum segmentation advantages:");
    println!("   - Quantum attention captures long-range dependencies");
    println!("   - Hierarchical encoding preserves multi-scale features");
    println!("   - Entanglement enables pixel-to-pixel correlations");

    Ok(())
}

Trait Implementations

impl Clone for QuantumVisionConfig

fn clone(&self) -> QuantumVisionConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QuantumVisionConfig

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

Formats the value using the given formatter.