Singularity Machine Learning - Clasificación: una Qiskit Function de Multiverse Computing

Nota

• Las Qiskit Functions son una función experimental disponible únicamente para usuarios de los planes IBM Quantum® Premium, Flex y On-Prem (a través de la API de IBM Quantum Platform). Se encuentran en estado de versión preliminar y pueden cambiar.

Descripción general

Con la función "Singularity Machine Learning - Clasificación" puedes resolver problemas reales de aprendizaje automático en hardware cuántico sin necesitar experiencia en computación cuántica. Esta función de aplicación, basada en métodos ensemble, es un clasificador híbrido. Aprovecha métodos clásicos como boosting, bagging y stacking para el entrenamiento inicial del ensemble. Posteriormente, se emplean algoritmos cuánticos como el solucionador cuántico variacional de valores propios (VQE) y el algoritmo cuántico de optimización aproximada (QAOA) para mejorar la diversidad, las capacidades de generalización y la complejidad global del ensemble entrenado.

A diferencia de otras soluciones de aprendizaje automático cuántico, esta función es capaz de manejar conjuntos de datos a gran escala con millones de ejemplos y características sin estar limitada por el número de qubits del QPU objetivo. El número de qubits solo determina el tamaño del ensemble que se puede entrenar. También es altamente flexible y puede utilizarse para resolver problemas de clasificación en una amplia variedad de dominios, incluyendo finanzas, salud y ciberseguridad. Logra de manera consistente altas precisiones en problemas clásicamente difíciles que involucran conjuntos de datos de alta dimensión, ruidosos y desbalanceados. Está diseñada para:

1. Ingenieros y científicos de datos en empresas que buscan mejorar sus ofertas tecnológicas integrando el aprendizaje automático cuántico en sus productos y servicios,
2. Investigadores en laboratorios de investigación cuántica que exploran aplicaciones de aprendizaje automático cuántico y buscan aprovechar la computación cuántica para tareas de clasificación, y
3. Estudiantes y docentes en instituciones educativas en cursos como aprendizaje automático, que buscan demostrar las ventajas de la computación cuántica.

El siguiente ejemplo muestra sus diversas funcionalidades, incluyendo create, list, fit y predict, y demuestra su uso en un problema sintético compuesto por dos semiciclos entrelazados, un problema notoriamente difícil debido a su frontera de decisión no lineal.

Descripción de la función

Esta Qiskit Function permite a los usuarios resolver problemas de clasificación binaria utilizando el clasificador ensemble mejorado cuánticamente de Singularity. En segundo plano, utiliza un enfoque híbrido para entrenar clásicamente un ensemble de clasificadores sobre el conjunto de datos etiquetado y, a continuación, optimizarlo para maximizar la diversidad y la generalización mediante el Algoritmo Cuántico de Optimización Aproximada (QAOA) en QPUs de IBM®. A través de una interfaz fácil de usar, los usuarios pueden configurar un clasificador según sus requisitos, entrenarlo con el conjunto de datos de su elección y utilizarlo para hacer predicciones sobre un conjunto de datos no visto previamente.

Para resolver un problema de clasificación genérico:

1. Preprocesa el conjunto de datos y divídelo en conjuntos de entrenamiento y prueba. Opcionalmente, puedes dividir además el conjunto de entrenamiento en conjuntos de entrenamiento y validación. Esto se puede lograr usando scikit-learn.
2. Si el conjunto de entrenamiento está desbalanceado, puedes remuestrearlo para equilibrar las clases usando imbalanced-learn.
3. Sube los conjuntos de entrenamiento, validación y prueba por separado al almacenamiento de la función usando el método file_upload del catálogo, pasándole la ruta correspondiente cada vez.
4. Inicializa el clasificador cuántico usando la acción create de la función, que acepta hiperparámetros como el número y los tipos de aprendices, la regularización (valor lambda) y las opciones de optimización incluyendo el número de capas, el tipo de optimizador clásico, el backend cuántico, entre otros.
5. Entrena el clasificador cuántico sobre el conjunto de entrenamiento usando la acción fit de la función, pasándole el conjunto de entrenamiento etiquetado y el conjunto de validación si corresponde.
6. Realiza predicciones sobre el conjunto de prueba no visto previamente usando la acción predict de la función.

Enfoque basado en acciones

