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

Consulte la referencia de la API

• Versiones del paquete

  El código de esta página se ha desarrollado teniendo en cuenta los siguientes requisitos. Recomendamos utilizar estas versiones o posteriores.

  scikit-learn~=1.8.0
  

Visión general

Con la función "Singularity Machine Learning - Clasificación", puede resolver problemas de aprendizaje automático del mundo real en hardware cuántico sin necesidad de conocimientos cuánticos. 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 de conjuntos. Posteriormente, se emplean algoritmos cuánticos como el eigensolver cuántico variacional (VQE) y el algoritmo de optimización aproximada cuántica (QAOA) para mejorar la diversidad, la capacidad de generalización y la complejidad general del conjunto 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 de la QPU de destino. El número de qubits sólo determina el tamaño del conjunto que se puede entrenar. También es muy flexible y puede utilizarse para resolver problemas de clasificación en una amplia gama de ámbitos, incluidos las finanzas, la sanidad y la ciberseguridad.

Consigue sistemáticamente altas precisiones en problemas clásicos que implican conjuntos de datos de alta dimensión, ruidosos y desequilibrados.

Está construido para:

1. Ingenieros y científicos de datos de empresas que buscan mejorar su oferta tecnológica integrando el aprendizaje automático cuántico en sus productos y servicios,
2. Investigadores de 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 profesores de instituciones educativas en cursos como aprendizaje automático, y 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 que comprende dos medios círculos intercalados, un problema notoriamente desafiante debido a su límite de decisión no lineal.

Descripción de la función

Esta función de Qiskit permite a los usuarios resolver problemas de clasificación binaria utilizando el clasificador conjunto mejorado cuánticamente de Singularity. Entre bastidores, utiliza un enfoque híbrido para entrenar de forma clásica un conjunto de clasificadores en el conjunto de datos etiquetados y, a continuación, optimizarlo para obtener la máxima diversidad y generalización mediante el algoritmo de optimización aproximada cuántica (QAOA) en las QPU de IBM®. A través de una interfaz fácil de usar, los usuarios pueden configurar un clasificador según sus requisitos, entrenarlo en el conjunto de datos de su elección y utilizarlo para hacer predicciones en un conjunto de datos no visto previamente.

Resolver un problema genérico de clasificación:

1. Preprocese el conjunto de datos y divídalo en conjuntos de entrenamiento y de prueba. Opcionalmente, puede dividir el conjunto de entrenamiento en conjuntos de entrenamiento y validación. Esto puede lograrse utilizando scikit-learn.
2. Si el conjunto de entrenamiento está desequilibrado, puede volver a muestrearlo para equilibrar las clases utilizando imbalanced-learn.
3. Cargue los conjuntos de entrenamiento, validación y prueba por separado en el almacenamiento de la función utilizando el método file_upload del catálogo, pasándole cada vez la ruta correspondiente.
4. Inicialice el clasificador cuántico utilizando la acción de la función create , que acepta hiperparámetros como el número y tipos de aprendices, la regularización (valor lambda), y opciones de optimización incluyendo el número de capas, el tipo de optimizador clásico, el backend cuántico, etc.
5. Entrene el clasificador cuántico en el conjunto de entrenamiento utilizando la acción fit de la función, pasándole el conjunto de entrenamiento etiquetado y el conjunto de validación si procede.
6. Realiza predicciones sobre el conjunto de pruebas no visto previamente utilizando la acción predict de la función.

Cómo empezar

Autentícate utilizando tu clave API de IBM Quantum Platform, y selecciona la Función Qiskit como se indica a continuación:

from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

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

Ejemplos

Clasificar un conjunto de datos

En este ejemplo, utilizará la función "Singularidad Machine Learning - Clasificación" para clasificar un conjunto de datos formado por dos semicírculos intercalados con forma de luna. El conjunto de datos es sintético, bidimensional y con etiquetas binarias. Está creado para ser un reto 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, utilizarlo para predecir en los datos de prueba y eliminar el clasificador cuando hayas terminado.

Antes de empezar, es necesario instalar scikit-learn. Instálelo utilizando el siguiente comando:

python3 -m pip install scikit-learn

Siga los pasos siguientes:

1. Crea el conjunto de datos sintéticos utilizando la make_moons función de scikit-learn.
2. Sube el conjunto de datos sintéticos generado al directorio de datos compartido.
3. Crea el clasificador mejorado cuánticamente utilizando la create acción.
4. Incorpora tus clasificadores mediante la list acción.
5. Entrena el clasificador con los datos de entrenamiento utilizando la fit acción.
6. Utiliza el clasificador entrenado para realizar predicciones sobre los datos de prueba mediante la predict acción.
7. Elimina el clasificador mediante la delete acción.
8. Limpia cuando termines.

Paso 1. Importe los módulos necesarios y genere el conjunto de datos sintéticos; a continuación, divídalo en conjuntos de datos de entrenamiento y de 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])

Output:

