⚛️ Hybrid Quantum-Classical NLP Classifier

A production-grade hybrid quantum-classical machine learning system for text classification. Combines classical NLP preprocessing with a Variational Quantum Circuit (VQC) layer using PennyLane and PyTorch — trained end-to-end via gradient descent through quantum backpropagation.

---

🎯 Real Training Outputs

Training History

Quantum vs Classical Baseline Comparison

Confusion Matrix

Variational Quantum Circuit Diagram

PCA Feature Importance for Quantum Encoding

Model Architecture

---

📌 What is this?

This project implements a Hybrid Quantum-Classical Neural Network for NLP — one of the most active research areas in quantum machine learning. The key idea:

• Classical computers handle text preprocessing (TF-IDF, PCA) and output classification
• Quantum circuit (VQC) performs non-linear feature transformation in high-dimensional Hilbert space — something exponentially expensive to simulate classically
• The entire pipeline is trained end-to-end using quantum backpropagation (parameter-shift rule)

---

🏗️ Architecture

Raw Text Input
      │
      ▼
┌─────────────────────────────────────────────────────────────┐
│  CLASSICAL PRE-PROCESSING                                    │
│  TF-IDF Vectorizer (bigrams) → PCA → MinMaxScaler [0, π]   │
└────────────────────────┬────────────────────────────────────┘
                         │  n_qubits features
                         ▼
┌─────────────────────────────────────────────────────────────┐
│  CLASSICAL PRE-NET                                           │
│  Linear(n→n) → BatchNorm → Tanh                             │
└────────────────────────┬────────────────────────────────────┘
                         │  angles ∈ [0, π]
                         ▼
┌─────────────────────────────────────────────────────────────┐
│  QUANTUM VQC LAYER  ⚛️                                      │
│                                                             │
│  |q0⟩ ──RY(x0)──RZ(θ)──RY(φ)──●─────────────── ⟨Z0⟩      │
│  |q1⟩ ──RY(x1)──RZ(θ)──RY(φ)──⊕──●──────────── ⟨Z1⟩      │
│  |q2⟩ ──RY(x2)──RZ(θ)──RY(φ)─────⊕──●───────── ⟨Z2⟩      │
│  |q3⟩ ──RY(x3)──RZ(θ)──RY(φ)────────⊕───────── ⟨Z3⟩      │
│                                                             │
│  Repeated n_layers times with trainable θ, φ parameters    │
└────────────────────────┬────────────────────────────────────┘
                         │  n_qubits expectation values
                         ▼
┌─────────────────────────────────────────────────────────────┐
│  CLASSICAL POST-NET                                          │
│  Linear(n→32) → BatchNorm → ReLU → Dropout                  │
│  Linear(32→n_classes) → Softmax                             │
└────────────────────────┬────────────────────────────────────┘
                         │
                         ▼
                  Class Prediction

---

⚛️ How the Quantum Circuit Works

1. Angle Encoding

Each classical feature $x_i$ is encoded as a rotation angle on qubit $i$:

RY(x_i)|0⟩ = cos(x_i/2)|0⟩ + sin(x_i/2)|1⟩

This maps the classical input into quantum state (Hilbert space).

2. Variational Layers

Each layer applies parameterized rotations:

RZ(θ_i) RY(φ_i) on qubit i    ← trainable parameters

Followed by CNOT entanglement gates creating quantum correlations between qubits.

3. Entanglement (CNOT Ring)

CNOT(0→1), CNOT(1→2), CNOT(2→3), CNOT(3→0)

Creates correlations between all qubits — capturing relationships between input features.

4. Measurement

⟨Z_i⟩ = ⟨ψ|Z_i|ψ⟩  ∈ [-1, +1]

Pauli-Z expectation value collapses quantum state back to classical values.

5. Training (Backpropagation through Quantum Circuit)

Parameters are optimized using quantum backpropagation via PennyLane's diff_method="backprop", computing exact gradients through the quantum circuit.

---

✨ Features