La función utiliza un enfoque basado en acciones. Puedes pensarlo como un entorno virtual donde usas acciones para realizar tareas o cambiar su estado. Actualmente, ofrece las siguientes acciones: list, create, delete, fit, predict, fit_predict y create_fit_predict. El siguiente ejemplo demuestra la acción create_fit_predict.

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit-ibm-catalog scikit-learn

# Import QiskitFunctionsCatalog to load the
# "Singularity Machine Learning - Classification" function by Multiverse Computing
from qiskit_ibm_catalog import QiskitFunctionsCatalog

# Import the make_moons and the train_test_split functions from scikit-learn
# to create a synthetic dataset and split it into training and test datasets
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split

# authentication
# If you have not previously saved your credentials, follow instructions at
# /docs/guides/functions
# to authenticate with your API key.
catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

# load "Singularity Machine Learning - Classification" function by Multiverse Computing
singularity = catalog.load("multiverse/singularity")

# generate the synthetic dataset
X, y = make_moons(n_samples=1000)

# split the data into training and test datasets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

job = singularity.run(
    action="create_fit_predict",
    num_learners=10,
    regularization=0.01,
    optimizer_options={"simulator": True},
    X_train=X_train,
    y_train=y_train,
    X_test=X_test,
    options={"save": False},
)

# get job status and result
status = job.status()
result = job.result()

print("Job status: ", status)
print("Action result status: ", result["status"])
print("Action result message: ", result["message"])
print("Predictions (first five results): ", result["data"]["predictions"][:5])
print(
    "Probabilities (first five results): ",
    result["data"]["probabilities"][:5],
)
print("Usage metadata: ", result["metadata"]["resource_usage"])

Job status:  QUEUED
Action result status:  ok
Action result message:  Classifier created, fitted, and predicted.
Predictions (first five results):  [1, 0, 0, 1, 0]
Probabilities (first five results):  [[0.16849563539001172, 0.8315043646099888], [0.8726393386620336, 0.12736066133796647], [0.795344837290717, 0.20465516270928288], [0.36822585748882725, 0.6317741425111725], [0.6656662698604361, 0.3343337301395641]]
Usage metadata:  {'RUNNING: MAPPING': {'CPU_TIME': 7.945035696029663}, 'RUNNING: WAITING_QPU': {'CPU_TIME': 82.41029238700867}, 'RUNNING: POST_PROCESSING': {'CPU_TIME': 77.3459484577179}, 'RUNNING: EXECUTING_QPU': {'QPU_TIME': 71.27004957199097}}

1. List

La acción list recupera todos los clasificadores almacenados en formato *.pkl.tar del directorio de datos compartido. También puedes acceder al contenido de este directorio usando el método catalog.files(). En general, la acción list busca archivos con la extensión *.pkl.tar en el directorio de datos compartido y los devuelve en formato de lista.

Entradas

Nombre	Tipo	Descripción	Requerido
action	str	El nombre de la acción entre create, list, fit, predict, fit_predict, create_fit_predict y delete.	Sí

Uso

job = singularity.run(action="list")

2. Create

La acción create crea un clasificador del tipo quantum_classifier especificado usando los parámetros proporcionados, y lo guarda en el directorio de datos compartido.

nota

La función actualmente solo admite QuantumEnhancedEnsembleClassifier.

Entradas

