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

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. Comment ça fonctionne Elle est conçue pour :

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,
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
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 :

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.
Si l'ensemble d'entraînement est déséquilibré, tu peux le rééchantillonner pour équilibrer les classes à l'aide de imbalanced-learn.
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.
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.
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.
Effectue des prédictions sur le jeu de test inédit à l'aide de l'action predict de la fonction.

Approche par actions

La fonction utilise une approche par actions. Tu peux la concevoir comme un environnement virtuel dans lequel tu utilises des actions pour effectuer des tâches ou modifier son état. Actuellement, elle propose les actions suivantes : list, create, delete, fit, predict, fit_predict et create_fit_predict. L'exemple suivant illustre l'action 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

L'action list récupère tous les classificateurs stockés au format *.pkl.tar depuis le répertoire de données partagé. Tu peux également accéder au contenu de ce répertoire en utilisant la méthode catalog.files(). En général, l'action list recherche les fichiers avec l'extension *.pkl.tar dans le répertoire de données partagé et les renvoie sous forme de liste.

Entrées

Nom	Type	Description	Requis
`action`	`str`	Le nom de l'action parmi `create`, `list`, `fit`, `predict`, `fit_predict`, `create_fit_predict` et `delete`.	Oui

Utilisation

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

2. Create

L'action create crée un classificateur du type quantum_classifier spécifié en utilisant les paramètres fournis, et le sauvegarde dans le répertoire de données partagé.

remarque

La fonction ne supporte actuellement que le QuantumEnhancedEnsembleClassifier.

Entrées

Nom	Type	Description	Requis	Défaut
`action`	`str`	Le nom de l'action parmi `create`, `list`, `fit`, `predict`, `fit_predict`, `create_fit_predict` et `delete`.	Oui	-
`name`	`str`	Le nom du classificateur quantique, par ex. `spam_classifier`.	Oui	-
`instance`	`str`	Instance IBM.	Oui	-
`backend_name`	`str`	Ressource de calcul IBM. Par défaut `None`, ce qui signifie que le backend avec le moins de tâches en attente sera utilisé.	Non	`None`
`quantum_classifier`	`str`	Le type du classificateur quantique, c'est-à-dire `QuantumEnhancedEnsembleClassifier`.	Non	`QuantumEnhancedEnsembleClassifier`
`num_learners`	`integer`	Le nombre d'apprenants dans l'ensemble.	Non	`10`
`learners_types`	`list`	Types d'apprenants. Parmi les types supportés : `DecisionTreeClassifier`, `GaussianNB`, `KNeighborsClassifier`, `MLPClassifier` et `LogisticRegression`. Plus de détails sur chacun sont disponibles dans la documentation scikit-learn.	Non	`[DecisionTreeClassifier]`
`learners_proportions`	`list`	Proportions de chaque type d'apprenant dans l'ensemble.	Non	`[1.0]`
`learners_options`	`list`	Options pour chaque type d'apprenant dans l'ensemble. Pour une liste complète des options correspondant aux types d'apprenants choisis, consulte la documentation scikit-learn.	Non	`[{"max_depth": 3, "splitter": "random", "class_weight": None}]`
`regularization_type`	`str` ou `list`	Type(s) de régularisation à utiliser : `onsite` ou `alpha`. `onsite` contrôle le terme onsite où des valeurs plus élevées conduisent à des ensembles plus creux. `alpha` contrôle le compromis entre les termes d'interaction et onsite où des valeurs plus basses conduisent à des ensembles plus creux. Si une liste est fournie, des modèles seront entraînés pour chaque type et le meilleur sera sélectionné.	Non	`onsite`
`regularization`	`str` ou `float` ou `list`	Valeur de régularisation. Comprise entre `0` et `+inf` si `regularization_type` est `onsite`. Comprise entre `0` et `1` si `regularization_type` est `alpha`. Si défini à `auto`, la régularisation automatique est utilisée — le paramètre de régularisation optimal est trouvé par recherche binaire avec le ratio désiré de classificateurs sélectionnés par rapport au total (`regularization_desired_ratio`) et la borne supérieure du paramètre de régularisation (`regularization_upper_bound`). Si une liste est fournie, des modèles seront entraînés pour chaque valeur et le meilleur sera sélectionné.	Non	`0.01`
`regularization_desired_ratio`	`float` ou `list`	Ratio(s) désiré(s) de classificateurs sélectionnés par rapport au total pour la régularisation automatique. Si une liste est fournie, des modèles seront entraînés pour chaque ratio et le meilleur sera sélectionné.	Non	`0.75`
`regularization_upper_bound`	`float` ou `list`	Borne(s) supérieure(s) du paramètre de régularisation lors de l'utilisation de la régularisation automatique. Si une liste est fournie, des modèles seront entraînés pour chaque borne supérieure et le meilleur sera sélectionné.	Non	`200`
`weight_update_method`	`str`	Méthode de mise à jour des poids des échantillons parmi `logarithmic` et `quadratic`.	Non	`logarithmic`
`sample_scaling`	`boolean`	Indique si la mise à l'échelle des échantillons doit être appliquée.	Non	`False`
`prediction_scaling`	`float`	Facteur de mise à l'échelle pour les prédictions.	Non	`None`
`optimizer_options`	`dictionary`	Options de l'optimiseur QAOA. Une liste des options disponibles est présentée plus loin dans cette documentation.	Non	...
`voting`	`str`	Utilise le vote majoritaire (`hard`) ou la moyenne des probabilités (`soft`) pour agréger les prédictions/probabilités des apprenants.	Non	`hard`
`prob_threshold`	`float`	Seuil de probabilité optimal.	Non	`0.5`
`random_state`	`integer`	Contrôle l'aléatoire pour la reproductibilité.	Non	`None`