Feature	Details
⚛️ Quantum Layer	PennyLane VQC with angle encoding + entanglement
🔀 Hybrid Design	Classical pre/post nets + quantum middle layer
📝 NLP Pipeline	TF-IDF (bigrams) + PCA dimensionality reduction
🎓 End-to-End Training	Quantum backpropagation via parameter-shift rule
📊 Comparison	Quantum vs Classical baseline training
🌐 Streamlit App	Interactive demo with circuit visualization
🧪 Unit Tests	Full test suite for all modules
📈 Visualizations	6 real output plots from actual training run

---

📁 Project Structure

Quantum-Classical-NLP/
├── app.py                          # Streamlit interactive demo
├── train.py                        # Main training script
├── predict.py                      # Inference on new text
├── src/
│   ├── __init__.py
│   ├── quantum_circuit.py          # VQC definition (PennyLane QNodes)
│   ├── classical_preprocessor.py  # TF-IDF + PCA + dataset utilities
│   ├── hybrid_model.py             # HybridQuantumClassifier + ClassicalBaseline
│   ├── trainer.py                  # Training loop + evaluation + early stopping
│   └── visualizer.py              # All matplotlib plots (dark theme)
├── tests/
│   └── test_quantum_nlp.py        # Unit tests (preprocessing + model + training)
├── outputs/
│   ├── training_history.png        # Real training curves
│   ├── quantum_vs_classical.png   # Model comparison plot
│   ├── confusion_matrix.png        # Test set confusion matrix
│   ├── circuit_diagram.png         # VQC architecture diagram
│   ├── feature_importance.png      # PCA variance explained
│   └── model_architecture.png     # Full hybrid architecture
├── notebooks/                      # Jupyter exploration notebooks
├── data/                           # Custom datasets (CSV format)
├── requirements.txt
├── .env.example
├── .gitignore
└── README.md

---

⚙️ Setup & Installation

1. Clone the repo

git clone https://github.com/NandithKumar/Quantum-Classical-NLP-Classifier.git
cd Quantum-Classical-NLP-Classifier

2. Create virtual environment

python -m venv venv
source venv/bin/activate     # Linux/Mac
venv\Scripts\activate        # Windows

3. Install dependencies

pip install -r requirements.txt

No API keys required — runs fully locally using quantum simulation!

---

🚀 Usage

Train the model

python train.py

Run interactive Streamlit demo

streamlit run app.py

Predict on custom text

python predict.py --text "This product is absolutely amazing!"

Run unit tests

python -m pytest tests/ -v

---

🔬 Quantum Advantage

Aspect	Classical Model	Quantum-Classical Model
Feature transformation	Linear / polynomial	Hilbert space (exponential)
Entanglement	Not possible	CNOT gates create correlations
Parameter efficiency	More params needed	Fewer quantum params, same expressivity
Training	Standard backprop	Quantum backpropagation
Hardware	CPU / GPU	Quantum simulator (→ real QPU)

---

🛠️ Tech Stack

Component	Technology
Quantum Computing	PennyLane 0.36+
Deep Learning	PyTorch 2.0+
NLP Features	Scikit-learn (TF-IDF, PCA)
Visualization	Matplotlib (dark theme)
Interactive Demo	Streamlit
Language	Python 3.8+

---

🌐 Real-World Applications

• Sentiment Analysis — product reviews, social media, customer feedback
• Document Classification — spam detection, topic labeling
• Intent Detection — chatbots, virtual assistants
• Fraud Text Detection — financial NLP

---

👤 Author

Paladugu Nandith Kumar

• 🎓 B.Tech CSE (AI & ML) — RGMCET, Kadapa
• 💼 LinkedIn
• 🌐 Portfolio
• 📧 nandith1411@gmail.com

---

📚 References

• Schuld, M., & Petruccione, F. (2021). Machine Learning with Quantum Computers. Springer.
• Bergholm, V., et al. (2022). PennyLane: Automatic differentiation of hybrid quantum-classical computations. arXiv:1811.04968
• Cerezo, M., et al. (2021). Variational quantum algorithms. Nature Reviews Physics, 3(9), 625-644.

---

📄 License

MIT License