Examples Gallery

This section provides comprehensive examples demonstrating various use cases and applications of the Quantum Data Embedding Suite.

Getting Started Examples

Classification with Quantum Kernels

Learn how to use quantum embeddings for classification tasks with real datasets including Iris, Wine, and Breast Cancer datasets. Covers data preprocessing, kernel computation, and performance evaluation.

Dimensionality Reduction

Use quantum embeddings as a preprocessing step for dimensionality reduction. Compare with classical methods like PCA and t-SNE.

Advanced Applications

Custom Embedding Development

Create your own quantum embedding types by extending the base classes. Includes examples of problem-specific embeddings and hybrid quantum-classical approaches.

Multi-Backend Comparison

Compare performance across different quantum backends (Qiskit, PennyLane) and devices. Includes noise analysis and error mitigation strategies.

Large-Scale Data Processing

Handle large datasets efficiently using batch processing, distributed computing, and optimization techniques.

Specialized Use Cases

Time Series Analysis

Apply quantum embeddings to time series data for forecasting and anomaly detection. Includes financial data and sensor data examples.

Image Classification

Use quantum embeddings for computer vision tasks. Examples with MNIST, CIFAR-10, and custom image datasets.

Natural Language Processing

Quantum embeddings for text classification and sentiment analysis. Includes preprocessing techniques and comparison with classical NLP methods.

Performance and Optimization

Benchmarking and Profiling

Comprehensive benchmarking suite for comparing quantum and classical methods. Includes timing analysis, memory profiling, and scalability studies.

Hyperparameter Optimization

Systematic approaches to finding optimal parameters for quantum embeddings. Includes grid search, random search, and Bayesian optimization.

Noise Analysis and Mitigation

Understanding and mitigating the effects of quantum noise on embedding quality. Includes error correction techniques and noise models.

Integration Examples

Scikit-learn Integration

Deep integration with scikit-learn ecosystem including pipelines, cross-validation, and model selection.

PyTorch Integration

Use quantum embeddings within PyTorch workflows for deep learning applications. Includes gradient computation and backpropagation.

MLOps and Production Deployment

Best practices for deploying quantum machine learning models in production environments. Includes containerization, monitoring, and scaling.

Quick Reference

Common Patterns

# Basic classification pipeline
from quantum_data_embedding_suite import QuantumEmbeddingPipeline
from sklearn.svm import SVC

pipeline = QuantumEmbeddingPipeline(embedding_type="angle", n_qubits=4)
K_train = pipeline.fit_transform(X_train)
K_test = pipeline.transform(X_test)

svm = SVC(kernel='precomputed')
svm.fit(K_train, y_train)
predictions = svm.predict(K_test)

# Embedding quality assessment
metrics = pipeline.evaluate_embedding(X)
print(f"Expressibility: {metrics['expressibility']:.3f}")
print(f"Trainability: {metrics['trainability']:.3f}")

# Multi-embedding comparison
embeddings = ["angle", "amplitude", "iqp"]
for emb_type in embeddings:
    pipeline = QuantumEmbeddingPipeline(embedding_type=emb_type, n_qubits=4)
    accuracy = evaluate_classification(pipeline, X, y)
    print(f"{emb_type}: {accuracy:.3f}")

Performance Tips

Start Small: Begin with 3-4 qubits and simple embeddings
Normalize Data: Always preprocess data with StandardScaler
Choose Appropriate Shots: 1024-2048 shots balance accuracy and speed
Cache Results: Enable caching for repeated computations
Batch Processing: Use batches for large datasets (>1000 samples)

Common Pitfalls

Insufficient Qubits: Too few qubits limit expressibility
Poor Normalization: Unnormalized data leads to poor embeddings
Overfitting: High-dimensional quantum spaces can overfit easily
Noise Sensitivity: Real quantum devices introduce additional noise
Computational Cost: Quantum simulations scale exponentially

Dataset Examples

Small Datasets (< 1000 samples)

Iris (150 samples, 4 features, 3 classes)
Wine (178 samples, 13 features, 3 classes)
Breast Cancer Wisconsin (569 samples, 30 features, 2 classes)

Medium Datasets (1000-10000 samples)

MNIST subset (5000 samples, 784 features, 10 classes)
Digits (1797 samples, 64 features, 10 classes)
Olivetti Faces (400 samples, 4096 features, 40 classes)

Large Datasets (> 10000 samples)

CIFAR-10 (50000 samples, 3072 features, 10 classes)
Fashion-MNIST (60000 samples, 784 features, 10 classes)
20 Newsgroups (18846 samples, variable features, 20 classes)

Contribution Guidelines

We welcome contributions of new examples! Please follow these guidelines:

Clear Documentation: Include comprehensive docstrings and comments
Reproducible Results: Set random seeds and provide environment details
Performance Metrics: Include timing and accuracy measurements
Error Handling: Demonstrate robust error handling practices
Visualization: Include relevant plots and visualizations

Example Template

"""
Example: [Your Example Title]

Description: [Brief description of what this example demonstrates]

Requirements:
- quantum-data-embedding-suite
- scikit-learn
- matplotlib
- [other dependencies]

Author: [Your Name]
Date: [Date]
"""

import numpy as np
import matplotlib.pyplot as plt
from quantum_data_embedding_suite import QuantumEmbeddingPipeline

def main():
    """Main example function."""
    # Your example code here
    pass

if __name__ == "__main__":
    main()

Getting Help

If you encounter issues with any examples:

Check the Installation Guide for setup issues
Review the API Documentation for detailed usage
See the User Guide for conceptual explanations
Check Common Issues for known problems

Next Steps

Start with Basic Classification for a gentle introduction
Try Custom Embeddings to create your own methods
Explore Performance Analysis for optimization techniques
Read Research Examples for cutting-edge applications