qlearnkit.algorithms package

Subpackages

Submodules

qlearnkit.algorithms.quantum_estimator module

class qlearnkit.algorithms.quantum_estimator.QuantumEstimator(encoding_map=None, quantum_instance: Optional[Union[qiskit.utils.quantum_instance.QuantumInstance, qiskit.providers.basebackend.BaseBackend, qiskit.providers.backend.Backend]] = None)[source]

Bases: sklearn.base.TransformerMixin

property encoding_map

Returns the Encoding Map

execute(qcircuits: Union[qiskit.circuit.quantumcircuit.QuantumCircuit, List[qiskit.circuit.quantumcircuit.QuantumCircuit]]) Optional[qiskit.result.result.Result][source]

Executes the given quantum circuit :param qcircuits: a QuantumCircuit or a list of

this type to be executed

Returns

the execution results

abstract fit(X_train: numpy.ndarray, y_train: numpy.ndarray)[source]

Fits the model using X as training dataset and y as training labels :param X_train: training dataset :param y_train: training labels

abstract predict(X_test: numpy.ndarray) numpy.ndarray[source]

Predicts the labels associated to the unclassified data X_test :param X_test: the unclassified data

Returns

the labels associated to X_test

property quantum_instance: qiskit.utils.quantum_instance.QuantumInstance

Returns the quantum instance to evaluate the circuit.

abstract score(X: numpy.ndarray, y: numpy.ndarray, sample_weight: Optional[numpy.ndarray] = None) float[source]

Returns a score of this model given samples and true values for the samples. In case of classification, this value should correspond to mean accuracy, in case of regression, the coefficient of determination \(R^2\) of the prediction. In case of clustering, the y parameter is typically ignored.

Parameters
  • X – array-like of shape (n_samples, n_features)

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

  • sample_weight – array-like of shape (n_samples,), default=None The weights for each observation in X. If None, all observations are assigned equal weight.

Returns

a float score of the model.

Module contents

class qlearnkit.algorithms.QKMeans(n_clusters: int = 6, quantum_instance: Optional[Union[qiskit.utils.quantum_instance.QuantumInstance, qiskit.providers.basebackend.BaseBackend, qiskit.providers.backend.Backend]] = None, *, init: Union[str, numpy.ndarray] = 'kmeans++', n_init: int = 1, max_iter: int = 30, tol: float = 0.0001, random_state: int = 42)[source]

Bases: sklearn.base.ClusterMixin, qlearnkit.algorithms.quantum_estimator.QuantumEstimator

The Quantum K-Means algorithm for classification

Note

The naming conventions follow the KMeans from sklearn.cluster

Example

Classify data using the Iris dataset.

import numpy as np
import matplotlib.pyplot as plt
from qlearnkit.algorithms import QKMeans
from qiskit import BasicAer
from qiskit.utils import QuantumInstance, algorithm_globals
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

seed = 42
algorithm_globals.random_seed = seed

quantum_instance = QuantumInstance(BasicAer.get_backend('qasm_simulator'),
                                   shots=1024,
                                   optimization_level=1,
                                   seed_simulator=seed,
                                   seed_transpiler=seed)

# Use iris data set for training and test data
X, y = load_iris(return_X_y=True)

num_features = 2
X = np.asarray([x[0:num_features] for x, y_ in zip(X, y) if y_ != 2])
y = np.asarray([y_ for x, y_ in zip(X, y) if y_ != 2])

qkmeans = QKMeans(n_clusters=3,
                  quantum_instance=quantum_instance
)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=seed)
qkmeans.fit(X_train)

print(qkmeans.labels_)
print(qkmeans.cluster_centers_)

# Plot the results
colors = ['blue', 'orange', 'green']
for i in range(X_train.shape[0]):
    plt.scatter(X_train[i, 0], X_train[i, 1], color=colors[qkmeans.labels_[i]])
plt.scatter(qkmeans.cluster_centers_[:, 0], qkmeans.cluster_centers_[:, 1], marker='*', c='g', s=150)
plt.show()

