Machine Learning de singularité - Classification : une fonction Qiskit par Multiverse Computing

Consultez la documentation de l'API

• Versions de package

  Le code présenté sur cette page a été développé en respectant les exigences suivantes. Nous vous recommandons d'utiliser ces versions ou des versions plus récentes.

  scikit-learn~=1.8.0
  

Aperçu

Avec la fonction "Singularity Machine Learning - Classification", vous pouvez résoudre des problèmes d'apprentissage automatique du monde réel sur du matériel quantique sans avoir besoin d'une expertise quantique. Cette fonction d'application, basée sur des méthodes d'ensemble, est un classificateur hybride. Il s'appuie sur des méthodes classiques telles que le boosting, le bagging et l'empilage pour la formation initiale de l'ensemble. Ensuite, des algorithmes quantiques tels que le résolveur quantique variationnel (VQE) et l'algorithme d'optimisation approximative quantique (QAOA) sont utilisés pour améliorer la diversité, les capacités de généralisation et la complexité globale de l'ensemble formé.

Contrairement à d'autres solutions d'apprentissage automatique quantique, cette fonction est capable de traiter des ensembles de données à grande échelle avec des millions d'exemples et de caractéristiques sans être limitée par le nombre de qubits dans la QPU cible. Le nombre de qubits ne détermine que la taille de l'ensemble qui peut être formé. Il est également très flexible et peut être utilisé pour résoudre des problèmes de classification dans un large éventail de domaines, y compris la finance, les soins de santé et la cybersécurité.

Il obtient régulièrement des taux de précision élevés sur des problèmes classiques difficiles impliquant des ensembles de données de haute dimension, bruyants et déséquilibrés.

Il est conçu pour :

1. Ingénieurs et scientifiques des données au sein d'entreprises cherchant à améliorer leurs offres technologiques en intégrant l'apprentissage automatique quantique dans leurs produits et services,
2. Les chercheurs des laboratoires de recherche quantique qui explorent les applications de l'apprentissage automatique quantique et cherchent à tirer parti de l'informatique quantique pour les tâches de classification, et
3. Les étudiants et les enseignants des établissements d'enseignement qui suivent des cours tels que l'apprentissage automatique et qui cherchent à démontrer les avantages de l'informatique quantique.

L'exemple suivant présente ses différentes fonctionnalités, notamment create, list, fit, et predict, et démontre son utilisation dans un problème synthétique comprenant deux demi-cercles entrelacés, un problème notoirement difficile en raison de sa limite de décision non linéaire.

Description de la fonction

Cette fonction Qiskit permet aux utilisateurs de résoudre des problèmes de classification binaire en utilisant le classificateur d'ensemble amélioré par les quanta de Singularity. En coulisses, il utilise une approche hybride pour former classiquement un ensemble de classificateurs sur l'ensemble de données étiquetées, puis l'optimiser pour une diversité et une généralisation maximales à l'aide de l'algorithme d'optimisation approximative quantique (QAOA) sur IBM® QPU. Grâce à une interface conviviale, les utilisateurs peuvent configurer un classificateur en fonction de leurs besoins, l'entraîner sur l'ensemble de données de leur choix et l'utiliser pour faire des prédictions sur un ensemble de données inédit.

Résoudre un problème de classification générique :

1. Prétraiter l'ensemble de données et le diviser en ensembles de formation et de test. En option, vous pouvez diviser l'ensemble de formation en deux ensembles, l'un de formation et l'autre de validation. Cela peut être réalisé à l'aide de scikit-learn.
2. Si l'ensemble d'apprentissage est déséquilibré, vous pouvez le rééchantillonner pour équilibrer les classes à l'aide de l' apprentissage déséquilibré.
3. Téléchargez les ensembles de formation, de validation et de test séparément dans le stockage de la fonction à l'aide de la méthode file_upload du catalogue, en lui transmettant à chaque fois le chemin d'accès approprié.
4. Initialiser le classificateur quantique en utilisant l'action create de la fonction, qui accepte des hyperparamètres tels que le nombre et les types d'apprenants, la régularisation (valeur lambda) et les options d'optimisation, notamment le nombre de couches, le type d'optimiseur classique, le backend quantique, etc.
5. Former le classificateur quantique sur l'ensemble d'apprentissage à l'aide de l'action fit de la fonction, en lui transmettant l'ensemble d'apprentissage étiqueté et l'ensemble de validation, le cas échéant.
6. Faire des prédictions sur l'ensemble de test non vu précédemment en utilisant l'action de la fonction predict .

Premiers pas

Authentifiez-vous à l'aide de votre clé API IBM Quantum Platform et sélectionnez la fonction Qiskit comme suit :

from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

# Verify that you have access to the function
catalog.list()

Output:

[QiskitFunction(qunova/hivqe-chemistry),
 QiskitFunction(global-data-quantum/quantum-portfolio-optimizer),
 QiskitFunction(algorithmiq/tem),
 QiskitFunction(qedma/qesem),
 QiskitFunction(multiverse/singularity),
 QiskitFunction(ibm/circuit-function),
 QiskitFunction(q-ctrl/optimization-solver),
 QiskitFunction(colibritd/quick-pde),
 QiskitFunction(q-ctrl/performance-management),
 QiskitFunction(kipu-quantum/iskay-quantum-optimizer)]

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

