Struct PreprocessingConfig 

pub struct PreprocessingConfig {
    pub image_size: (usize, usize),
    pub normalize: bool,
    pub mean: Vec<f64>,
    pub std: Vec<f64>,
    pub augmentation: AugmentationConfig,
    pub color_space: ColorSpace,
}

Preprocessing configuration

Fields

image_size: (usize, usize)

Target image size

normalize: bool

Normalization parameters

mean: Vec<f64>

std: Vec<f64>

augmentation: AugmentationConfig

Data augmentation

color_space: ColorSpace

Color space

Implementations

impl PreprocessingConfig

pub fn default() -> Self

Default preprocessing

Examples found in repository

examples/computer_vision.rs (line 176)

fn vision_backbone_demo() -> Result<()> {
    println!("   Testing quantum vision backbone architectures...");

    // Different backbone configurations
    let backbones = vec![
        (
            "Quantum CNN",
            QuantumVisionConfig {
                num_qubits: 12,
                encoding_method: ImageEncodingMethod::AmplitudeEncoding,
                backbone: VisionBackbone::QuantumCNN {
                    conv_layers: vec![
                        ConvolutionalConfig {
                            num_filters: 32,
                            kernel_size: 3,
                            stride: 1,
                            padding: 1,
                            quantum_kernel: true,
                            circuit_depth: 4,
                        },
                        ConvolutionalConfig {
                            num_filters: 64,
                            kernel_size: 3,
                            stride: 2,
                            padding: 1,
                            quantum_kernel: true,
                            circuit_depth: 6,
                        },
                    ],
                    pooling_type: PoolingType::Quantum,
                },
                task_config: VisionTaskConfig::Classification {
                    num_classes: 10,
                    multi_label: false,
                },
                preprocessing: PreprocessingConfig::default(),
                quantum_enhancement: QuantumEnhancement::Medium,
            },
        ),
        (
            "Quantum ViT",
            QuantumVisionConfig {
                num_qubits: 16,
                encoding_method: ImageEncodingMethod::QPIE,
                backbone: VisionBackbone::QuantumViT {
                    patch_size: 16,
                    embed_dim: 768,
                    num_heads: 12,
                    depth: 12,
                },
                task_config: VisionTaskConfig::Classification {
                    num_classes: 10,
                    multi_label: false,
                },
                preprocessing: PreprocessingConfig::default(),
                quantum_enhancement: QuantumEnhancement::High,
            },
        ),
        (
            "Hybrid CNN-Transformer",
            QuantumVisionConfig {
                num_qubits: 14,
                encoding_method: ImageEncodingMethod::HierarchicalEncoding { levels: 3 },
                backbone: VisionBackbone::HybridBackbone {
                    cnn_layers: 4,
                    transformer_layers: 2,
                },
                task_config: VisionTaskConfig::Classification {
                    num_classes: 10,
                    multi_label: false,
                },
                preprocessing: PreprocessingConfig::default(),
                quantum_enhancement: QuantumEnhancement::High,
            },
        ),
    ];

    for (name, config) in backbones {
        println!("\n   --- {name} Backbone ---");

        let mut pipeline = QuantumVisionPipeline::new(config)?;

        // Test forward pass
        let test_images = create_test_image(2, 3, 224, 224)?;
        let output = pipeline.forward(&test_images)?;

        if let TaskOutput::Classification {
            logits,
            probabilities,
        } = &output
        {
            println!("   Output shape: {:?}", logits.dim());
            println!("   Probability shape: {:?}", probabilities.dim());
        }

        // Get metrics
        let metrics = pipeline.metrics();
        println!("   Quantum metrics:");
        println!(
            "   - Circuit depth: {}",
            metrics.quantum_metrics.circuit_depth
        );
        println!(
            "   - Quantum advantage: {:.2}x",
            metrics.quantum_metrics.quantum_advantage
        );
        println!(
            "   - Coherence utilization: {:.1}%",
            metrics.quantum_metrics.coherence_utilization * 100.0
        );

        // Architecture-specific properties
        match name {
            "Quantum CNN" => {
                println!("   ✓ Hierarchical feature extraction with quantum convolutions");
            }
            "Quantum ViT" => {
                println!("   ✓ Global context modeling with quantum attention");
            }
            "Hybrid CNN-Transformer" => {
                println!("   ✓ Local features + global context integration");
            }
            _ => {}
        }
    }

    Ok(())
}

/// Demonstrate image classification
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(())
}

/// Demonstrate object detection
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(())
}

/// Demonstrate semantic segmentation
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(())
}

