Skip to content

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

image

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}\):

\[T(\mathbf{x}, \mathbf{y}) = \frac{|\mathbf{x}\cap\mathbf{y}|}{|\mathbf{x}\cup\mathbf{y}|} = \frac{\mathbf{x}^\top\mathbf{y}}{\|\mathbf{x}\|^2 + \|\mathbf{y}\|^2 - \mathbf{x}^\top\mathbf{y}}\tag{21.1}\]

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:

  1. Extract features with pre-trained CNN (ResNet, DenseNet) on large dataset

  2. Reduce to \(n\) dimensions via PCA

  3. Encode into quantum state using angle encoding

  4. 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:

\[k_Q(\mathbf{x}_{\text{gene}}, \mathbf{y}_{\text{gene}}) = |\langle\phi(\mathbf{x})|\phi(\mathbf{y})\rangle|^2\tag{21.2}\]

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:

  1. Global quantum model parameters \(\boldsymbol{\theta}_0\) broadcast to all clients

  2. Each client \(c\) trains locally on private data: \(\boldsymbol{\theta}_c = \boldsymbol{\theta}_0 - \eta\nabla_\theta\mathcal{L}_c\)

  3. Server aggregates updates: \(\boldsymbol{\theta}_{\text{new}} = \sum_c \frac{n_c}{N}\boldsymbol{\theta}_c\) (FedAvg)

  4. 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