Nota

Esta página fue generada a partir de docs/tutorials/02_neural_network_classifier_and_regressor.ipynb.

Redes Neuronales de Clasificación y Regresión

En este tutorial mostramos cómo se utiliza la NeuralNetworkClassifier y la NeuralNetworkRegressor. Ambas toman como entrada una NeuralNetwork (Cuántica) y la aprovechan en un contexto específico. En ambos casos, también ofrecemos una variante preconfigurada para mayor comodidad, el Clasificador Cuántico Variacional (Variational Quantum Classifier, VQC) y el Regresor Cuántico Variacional (Variational Quantum Regressor, VQR). El tutorial está estructurado de la siguiente manera:

1. Clasificación

   • Clasificación con una EstimatorQNN

   • Clasificación con una SamplerQNN

   • Clasificador Cuántico Variacional (Variational Quantum Classifier, VQC)

2. Regresión

   • Regresión con una EstimatorQNN

   • Regresor Cuántico Variacional (Variational Quantum Regressor, VQR)

import matplotlib.pyplot as plt
import numpy as np
from IPython.display import clear_output
from qiskit import QuantumCircuit
from qiskit.algorithms.optimizers import COBYLA, L_BFGS_B
from qiskit.circuit import Parameter
from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap
from qiskit.utils import algorithm_globals

from qiskit_machine_learning.algorithms.classifiers import NeuralNetworkClassifier, VQC
from qiskit_machine_learning.algorithms.regressors import NeuralNetworkRegressor, VQR
from qiskit_machine_learning.neural_networks import SamplerQNN, EstimatorQNN

algorithm_globals.random_seed = 42

Clasificación

Preparamos un conjunto de datos de clasificación simple para ilustrar los siguientes algoritmos.

num_inputs = 2
num_samples = 20
X = 2 * algorithm_globals.random.random([num_samples, num_inputs]) - 1
y01 = 1 * (np.sum(X, axis=1) >= 0)  # in { 0,  1}
y = 2 * y01 - 1  # in {-1, +1}
y_one_hot = np.zeros((num_samples, 2))
for i in range(num_samples):
    y_one_hot[i, y01[i]] = 1

for x, y_target in zip(X, y):
    if y_target == 1:
        plt.plot(x[0], x[1], "bo")
    else:
        plt.plot(x[0], x[1], "go")
plt.plot([-1, 1], [1, -1], "--", color="black")
plt.show()

Clasificación con una EstimatorQNN

Primero mostramos cómo se puede usar una EstimatorQNN para la clasificación dentro de un NeuralNetworkClassifier. En este contexto, se espera que EstimatorQNN devuelva una salida unidimensional en \([-1, +1]\). Esto solo funciona para la clasificación binaria y asignamos las dos clases a \(\{-1, +1\}\).

# construct QNN
qc = QuantumCircuit(2)
feature_map = ZZFeatureMap(2)
ansatz = RealAmplitudes(2)
qc.compose(feature_map, inplace=True)
qc.compose(ansatz, inplace=True)
qc.draw(output="mpl")

Crear una red neuronal cuántica

estimator_qnn = EstimatorQNN(
    circuit=qc, input_params=feature_map.parameters, weight_params=ansatz.parameters
)

# QNN maps inputs to [-1, +1]
estimator_qnn.forward(X[0, :], algorithm_globals.random.random(estimator_qnn.num_weights))

array([[0.23521988]])

Agregaremos una función de devolución de llamada nombrada callback_graph. Esto se llamará para cada iteración del optimizador y se le pasarán dos parámetros: los pesos actuales y el valor de la función objetivo en esos pesos. Para nuestra función, agregamos el valor de la función objetivo a un arreglo para que podamos graficar la iteración frente al valor de la función objetivo y actualizar la gráfica con cada iteración. Sin embargo, puedes hacer lo que desees con una función de devolución de llamada siempre y cuando se pasen los dos parámetros mencionados.

# callback function that draws a live plot when the .fit() method is called
def callback_graph(weights, obj_func_eval):
    clear_output(wait=True)
    objective_func_vals.append(obj_func_eval)
    plt.title("Objective function value against iteration")
    plt.xlabel("Iteration")
    plt.ylabel("Objective function value")
    plt.plot(range(len(objective_func_vals)), objective_func_vals)
    plt.show()