Nombre	Tipo	Descripción	Requerido	Por defecto
action	str	El nombre de la acción entre create, list, fit, predict, fit_predict, create_fit_predict y delete.	Sí	-
name	str	El nombre del clasificador cuántico, p. ej., spam_classifier.	Sí	-
instance	str	Instancia de IBM.	Sí	-
backend_name	str	Recurso de cómputo de IBM. El valor por defecto es None, lo que significa que se usará el backend con el menor número de trabajos pendientes.	No	None
quantum_classifier	str	El tipo de clasificador cuántico, es decir, QuantumEnhancedEnsembleClassifier.	No	QuantumEnhancedEnsembleClassifier
num_learners	integer	El número de aprendices en el ensemble.	No	10
learners_types	list	Tipos de aprendices. Entre los tipos admitidos se encuentran: DecisionTreeClassifier, GaussianNB, KNeighborsClassifier, MLPClassifier y LogisticRegression. Más detalles sobre cada uno se pueden encontrar en la documentación de scikit-learn.	No	[DecisionTreeClassifier]
learners_proportions	list	Proporciones de cada tipo de aprendiz en el ensemble.	No	[1.0]
learners_options	list	Opciones para cada tipo de aprendiz en el ensemble. Para una lista completa de opciones correspondientes al tipo o tipos de aprendiz elegido, consulta la documentación de scikit-learn.	No	[{"max_depth": 3, "splitter": "random", "class_weight": None}]
regularization_type	str o list	Tipo(s) de regularización a utilizar: onsite o alpha. onsite controla el término onsite donde valores más altos llevan a ensembles más dispersos. alpha controla el equilibrio entre los términos de interacción y onsite donde valores más bajos llevan a ensembles más dispersos. Si se proporciona una lista, se entrenarán modelos para cada tipo y se seleccionará el de mejor rendimiento.	No	onsite
regularization	str o float o list	Valor de regularización. Acotado entre 0 y +inf si regularization_type es onsite. Acotado entre 0 y 1 si regularization_type es alpha. Si se establece en auto, se utiliza la regularización automática: el parámetro de regularización óptimo se encuentra mediante búsqueda binaria con la proporción deseada de clasificadores seleccionados respecto al total (regularization_desired_ratio) y el límite superior del parámetro de regularización (regularization_upper_bound). Si se proporciona una lista, se entrenarán modelos para cada valor y se seleccionará el de mejor rendimiento.	No	0.01
regularization_desired_ratio	float o list	Proporción(es) deseada(s) de clasificadores seleccionados respecto al total para la regularización automática. Si se proporciona una lista, se entrenarán modelos para cada proporción y se seleccionará el de mejor rendimiento.	No	0.75
regularization_upper_bound	float o list	Límite(s) superior(es) para el parámetro de regularización al usar la regularización automática. Si se proporciona una lista, se entrenarán modelos para cada límite superior y se seleccionará el de mejor rendimiento.	No	200
weight_update_method	str	Método para actualizar los pesos de las muestras entre logarithmic y quadratic.	No	logarithmic
sample_scaling	boolean	Si se debe aplicar escalado de muestras.	No	False
prediction_scaling	float	Factor de escala para las predicciones.	No	None
optimizer_options	dictionary	Opciones del optimizador QAOA. Una lista de opciones disponibles se presenta más adelante en esta documentación.	No	...
voting	str	Usar votación por mayoría (hard) o promedio de probabilidades (soft) para agregar las predicciones/probabilidades de los aprendices.	No	hard
prob_threshold	float	Umbral de probabilidad óptimo.	No	0.5
random_state	integer	Controla la aleatoriedad para la reproducibilidad.	No	None

• Además, optimizer_options se detallan a continuación:

Nombre	Tipo	Descripción	Requerido	Por defecto
num_solutions	integer	El número de soluciones	No	1024
reps	integer	El número de repeticiones	No	4
sparsify	float	El umbral de dispersión	No	0.001
theta	float	El valor inicial de theta, un parámetro variacional de QAOA	No	None
simulator	boolean	Si se usa un simulador o un QPU	No	False
classical_optimizer	str	Nombre del optimizador clásico para el QAOA. Todos los solvers ofrecidos por SciPy, listados aquí, son utilizables. Deberás configurar classical_optimizer_options en consecuencia.	No	COBYLA
classical_optimizer_options	dictionary	Opciones del optimizador clásico. Para una lista completa de opciones disponibles, consulta la documentación de SciPy	No	{"maxiter": 60}
optimization_level	integer	La profundidad del circuito QAOA	No	3
num_transpiler_runs	integer	Número de ejecuciones del transpilador	No	30
pass_manager_options	dictionary	Opciones para generar el gestor de pases preestablecido	No	{"approximation_degree": 1.0}
estimator_options	dictionary	Opciones del Estimator. Para una lista completa de opciones disponibles, consulta la documentación del cliente Qiskit Runtime	No	None
sampler_options	dictionary	Opciones del Sampler. Para una lista completa de opciones disponibles, consulta la documentación del cliente Qiskit Runtime	No	None

• Los valores por defecto de estimator_options son:

