VQCClassifier

The VQCClassifier is a variational quantum classifier compatible with scikit-learn.

class VQCClassifier(n_qubits: int = 4, encoder: BaseEncoder | None = None, ansatz: BaseAnsatz | None = None, optimizer: str | Callable = 'adam', learning_rate: float = 0.01, n_iter: int = 100, batch_size: int | None = None, random_state: int | None = None, device: str = 'default.qubit')

Bases: QuantumEstimator, ClassifierMixin

Variational Quantum Classifier.

A quantum classifier that uses a parameterized quantum circuit to make predictions. Follows the scikit-learn API.

For binary classification, a single quantum circuit is trained. For multi-class classification (3+ classes), uses a one-vs-rest strategy: trains one binary classifier per class.

This implements the variational quantum classifier from:

• Farhi & Neven (2018), “Classification with Quantum Neural Networks on Near Term Processors” (arXiv:1802.06002). Introduces QNNs with parametrized unitaries and Pauli-Z measurements for binary classification.

• Schuld, Bocharov, Svore & Wiebe (2018), “Circuit-centric quantum classifiers” (arXiv:1804.00633). Uses amplitude encoding and variational circuits with analytical gradient estimation for near-term hardware.

Mathematically, for binary classification:

\[f(\mathbf{x}) = \langle 0^{\otimes n} | U_{\text{ansatz}}^{\dagger}(\mathbf{w}) U_{\text{enc}}(\mathbf{x})^{\dagger} Z_0 U_{\text{enc}}(\mathbf{x}) U_{\text{ansatz}}(\mathbf{w}) |0^{\otimes n} \rangle\]

The prediction probability for class 1 is \((f(\mathbf{x}) + 1)/2\). Training minimizes the binary cross-entropy loss:

\[\mathcal{L} = -\frac{1}{N} \sum_{i=1}^N [y_i \log(p_i) + (1-y_i) \log(1-p_i)]\]

Parameters:

• n_qubits (int, default=4) – Number of qubits in the quantum circuit.

• encoder (BaseEncoder, optional) – Data encoding circuit. If None, defaults to AngleEncoder().

• ansatz (BaseAnsatz, optional) – Parameterized circuit. If None, defaults to StronglyEntanglingAnsatz(layers=2).

• optimizer ({"adam", "sgd"} or callable, default="adam") – Optimization algorithm. If a string, uses PennyLane’s built-in optimizer. If callable, should return an optimizer instance with step() and reset() methods.

• learning_rate (float, default=0.01) – Learning rate for the optimizer.

• n_iter (int, default=100) – Number of optimization iterations.

• batch_size (int, optional) – Batch size for training. If None, uses full batch.

• random_state (int, optional) – Random seed for reproducibility.

• device (str, default="default.qubit") – PennyLane device to use.

classes_

Class labels.

Type:

ndarray

n_features_in_

Number of features seen during fit.

Type:

int

n_classes_

Number of classes (binary: 2, multi-class: >2).

Type:

int

weights_

Trained circuit parameters (binary classification only).

Type:

ndarray

encoder_

Fitted encoder (binary classification only).

Type:

BaseEncoder

ansatz_

Fitted ansatz (binary classification only).

Type:

BaseAnsatz

estimators_

List of fitted binary classifiers for multi-class classification. Each is a trained VQCClassifier for one class vs rest.

Type:

list[VQCClassifier]

loss_history_

Training loss at each iteration. For binary: direct loss history. For multi-class: average loss across all binary classifiers.

Type:

list[float]

qnode_

Cached QNode for inference (binary classification only). Set after fit(). Advanced users can call this directly for debugging or custom measurements.

Type:

callable

fit(X, y)

Fit the quantum classifier.

Supports both binary and multi-class classification using one-vs-rest strategy.

Parameters:

• X (array-like, shape (n_samples, n_features)) – Training data.

• y (array-like, shape (n_samples,)) – Target labels.

Returns:

self – Returns the fitted estimator.

Return type:

VQCClassifier

predict(X)

Predict class labels for samples.

Parameters:

X (array-like, shape (n_samples, n_features)) – Input samples.

Returns:

y – Predicted class labels.

Return type:

ndarray, shape (n_samples,)

predict_proba(X)

Predict class probabilities.

For binary classification, returns probabilities for both classes. For multi-class, returns normalized probabilities across all classes from the one-vs-rest classifiers.

Parameters:

X (array-like, shape (n_samples, n_features)) – Input samples.

Returns:

proba – Class probabilities.

Return type:

ndarray, shape (n_samples, n_classes)

score(X, y)

Return classification accuracy.

Binary vs Multi-class

For binary classification (2 classes), a single QNode measures Pauli-Z expectation. For multi-class, one-vs-rest strategy trains one binary classifier per class.

Using with sklearn

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from psipose.estimators import VQCClassifier

pipe = Pipeline([
    ("scaler", StandardScaler()),
    ("vqc", VQCClassifier(n_qubits=4, n_iter=100))
])
pipe.fit(X_train, y_train)