# Predict new points
prediction = qkmeans.predict(X_test)
print(prediction)
[0 0 2 1 0 2 2 0 1 0 1 1 2 2 0 2 0 0 1 2 1 1 2 0 2 2 0 1 0 1 1 1 2 1 1 0 1
 0 2 0 0 0 0 2 2 0 2 0 0 0 0 1 0 2 1 1 0 2 0 1 0 0 2 1 1 0 2 1 2 0 0 0 0 0
 2 0 0 2 0 0]
[[5.96216216 2.77027027]
 [4.74761905 3.02857143]
 [5.34090909 3.63181818]]
_images/qlearnkit.algorithms_0_1.png
[0 0 0 1 2 2 2 0 2 2 2 1 0 2 0 2 0 0 1 2]
fit(X: numpy.ndarray, y: Optional[numpy.ndarray] = None)[source]

Fits the model using X as training dataset and y as training labels. For the qkmeans algorithm y is ignored. The fit model creates clusters from the training dataset given as input

Parameters
  • X – training dataset

  • y – Ignored. Kept here for API consistency

Returns

trained QKMeans object

predict(X_test: numpy.ndarray) numpy.ndarray[source]

Predict the labels of the provided data.

Parameters

X_test – New data to predict.

Returns

Index of the cluster each sample belongs to.

score(X: numpy.ndarray, y: Optional[numpy.ndarray] = None, sample_weight: Optional[numpy.ndarray] = None) float[source]

Returns Mean Silhouette Coefficient for all samples. :param X: array of features :param y: Ignored.

Not used, present here for API consistency by convention.

Parameters

sample_weight – Ignored. Not used, present here for API consistency by convention.

Returns

Mean Silhouette Coefficient for all samples.

class qlearnkit.algorithms.QKNeighborsClassifier(n_neighbors: int = 3, encoding_map: Optional[qlearnkit.encodings.encoding_map.EncodingMap] = None, quantum_instance: Optional[Union[qiskit.utils.quantum_instance.QuantumInstance, qiskit.providers.basebackend.BaseBackend, qiskit.providers.backend.Backend]] = None)[source]

Bases: sklearn.base.ClassifierMixin, qlearnkit.algorithms.qknn.qknn_base.QNeighborsBase

The Quantum K-Nearest Neighbors algorithm for classification

Note

The naming conventions follow the KNeighborsClassifier from sklearn.neighbors

Example

Classify data using the Iris dataset.

import numpy as np
from qlearnkit.algorithms import QKNeighborsClassifier
from qlearnkit.encodings import AmplitudeEncoding
from qiskit import BasicAer
from qiskit.utils import QuantumInstance, algorithm_globals
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

seed = 42
algorithm_globals.random_seed = seed

quantum_instance = QuantumInstance(BasicAer.get_backend('qasm_simulator'),
                                   shots=1024,
                                   optimization_level=1,
                                   seed_simulator=seed,
                                   seed_transpiler=seed)

encoding_map = AmplitudeEncoding()

# Use iris data set for training and test data
X, y = load_iris(return_X_y=True)

num_features = 2
X = np.asarray([x[0:num_features] for x, y_ in zip(X, y) if y_ != 2])
y = np.asarray([y_ for x, y_ in zip(X, y) if y_ != 2])

qknn = QKNeighborsClassifier(
    n_neighbors=3,
    quantum_instance=quantum_instance,
    encoding_map=encoding_map
)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=seed)
qknn.fit(X_train, y_train)

print(f"Testing accuracy: "
      f"{qknn.score(X_test, y_test):0.2f}")
Testing accuracy: 1.00
predict(X_test: numpy.ndarray) numpy.ndarray[source]

Predict the labels of the provided data.

class qlearnkit.algorithms.QKNeighborsRegressor(n_neighbors: int = 3, encoding_map: Optional[qlearnkit.encodings.encoding_map.EncodingMap] = None, quantum_instance: Optional[Union[qiskit.utils.quantum_instance.QuantumInstance, qiskit.providers.basebackend.BaseBackend, qiskit.providers.backend.Backend]] = None)[source]

Bases: sklearn.base.RegressorMixin, qlearnkit.algorithms.qknn.qknn_base.QNeighborsBase

The Quantum K-Nearest Neighbors algorithm for regression

Note

The naming conventions follow the KNeighborsRegressor from sklearn.neighbors

predict(X_test: numpy.ndarray) numpy.ndarray[source]

Predict the labels of the provided data.