Nombre	Tipo	Valor
default_shots	integer	1024
resilience_level	integer	2
twirling	dictionary	{"enable_gates": True}
dynamical_decoupling	dictionary	{"enable": True}
resilience_options	dictionary	{"zne_mitigation": False, "zne": {"amplifier": "pea", "noise_factors": [1.0, 1.3, 1.6], "extrapolator": ["linear", "polynomial_degree_2", "exponential"],}}

• Los valores por defecto de sampler_options son:

Nombre	Tipo	Valor
default_shots	integer	1024
resilience_level	integer	1
twirling	dictionary	{"enable_gates": True}
dynamical_decoupling	dictionary	{"enable": True}

Uso

job = singularity.run(
    action="create",
    name="classifier_name",  # specify your custom name for the classifier here
    num_learners=10,
    regularization=0.01,
    optimizer_options={"simulator": True},
)

Validaciones

• name:
  • El nombre debe ser único, una cadena de hasta 64 caracteres.
  • Solo puede incluir caracteres alfanuméricos y guiones bajos.
  • Debe comenzar con una letra y no puede terminar con un guion bajo.
  • No debe existir ya ningún clasificador con el mismo nombre en el directorio de datos compartido.

3. Delete

La acción delete elimina un clasificador del directorio de datos compartido.

Entradas

Nombre	Tipo	Descripción	Requerido
action	str	El nombre de la acción. Debe ser delete.	Sí
name	str	El nombre del clasificador a eliminar.	Sí

Uso

job = singularity.run(
    action="delete",
    name="classifier_name",  # specify the name of the classifier to delete here
)

Validaciones

• name:
  • El nombre debe ser único, una cadena de hasta 64 caracteres.
  • Solo puede incluir caracteres alfanuméricos y guiones bajos.
  • Debe comenzar con una letra y no puede terminar con un guion bajo.
  • Ya debe existir un clasificador con el mismo nombre en el directorio de datos compartido.

4. Fit

La acción fit entrena un clasificador usando los datos de entrenamiento proporcionados.

Entradas

Nombre	Tipo	Descripción	Requerido
action	str	El nombre de la acción. Debe ser fit.	Sí
name	str	El nombre del clasificador a entrenar.	Sí
X	array o list o str	Los datos de entrenamiento. Puede ser un array NumPy, una lista o una cadena que referencie un nombre de archivo en el directorio de datos compartido.	Sí
y	array o list o str	Los valores objetivo de entrenamiento. Puede ser un array NumPy, una lista o una cadena que referencie un nombre de archivo en el directorio de datos compartido.	Sí
fit_params	dictionary	Parámetros adicionales para pasar al método fit del clasificador.	No

fit_params

Nombre	Tipo	Descripción	Requerido	Por defecto
validation_data	tuple	Los datos y etiquetas de validación.	No	None
pos_label	integer o str	La etiqueta de clase que se mapea a 1.	No	None
optimization_data	str	Conjunto de datos sobre el que optimizar el ensemble. Puede ser uno de: train, validation, both.	No	train

Uso

job = singularity.run(
    action="fit",
    name="classifier_name",  # specify the name of the classifier to train here
    X=X_train,  # or "X_train.npy" if you uploaded it in the shared data directory
    y=y_train,  # or "y_train.npy" if you uploaded it in the shared data directory
    fit_params={},  # define the fit parameters here
)

Validaciones

• name:
  • El nombre debe ser único, una cadena de hasta 64 caracteres.
  • Solo puede incluir caracteres alfanuméricos y guiones bajos.
  • Debe comenzar con una letra y no puede terminar con un guion bajo.
  • Ya debe existir un clasificador con el mismo nombre en el directorio de datos compartido.

5. Predict

La acción predict se usa para obtener predicciones duras y suaves (probabilidades).

Entradas

Nombre	Tipo	Descripción	Requerido
action	str	El nombre de la acción. Debe ser predict.	Sí
name	str	El nombre del clasificador a utilizar.	Sí
X	array o list o str	Los datos de prueba. Puede ser un array NumPy, una lista o una cadena que referencie un nombre de archivo en el directorio de datos compartido.	Sí
options["out"]	str	El nombre del archivo JSON de salida para guardar las predicciones en el directorio de datos compartido. Si no se proporciona, las predicciones se devuelven en el resultado del trabajo.	No

Uso

