Quantum Machine Learning | Mohammad Junayed Hasan

Overview

A comprehensive repository containing codes, tutorials, and research implementations for quantum machine learning using PyTorch and Qiskit. Covers topics from qiskit basics to hybrid quantum-classical models, demonstrating practical applications of quantum computing in machine learning.

💻 GitHub: Quantum-Machine-Learning-Qiskit-PyTorch
📚 Topics: Quantum Computing, Quantum Neural Networks, Hybrid Models
⭐ Stars: Educational resource for QML researchers

Features

1. Qiskit Fundamentals

Quantum gates and circuits
Quantum entanglement and superposition
Quantum measurement and state visualization
Variational Quantum Eigensolver (VQE)
Quantum Approximate Optimization Algorithm (QAOA)

2. Deep Learning with PyTorch

Neural network fundamentals
CNN architectures for image classification
Transfer learning and fine-tuning
Gradient descent optimization
Model evaluation and metrics

3. Hybrid Quantum-Classical Models

Quantum Convolutional Layers: Replace classical conv layers with quantum circuits
Quantum Fully Connected Networks: Quantum linear transformations
TorchQuantum Integration: PyTorch-based quantum neural network framework
Variational Quantum Circuits (VQC): Trainable quantum circuits

4. Applications

Image Classification: MNIST, Fashion-MNIST with quantum layers
Quantum Autoencoders: Dimensionality reduction on quantum hardware
Quantum GANs: Generative models with quantum discriminators
Medical Imaging: Hybrid quantum-classical models for diagnosis

Repository Structure

Quantum-Machine-Learning-Qiskit-PyTorch/
├── 01_Qiskit_Basics/
│   ├── quantum_gates.ipynb
│   ├── entanglement_demo.ipynb
│   └── measurement_visualization.ipynb
├── 02_PyTorch_DL/
│   ├── cnn_mnist.ipynb
│   ├── transfer_learning.ipynb
│   └── optimization_techniques.ipynb
├── 03_Hybrid_QML/
│   ├── quantum_conv_layer.ipynb
│   ├── vqc_classifier.ipynb
│   └── torch_quantum_integration.ipynb
├── 04_Applications/
│   ├── quantum_mnist.ipynb
│   ├── quantum_autoencoder.ipynb
│   └── medical_imaging_qml.ipynb
├── requirements.txt
└── README.md

Key Implementations

Quantum Convolutional Layer

import torch
import torch.nn as nn
from qiskit import QuantumCircuit, Aer, execute
import torchquantum as tq

class QuantumConvLayer(nn.Module):
    def __init__(self, n_qubits=4):
        super().__init__()
        self.n_qubits = n_qubits
        self.q_device = tq.QuantumDevice(n_wires=n_qubits)
        
        # Variational quantum circuit
        self.encoder = tq.GeneralEncoder([
            {'input_idx': [i], 'func': 'rx', 'wires': [i]} 
            for i in range(n_qubits)
        ])
        
        # Trainable layers
        self.layers = nn.ModuleList([
            tq.Op1QAllLayer(op=tq.RY, n_wires=n_qubits),
            tq.Op2QAllLayer(op=tq.CNOT, n_wires=n_qubits),
            tq.Op1QAllLayer(op=tq.RZ, n_wires=n_qubits)
        ])
        
        self.measure = tq.MeasureAll(tq.PauliZ)
    
    def forward(self, x):
        self.q_device.reset_states(x.shape[0])
        self.encoder(self.q_device, x)
        for layer in self.layers:
            layer(self.q_device)
        return self.measure(self.q_device)

Hybrid Quantum-Classical CNN

class HybridQCNN(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()
        # Classical preprocessing
        self.conv1 = nn.Conv2d(1, 32, 3, 1)
        self.conv2 = nn.Conv2d(32, 64, 3, 1)
        self.pool = nn.MaxPool2d(2, 2)
        
        # Quantum layer
        self.quantum = QuantumConvLayer(n_qubits=4)
        
        # Classical post-processing
        self.fc1 = nn.Linear(64 * 5 * 5, 128)
        self.fc2 = nn.Linear(128 + 4, num_classes)  # +4 from quantum
        
    def forward(self, x):
        # Classical feature extraction
        x = F.relu(self.conv1(x))
        x = self.pool(x)
        x = F.relu(self.conv2(x))
        x = self.pool(x)
        x_classical = x.view(x.size(0), -1)
        
        # Quantum processing
        x_quantum = self.quantum(x_classical[:, :4])
        
        # Fusion
        x_fused = torch.cat([x_classical, x_quantum], dim=1)
        x = F.relu(self.fc1(x_fused))
        return self.fc2(x)

Educational Value

Learning Path

Beginners: Start with Qiskit basics and PyTorch fundamentals
Intermediate: Explore hybrid models and TorchQuantum
Advanced: Implement custom quantum layers and research papers

Covered Concepts

Quantum superposition and entanglement
Variational quantum algorithms
Quantum gradients (parameter shift rule)
Barren plateaus in quantum training
Quantum advantage vs classical baselines

Technical Stack

Quantum Computing: Qiskit, TorchQuantum, PennyLane
Deep Learning: PyTorch, torchvision
Visualization: Matplotlib, Qiskit visualization tools
Simulators: Qiskit Aer, IBMQ simulators
Hardware Access: IBM Quantum Experience (optional)

Use Cases

✅ Educational resource for learning quantum machine learning
✅ Research prototyping for hybrid quantum-classical models
✅ Benchmarking quantum vs classical performance
✅ Exploring NISQ (Noisy Intermediate-Scale Quantum) algorithms

This repository supports research on:

Bridging Classical & Quantum ML: Knowledge distillation from classical to quantum networks
CQ-CNN: Hybrid classical-quantum CNN for Alzheimer’s detection
QuantumMedKD: Quantum knowledge distillation for medical imaging

Getting Started

# Clone repository
git clone https://github.com/junayed-hasan/Quantum-Machine-Learning-Qiskit-PyTorch.git
cd Quantum-Machine-Learning-Qiskit-PyTorch

# Install dependencies
pip install -r requirements.txt

# Run Jupyter notebooks
jupyter notebook

Requirements

qiskit>=0.45.0
torch>=2.0.0
torchquantum>=0.2.0
pennylane>=0.30.0
numpy>=1.24.0
matplotlib>=3.7.0
jupyter>=1.0.0

Future Enhancements

Add quantum reinforcement learning examples
Implement quantum attention mechanisms
Integrate with real quantum hardware (IBM, Rigetti)
Add noise-aware training strategies
Benchmarking suite for NISQ algorithms

Status: Active Development
Language: Python
License: MIT
Contributors: Open to contributions!