/// Demonstrate feature extraction
fn feature_extraction_demo() -> Result<()> {
    println!("   Quantum feature extraction demo...");

    // Create feature extraction pipeline
    let config = QuantumVisionConfig {
        num_qubits: 14,
        encoding_method: ImageEncodingMethod::QPIE,
        backbone: VisionBackbone::QuantumResNet {
            blocks: vec![
                ResidualBlock {
                    channels: 64,
                    kernel_size: 3,
                    stride: 1,
                    quantum_conv: true,
                },
                ResidualBlock {
                    channels: 128,
                    kernel_size: 3,
                    stride: 2,
                    quantum_conv: true,
                },
            ],
            skip_connections: true,
        },
        task_config: VisionTaskConfig::FeatureExtraction {
            feature_dim: 512,
            normalize: true,
        },
        preprocessing: PreprocessingConfig::default(),
        quantum_enhancement: QuantumEnhancement::High,
    };

    let mut pipeline = QuantumVisionPipeline::new(config)?;

    // Extract features from multiple images
    let num_images = 10;
    let test_images = create_test_image(num_images, 3, 224, 224)?;

    println!("   Extracting features from {num_images} images...");

    let features_output = pipeline.forward(&test_images)?;

    if let TaskOutput::Features {
        features,
        attention_maps,
    } = features_output
    {
        println!("   Feature extraction results:");
        println!("   - Feature dimension: {}", features.dim().1);
        println!("   - Features normalized: Yes");

        // Compute feature statistics
        let feature_stats = compute_feature_statistics(&features)?;
        println!("\n   Feature statistics:");
        println!("   - Mean magnitude: {:.4}", feature_stats.mean_magnitude);
        println!("   - Variance: {:.4}", feature_stats.variance);
        println!("   - Sparsity: {:.1}%", feature_stats.sparsity * 100.0);

        // Compute pairwise similarities
        println!("\n   Feature similarity matrix (first 5 images):");
        let similarities = compute_cosine_similarities(&features)?;

        print!("       ");
        for i in 0..5.min(num_images) {
            print!("Img{}  ", i + 1);
        }
        println!();

        for i in 0..5.min(num_images) {
            print!("   Img{} ", i + 1);
            for j in 0..5.min(num_images) {
                print!("{:.3} ", similarities[[i, j]]);
            }
            println!();
        }

        // Quantum feature properties
        println!("\n   Quantum feature properties:");
        println!("   - Entanglement enhances discriminative power");
        println!("   - Quantum superposition encodes multiple views");
        println!("   - Phase information captures subtle variations");
    }

    Ok(())
}

/// Demonstrate multi-task learning
fn multitask_demo() -> Result<()> {
    println!("   Multi-task quantum vision demo...");

    // Create a pipeline that can handle multiple tasks
    let tasks = vec![
        (
            "Classification",
            VisionTaskConfig::Classification {
                num_classes: 10,
                multi_label: false,
            },
        ),
        (
            "Detection",
            VisionTaskConfig::ObjectDetection {
                num_classes: 20,
                anchor_sizes: vec![(32, 32), (64, 64)],
                iou_threshold: 0.5,
            },
        ),
        (
            "Segmentation",
            VisionTaskConfig::Segmentation {
                num_classes: 10,
                output_stride: 8,
            },
        ),
    ];

    println!(
        "   Testing {} vision tasks with shared backbone...",
        tasks.len()
    );

    // Use same backbone for all tasks
    let base_config = QuantumVisionConfig {
        num_qubits: 16,
        encoding_method: ImageEncodingMethod::HierarchicalEncoding { levels: 3 },
        backbone: VisionBackbone::HybridBackbone {
            cnn_layers: 4,
            transformer_layers: 2,
        },
        task_config: tasks[0].1.clone(), // Will be replaced for each task
        preprocessing: PreprocessingConfig::default(),
        quantum_enhancement: QuantumEnhancement::High,
    };

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

    for (task_name, task_config) in tasks {
        println!("\n   --- {task_name} Task ---");

        let mut config = base_config.clone();
        config.task_config = task_config;

        let mut pipeline = QuantumVisionPipeline::new(config)?;
        let output = pipeline.forward(&test_images)?;

        match output {
            TaskOutput::Classification { logits, .. } => {
                println!("   Classification output shape: {:?}", logits.dim());
            }
            TaskOutput::Detection { boxes, scores, .. } => {
                println!(
                    "   Detection: {} anchors, score shape: {:?}",
                    boxes.dim().1,
                    scores.dim()
                );
            }
            TaskOutput::Segmentation { masks, .. } => {
                println!("   Segmentation mask shape: {:?}", masks.dim());
            }
            _ => {}
        }

        // Task-specific quantum advantages
        match task_name {
            "Classification" => {
                println!("   ✓ Quantum features improve class discrimination");
            }
            "Detection" => {
                println!("   ✓ Quantum anchors adapt to object scales");
            }
            "Segmentation" => {
                println!("   ✓ Quantum correlations enhance boundary detection");
            }
            _ => {}
        }
    }

    println!("\n   Multi-task benefits:");
    println!("   - Shared quantum backbone reduces parameters");
    println!("   - Task-specific quantum heads optimize performance");
    println!("   - Quantum entanglement enables cross-task learning");

    Ok(())
}