job = singularity.run(
    action="predict",
    name="classifier_name",  # specify the name of the classifier to use here
    X=X_test,  # or "X_test.npy" if you uploaded it to the shared data directory
    options={
        "out": "output.json",
    },
)

Validaciones

• name:
  • El nombre debe ser único, una cadena de hasta 64 caracteres.
  • Solo puede incluir caracteres alfanuméricos y guiones bajos.
  • Debe comenzar con una letra y no puede terminar con un guion bajo.
  • Ya debe existir un clasificador con el mismo nombre en el directorio de datos compartido.
• options["out"]:
  • El nombre del archivo debe ser único, una cadena de hasta 64 caracteres.
  • Solo puede incluir caracteres alfanuméricos y guiones bajos.
  • Debe comenzar con una letra y no puede terminar con un guion bajo.
  • Debe tener la extensión .json.

6. Fit-predict

La acción fit_predict entrena un clasificador usando los datos de entrenamiento y luego lo usa para obtener predicciones duras y suaves (probabilidades).

Entradas

Nombre	Tipo	Descripción	Requerido
action	str	El nombre de la acción. Debe ser fit_predict.	Sí
name	str	El nombre del clasificador a utilizar.	Sí
X_train	array o list o str	Los datos de entrenamiento. Puede ser un array NumPy, una lista o una cadena que referencie un nombre de archivo en el directorio de datos compartido.	Sí
y_train	array o list o str	Los valores objetivo de entrenamiento. Puede ser un array NumPy, una lista o una cadena que referencie un nombre de archivo en el directorio de datos compartido.	Sí
X_test	array o list o str	Los datos de prueba. Puede ser un array NumPy, una lista o una cadena que referencie un nombre de archivo en el directorio de datos compartido.	Sí
fit_params	dictionary	Parámetros adicionales para pasar al método fit del clasificador.	No
options["out"]	str	El nombre del archivo JSON de salida para guardar las predicciones en el directorio de datos compartido. Si no se proporciona, las predicciones se devuelven en el resultado del trabajo.	No

Uso

job = singularity.run(
    action="fit_predict",
    name="classifier_name",  # specify the name of the classifier to use here
    X_train=X_train,  # or "X_train.npy" if you uploaded it in the shared data directory
    y_train=y_train,  # or "y_train.npy" if you uploaded it in the shared data directory
    X_test=X_test,  # or "X_test.npy" if you uploaded it in the shared data directory
    fit_params={},  # define the fit parameters here
    options={
        "out": "output.json",
    },
)

Validaciones

• name:

  • El nombre debe ser único, una cadena de hasta 64 caracteres.
  • Solo puede incluir caracteres alfanuméricos y guiones bajos.
  • Debe comenzar con una letra y no puede terminar con un guion bajo.
  • Ya debe existir un clasificador con el mismo nombre en el directorio de datos compartido.

• options["out"]:

  • El nombre del archivo debe ser único, una cadena de hasta 64 caracteres.
  • Solo puede incluir caracteres alfanuméricos y guiones bajos.
  • Debe comenzar con una letra y no puede terminar con un guion bajo.
  • Debe tener la extensión .json.

7. Create-fit-predict

La acción create_fit_predict crea un clasificador, lo entrena usando los datos de entrenamiento proporcionados y luego lo usa para obtener predicciones duras y suaves (probabilidades).

Entradas

Nombre	Tipo	Descripción	Requerido
action	str	El nombre de la acción entre create, list, fit, predict, fit_predict, create_fit_predict y delete.	Sí
name	str	El nombre del clasificador a utilizar.	Sí
quantum_classifier	str	El tipo de clasificador, es decir, QuantumEnhancedEnsembleClassifier. Por defecto es QuantumEnhancedEnsembleClassifier.	No
X_train	array o list o str	Los datos de entrenamiento. Puede ser un array NumPy, una lista o una cadena que referencie un nombre de archivo en el directorio de datos compartido.	Sí
y_train	array o list o str	Los valores objetivo de entrenamiento. Puede ser un array NumPy, una lista o una cadena que referencie un nombre de archivo en el directorio de datos compartido.	Sí
X_test	array o list o str	Los datos de prueba. Puede ser un array NumPy, una lista o una cadena que referencie un nombre de archivo en el directorio de datos compartido.	Sí
fit_params	dictionary	Parámetros adicionales para pasar al método fit del clasificador.	No
options["save"]	boolean	Si se guarda el clasificador entrenado en el directorio de datos compartido. Por defecto es True.	No
options["out"]	str	El nombre del archivo JSON de salida para guardar las predicciones en el directorio de datos compartido. Si no se proporciona, las predicciones se devuelven en el resultado del trabajo.	No