Features: [[ 0.84757037 -0.48831433]
 [ 0.98132552  0.19235443]
 [-0.71626723  0.6978261 ]
 [ 1.18957848 -0.48186557]
 [ 0.52118982 -0.37791846]
 [ 0.81115408  0.58483251]
 [ 0.48706462  0.87336593]
 [-0.81880144  0.57407682]
 [ 1.67335408 -0.23932015]
 [ 0.50181306  0.8649761 ]]
Targets: [1 0 0 1 1 0 0 0 1 0]

Paso 2. Guarda los conjuntos de datos de entrenamiento y de prueba etiquetados en tu disco local y, a continuación, 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))

Output:

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

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

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())

Output:

{'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))

Output:

{'status': 'ok', 'message': 'Classifiers listed.', 'data': {'classifiers': ['my_classifier']}, 'metadata': {'resource_usage': {}}}

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

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

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())

Output:

{'status': 'ok', 'message': 'Classifier fitted.', 'data': {}, 'metadata': {'resource_usage': {'RUNNING: MAPPING': {'CPU_TIME': 13.655871629714966}, 'RUNNING: WAITING_QPU': {'CPU_TIME': 54.688621282577515}, 'RUNNING: POST_PROCESSING': {'CPU_TIME': 56.92286920547485}, 'RUNNING: EXECUTING_QPU': {'QPU_TIME': 57.92738223075867}}}}

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

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]
)

Output:

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

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

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())

Output:

{'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)

Output:

'Requested file was deleted.'

Ejemplo de create_fit_predict

El siguiente ejemplo muestra cómo funciona la create_fit_predict acción.

# 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"])

Output:

Job status:  QUEUED
Action result status:  ok
Action result message:  Classifier created, fitted, and predicted.
Predictions (first five results):  [0, 0, 1, 0, 0]
Probabilities (first five results):  [[0.87119766531518, 0.1288023346848197], [0.87119766531518, 0.1288023346848197], [0.24470328446479797, 0.7552967155352032], [0.820524432250189, 0.17947556774981072], [0.6847610293419495, 0.31523897065805173]]
Usage metadata:  {'RUNNING: MAPPING': {'CPU_TIME': 10.967791318893433}, 'RUNNING: WAITING_QPU': {'CPU_TIME': 59.91712307929993}, 'RUNNING: POST_PROCESSING': {'CPU_TIME': 59.097386837005615}, 'RUNNING: EXECUTING_QPU': {'QPU_TIME': 56.93338203430176}}

Referencias comparativas

Estas pruebas demuestran que el clasificador puede alcanzar precisiones extremadamente altas en problemas difíciles. También muestran que aumentar el número de aprendices en el conjunto (número de qubits) puede conducir a una mayor precisión.

"Precisión clásica" se refiere a la precisión obtenida utilizando el correspondiente estado clásico de la técnica que, en este caso, es un clasificador AdaBoost basado en un conjunto de tamaño 75. "Precisión cuántica", por su parte, se refiere a la precisión obtenida utilizando la "Singularidad Machine Learning - Clasificación".

A medida que el hardware cuántico evoluciona y se amplía, las implicaciones para nuestro clasificador cuántico son cada vez más significativas. Aunque el número de qubits impone limitaciones al tamaño del conjunto que puede utilizarse, no restringe el volumen de datos que pueden procesarse. Esta potente capacidad permite al clasificador manejar con eficacia conjuntos de datos que contienen millones de puntos de datos y miles de características. Es importante destacar que las limitaciones relacionadas con el tamaño del conjunto pueden abordarse mediante la aplicación de una versión a gran escala del clasificador. Al aprovechar un enfoque iterativo de bucle externo, el conjunto puede ampliarse dinámicamente, lo que mejora la flexibilidad y el rendimiento general. Sin embargo, cabe señalar que esta función aún no se ha implementado en la versión actual del clasificador.

Registro de cambios

4 de junio de 2025

• Actualizado QuantumEnhancedEnsembleClassifier con las siguientes actualizaciones:
  • Añadida regularización in situ/alfa. Puede especificar que regularization_type sea onsite o alpha
  • Añadida la autorregularización. Puede configurar regularization en auto para utilizar la autorregularización
  • Añadido el parámetro optimization_data al método fit para elegir los datos de optimización para la optimización cuántica. Puede utilizar una de estas opciones: train, validation, o both
  • Mejora del rendimiento general
• Se ha añadido un seguimiento detallado del estado de los trabajos en ejecución

20 de mayo de 2025

• Gestión de errores estandarizada

18 de marzo de 2025

• Actualizado qiskit-serverless a 0.20.0 y la imagen base a 0.20.1

14 de febrero de 2025

• Imagen base actualizada a 0.19.1

6 de febrero de 2025

• Actualizado qiskit-serverless a 0.19.0 y la imagen base a 0.19.0

13 de noviembre de 2024

• Publicación de Singularity Machine Learning - Clasificación

Obtener soporte

Si tiene alguna pregunta, póngase en contacto con Multiverse Computing.

Asegúrese de incluir la siguiente información:

• La función Qiskit ID del puesto (job.job_id)
• Descripción detallada del problema
• Cualquier mensaje o código de error relevante
• Pasos para reproducir el problema

Próximos pasos