# construct neural network classifier
estimator_classifier = NeuralNetworkClassifier(
    estimator_qnn, optimizer=COBYLA(maxiter=60), callback=callback_graph
)

# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)

# fit classifier to data
estimator_classifier.fit(X, y)

# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)

# score classifier
estimator_classifier.score(X, y)

0.8

# evaluate data points
y_predict = estimator_classifier.predict(X)

# plot results
# red == wrongly classified
for x, y_target, y_p in zip(X, y, y_predict):
    if y_target == 1:
        plt.plot(x[0], x[1], "bo")
    else:
        plt.plot(x[0], x[1], "go")
    if y_target != y_p:
        plt.scatter(x[0], x[1], s=200, facecolors="none", edgecolors="r", linewidths=2)
plt.plot([-1, 1], [1, -1], "--", color="black")
plt.show()

Ahora, cuando el modelo está entrenado, podemos explorar los pesos de la red neuronal. Ten en cuenta que el número de pesos está definido por el ansatz.

estimator_classifier.weights

array([ 0.86209107, -1.06526254, -0.10663602, -0.39086371,  1.0894299 ,
        0.59368219,  2.22731471, -1.04769663])

Clasificación con una SamplerQNN

A continuación mostramos cómo se puede usar una SamplerQNN para la clasificación dentro de un NeuralNetworkClassifier. En este contexto, se espera que SamplerQNN devuelva un vector de probabilidad de dimensión \(d\) como salida, donde \(d\) denota el número de clases. La primitiva Sampler subyacente devuelve cuasi-distribuciones de cadenas de bits y solo necesitamos definir un mapeo de las cadenas de bits medidas a las diferentes clases. Para la clasificación binaria usamos el mapeo de paridad.

# construct feature map
feature_map = ZZFeatureMap(num_inputs)

# construct ansatz
ansatz = RealAmplitudes(num_inputs, reps=1)

# construct quantum circuit
qc = QuantumCircuit(num_inputs)
qc.append(feature_map, range(num_inputs))
qc.append(ansatz, range(num_inputs))
qc.decompose().draw(output="mpl")

# parity maps bitstrings to 0 or 1
def parity(x):
    return "{:b}".format(x).count("1") % 2


output_shape = 2  # corresponds to the number of classes, possible outcomes of the (parity) mapping.

# construct QNN
sampler_qnn = SamplerQNN(
    circuit=qc,
    input_params=feature_map.parameters,
    weight_params=ansatz.parameters,
    interpret=parity,
    output_shape=output_shape,
)

# construct classifier
sampler_classifier = NeuralNetworkClassifier(
    neural_network=sampler_qnn, optimizer=COBYLA(maxiter=30), callback=callback_graph
)

# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)

# fit classifier to data
sampler_classifier.fit(X, y01)

# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)

# score classifier
sampler_classifier.score(X, y01)

0.7

# evaluate data points
y_predict = sampler_classifier.predict(X)

# plot results
# red == wrongly classified
for x, y_target, y_p in zip(X, y01, y_predict):
    if y_target == 1:
        plt.plot(x[0], x[1], "bo")
    else:
        plt.plot(x[0], x[1], "go")
    if y_target != y_p:
        plt.scatter(x[0], x[1], s=200, facecolors="none", edgecolors="r", linewidths=2)
plt.plot([-1, 1], [1, -1], "--", color="black")
plt.show()

Nuevamente, una vez que el modelo está entrenado, podemos echar un vistazo a los pesos. Como configuramos explícitamente reps=1 en nuestro ansatz, podemos ver menos parámetros que en el modelo anterior.

sampler_classifier.weights

array([ 1.67198565,  0.46045402, -0.93462862, -0.95266092])

Clasificador Cuántico Variacional (Variational Quantum Classifier, VQC)