Uso

job = singularity.run(
    action="create_fit_predict",
    name="classifier_name",  # specify your custom name for the classifier here
    num_learners=10,
    regularization=0.01,
    optimizer_options={"simulator": True},
    X_train=X_train,  # or "X_train.npy" if you uploaded it in the shared data directory
    y_train=y_train,  # or "y_train.npy" if you uploaded it in the shared data directory
    X_test=X_test,  # or "X_test.npy" if you uploaded it in the shared data directory
    fit_params={},  # define the fit parameters here
    options={
        "save": True,
        "out": "output.json",
    },
)

Validaciones

• name:

  • Si options["save"] está establecido en True:
    • El nombre debe ser único, una cadena de hasta 64 caracteres.
    • Solo puede incluir caracteres alfanuméricos y guiones bajos.
    • Debe comenzar con una letra y no puede terminar con un guion bajo.
    • No debe existir ya ningún clasificador con el mismo nombre en el directorio de datos compartido.

• options["out"]:

  • El nombre del archivo debe ser único, una cadena de hasta 64 caracteres.
  • Solo puede incluir caracteres alfanuméricos y guiones bajos.
  • Debe comenzar con una letra y no puede terminar con un guion bajo.
  • Debe tener la extensión .json.

---

Primeros pasos

Autentícate usando tu clave de API de IBM Quantum Platform y selecciona la Qiskit Function de la siguiente manera:

from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

# load function
singularity = catalog.load("multiverse/singularity")

Ejemplo

En este ejemplo, usarás la función "Singularity Machine Learning - Clasificación" para clasificar un conjunto de datos que consiste en dos semicírculos en forma de luna entrelazados. El conjunto de datos es sintético, bidimensional y etiquetado con etiquetas binarias. Está diseñado para ser desafiante para algoritmos como la agrupación basada en centroides y la clasificación lineal. A través de este proceso, aprenderás a crear el clasificador, ajustarlo a los datos de entrenamiento, usarlo para predecir en los datos de prueba y eliminar el clasificador cuando hayas terminado. Antes de comenzar, necesitas instalar scikit-learn. Instálalo usando el siguiente comando:

python3 -m pip install scikit-learn

Realiza los siguientes pasos:

1. Crea el conjunto de datos sintético usando la función make_moons de scikit-learn.
2. Sube el conjunto de datos sintético generado al directorio de datos compartido.
3. Crea el clasificador mejorado cuánticamente usando la acción create.
4. Lista tus clasificadores usando la acción list.
5. Entrena el clasificador con los datos de entrenamiento usando la acción fit.
6. Usa el clasificador entrenado para predecir en los datos de prueba usando la acción predict.
7. Elimina el clasificador usando la acción delete.
8. Limpia cuando hayas terminado. Paso 1. Importa los módulos necesarios y genera el conjunto de datos sintético, luego divídelo en conjuntos de datos de entrenamiento y prueba.

# import the necessary modules for this example
import os
import tarfile
import numpy as np

# Import the make_moons and the train_test_split functions from scikit-learn
# to create a synthetic dataset and split it into training and test datasets
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split

# generate the synthetic dataset
X, y = make_moons(n_samples=10000)

# split the data into training and test datasets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# print the first 10 samples of the training dataset
print("Features:", X_train[:10, :])
print("Targets:", y_train[:10])

Features: [[-0.99958218  0.02890441]
 [ 0.03285169  0.24578719]
 [ 1.13127903 -0.49134546]
 [ 1.86951286  0.00608971]
 [ 0.20190413  0.97940529]
 [ 0.8831311   0.46912627]
 [-0.10819442  0.99412975]
 [-0.20005727  0.97978421]
 [-0.78775705  0.61598607]
 [ 1.82453236 -0.0658148 ]]
Targets: [0 1 1 1 0 0 0 0 0 1]

Paso 2. Guarda los conjuntos de datos de entrenamiento y prueba etiquetados en tu disco local y luego súbelos al directorio de datos compartido.

