hybrid_quantum_deep_learning

KO | EN

gitlite — search

#python #ai #typescript #llm #golang #deep-learning #linux #nodejs #java #windows #awesome #vue #pytorch #security

hybrid_quantum_deep_learning

(★ 9)

Hybrid Quantum-Classical Deep Learning framework combining Variational Quantum Circuits (PennyLane) with Classical Neural Networks (PyTorch) for binary classification. Features 8-qubit VQC, data re-uploading, dual-rate optimizer, and comprehensive visualization engine.

hybrid_quantum_deep_learning 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Hybrid Quantum-Classical Deep Learning

### Variational Quantum Classifier with Neural Network Integration

[![Python](https://img.shields.io/badge/Python-3.9+-3776AB?style=for-the-badge&logo=python&logoColor=white)](https://python.org)
[![PyTorch](https://img.shields.io/badge/PyTorch-2.0+-EE4C2C?style=for-the-badge&logo=pytorch&logoColor=white)](https://pytorch.org)
[![PennyLane](https://img.shields.io/badge/PennyLane-Quantum_ML-6C3483?style=for-the-badge)](https://pennylane.ai)
[![License](https://img.shields.io/badge/License-MIT-green?style=for-the-badge)](https://raw.githubusercontent.com/rasidi3112/hybrid_quantum_deep_learning/main/LICENSE)

*A production-grade hybrid quantum-classical machine learning framework that combines the power of variational quantum circuits with classical neural networks for binary classification tasks.*

</div>

---

## Training Results

![Comprehensive visualization of the Hybrid Quantum-Classical Deep Learning system showing training dynamics, quantum parameter evolution, decision boundary, loss landscape, and measurement distribution](https://raw.githubusercontent.com/rasidi3112/hybrid_quantum_deep_learning/main/assets/hybrid_quantum_dl_visualization.png)

</div>

> The visualization above shows 8 panels generated by the `QuantumVisualizationEngine`: **(1)** Loss convergence — train & validation loss reaching best val loss 0.0014, **(2)** Accuracy evolution — reaching 100% final validation accuracy, **(3)** Quantum parameter norm evolution over epochs, **(4)** Variational parameters heatmap across qubits × layers, **(5)** PCA-projected decision boundary of the hybrid classifier, **(6)** 2D loss landscape around optimal quantum parameters θ*, **(7)** Quantum measurement ⟨Z⟩ distribution per qubit per class, **(8)** Architecture summary with parameter counts.

---

## Architecture Overview

![Architecture diagram showing the three-stage pipeline: Classical Encoder, Variational Quantum Circuit, and Classical Decoder](https://raw.githubusercontent.com/rasidi3112/hybrid_quantum_deep_learning/main/assets/architecture_diagram.png)

</div>

The system implements a **three-stage hybrid pipeline**:

```
Input (20 features)
    │
    ▼
┌──────────────────────────────────┐
│      CLASSICAL ENCODER           │
│  Linear(20→64) → BN → GELU → DO│
│  Linear(64→32) → BN → GELU → DO│
│  Linear(32→16) → BN → GELU → DO│
│  Linear(16→8) → Tanh            │
└──────────────────────────────────┘
    │  (8-dim normalized vector)
    ▼
┌──────────────────────────────────┐
│   VARIATIONAL QUANTUM CIRCUIT    │
│  8 Qubits │ 6 Layers │ Circular │
│  H → RY_enc → RY/RZ_var → CNOT │
│  + Controlled-Z (odd layers)     │
│  + Data Re-uploading             │
│  Measurement: ⟨Z⟩ on Q0–Q3      │
└──────────────────────────────────┘
    │  (4 expectation values)
    ▼
┌──────────────────────────────────┐
│      CLASSICAL DECODER           │
│  Linear(4→16) → BN → GELU → DO │
│  Linear(16→8) → BN → GELU → DO │
│  Linear(8→2)                     │
└──────────────────────────────────┘
    │
    ▼
  Output (2 classes)
```

---

## Module Structure

```
hybrid_quantum_deep_learning/
├── __init__.py              # Package exports
├── config.py                # Configuration dataclasses & enums
├── quantum_circuit.py       # Variational Quantum Circuit (PennyLane)
├── neural_network.py        # Classical Encoder & Decoder (PyTorch)
├── model.py                 # Hybrid Quantum-Classical Model
├── trainer.py               # Training loop with AdamW + scheduler
├── utils.py                 # Dataset generation utilities
├── visualization.py         # Comprehensive 8-panel visualization engine
└── assets/
    ├── architecture_diagram.png
    └── hybrid_quantum_dl_visualization.png
```

| Module | Lines | Description |
|--------|-------|-------------|
| `config.py` | 43 | `QuantumCircuitConfig`, `ClassicalNetworkConfig`, `TrainingConfig` dataclasses and `EntanglementPattern` enum |
| `quantum_circuit.py` | 84 | `VariationalQuantumCircuit` — builds a PennyLane QNode with configurable encoding, rotation, entanglement, and controlled-phase layers |
| `neural_network.py` | 52 | `ClassicalEncoder` (input→qubits) and `ClassicalDecoder` (measurements→classes) using GELU activation, BatchNorm, and Dropout |
| `model.py` | 75 | `HybridQuantumClassicalModel` — combines encoder, quantum circuit, and decoder into a single `nn.Module` with `forward`, `predict`, `predict_proba` |
| `trainer.py` | 163 | `HybridTrainer` — dual learning rate AdamW optimizer, ReduceLROnPlateau scheduler, gradient clipping, early stopping |
| `utils.py` | 51 | `generate_complex_dataset` — generates synthetic datasets with 3 complexity levels (low/medium/high) using scikit-learn |
| `visualization.py` | 317 | `QuantumVisualizationEngine` — generates an 8-panel comprehensive visualization dashboard |

---

## Configuration

All hyperparameters are controlled through **three dataclass configs**:

### Quantum Circuit Config
```python
QuantumCircuitConfig(
    n_qubits=8,                    # Number of qubits
    n_layers=6,                    # Variational layers depth
    n_measurement_qubits=4,        # Qubits measured (⟨Z⟩)
    rotation_gates=('RY', 'RZ'),   # Parameterized rotation gates
    entanglement_type='circular',  # linear | circular | full | alternate
    use_controlled_phase=True,     # CZ gates on odd layers
    use_data_reuploading=True      # Re-encode input each layer
)
```

### Classical Network Config
```python
ClassicalNetworkConfig(
    input_dim=20,                       # Input feature dimension
    encoder_hidden_dims=(64, 32, 16),   # Encoder hidden layers
    decoder_hidden_dims=(16, 8),        # Decoder hidden layers
    output_dim=2,                       # Number of classes
    activation='gelu',                  # Activation function
    dropout_rate=0.1                    # Dropout probability
)
```

### Training Config
```python
TrainingConfig(
    n_epochs=100,                     # Maximum training epochs
    batch_size=32,                    # Mini-batch size
    learning_rate_quantum=0.01,       # LR for quantum parameters
    learning_rate_classical=0.001,    # LR for classical parameters
    weight_decay=1e-5,                # AdamW weight decay
    scheduler_patience=10,            # ReduceLROnPlateau patience
    early_stopping_patience=20        # Early stopping patience
)
```

> **Note:** The trainer uses **dual learning rates** — a higher rate (`0.01–0.02`) for quantum parameters and a lower rate (`0.001`) for classical parameters, as quantum landscapes benefit from larger step sizes.

---

## Quantum Circuit Details

The `VariationalQuantumCircuit` is built on **PennyLane** with the `default.qubit` simulator using `backprop` differentiation:

### Circuit Structure (per layer)

| Step | Gates | Description |
|------|-------|-------------|
| **1. Initialization** | `H` on all qubits | Create superposition state |
| **2. Data Encoding** | `RY(x_i × π)` | Encode classical features (repeated each layer if data re-uploading is enabled) |
| **3. Variational Rotation** | `RY(θ)`, `RZ(θ)` | Learnable rotation parameters per qubit |
| **4. Entanglement** | `CNOT` | Circular: Q0→Q1→...→Q7→Q0 |
| **5. Controlled Phase** | `CZ` (odd layers only) | Additional entanglement on pairs (Q0-Q1, Q2-Q3, ...) |
| **6. Measurement** | `⟨Z⟩` on Q0–Q3 | Pauli-Z expectation values |

### Entanglement Patterns

```
LINEAR:     Q0─Q1─Q2─Q3─Q4─Q5─Q6─Q7

CIRCULAR:   Q0─Q1─Q2─Q3─Q4─Q5─Q6─Q7─Q0

FULL:       All-to-all CNOT connections

ALTERNATE:  Even layers: (Q0,Q1)(Q2,Q3)(Q4,Q5)(Q6,Q7)
            Odd layers:  (Q1,Q2)(Q3,Q4)(Q5,Q6)
```

### Parameter Count
- **Quantum parameters:** `n_layers × n_qubits × 2` = 6 × 8 × 2 = **96 parameters**
- **Encoder parameters:** ~**4,456** (Linear + BatchNorm weights/biases)
- **Decoder parameters:** ~**138** (Linear + BatchNorm weights/biases)
- **Total:** ~**4,690 parameters**

---

## Visualization Engine

The `QuantumVisualizationEngine` generates a publication-quality **3×4 grid visualization** with 8 panels:

| Panel | Title | What it Shows |
|-------|-------|---------------|
| **1** | Loss Convergence | Train/validation cross-entropy loss with fill-between and best-loss annotation |
| **2** | Accuracy Evolution | Train/validation accuracy curves with final accuracy annotation |
| **3** | Quantum Parameter Norm | L2 norm ‖θ‖₂ of quantum weights over epochs |
| **4** | Parameter Heatmap | Mean variational parameter values across qubits × layers |
| **5** | Decision Boundary | PCA-projected 2D decision boundary with class probability contour |
| **6** | Loss Landscape | 2D random projection of the quantum parameter loss landscape around θ* |
| **7** | Measurement Distribution | Per-class mean ⟨Z⟩ expectation values on each measurement qubit |
| **8** | Architecture Summary | Text summary of architecture specs, parameter counts, and training results |

---

## Quick Start

### Prerequisites

```bash
pip install torch pennylane numpy scikit-learn matplotlib scipy
```

### Run Training

```python
from hybrid_quantum_deep_learning import (
    QuantumCircuitConfig,
    ClassicalNetworkConfig,
    TrainingConfig,
    HybridQuantumClassicalModel,
    HybridTrainer,
    QuantumVisualizationEngine,
    generate_complex_dataset
)
from torch.utils.data import DataLoader, TensorDataset
from sklearn.model_selection import train_test_split
import torch

# Generate dataset
X, y = generate_complex_dataset(n_samples=800, n_features=20, complexity='high')
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)

# Create data loaders
train_loader = DataLoader(
    TensorDataset(torch.FloatTensor(X_train), torch.LongTensor(y_train)),
    batch_size=32, shuffle=True
)
test_loader = DataLoader(
    TensorDataset(torch.FloatTensor(X_test), torch.LongTensor(y_test)),
    batch_size=32
)

# Initialize model
qc_config = QuantumCircuitConfig(n_qubits=8, n_layers=6, n_measurement_qubits=4)
nn_config = ClassicalNetworkConfig(input_dim=20, output_dim=2)
train_config = TrainingConfig(n_epochs=100, batch_size=32)

model = HybridQuantumClassicalModel(qc_config, nn_config)

# Train
trainer = HybridTrainer(model, train_config, device='cpu')
history = trainer.train(train_loader, test_loader, verbose=True)

# Visualize
viz = QuantumVisualizationEngine(figsize=(20, 16))
fig = viz.create_comprehensive_visualization(
    model=model, history=history,
    X_test=X_test, y_test=y_test,
    save_path='visualization.png'
)
```

Or simply run the provided main script:

```bash
python main.py
```

### Inference

```python
# Single prediction
model.eval()
with torch.no_grad():
    input_data = torch.FloatTensor(X_test[:5])
    predictions = model.predict(input_data)          # Class labels
    probabilities = model.predict_proba(input_data)  # Class probabilities
    print(f"Predictions: {predictions}")
    print(f"Probabilities: {probabilities}")
```

---

## Dataset Generation

The `generate_complex_dataset` utility creates synthetic binary classification datasets with three complexity levels:

| Complexity | Base Generator | Feature Engineering |
|------------|---------------|-------------------|
| `low` | `make_classification` (10 informative, 5 redundant) | None |
| `medium` | `make_moons` (noise=0.15) | Sinusoidal cross-features |
| `high` | `make_circles` (noise=0.1, factor=0.5) | Sinusoidal + exponential transforms + correlation injection |

All datasets are standardized with `StandardScaler` and support configurable `n_samples` and `n_features` (default: 1000 samples, 20 features).

---

## Training Strategy

The `HybridTrainer` implements several best practices:

- **Dual-rate AdamW optimizer** — separate learning rates for quantum (higher) and classical (lower) parameters
- **ReduceLROnPlateau scheduler** — halves learning rate after 10 epochs without validation loss improvement
- **Gradient clipping** — max norm of 1.0 to prevent exploding gradients through the quantum circuit
- **Early stopping** — stops training after 20 epochs without validation loss improvement
- **Best model checkpointing** — restores the best model state after training completes
- **Cross-entropy loss** — standard classification objective

---

## Tech Stack

| Technology | Version | Purpose |
|-----------|---------|---------|
| **Python** | 3.9+ | Core language |
| **PyTorch** | 2.0+ | Classical neural networks & autograd |
| **PennyLane** | Latest | Quantum circuit simulation & differentiation |
| **NumPy** | Latest | Numerical operations |
| **scikit-learn** | Latest | Dataset generation, PCA, metrics |
| **Matplotlib** | Latest | Visualization engine |
| **SciPy** | Latest | Interpolation for decision boundary plots |

---

## License

This project is available under the MIT License. See [LICENSE](LICENSE) for details.

---

*Built with quantum computing and deep learning*

</div>

hybrid_quantum_deep_learning

hybrid_quantum_deep_learning 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

hybrid_quantum_deep_learning

hybrid_quantum_deep_learning 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README