De plus, les optimizer_options sont listées comme suit :

Nom	Type	Description	Requis	Défaut
`num_solutions`	`integer`	Le nombre de solutions	Non	`1024`
`reps`	`integer`	Le nombre de répétitions	Non	`4`
`sparsify`	`float`	Le seuil de sparsification	Non	`0.001`
`theta`	`float`	La valeur initiale de theta, un paramètre variationnel du QAOA	Non	`None`
`simulator`	`boolean`	Indique s'il faut utiliser un simulateur ou un QPU	Non	`False`
`classical_optimizer`	`str`	Nom de l'optimiseur classique pour le QAOA. Tous les solveurs proposés par SciPy, listés ici, sont utilisables. Tu devras configurer `classical_optimizer_options` en conséquence	Non	`COBYLA`
`classical_optimizer_options`	`dictionary`	Options de l'optimiseur classique. Pour une liste complète des options disponibles, consulte la documentation SciPy	Non	`{"maxiter": 60}`
`optimization_level`	`integer`	La profondeur du circuit QAOA	Non	`3`
`num_transpiler_runs`	`integer`	Nombre d'exécutions du transpileur	Non	`30`
`pass_manager_options`	`dictionary`	Options pour générer le gestionnaire de passes préconfiguré	Non	`{"approximation_degree": 1.0}`
`estimator_options`	`dictionary`	Options de l'Estimator. Pour une liste complète des options disponibles, consulte la documentation Qiskit Runtime Client	Non	`None`
`sampler_options`	`dictionary`	Options du Sampler. Pour une liste complète des options disponibles, consulte la documentation Qiskit Runtime Client	Non	`None`

Les estimator_options par défaut sont :

Nom	Type	Valeur
`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"],}}`

Les sampler_options par défaut sont :

Nom	Type	Valeur
`default_shots`	`integer`	`1024`
`resilience_level`	`integer`	`1`
`twirling`	`dictionary`	`{"enable_gates": True}`
`dynamical_decoupling`	`dictionary`	`{"enable": True}`

Utilisation

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

Validations

name :
- Le nom doit être unique, une chaîne d'au plus 64 caractères.
- Il ne peut contenir que des caractères alphanumériques et des underscores.
- Il doit commencer par une lettre et ne peut pas se terminer par un underscore.
- Aucun classificateur portant le même nom ne doit déjà exister dans le répertoire de données partagé.

3. Delete

L'action delete supprime un classificateur du répertoire de données partagé.

Entrées

Nom	Type	Description	Requis
`action`	`str`	Le nom de l'action. Doit être `delete`.	Oui
`name`	`str`	Le nom du classificateur à supprimer.	Oui

Utilisation

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

Validations

name :
- Le nom doit être unique, une chaîne d'au plus 64 caractères.
- Il ne peut contenir que des caractères alphanumériques et des underscores.
- Il doit commencer par une lettre et ne peut pas se terminer par un underscore.
- Un classificateur portant le même nom doit déjà exister dans le répertoire de données partagé.

4. Fit

L'action fit entraîne un classificateur à l'aide des données d'entraînement fournies.

Entrées

Nom	Type	Description	Requis
`action`	`str`	Le nom de l'action. Doit être `fit`.	Oui
`name`	`str`	Le nom du classificateur à entraîner.	Oui
`X`	`array` ou `list` ou `str`	Les données d'entraînement. Cela peut être un tableau NumPy, une liste ou une chaîne référençant un nom de fichier dans le répertoire de données partagé.	Oui
`y`	`array` ou `list` ou `str`	Les valeurs cibles d'entraînement. Cela peut être un tableau NumPy, une liste ou une chaîne référençant un nom de fichier dans le répertoire de données partagé.	Oui
`fit_params`	`dictionary`	Paramètres supplémentaires à passer à la méthode `fit` du classificateur.	Non