def make_tarfile(file_path, tar_file_name):
    with tarfile.open(tar_file_name, "w") as tar:
        tar.add(file_path, arcname=os.path.basename(file_path))

# save the training and test datasets on your local disk
np.save("X_train.npy", X_train)
np.save("y_train.npy", y_train)
np.save("X_test.npy", X_test)
np.save("y_test.npy", y_test)

# create tar files for the datasets
make_tarfile("X_train.npy", "X_train.npy.tar")
make_tarfile("y_train.npy", "y_train.npy.tar")
make_tarfile("X_test.npy", "X_test.npy.tar")
make_tarfile("y_test.npy", "y_test.npy.tar")

# upload the datasets to the shared data directory
catalog.file_upload("X_train.npy.tar", singularity)
catalog.file_upload("y_train.npy.tar", singularity)
catalog.file_upload("X_test.npy.tar", singularity)
catalog.file_upload("y_test.npy.tar", singularity)

# view/enlist the uploaded files in the shared data directory
print(catalog.files(singularity))

['X_test.npy.tar', 'X_train.npy.tar', 'y_test.npy.tar', 'y_train.npy.tar']

Paso 3. Crea un clasificador mejorado cuánticamente usando la acción create.

job = singularity.run(
    action="create",
    name="my_classifier",
    num_learners=10,
    learners_types=[
        "DecisionTreeClassifier",
        "KNeighborsClassifier",
    ],
    learners_proportions=[0.5, 0.5],
    learners_options=[{}, {}],
    regularization=0.01,
    weight_update_method="logarithmic",
    sample_scaling=True,
    optimizer_options={"simulator": True},
    voting="soft",
    prob_threshold=0.5,
)

print(job.result())

{'status': 'ok', 'message': 'Classifier created.', 'data': {}, 'metadata': {'resource_usage': {}}}

# list available classifiers using the list action
job = singularity.run(action="list")

print(job.result())

# you can also find your classifiers in the shared data directory with a *.pkl.tar extension
print(catalog.files(singularity))

{'status': 'ok', 'message': 'Classifiers listed.', 'data': {'classifiers': ['my_classifier']}, 'metadata': {'resource_usage': {}}}
['X_test.npy.tar', 'X_train.npy.tar', 'y_test.npy.tar', 'y_train.npy.tar', 'my_classifier.pkl.tar']

Paso 4. Entrena el clasificador mejorado cuánticamente usando la acción fit.

job = singularity.run(
    action="fit",
    name="my_classifier",
    X="X_train.npy",  # you do not need to specify the tar extension
    y="y_train.npy",  # you do not need to specify the tar extension
)

print(job.result())

{'status': 'ok', 'message': 'Classifier fitted.', 'data': {}, 'metadata': {'resource_usage': {'RUNNING: MAPPING': {'CPU_TIME': 8.45469617843628}, 'RUNNING: WAITING_QPU': {'CPU_TIME': 69.4949426651001}, 'RUNNING: POST_PROCESSING': {'CPU_TIME': 73.01881957054138}, 'RUNNING: EXECUTING_QPU': {'QPU_TIME': 75.4787163734436}}}}

Paso 5. Obtén predicciones y probabilidades del clasificador mejorado cuánticamente usando la acción predict.

job = singularity.run(
    action="predict",
    name="my_classifier",
    X="X_test.npy",  # you do not need to specify the tar extension
)

result = job.result()

print("Action result status: ", result["status"])
print("Action result message: ", result["message"])
print("Predictions (first five results):", result["data"]["predictions"][:5])
print(
    "Probabilities (first five results):", result["data"]["probabilities"][:5]
)

Action result status:  ok
Action result message:  Classifier predicted.
Predictions (first five results): [0, 1, 0, 0, 1]
Probabilities (first five results): [[1.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 0.0], [0.0, 1.0]]

Paso 6. Elimina el clasificador mejorado cuánticamente usando la acción delete.

job = singularity.run(
    action="delete",
    name="my_classifier",
)

# or you can delete from the shared data directory
# catalog.file_delete("my_classifier.pkl.tar", singularity)

print(job.result())

{'status': 'ok', 'message': 'Classifier deleted.', 'data': {}, 'metadata': {'resource_usage': {}}}

