Variational classifier

This page contains advanced examples for the tno.quantum.ml.classifiers.vc package. Examples of basic usage can be found in the module documentation.

The package provides a VariationalClassifier which has been implemented in accordance with the scikit-learn estimator API. This means that the classifier can be used as any other (binary and multiclass) scikit-learn classifier and combined with transformers through Pipelines. In addition, the VariationalClassifier makes use of PyTorch tensors, optimizers, and loss functions.

Requirements

Install the following dependencies to run the examples below:

pip install tno.quantum.ml.classifiers.vc~=3.0
pip install matplotlib

Examples

Example 1: Demonstrate classifier usage via sklearn pipelines.

"""Example using VariationalClassifier using Sklearn Pipeline."""

import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn.inspection import DecisionBoundaryDisplay
from sklearn.neighbors import KNeighborsClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier

from tno.quantum.ml.classifiers.vc import VariationalClassifier
from tno.quantum.ml.datasets import get_iris_dataset

X_training, y_training, X_validation, y_validation = get_iris_dataset(
    n_features=2, n_classes=2, random_seed=0
)

# Define classifiers
classifiers = {
    "VC": VariationalClassifier(
        batch_size=10,
        backend={"name": "default.qubit", "options": {}},
        model={
            "name": "expected_value_model",
            "options": {"n_layers": 2, "n_trainable_sublayers": 2, "scaling": 0.3},
        },
        optimizer={"name": "adam", "options": {}},
        use_bias=False,
        random_init=True,
        warm_init=False,
        random_state=2,
    ),
    "Nearest Neighbors": KNeighborsClassifier(3),
    "Linear SVM": SVC(kernel="linear", C=0.025),
    "Decision Tree": DecisionTreeClassifier(max_depth=5),
}

cmap = ListedColormap(["#FF0000", "#0000FF"])
plt.figure(figsize=(16, 16))

for i, (name, classifier) in enumerate(classifiers.items(), 1):
    ax = plt.subplot(2, 2, i)

    if name == "VC":
        classifier = make_pipeline(StandardScaler(), classifier)
        classifier.fit(X_training, y_training, variationalclassifier__n_iter=150)
    else:
        classifier = make_pipeline(StandardScaler(), classifier)
        classifier.fit(X_training, y_training)

    DecisionBoundaryDisplay.from_estimator(
        classifier,
        X_training,
        cmap=plt.cm.RdBu,
        alpha=0.8,
        ax=ax,
        eps=0.5,
        grid_resolution=50,
    )
    ax.scatter(
        X_training[:, 0],
        X_training[:, 1],
        c=y_training,
        cmap=cmap,
        edgecolors="k",
        alpha=0.4,
    )

    ax.scatter(
        X_validation[:, 0],
        X_validation[:, 1],
        c=y_validation,
        cmap=cmap,
        edgecolors="k",
    )

    score = classifier.score(X_training, y_training)
    ax.text(
        ax.get_xlim()[1] - 0.5,
        ax.get_ylim()[0] + 0.1,
        f"{score:.2}",
        size=16,
    )
    ax.set_title(name)
    ax.set_xlabel("Sepal Length")
    ax.set_ylabel("Sepal Width")

plt.show()

Example 2: Demonstrate how to use different post-processing models.

"""Example to showcase different models."""

import matplotlib.pyplot as plt
import numpy as np
from numpy.typing import NDArray
from sklearn.preprocessing import StandardScaler
from tqdm import tqdm

from tno.quantum.ml.classifiers.vc import VariationalClassifier
from tno.quantum.ml.datasets import get_wine_dataset

# Load Wine dataset:
X_training, y_training, X_validation, y_validation = get_wine_dataset(
    n_features=8, n_classes=3, random_seed=0
)


def _std_scale(
    X_training: NDArray[np.float64], X_validation: NDArray[np.float64]
) -> StandardScaler:
    std_scale = StandardScaler().fit(X_training)
    return std_scale.transform(X_training), std_scale.transform(X_validation)


def _accuracy(
    labels: NDArray[np.float64], predictions: NDArray[np.float64]
) -> np.float64:
    return np.sum(np.isclose(labels, predictions)) / labels.size


X_training, X_validation = _std_scale(X_training, X_validation)
X_training = X_training / np.linalg.norm(X_training, ord=2, axis=-1)[:, None]
X_validation = X_validation / np.linalg.norm(X_validation, ord=2, axis=-1)[:, None]


# Perform classification for different models
model_names = [
    "expected_value_model",
    "modulo_model",
    "parity_model",
]

max_iterations = 150
iterations = np.arange(10, max_iterations + 1, 10)
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 8))

for model in model_names:
    classifier = VariationalClassifier(
        model={
            "name": model,
            "options": {"n_layers": 2, "n_trainable_sublayers": 2, "scaling": 0.3},
        },
        optimizer={"name": "adam", "options": {}},
        warm_init=True,
    )

    accuracy_validation = []
    accuracy_training = []

    for _ in tqdm(iterations, desc=f"Processing {model}"):
        classifier.fit(X_training, y_training, n_iter=10)

        pred_validation = classifier.predict(X_validation)
        pred_training = classifier.predict(X_training)

        accuracy_validation.append(_accuracy(y_validation, pred_validation))
        accuracy_training.append(_accuracy(y_training, pred_training))

    ax1.plot(iterations, accuracy_training, label=model, marker="o")
    ax2.plot(iterations, accuracy_validation, label=model, marker="o")

# Set axis
ax1.set_title("Training Accuracy")
ax2.set_title("Validation Accuracy")
ax1.set_xlabel("Iterations")
ax2.set_xlabel("Iterations")
ax1.set_ylabel("Accuracy")
ax2.set_ylabel("Accuracy")
ax1.set_ylim(0, 1)
ax2.set_ylim(0, 1)
ax1.legend()
ax2.legend()
plt.show()