fit_params

Nom	Type	Description	Requis	Défaut
`validation_data`	`tuple`	Les données et étiquettes de validation.	Non	`None`
`pos_label`	`integer` ou `str`	L'étiquette de classe à mapper sur 1.	Non	`None`
`optimization_data`	`str`	Jeu de données sur lequel optimiser l'ensemble. Peut être l'un des suivants : `train`, `validation`, `both`.	Non	`train`

Utilisation

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
)

Validations

name :
- Le nom doit être unique, une chaîne d'au plus 64 caractères.
- Il ne peut contenir que des caractères alphanumériques et des underscores.
- Il doit commencer par une lettre et ne peut pas se terminer par un underscore.
- Un classificateur portant le même nom doit déjà exister dans le répertoire de données partagé.

5. Predict

L'action predict permet d'obtenir des prédictions dures (hard) et douces (soft) (probabilités).

Entrées

Nom	Type	Description	Requis
`action`	`str`	Le nom de l'action. Doit être `predict`.	Oui
`name`	`str`	Le nom du classificateur à utiliser.	Oui
`X`	`array` ou `list` ou `str`	Les données de test. Cela peut être un tableau NumPy, une liste ou une chaîne référençant un nom de fichier dans le répertoire de données partagé.	Oui
`options["out"]`	`str`	Le nom du fichier JSON de sortie pour sauvegarder les prédictions dans le répertoire de données partagé. Si non fourni, les prédictions sont retournées dans le résultat de la tâche.	Non

Utilisation

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",
    },
)

Validations

name :
- Le nom doit être unique, une chaîne d'au plus 64 caractères.
- Il ne peut contenir que des caractères alphanumériques et des underscores.
- Il doit commencer par une lettre et ne peut pas se terminer par un underscore.
- Un classificateur portant le même nom doit déjà exister dans le répertoire de données partagé.
options["out"] :
- Le nom du fichier doit être unique, une chaîne d'au plus 64 caractères.
- Il ne peut contenir que des caractères alphanumériques et des underscores.
- Il doit commencer par une lettre et ne peut pas se terminer par un underscore.
- Il doit avoir l'extension .json.

6. Fit-predict

L'action fit_predict entraîne un classificateur sur les données d'entraînement, puis l'utilise pour obtenir des prédictions dures et douces (probabilités).

Entrées

Nom	Type	Description	Requis
`action`	`str`	Le nom de l'action. Doit être `fit_predict`.	Oui
`name`	`str`	Le nom du classificateur à utiliser.	Oui
`X_train`	`array` ou `list` ou `str`	Les données d'entraînement. Cela peut être un tableau NumPy, une liste ou une chaîne référençant un nom de fichier dans le répertoire de données partagé.	Oui
`y_train`	`array` ou `list` ou `str`	Les valeurs cibles d'entraînement. Cela peut être un tableau NumPy, une liste ou une chaîne référençant un nom de fichier dans le répertoire de données partagé.	Oui
`X_test`	`array` ou `list` ou `str`	Les données de test. Cela peut être un tableau NumPy, une liste ou une chaîne référençant un nom de fichier dans le répertoire de données partagé.	Oui
`fit_params`	`dictionary`	Paramètres supplémentaires à passer à la méthode `fit` du classificateur.	Non
`options["out"]`	`str`	Le nom du fichier JSON de sortie pour sauvegarder les prédictions dans le répertoire de données partagé. Si non fourni, les prédictions sont retournées dans le résultat de la tâche.	Non

Utilisation

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",
    },
)

Validations

name :
- Le nom doit être unique, une chaîne d'au plus 64 caractères.
- Il ne peut contenir que des caractères alphanumériques et des underscores.
- Il doit commencer par une lettre et ne peut pas se terminer par un underscore.
- Un classificateur portant le même nom doit déjà exister dans le répertoire de données partagé.
options["out"] :
- Le nom du fichier doit être unique, une chaîne d'au plus 64 caractères.
- Il ne peut contenir que des caractères alphanumériques et des underscores.
- Il doit commencer par une lettre et ne peut pas se terminer par un underscore.
- Il doit avoir l'extension .json.

7. Create-fit-predict

L'action create_fit_predict crée un classificateur, l'entraîne sur les données d'entraînement fournies, puis l'utilise pour obtenir des prédictions dures et douces (probabilités).

Entrées