Paso 7. Limpia los directorios de datos locales y compartidos.

# delete the numpy files from your local disk
os.remove("X_train.npy")
os.remove("y_train.npy")
os.remove("X_test.npy")
os.remove("y_test.npy")

# delete the tar files from your local disk
os.remove("X_train.npy.tar")
os.remove("y_train.npy.tar")
os.remove("X_test.npy.tar")
os.remove("y_test.npy.tar")

# delete the tar files from the shared data
catalog.file_delete("X_train.npy.tar", singularity)
catalog.file_delete("y_train.npy.tar", singularity)
catalog.file_delete("X_test.npy.tar", singularity)
catalog.file_delete("y_test.npy.tar", singularity)

Benchmarks

Estos benchmarks muestran que el clasificador puede lograr precisiones extremadamente altas en problemas desafiantes. También muestran que aumentar el número de aprendices en el ensemble (número de qubits) puede llevar a una mayor precisión.

"Precisión clásica" se refiere a la precisión obtenida usando el estado del arte clásico correspondiente que, en este caso, es un clasificador AdaBoost basado en un ensemble de tamaño 75. "Precisión cuántica", por otro lado, se refiere a la precisión obtenida usando "Singularity Machine Learning - Clasificación".

Problema	Tamaño del conjunto de datos	Tamaño del ensemble	Número de qubits	Precisión clásica	Precisión cuántica	Mejora
Estabilidad de la red	5000 ejemplos, 12 características	55	55	76%	91%	15%
Estabilidad de la red	5000 ejemplos, 12 características	65	65	76%	92%	16%
Estabilidad de la red	5000 ejemplos, 12 características	75	75	76%	94%	18%
Estabilidad de la red	5000 ejemplos, 12 características	85	85	76%	94%	18%
Estabilidad de la red	5000 ejemplos, 12 características	100	100	76%	95%	19%

---

A medida que el hardware cuántico evoluciona y escala, las implicaciones para nuestro clasificador cuántico se vuelven cada vez más significativas. Si bien el número de qubits impone limitaciones en el tamaño del ensemble que se puede utilizar, no restringe el volumen de datos que se puede procesar. Esta poderosa capacidad permite al clasificador manejar eficientemente conjuntos de datos que contienen millones de puntos de datos y miles de características. Es importante destacar que las restricciones relacionadas con el tamaño del ensemble pueden abordarse mediante la implementación de una versión a gran escala del clasificador. Al aprovechar un enfoque de bucle externo iterativo, el ensemble puede expandirse dinámicamente, mejorando la flexibilidad y el rendimiento general. Sin embargo, cabe señalar que esta característica aún no está implementada en la versión actual del clasificador.

Historial de cambios

4 de junio de 2025

• QuantumEnhancedEnsembleClassifier actualizado con los siguientes cambios:
  • Se añadió regularización onsite/alpha. Puedes especificar regularization_type como onsite o alpha
  • Se añadió la regularización automática. Puedes establecer regularization en auto para usar la regularización automática
  • Se añadió el parámetro optimization_data al método fit para elegir los datos de optimización para la optimización cuántica. Puedes usar una de estas opciones: train, validation o both
  • Rendimiento general mejorado
• Se añadió seguimiento detallado del estado para los trabajos en ejecución

20 de mayo de 2025

• Manejo de errores estandarizado

18 de marzo de 2025

• qiskit-serverless actualizado a 0.20.0 e imagen base a 0.20.1

14 de febrero de 2025

• Imagen base actualizada a 0.19.1

6 de febrero de 2025

• qiskit-serverless actualizado a 0.19.0 e imagen base a 0.19.0

13 de noviembre de 2024

• Lanzamiento de Singularity Machine Learning - Clasificación

Obtener soporte

Para cualquier pregunta, contacta con Multiverse Computing.

Asegúrate de incluir la siguiente información:

• El ID del trabajo de la Qiskit Function (job.job_id)
• Una descripción detallada del problema
• Cualquier mensaje o código de error relevante
• Los pasos para reproducir el problema

Próximos pasos

Recomendaciones

• Solicita acceso a la función de Clasificación de Singularity Machine Learning de Multiverse Computing.
• Consulta Leclerc, L., et al. (2023). Financial risk management on a neutral atom quantum processor. Physical Review Research, 5, 043117.