Singularity Machine Learning - Classification : une Qiskit Function par Multiverse Computing

Consulte la référence API

Package versions

The code on this page was developed using the following requirements. We recommend using these versions or newer.

scikit-learn~=1.8.0

Note

• Les Qiskit Functions sont une fonctionnalité expérimentale disponible uniquement pour les utilisateurs des plans IBM Quantum® Premium, Flex et On-Prem (via l'API IBM Quantum Platform). Elles sont en version préliminaire et susceptibles d'évoluer.

Vue d'ensemble

Avec la fonction « Singularity Machine Learning - Classification », tu peux résoudre des problèmes réels d'apprentissage automatique sur du matériel quantique sans avoir besoin d'expertise quantique. Cette fonction applicative, basée sur des méthodes ensemblistes, est un classificateur hybride. Elle exploite des méthodes classiques comme le boosting, le bagging et le stacking pour l'entraînement initial de l'ensemble. Ensuite, des algorithmes quantiques tels que le solveur variationnel quantique des valeurs propres (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 entraîné.

Contrairement à d'autres solutions de machine learning quantique, cette fonction est capable de gérer des jeux de données à grande échelle contenant des millions d'exemples et de caractéristiques, sans être limitée par le nombre de qubits du QPU cible. Le nombre de qubits détermine uniquement la taille de l'ensemble qui peut être entraîné. Elle est également très flexible et peut être utilisée pour résoudre des problèmes de classification dans un large éventail de domaines, notamment la finance, la santé et la cybersécurité. Elle atteint systématiquement de hautes précisions sur des problèmes classiquement difficiles impliquant des jeux de données de grande dimension, bruités et déséquilibrés. Elle est conçue pour :

1. Les ingénieurs et les data scientists d'entreprises souhaitant enrichir leurs offres technologiques en intégrant le machine learning quantique dans leurs produits et services,
2. Les chercheurs dans des laboratoires de recherche quantique explorant les applications du machine learning quantique et cherchant à tirer parti de l'informatique quantique pour des tâches de classification, et
3. Les étudiants et les enseignants dans des établissements d'enseignement, dans des cours tels que le machine learning, qui souhaitent démontrer les avantages de l'informatique quantique.

L'exemple suivant illustre ses différentes fonctionnalités, notamment create, list, fit et predict, et en démontre l'utilisation sur un problème synthétique composé de deux demi-cercles entrelacés, un problème notoirement difficile en raison de sa frontière de décision non linéaire.

Description de la fonction

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

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

1. Prétraite le jeu de données et divise-le en ensembles d'entraînement et de test. Optionnellement, tu peux subdiviser l'ensemble d'entraînement en ensembles d'entraînement et de validation. Cela peut être réalisé à l'aide de scikit-learn.
2. Si l'ensemble d'entraînement est déséquilibré, tu peux le rééchantillonner pour équilibrer les classes à l'aide de imbalanced-learn.
3. Téléverse les ensembles d'entraînement, 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 passant le chemin pertinent à chaque fois.
4. Initialise 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. Entraîne le classificateur quantique sur l'ensemble d'entraînement en utilisant l'action fit de la fonction, en lui passant l'ensemble d'entraînement étiqueté et l'ensemble de validation le cas échéant.
6. Effectue des prédictions sur le jeu de test inédit à l'aide de l'action predict de la fonction.

---

Premiers pas

Authentifie-toi avec ta clé API IBM Quantum Platform et sélectionne la Qiskit Function comme suit :

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

from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

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

Exemples

Classer un jeu de données

Dans cet exemple, tu vas utiliser la fonction « Singularity Machine Learning - Classification » pour classifier un jeu de données composé de deux demi-cercles entrelacés en forme de lune. Le jeu de données est synthétique, bidimensionnel et étiqueté avec des étiquettes binaires. Il est conçu pour être difficile à traiter par des algorithmes tels que le clustering centroïde et la classification linéaire. À travers ce processus, tu apprendras à créer le classificateur, à l'ajuster aux données d'entraînement, à l'utiliser pour prédire sur les données de test et à supprimer le classificateur une fois terminé. Avant de commencer, tu dois installer scikit-learn. Installe-le avec la commande suivante :

python3 -m pip install scikit-learn

Effectue les étapes suivantes :

1. Crée le jeu de données synthétique en utilisant la fonction make_moons de scikit-learn.
2. Téléverse le jeu de données synthétique généré vers le répertoire de données partagé.
3. Crée le classificateur amélioré quantiquement en utilisant l'action create.
4. Liste tes classificateurs en utilisant l'action list.
5. Entraîne le classificateur sur les données d'entraînement en utilisant l'action fit.
6. Utilise le classificateur entraîné pour prédire sur les données de test en utilisant l'action predict.
7. Supprime le classificateur en utilisant l'action delete.
8. Nettoie une fois que tu as terminé. Étape 1. Importe les modules nécessaires et génère le jeu de données synthétique, puis divise-le en ensembles d'entraînement 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])

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. Sauvegarde les jeux de données d'entraînement et de test étiquetés sur ton disque local, puis téléverse-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))

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

Étape 3. Crée un classificateur amélioré quantiquement en utilisant l'action 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', 'my_classifier.pkl.tar', 'y_test.npy.tar', 'y_train.npy.tar']

Étape 4. Entraîne le classificateur amélioré quantiquement en utilisant l'action 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': 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. Obtiens des prédictions et des probabilités du classificateur amélioré quantiquement en utilisant l'action 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, 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. Supprime le classificateur amélioré quantiquement en utilisant l'action 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': {}}}

Étape 7. Nettoie 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)