El VQC es una variante especial del NeuralNetworkClassifier con una SamplerQNN. Aplica un mapeo de paridad (o extensiones a varias clases) para mapear desde la cadena de bits hasta la clasificación, lo que da como resultado un vector de probabilidad, que se interpreta como un resultado codificado con one-hot. Por defecto, aplica esta función CrossEntropyLoss que espera etiquetas dadas en el formato codificado con one-hot y devolverá predicciones en ese formato también.

# construct feature map, ansatz, and optimizer
feature_map = ZZFeatureMap(num_inputs)
ansatz = RealAmplitudes(num_inputs, reps=1)

# construct variational quantum classifier
vqc = VQC(
    feature_map=feature_map,
    ansatz=ansatz,
    loss="cross_entropy",
    optimizer=COBYLA(maxiter=30),
    callback=callback_graph,
)

# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)

# fit classifier to data
vqc.fit(X, y_one_hot)

# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)

# score classifier
vqc.score(X, y_one_hot)

0.8

# evaluate data points
y_predict = vqc.predict(X)

# plot results
# red == wrongly classified
for x, y_target, y_p in zip(X, y_one_hot, y_predict):
    if y_target[0] == 1:
        plt.plot(x[0], x[1], "bo")
    else:
        plt.plot(x[0], x[1], "go")
    if not np.all(y_target == y_p):
        plt.scatter(x[0], x[1], s=200, facecolors="none", edgecolors="r", linewidths=2)
plt.plot([-1, 1], [1, -1], "--", color="black")
plt.show()

Clases múltiples con VQC

En esta sección generamos un conjunto de datos artificial que contiene muestras de tres clases y mostramos cómo entrenar un modelo para clasificar este conjunto de datos. Este ejemplo muestra cómo abordar problemas más interesantes en el machine learning. Por supuesto, en aras del corto tiempo de entrenamiento, preparamos un pequeño conjunto de datos. Empleamos make_classification de SciKit-Learn para generar un conjunto de datos. Hay 10 muestras en el conjunto de datos, con 2 características, lo que significa que todavía podemos tener una buena gráfica del conjunto de datos, así como características redundantes, estas características se generan como una combinación de las otras. Además, tenemos 3 clases diferentes en el conjunto de datos, cada clase tiene un tipo de centroide y establecemos la separación de clases en 2.0, un ligero aumento del valor predeterminado de 1.0 para facilitar el problema de clasificación.

Una vez que el conjunto de datos es generado, escalamos las características en el rango [0, 1].

from sklearn.datasets import make_classification
from sklearn.preprocessing import MinMaxScaler

X, y = make_classification(
    n_samples=10,
    n_features=2,
    n_classes=3,
    n_redundant=0,
    n_clusters_per_class=1,
    class_sep=2.0,
    random_state=algorithm_globals.random_seed,
)
X = MinMaxScaler().fit_transform(X)

Let’s see how our dataset looks like.

plt.scatter(X[:, 0], X[:, 1], c=y)

<matplotlib.collections.PathCollection at 0x24a97b228c8>

También transformamos las etiquetas y las convertimos en categóricas.

y_cat = np.empty(y.shape, dtype=str)
y_cat[y == 0] = "A"
y_cat[y == 1] = "B"
y_cat[y == 2] = "C"
print(y_cat)

['A' 'A' 'B' 'C' 'C' 'A' 'B' 'B' 'A' 'C']

Creamos una instancia de VQC similar al ejemplo anterior, pero en este caso pasamos un conjunto mínimo de parámetros. En lugar de un mapa de características y un ansatz, pasamos solo la cantidad de qubits que es igual a la cantidad de características en el conjunto de datos, un optimizador con un bajo número de iteraciones para reducir el tiempo de entrenamiento, una instancia cuántica (quantum instance) y una devolución de llamada (callback) para observar el progreso.

vqc = VQC(
    num_qubits=2,
    optimizer=COBYLA(maxiter=30),
    callback=callback_graph,
)

Inicia el proceso de entrenamiento de la misma forma que en los ejemplos anteriores.

# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)

# fit classifier to data
vqc.fit(X, y_cat)

# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)

# score classifier
vqc.score(X, y_cat)

0.9

A pesar de que tuvimos el bajo número de iteraciones, logramos una puntuación bastante buena. Veamos el resultado del método predict y comparemos el resultado con la verdad fundamental.