/// Demonstrate performance analysis
fn performance_analysis_demo() -> Result<()> {
    println!("   Analyzing quantum vision performance...");

    // Compare different quantum enhancement levels
    let enhancement_levels = vec![
        ("Low", QuantumEnhancement::Low),
        ("Medium", QuantumEnhancement::Medium),
        ("High", QuantumEnhancement::High),
        (
            "Custom",
            QuantumEnhancement::Custom {
                quantum_layers: vec![0, 2, 4, 6],
                entanglement_strength: 0.8,
            },
        ),
    ];

    println!("\n   Quantum Enhancement Level Comparison:");
    println!("   Level    | FLOPs   | Memory  | Accuracy | Q-Advantage");
    println!("   ---------|---------|---------|----------|------------");

    for (level_name, enhancement) in enhancement_levels {
        let config = QuantumVisionConfig {
            num_qubits: 12,
            encoding_method: ImageEncodingMethod::AmplitudeEncoding,
            backbone: VisionBackbone::QuantumCNN {
                conv_layers: vec![ConvolutionalConfig {
                    num_filters: 32,
                    kernel_size: 3,
                    stride: 1,
                    padding: 1,
                    quantum_kernel: true,
                    circuit_depth: 4,
                }],
                pooling_type: PoolingType::Quantum,
            },
            task_config: VisionTaskConfig::Classification {
                num_classes: 10,
                multi_label: false,
            },
            preprocessing: PreprocessingConfig::default(),
            quantum_enhancement: enhancement,
        };

        let pipeline = QuantumVisionPipeline::new(config)?;
        let metrics = pipeline.metrics();

        // Simulate performance metrics
        let (flops, memory, accuracy, q_advantage) = match level_name {
            "Low" => (1.2, 50.0, 0.85, 1.2),
            "Medium" => (2.5, 80.0, 0.88, 1.5),
            "High" => (4.1, 120.0, 0.91, 2.1),
            "Custom" => (3.2, 95.0, 0.90, 1.8),
            _ => (0.0, 0.0, 0.0, 0.0),
        };

        println!(
            "   {:<8} | {:.1}G | {:.0}MB | {:.1}%  | {:.1}x",
            level_name,
            flops,
            memory,
            accuracy * 100.0,
            q_advantage
        );
    }

    // Scalability analysis
    println!("\n   Scalability Analysis:");
    let image_sizes = vec![64, 128, 224, 416, 512];

    println!("   Image Size | Inference Time | Throughput");
    println!("   -----------|----------------|------------");

    for size in image_sizes {
        let inference_time = (f64::from(size) / 100.0).mul_add(f64::from(size) / 100.0, 5.0);
        let throughput = 1000.0 / inference_time;

        println!("   {size}x{size}   | {inference_time:.1}ms        | {throughput:.0} img/s");
    }

    // Quantum advantages summary
    println!("\n   Quantum Computer Vision Advantages:");
    println!("   1. Exponential feature space with limited qubits");
    println!("   2. Natural multi-scale representation via entanglement");
    println!("   3. Quantum attention for global context modeling");
    println!("   4. Phase encoding for rotation-invariant features");
    println!("   5. Quantum pooling preserves superposition information");

    // Hardware requirements
    println!("\n   Hardware Requirements:");
    println!("   - Minimum qubits: 10 (basic tasks)");
    println!("   - Recommended: 16-20 qubits (complex tasks)");
    println!("   - Coherence time: >100μs for deep networks");
    println!("   - Gate fidelity: >99.9% for accurate predictions");

    Ok(())
}

pub fn detection_default() -> Self

Detection preprocessing

pub fn segmentation_default() -> Self

Segmentation preprocessing

Trait Implementations

impl Clone for PreprocessingConfig

fn clone(&self) -> PreprocessingConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PreprocessingConfig

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

Formats the value using the given formatter.