Exemples

Classer un ensemble de données

Dans cet exemple, vous utiliserez la fonction "Singularité Machine Learning - Classification" pour classer un ensemble de données composé de deux demi-cercles en forme de lune qui s'entrecroisent. L'ensemble de données est synthétique, bidimensionnel et étiqueté de manière binaire. Il a été créé pour représenter un défi pour les algorithmes tels que le regroupement basé sur les centroïdes et la classification linéaire.

Au cours de ce processus, vous apprendrez à créer le classificateur, à l'adapter aux données d'apprentissage, à l'utiliser pour prédire sur les données de test et à le supprimer lorsque vous avez terminé.

Avant de commencer, vous devez installer scikit-learn. Installez-le à l'aide de la commande suivante :

python3 -m pip install scikit-learn

Effectuez les opérations suivantes :

1. Créez l'ensemble de données synthétiques à l'aide de la make_moons fonction de scikit-learn.
2. Envoyez l'ensemble de données synthétiques généré vers le répertoire de données partagé.
3. Créez le classificateur amélioré par la mécanique quantique à l'aide de create l'action.
4. Enregistrez vos classificateurs à l'aide de list l'action.
5. Entraînez le classificateur sur les données d'entraînement à l'aide de fit l'action.
6. Utilisez le classificateur entraîné pour effectuer des prédictions sur les données de test à l'aide de predict l'action.
7. Supprimez le classificateur à l'aide de delete l'action.
8. Nettoyez après avoir terminé.

Etape 1. Importez les modules nécessaires et générez l'ensemble de données synthétiques, puis divisez-le en ensembles de données de formation et de test.

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

Étape 2. Enregistrez les ensembles de données d'entraînement et de test étiquetés sur votre disque local, puis téléchargez-les dans le répertoire de données partagé.

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

Étape 3. Créez un classificateur optimisé par l'informatique quantique à l'aide de create l'action.

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

Étape 4 : Entraînez le classificateur amélioré par la mécanique quantique à l'aide de fit l'action.

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}}}}

Étape 5. Obtenez les prédictions et les probabilités du classificateur amélioré par la mécanique quantique à l'aide de predict l'action.

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

Étape 6. Supprimez le classificateur quantique à l'aide de delete l'action.

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': {}}}

Etape 7. Nettoyer les répertoires de données locaux et partagés.

# 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.'

create_fit_predictexemple

L'exemple suivant illustre cette create_fit_predict action.

# 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}}

Tests de performances

Ces tests de référence montrent que le classificateur peut atteindre des niveaux de précision extrêmement élevés sur des problèmes difficiles. Ils montrent également que l'augmentation du nombre d'apprenants dans l'ensemble (nombre de qubits) peut conduire à une plus grande précision.

par "précision classique", on entend la précision obtenue en utilisant l'état de l'art classique correspondant qui, dans le cas présent, est un classificateur AdaBoost basé sur un ensemble de taille 75. la "précision quantique", quant à elle, fait référence à la précision obtenue en utilisant la "Singularité Machine Learning - Classification".

Au fur et à mesure que le matériel quantique évolue et s'étend, les implications pour notre classificateur quantique deviennent de plus en plus significatives. Si le nombre de qubits impose des limites à la taille de l'ensemble qui peut être utilisé, il ne limite pas le volume de données qui peut être traité. Cette puissante capacité permet au classificateur de traiter efficacement des ensembles de données contenant des millions de points de données et des milliers de caractéristiques. Il est important de noter que les contraintes liées à la taille de l'ensemble peuvent être résolues par la mise en œuvre d'une version à grande échelle du classificateur. En tirant parti d'une approche itérative en boucle extérieure, l'ensemble peut être étendu de manière dynamique, ce qui améliore la flexibilité et les performances globales. Il convient toutefois de noter que cette fonctionnalité n'a pas encore été mise en œuvre dans la version actuelle du classificateur.

Journal des modifications

4 juin 2025

• Mise à jour de QuantumEnhancedEnsembleClassifier avec les mises à jour suivantes :
  • Ajout d'une régularisation sur site/alpha. Vous pouvez spécifier que regularization_type est onsite ou alpha
  • Ajout de l'auto-régularisation. Vous pouvez définir regularization sur auto pour utiliser l'auto-régularisation
  • Ajout du paramètre optimization_data à la méthode fit pour choisir les données d'optimisation pour l'optimisation quantique. Vous pouvez utiliser l'une des options suivantes : train, validation, ou both
  • Amélioration des performances globales
• Ajout d'un suivi détaillé de l'état des travaux en cours

20 mai 2025

• Gestion normalisée des erreurs

18 mars 2025

• Mise à jour de qiskit-serverless vers 0.20.0 et de l'image de base vers 0.20.1

14 février 2025

• Mise à jour de l'image de base vers 0.19.1

6 février 2025

• Mise à jour de qiskit-serverless vers 0.19.0 et de l'image de base vers 0.19.0

13 novembre 2024

• Publication de Singularity Machine Learning - Classification

Obtenir de l'aide

Pour toute question, contactez Multiverse Computing.

Veillez à inclure les informations suivantes :

• La fonction Qiskit Job ID (job.job_id)
• Une description détaillée du problème
• Tout message ou code d'erreur pertinent
• Etapes de reproduction du problème

Etapes suivantes