predict = vqc.predict(X)
print(f"Predicted labels: {predict}")
print(f"Ground truth:     {y_cat}")

Predicted labels: ['A' 'A' 'B' 'C' 'C' 'A' 'B' 'B' 'A' 'B']
Ground truth:     ['A' 'A' 'B' 'C' 'C' 'A' 'B' 'B' 'A' 'C']

Regresión

Preparamos un conjunto de datos de regresión simple para ilustrar los siguientes algoritmos.

num_samples = 20
eps = 0.2
lb, ub = -np.pi, np.pi
X_ = np.linspace(lb, ub, num=50).reshape(50, 1)
f = lambda x: np.sin(x)

X = (ub - lb) * algorithm_globals.random.random([num_samples, 1]) + lb
y = f(X[:, 0]) + eps * (2 * algorithm_globals.random.random(num_samples) - 1)

plt.plot(X_, f(X_), "r--")
plt.plot(X, y, "bo")
plt.show()

Regresión con una EstimatorQNN

Aquí restringimos la regresión con una EstimatorQNN que devuelve valores entre \([-1, +1]\). Se podrían construir modelos más complejos y también multidimensionales, así como basados en SamplerQNN, pero eso excede el alcance de este tutorial.

# construct simple feature map
param_x = Parameter("x")
feature_map = QuantumCircuit(1, name="fm")
feature_map.ry(param_x, 0)

# construct simple ansatz
param_y = Parameter("y")
ansatz = QuantumCircuit(1, name="vf")
ansatz.ry(param_y, 0)

# construct a circuit
qc = QuantumCircuit(1)
qc.compose(feature_map, inplace=True)
qc.compose(ansatz, inplace=True)

# construct QNN
regression_estimator_qnn = EstimatorQNN(
    circuit=qc, input_params=feature_map.parameters, weight_params=ansatz.parameters
)

# construct the regressor from the neural network
regressor = NeuralNetworkRegressor(
    neural_network=regression_estimator_qnn,
    loss="squared_error",
    optimizer=L_BFGS_B(maxiter=5),
    callback=callback_graph,
)

# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)

# fit to data
regressor.fit(X, y)

# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)

# score the result
regressor.score(X, y)

0.9769994291935521

# plot target function
plt.plot(X_, f(X_), "r--")

# plot data
plt.plot(X, y, "bo")

# plot fitted line
y_ = regressor.predict(X_)
plt.plot(X_, y_, "g-")
plt.show()

De manera similar a los modelos de clasificación, podemos obtener una matriz de pesos entrenados consultando una propiedad correspondiente del modelo. En este modelo solo tenemos un parámetro arriba definido como param_y.

regressor.weights

array([-1.58870599])

Regresión con el Regresor Cuántico Variacional (Variational Quantum Regressor, VQR)

Similar al VQC para la clasificación, el VQR es una variante especial del NeuralNetworkRegressor con una EstimatorQNN. De forma predeterminada, considera la función L2Loss para minimizar el error cuadrático medio entre las predicciones y los objetivos.

vqr = VQR(
    feature_map=feature_map,
    ansatz=ansatz,
    optimizer=L_BFGS_B(maxiter=5),
    callback=callback_graph,
)

# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)

# fit regressor
vqr.fit(X, y)

# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)

# score result
vqr.score(X, y)

0.9769955693935385

# plot target function
plt.plot(X_, f(X_), "r--")

# plot data
plt.plot(X, y, "bo")

# plot fitted line
y_ = vqr.predict(X_)
plt.plot(X_, y_, "g-")
plt.show()

import qiskit.tools.jupyter

%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
qiskit-terra	0.22.0
qiskit-aer	0.11.0
qiskit-ignis	0.7.0
qiskit	0.33.0
qiskit-machine-learning	0.5.0
System information
Python version	3.7.9
Python compiler	MSC v.1916 64 bit (AMD64)
Python build	default, Aug 31 2020 17:10:11
OS	Windows
CPUs	4
Memory (Gb)	31.837730407714844
Fri Oct 28 15:44:56 2022 GMT Daylight Time

This code is a part of Qiskit

© Copyright IBM 2017, 2022.

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.