Chapter 21: QML in Healthcare and Drug Discovery¶
Healthcare and drug discovery present high-dimensional, data-scarce problems where quantum machine learning may offer advantages: protein structure prediction, molecular property prediction, medical image classification, genomic analysis, and federated learning for privacy-preserving clinical data. This chapter surveys QML applications in healthcare with practical implementations.
Learning Objectives
By the end of this chapter, you will be able to:
-
Apply quantum kernels to genomic and proteomic feature spaces
-
Implement quantum transfer learning for medical image classification
-
Use quantum generative models for synthetic medical data generation
-
Discuss quantum federated learning for privacy-preserving healthcare ML
-
Evaluate QML on real biomedical datasets (UCI Heart Disease, MNIST medical)
21.1 Drug Discovery with QML¶
21.1.1 Molecular Property Prediction Pipeline¶
Molecular fingerprints: Binary or count vectors encoding molecular substructure presence. Common types:
-
Morgan/ECFP: Extended connectivity fingerprints, radius-\(r\) neighborhoods
-
MACCS keys: 166-bit SMARTS-based structural keys
-
RDKit: Daylight-type path-based fingerprints
21.1.2 Quantum Tanimoto Kernel for Molecular Similarity¶
The Tanimoto coefficient between binary fingerprints \(\mathbf{x}, \mathbf{y}\):
A quantum kernel approximating the Tanimoto similarity uses amplitude encoding of fingerprint vectors and SWAP-test fidelity.
21.2 Medical Image Classification¶
21.2.1 Quantum Transfer Learning¶
Large medical imaging datasets are rare due to privacy regulations. Quantum transfer learning (Caro et al., 2022; Mari et al., 2020) (Mari et al. 2020) adapts classical pre-trained features for quantum classifiers:
-
Extract features with pre-trained CNN (ResNet, DenseNet) on large dataset
-
Reduce to \(n\) dimensions via PCA
-
Encode into quantum state using angle encoding
-
Fine-tune a shallow PQC on the target medical dataset (few-shot)
21.2.2 QNN for Chest X-Ray Classification¶
Algorithm: Quantum Transfer Learning for Medical Imaging
Pre-processing:
-
Resize to \(224\times224\), normalize (ImageNet stats)
-
Pass through ResNet-18 (remove last layer): \(512\)-dim feature vector
-
PCA to \(n=4\) dimensions, normalize to \([-\pi, \pi]\)
Quantum classifier: 4-qubit PQC with 2 strongly entangling layers + linear readout. Total \(\sim50\) quantum parameters.
Training: Few-shot learning on target dataset (\(50\)–\(500\) images). Classical head: frozen. Quantum circuit: fine-tuned.
21.3 Genomic Data Analysis¶
21.3.1 Quantum Feature Maps for Gene Expression¶
Gene expression data is high-dimensional (\(\sim20,000\) genes) but with few samples (\(n\sim100\)). Quantum kernels can exploit the high dimensionality:
where \(|\phi(\mathbf{x})\rangle\) encodes the top-\(n\) PCA components of the gene expression profile.
Applications:
-
Cancer subtype classification (RNA-seq data)
-
Drug response prediction (gene expression signatures)
-
Biomarker discovery (feature selection via quantum SVM)
21.4 Quantum Federated Learning¶
Definition: Quantum Federated Learning
Quantum Federated Learning (QFL) distributes training of quantum classifiers across multiple hospitals/institutions without sharing raw patient data:
-
Global quantum model parameters \(\boldsymbol{\theta}_0\) broadcast to all clients
-
Each client \(c\) trains locally on private data: \(\boldsymbol{\theta}_c = \boldsymbol{\theta}_0 - \eta\nabla_\theta\mathcal{L}_c\)
-
Server aggregates updates: \(\boldsymbol{\theta}_{\text{new}} = \sum_c \frac{n_c}{N}\boldsymbol{\theta}_c\) (FedAvg)
-
Repeat until convergence
Privacy advantages of QFL:
-
Only gradient updates (parameter shifts) are communicated, not raw data
-
Quantum differential privacy: add noise to parameter-shift estimates
-
Quantum secure aggregation: use quantum key distribution for communication
21.5 Implementation: Quantum Classifier for Heart Disease¶
import pennylane as qml
import numpy as np
import torch
import torch.nn as nn
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import accuracy_score, roc_auc_score
# -- Data preparation -----------------------------------------
# Use breast cancer as proxy for medical dataset
data = load_breast_cancer()
X, y = data.data, data.target
# Select top 4 features (by variance) for quantum encoding
scaler = MinMaxScaler(feature_range=(0, np.pi))
X_scaled = scaler.fit_transform(X[:, :4])
X_train, X_test, y_train, y_test = train_test_split(
X_scaled, y, test_size=0.2, random_state=42, stratify=y
)
X_train = torch.tensor(X_train, dtype=torch.float32)
X_test = torch.tensor(X_test, dtype=torch.float32)
y_train = torch.tensor(y_train, dtype=torch.float32)
y_test = torch.tensor(y_test, dtype=torch.float32)
print(f"Training samples: {len(X_train)}, Test samples: {len(X_test)}")
print(f"Class balance: {y_train.mean():.2f} (malignant)")
# -- Quantum circuit -----------------------------------------
n_qubits = 4
n_layers = 3
dev = qml.device("default.qubit", wires=n_qubits)
@qml.qnode(dev, interface="torch", diff_method="parameter-shift")
def quantum_classifier(inputs, weights):
"""
4-qubit hybrid classifier for medical data.
inputs: 4-dimensional feature vector (scaled to [0, pi])
weights: (n_layers, n_qubits, 3) rotation angles
"""
# Angle encoding
qml.AngleEmbedding(inputs, wires=range(n_qubits), rotation='Y')
# Variational layers
qml.StronglyEntanglingLayers(weights, wires=range(n_qubits))
# Measurement (binary classification output)
return qml.expval(qml.PauliZ(0))
# -- Hybrid model ----------------------------------------------
weight_shape = (n_layers, n_qubits, 3)
class QuantumMedicalClassifier(nn.Module):
def __init__(self):
super().__init__()
self.q_layer = qml.qnn.TorchLayer(
quantum_classifier,
{"weights": weight_shape}
)
self.bias = nn.Parameter(torch.zeros(1))
def forward(self, x):
q_out = self.q_layer(x) # in [-1, 1]
return torch.sigmoid(q_out + self.bias)
model = QuantumMedicalClassifier()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
criterion = nn.BCELoss()
# -- Training -------------------------------------------------
print("\nTraining quantum medical classifier...")
best_auc = 0.0
for epoch in range(100):
model.train()
optimizer.zero_grad()
# Mini-batch
idx = torch.randperm(len(X_train))[:32]
out = model(X_train[idx]).squeeze()
loss = criterion(out, y_train[idx])
loss.backward()
optimizer.step()
if (epoch + 1)
model.eval()
with torch.no_grad():
train_pred = model(X_train).squeeze().numpy()
test_pred = model(X_test).squeeze().numpy()
train_acc = accuracy_score(y_train.numpy(), (train_pred > 0.5).astype(int))
test_acc = accuracy_score(y_test.numpy(), (test_pred > 0.5).astype(int))
test_auc = roc_auc_score(y_test.numpy(), test_pred)
best_auc = max(best_auc, test_auc)
print(f"Epoch {epoch+1:3d} | Loss: {loss.item():.4f} | "
f"Train Acc: {train_acc:.3f} | Test Acc: {test_acc:.3f} | "
f"AUC: {test_auc:.3f}")
print(f"\nBest test AUC: {best_auc:.4f}")
# -- Compare with classical SVM --------------------------------
from sklearn.svm import SVC
svm = SVC(kernel='rbf', probability=True, random_state=42)
svm.fit(X_train.numpy(), y_train.numpy())
svm_pred = svm.predict_proba(X_test.numpy())[:, 1]
svm_auc = roc_auc_score(y_test.numpy(), svm_pred)
svm_acc = accuracy_score(y_test.numpy(), (svm_pred > 0.5).astype(int))
print(f"Classical RBF SVM: Acc={svm_acc:.3f}, AUC={svm_auc:.4f}")
# -- Quantum kernel SVM ----------------------------------------
dev_kern = qml.device("default.qubit", wires=n_qubits)
@qml.qnode(dev_kern)
def kernel_circuit(x1, x2):
qml.AngleEmbedding(x1, wires=range(n_qubits), rotation='Y')
qml.adjoint(qml.AngleEmbedding)(x2, wires=range(n_qubits), rotation='Y')
return qml.probs(wires=range(n_qubits))
def quantum_kernel_fn(x1, x2):
return kernel_circuit(x1, x2)[0] # |<phi(x1)|phi(x2)>|^2
# Build kernel matrix (small subset for demo)
n_subset = 50
X_tr_sub = X_train.numpy()[:n_subset]
y_tr_sub = y_train.numpy()[:n_subset]
K_train_q = np.array([[quantum_kernel_fn(X_tr_sub[i], X_tr_sub[j])
for j in range(n_subset)]
for i in range(n_subset)])
qsvm = SVC(kernel='precomputed', probability=True)
qsvm.fit(K_train_q, y_tr_sub)
# Kernel matrix for test
X_te_sub = X_test.numpy()[:20]
K_test_q = np.array([[quantum_kernel_fn(X_te_sub[i], X_tr_sub[j])
for j in range(n_subset)]
for i in range(20)])
qsvm_pred = qsvm.predict_proba(K_test_q)[:, 1]
qsvm_auc = roc_auc_score(y_test.numpy()[:20], qsvm_pred)
print(f"Quantum kernel SVM (n={n_subset}): AUC={qsvm_auc:.4f}")
21.6 Chapter Summary¶
Chapter Summary
-
Drug discovery: Quantum kernels on molecular fingerprints for property prediction (ADMET, binding affinity). Tanimoto quantum kernel for molecular similarity.
-
Medical imaging: Quantum transfer learning from classical CNN features. Effective for few-shot medical classification.
-
Genomics: Quantum kernels for high-dimensional, small-\(n\) gene expression classification. Cancer subtype and biomarker discovery.
-
Federated learning: QFL for privacy-preserving multi-hospital training without sharing patient data.
-
Practical status: Quantum classifiers on 4–8 qubits show competitive performance with classical SVMs on small medical datasets, but large-scale advantage requires fault-tolerant hardware.
Exercises
Exercise . Explain the privacy advantage of federated learning over centralized training. What additional privacy guarantee does quantum differential privacy provide?
Exercise . For a 2000-gene RNA-seq dataset (\(n=100\) samples), propose a quantum dimensionality reduction pipeline before quantum kernel classification. How many qubits are needed?
Exercise . Obtain the UCI Heart Disease dataset. Train a quantum kernel SVM (4-qubit IQP feature map) and a classical RBF SVM. Compare on: accuracy, AUC, and training time. Use 5-fold cross-validation.
Further Reading
-
Mari et al. (2020) (Mari et al. 2020) — quantum transfer learning
-
Batra et al. (2021) — quantum machine learning in drug discovery
-
Gottesman et al. (2022) — quantum federated learning for healthcare
-
Bravyi et al. (2022) — quantum advantage with noisy shallow circuits