'Requested file was deleted.'

Exemple create_fit_predict

L'exemple suivant illustre l'action create_fit_predict.

# 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):  [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}}

Benchmarks

Ces benchmarks montrent que le classificateur peut atteindre des précisions extrêmement élevées sur des problèmes difficiles. Ils montrent également qu'augmenter le nombre d'apprenants dans l'ensemble (nombre de qubits) peut conduire à une précision accrue.

La « précision classique » désigne la précision obtenue avec l'état de l'art classique correspondant, qui est ici un classificateur AdaBoost basé sur un ensemble de taille 75. La « précision quantique », quant à elle, désigne la précision obtenue avec « Singularity Machine Learning - Classification ».

Problème	Taille du jeu de données	Taille de l'ensemble	Nombre de qubits	Précision classique	Précision quantique	Amélioration
Stabilité du réseau	5 000 exemples, 12 caractéristiques	55	55	76 %	91 %	15 %
Stabilité du réseau	5 000 exemples, 12 caractéristiques	65	65	76 %	92 %	16 %
Stabilité du réseau	5 000 exemples, 12 caractéristiques	75	75	76 %	94 %	18 %
Stabilité du réseau	5 000 exemples, 12 caractéristiques	85	85	76 %	94 %	18 %
Stabilité du réseau	5 000 exemples, 12 caractéristiques	100	100	76 %	95 %	19 %

---

À mesure que le matériel quantique évolue et se développe, les implications pour notre classificateur quantique deviennent de plus en plus significatives. Bien que le nombre de qubits impose des limites sur la taille de l'ensemble pouvant être utilisé, il ne restreint pas le volume de données pouvant être traité. Cette puissante capacité permet au classificateur de gérer efficacement des jeux 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 grâce à la mise en œuvre d'une version à grande échelle du classificateur. En exploitant une approche de boucle externe itérative, l'ensemble peut être étendu dynamiquement, améliorant ainsi la flexibilité et les performances globales. Cependant, il convient de noter que cette fonctionnalité n'a pas encore été implémentée dans la version actuelle du classificateur.

Journal des modifications

4 juin 2025

• Mise à niveau du QuantumEnhancedEnsembleClassifier avec les modifications suivantes :
  • Ajout de la régularisation onsite/alpha. Tu peux spécifier regularization_type sur onsite ou alpha
  • Ajout de la régularisation automatique. Tu peux définir regularization sur auto pour utiliser la régularisation automatique
  • Ajout du paramètre optimization_data à la méthode fit pour choisir les données d'optimisation pour l'optimisation quantique. Tu peux 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 tâches en cours

20 mai 2025

• Standardisation de la gestion des erreurs

18 mars 2025

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

14 février 2025

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

6 février 2025

• Mise à niveau 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 du support

Pour toute question, contacte Multiverse Computing.

Assure-toi d'inclure les informations suivantes :

• L'identifiant de la tâche Qiskit Function (job.job_id)
• Une description détaillée du problème
• Tous les messages d'erreur ou codes pertinents
• Les étapes pour reproduire le problème

Prochaines étapes

Recommandations

• Demande l'accès à la fonction Singularity Machine Learning Classification de Multiverse Computing.
• Consulte la référence API pour cette Qiskit Function.
• Consulte Leclerc, L., et al. (2023). Financial risk management on a neutral atom quantum processor. Physical Review Research, 5, 043117.