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)?;

    match predictions {
        TaskOutput::Classification { probabilities, .. } => {
            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(|(idx, &prob)| (idx, prob))
                    .unwrap_or((0, 0.0));

                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 356)

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)?;

    match detections {
        TaskOutput::Detection {
            boxes,
            scores,
            classes,
        } => {
            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(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 424)

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)?;

    match segmentation {
        TaskOutput::Segmentation {
            masks,
            class_scores,
        } => {
            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 {}: {:.1}% of pixels", class_id, percentage);
            }
        }
        _ => {}
    }

    // 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.