class qlearnkit.algorithms.QSVClassifier(encoding_map: Optional[qiskit.circuit.library.n_local.n_local.NLocal] = None, quantum_instance: Optional[Union[qiskit.utils.quantum_instance.QuantumInstance, qiskit.providers.basebackend.BaseBackend, qiskit.providers.backend.Backend]] = None, gamma: Union[float, str] = 'scale')[source]

Bases: sklearn.base.ClassifierMixin, qlearnkit.algorithms.quantum_estimator.QuantumEstimator

The Quantum Support Vector Machine algorithm for classification. Maps datapoints to quantum states using a FeatureMap or similar QuantumCircuit.

Example

Classify data using the Iris dataset.

import numpy as np
from qlearnkit.algorithms import QSVClassifier
from qiskit import BasicAer
from qiskit.utils import QuantumInstance, algorithm_globals
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from qiskit.circuit.library import ZZFeatureMap

seed = 42
algorithm_globals.random_seed = seed

quantum_instance = QuantumInstance(BasicAer.get_backend('statevector_simulator'),
                                   shots=1024,
                                   optimization_level=1,
                                   seed_simulator=seed,
                                   seed_transpiler=seed)

# Use iris data set for training and test data
X, y = load_iris(return_X_y=True)

num_features = 2
X = np.asarray([x[0:num_features] for x, y_ in zip(X, y) if y_ != 2])
y = np.asarray([y_ for x, y_ in zip(X, y) if y_ != 2])

encoding_map = ZZFeatureMap(2)

qsvc = QSVClassifier(
    encoding_map=encoding_map,
    quantum_instance=quantum_instance
)

# use iris dataset
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=seed)
qsvc.fit(X_train, y_train)

print(f"Testing accuracy: "
      f"{qsvc.score(X_test, y_test):0.2f}")
Testing accuracy: 0.95
fit(X, y)[source]

Fits the model using X as training dataset and y as training labels. The actual computation is done at the predict stage to allow running the qiskit backend only once

Parameters
  • X – training dataset

  • y – training labels

predict(X_test: numpy.ndarray) numpy.ndarray[source]

Solves a Least Squares problem to predict value of input data. Internally distinguishes between binary and multiclass case. For the binary case solves an optimization problem to find a dividing hyperplane. For the multiclass case uses a one-to-rest approach and thus needs to run the algorithm n_classes different times.

Parameters

X_test – the test data

Returns

numpy ndarray of predicted labels

class qlearnkit.algorithms.QuantumEstimator(encoding_map=None, quantum_instance: Optional[Union[qiskit.utils.quantum_instance.QuantumInstance, qiskit.providers.basebackend.BaseBackend, qiskit.providers.backend.Backend]] = None)[source]

Bases: sklearn.base.TransformerMixin

property encoding_map

Returns the Encoding Map

execute(qcircuits: Union[qiskit.circuit.quantumcircuit.QuantumCircuit, List[qiskit.circuit.quantumcircuit.QuantumCircuit]]) Optional[qiskit.result.result.Result][source]

Executes the given quantum circuit :param qcircuits: a QuantumCircuit or a list of

this type to be executed

Returns

the execution results

abstract fit(X_train: numpy.ndarray, y_train: numpy.ndarray)[source]

Fits the model using X as training dataset and y as training labels :param X_train: training dataset :param y_train: training labels

abstract predict(X_test: numpy.ndarray) numpy.ndarray[source]

Predicts the labels associated to the unclassified data X_test :param X_test: the unclassified data

Returns

the labels associated to X_test

property quantum_instance: qiskit.utils.quantum_instance.QuantumInstance

Returns the quantum instance to evaluate the circuit.

abstract score(X: numpy.ndarray, y: numpy.ndarray, sample_weight: Optional[numpy.ndarray] = None) float[source]

Returns a score of this model given samples and true values for the samples. In case of classification, this value should correspond to mean accuracy, in case of regression, the coefficient of determination \(R^2\) of the prediction. In case of clustering, the y parameter is typically ignored.

Parameters
  • X – array-like of shape (n_samples, n_features)

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

  • sample_weight – array-like of shape (n_samples,), default=None The weights for each observation in X. If None, all observations are assigned equal weight.

Returns

a float score of the model.