VQCClassifier

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

class VQCClassifier(n_qubits: int = 4, feature_map: FeatureMap | None = None, ansatz=None, measurement=None, optimizer='adam', learning_rate=0.01, n_iter=100, batch_size=None, random_state=None, device='default.qubit')

Bases: QuantumEstimator, ClassifierMixin

Variational Quantum Classifier.

A variational quantum classifier (VQC) is a quantum machine learning model that combines data encoding (feature map), a parameterized quantum circuit (ansatz), and measurement to perform binary or multi-class classification. The model is trained using gradient-based optimization.

This implementation follows the circuit-centric quantum classifier approach of Schuld et al. (2018, arXiv:1804.00633) and the broader variational quantum algorithm (VQA) paradigm. For multi-class problems, it uses a one-vs-rest (OvR) strategy.

The training process: 1. Encode classical data into quantum states using the feature map 2. Apply parameterized ansatz circuit 3. Measure expectation value (typically Pauli-Z on first qubit) 4. Minimize binary cross-entropy loss via gradient descent

The gradients are computed using the parameter shift rule, which provides exact gradients on quantum hardware (Mitarai et al., 2018, arXiv:1803.00745).

Parameters:

• n_qubits (int, default=4) – Number of qubits.

• feature_map (FeatureMap, optional) – Data encoding. Default: AngleFeatureMap()

• ansatz (Ansatz, optional) – Parameterized circuit. Default: StronglyEntanglingAnsatz(layers=2)

• measurement (Measurement, optional) – Measurement operator. Default: PauliZExpectation()

• optimizer (str or callable, default="adam") – Optimizer (adam or sgd from PennyLane).

• 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 weight initialization.

• device (str, default="default.qubit") – PennyLane device for simulation.

classes_

Class labels.

Type:

ndarray

n_features_in_

Number of features seen during fit.

Type:

int

n_classes_

Number of classes.

Type:

int

model_

The trained quantum model (binary case) or None (multiclass OvR).

Type:

VariationalModel, optional

estimators_

One-vs-rest classifiers for multi-class.

Type:

list[VQCClassifier]

loss_history_

Training loss per iteration.

Type:

list[float]

qnode_

Cached QNode for inference (binary case only).

Type:

callable, optional

weights_

Trained weights (binary case).

Type:

ndarray, optional

References

[1]

M. Schuld, A. Bocharov, K. Svore, and N. Wiebe, “Circuit-centric quantum classifiers,” arXiv:1804.00633, 2018.

[2]

K. Mitarai et al., “Quantum circuit learning,” Phys. Rev. A 98, 032309, 2018. arXiv:1803.00745.

fit(X, y)

Fit the classifier.

predict(X)

Predict class labels.

predict_proba(X)

Predict class probabilities.

decision_function(X)

Compute decision function (raw QNode output).

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)