Nom	Type	Description	Requis
`action`	`str`	Le nom de l'action parmi `create`, `list`, `fit`, `predict`, `fit_predict`, `create_fit_predict` et `delete`.	Oui
`name`	`str`	Le nom du classificateur à utiliser.	Oui
`quantum_classifier`	`str`	Le type du classificateur, c'est-à-dire `QuantumEnhancedEnsembleClassifier`. Par défaut `QuantumEnhancedEnsembleClassifier`.	Non
`X_train`	`array` ou `list` ou `str`	Les données d'entraînement. Cela peut être un tableau NumPy, une liste ou une chaîne référençant un nom de fichier dans le répertoire de données partagé.	Oui
`y_train`	`array` ou `list` ou `str`	Les valeurs cibles d'entraînement. Cela peut être un tableau NumPy, une liste ou une chaîne référençant un nom de fichier dans le répertoire de données partagé.	Oui
`X_test`	`array` ou `list` ou `str`	Les données de test. Cela peut être un tableau NumPy, une liste ou une chaîne référençant un nom de fichier dans le répertoire de données partagé.	Oui
`fit_params`	`dictionary`	Paramètres supplémentaires à passer à la méthode `fit` du classificateur.	Non
`options["save"]`	`boolean`	Indique s'il faut sauvegarder le classificateur entraîné dans le répertoire de données partagé. Par défaut `True`.	Non
`options["out"]`	`str`	Le nom du fichier JSON de sortie pour sauvegarder les prédictions dans le répertoire de données partagé. Si non fourni, les prédictions sont retournées dans le résultat de la tâche.	Non

Utilisation

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",
    },
)

Validations

name :
- Si options["save"] est défini à True :
  - Le nom doit être unique, une chaîne d'au plus 64 caractères.
  - Il ne peut contenir que des caractères alphanumériques et des underscores.
  - Il doit commencer par une lettre et ne peut pas se terminer par un underscore.
  - Aucun classificateur portant le même nom ne doit déjà exister dans le répertoire de données partagé.
options["out"] :
- Le nom du fichier doit être unique, une chaîne d'au plus 64 caractères.
- Il ne peut contenir que des caractères alphanumériques et des underscores.
- Il doit commencer par une lettre et ne peut pas se terminer par un underscore.
- Il doit avoir l'extension .json.

Premiers pas

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

from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

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

Exemple

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. Jeu de données moons À 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 :

Crée le jeu de données synthétique en utilisant la fonction make_moons de scikit-learn.
Téléverse le jeu de données synthétique généré vers le répertoire de données partagé.
Crée le classificateur amélioré quantiquement en utilisant l'action create.
Liste tes classificateurs en utilisant l'action list.
Entraîne le classificateur sur les données d'entraînement en utilisant l'action fit.
Utilise le classificateur entraîné pour prédire sur les données de test en utilisant l'action predict.
Supprime le classificateur en utilisant l'action delete.
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.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]

É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', 'y_test.npy.tar', 'y_train.npy.tar', 'my_classifier.pkl.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': 8.45469617843628}, 'RUNNING: WAITING_QPU': {'CPU_TIME': 69.4949426651001}, 'RUNNING: POST_PROCESSING': {'CPU_TIME': 73.01881957054138}, 'RUNNING: EXECUTING_QPU': {'QPU_TIME': 75.4787163734436}}}}

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

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

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

Vue d'ensemble​

Description de la fonction​

Approche par actions​

1. List​

Entrées​

Utilisation​

2. Create​

Entrées​

Utilisation​

Validations​

3. Delete​

Entrées​

Utilisation​

Validations​

4. Fit​

Entrées​

fit_params​

Utilisation​

Validations​

5. Predict​

Entrées​

Utilisation​

Validations​

6. Fit-predict​

Entrées​

Utilisation​

Validations​

7. Create-fit-predict​

Entrées​

Utilisation​

Validations​

Premiers pas​

Exemple​

Benchmarks​

Journal des modifications​

4 juin 2025​

20 mai 2025​

18 mars 2025​

14 février 2025​

6 février 2025​

13 novembre 2024​

Obtenir du support​

Prochaines étapes​

Vue d'ensemble

Description de la fonction

Approche par actions

1. List

Entrées

Utilisation

2. Create

Entrées

Utilisation

Validations

3. Delete

Entrées

Utilisation

Validations

4. Fit

Entrées

fit_params

Utilisation

Validations

5. Predict

Entrées

Utilisation

Validations

6. Fit-predict

Entrées

Utilisation

Validations

7. Create-fit-predict

Entrées

Utilisation

Validations

Premiers pas

Exemple

Benchmarks

Journal des modifications

4 juin 2025

20 mai 2025

18 mars 2025

14 février 2025

6 février 2025

13 novembre 2024

Obtenir du support

Prochaines étapes