{
"cells": [
{
"cell_type": "markdown",
"id": "fe74e692",
"metadata": {},
"source": [
"---\n",
"title: \"Singularity Machine Learning - Classification par le calcul multiversel\"\n",
"description: \"Une fonction Qiskit permettant de créer et d'entraîner un classificateur d'ensemble quantique hybride à partir de plusieurs apprenants et de les optimiser pour la diversité et la généralisation avec QAOA\"\n",
"---\n",
"\n",
"{/* cspell:ignore hyperparameters, sparsify, sparsification, Leclerc */}\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "dde95705",
"metadata": {},
"source": [
"\n",
"\n",
"# Machine Learning de singularité - Classification : une fonction Qiskit par Multiverse Computing\n",
"\n",
"*Consultez la [documentation de l'API](/docs/api/functions/multiverse-computing-singularity)*\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "99db0bb4",
"metadata": {
"tags": [
"version-info"
]
},
"source": [
"{/*\n",
" DO NOT EDIT THIS CELL!!!\n",
" This cell's content is generated automatically by a script. Anything you add\n",
" here will be removed next time the notebook is run. To add new content, create\n",
" a new cell before or after this one.\n",
" */}\n",
"\n",
"\n",
" \n",
" Le code présenté sur cette page a été développé en respectant les exigences suivantes.\n",
" Nous vous recommandons d'utiliser ces versions ou des versions plus récentes.\n",
"\n",
" ```\n",
" scikit-learn~=1.8.0\n",
" ```\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "9985b8f4",
"metadata": {},
"source": [
"\n",
" * Les fonctions Qiskit sont une fonctionnalité expérimentale disponible uniquement pour IBM Quantum® Premium Plan, Flex Plan, et On-Prem (via IBM Quantum Platform API). Elles sont en cours de publication et peuvent être modifiées.\n",
"\n",
"\n",
"\n",
"\n",
"## Aperçu\n",
"\n",
"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é.\n",
"\n",
"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é.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "353e72a4",
"metadata": {},
"source": [
"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.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "339c5737",
"metadata": {},
"source": [
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "0639e5e5",
"metadata": {},
"source": [
"Il est conçu pour :\n",
"\n",
"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,\n",
"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\n",
"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.\n",
"\n",
"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.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "ccf056e3",
"metadata": {},
"source": [
"{/* cspell:ignore quantumly */}\n",
"\n",
"\n",
"\n",
"## Description de la fonction\n",
"\n",
"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.\n",
"\n",
"Résoudre un problème de classification générique :\n",
"\n",
"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](https://scikit-learn.org/1.5/modules/generated/sklearn.model_selection.train_test_split.html).\n",
"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é](https://imbalanced-learn.org/stable/introduction.html#problem-statement-regarding-imbalanced-data-sets).\n",
"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é.\n",
"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.\n",
"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.\n",
"6. Faire des prédictions sur l'ensemble de test non vu précédemment en utilisant l'action de la fonction `predict` .\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "26472870",
"metadata": {},
"source": [
"***\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "73390a19",
"metadata": {},
"source": [
"\n",
"\n",
"## Premiers pas\n",
"\n",
"Authentifiez-vous à l'aide de votre [clé API IBM Quantum Platform](http://quantum.cloud.ibm.com/) et sélectionnez la fonction Qiskit comme suit :\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "95a715d2",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[QiskitFunction(qunova/hivqe-chemistry),\n",
" QiskitFunction(global-data-quantum/quantum-portfolio-optimizer),\n",
" QiskitFunction(algorithmiq/tem),\n",
" QiskitFunction(qedma/qesem),\n",
" QiskitFunction(multiverse/singularity),\n",
" QiskitFunction(ibm/circuit-function),\n",
" QiskitFunction(q-ctrl/optimization-solver),\n",
" QiskitFunction(colibritd/quick-pde),\n",
" QiskitFunction(q-ctrl/performance-management),\n",
" QiskitFunction(kipu-quantum/iskay-quantum-optimizer)]"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit_ibm_catalog import QiskitFunctionsCatalog\n",
"\n",
"catalog = QiskitFunctionsCatalog(channel=\"ibm_quantum_platform\")\n",
"\n",
"# Verify that you have access to the function\n",
"catalog.list()"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "b83c0077-412e-4f06-9e34-51599ffa7183",
"metadata": {},
"outputs": [],
"source": [
"# load function\n",
"singularity = catalog.load(\"multiverse/singularity\")"
]
},
{
"cell_type": "markdown",
"id": "e8837f5f",
"metadata": {},
"source": [
"\n",
"\n",
"## Exemples\n",
"\n",
"\n",
"\n",
"### Classer un ensemble de données\n",
"\n",
"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.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "b12f9ee4",
"metadata": {},
"source": [
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "b3cedca5",
"metadata": {},
"source": [
"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é.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "dba5a40e",
"metadata": {},
"source": [
"Avant de commencer, vous devez installer [scikit-learn](https://scikit-learn.org/). Installez-le à l'aide de la commande suivante :\n",
"\n",
"```sh\n",
"python3 -m pip install scikit-learn\n",
"```\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "ba982810",
"metadata": {},
"source": [
"Effectuez les opérations suivantes :\n",
"\n",
"1. Créez l'ensemble de données synthétiques à l'aide de la [`make_moons`](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_moons.html) fonction de [scikit-learn](https://scikit-learn.org/).\n",
"2. Envoyez l'ensemble de données synthétiques généré vers le [répertoire de données partagé](https://qiskit.github.io/qiskit-serverless/function_features/experimental/manage_data_directory.html).\n",
"3. Créez le classificateur amélioré par la mécanique quantique à l'aide de [`create`](/docs/api/functions/multiverse-computing-singularity#create) l'action.\n",
"4. Enregistrez vos classificateurs à l'aide de [`list`](/docs/api/functions/multiverse-computing-singularity#list) l'action.\n",
"5. Entraînez le classificateur sur les données d'entraînement à l'aide de [`fit`](/docs/api/functions/multiverse-computing-singularity#fit) l'action.\n",
"6. Utilisez le classificateur entraîné pour effectuer des prédictions sur les données de test à l'aide de [`predict`](/docs/api/functions/multiverse-computing-singularity#predict) l'action.\n",
"7. Supprimez le classificateur à l'aide de [`delete`](/docs/api/functions/multiverse-computing-singularity#delete) l'action.\n",
"8. Nettoyez après avoir terminé.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "c1877f96",
"metadata": {},
"source": [
"**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.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "731db300",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Features: [[ 0.84757037 -0.48831433]\n",
" [ 0.98132552 0.19235443]\n",
" [-0.71626723 0.6978261 ]\n",
" [ 1.18957848 -0.48186557]\n",
" [ 0.52118982 -0.37791846]\n",
" [ 0.81115408 0.58483251]\n",
" [ 0.48706462 0.87336593]\n",
" [-0.81880144 0.57407682]\n",
" [ 1.67335408 -0.23932015]\n",
" [ 0.50181306 0.8649761 ]]\n",
"Targets: [1 0 0 1 1 0 0 0 1 0]\n"
]
}
],
"source": [
"# import the necessary modules for this example\n",
"import os\n",
"import tarfile\n",
"import numpy as np\n",
"\n",
"# Import the make_moons and the train_test_split functions from scikit-learn\n",
"# to create a synthetic dataset and split it into training and test datasets\n",
"from sklearn.datasets import make_moons\n",
"from sklearn.model_selection import train_test_split\n",
"\n",
"# generate the synthetic dataset\n",
"X, y = make_moons(n_samples=10000)\n",
"\n",
"# split the data into training and test datasets\n",
"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)\n",
"\n",
"# print the first 10 samples of the training dataset\n",
"print(\"Features:\", X_train[:10, :])\n",
"print(\"Targets:\", y_train[:10])"
]
},
{
"cell_type": "markdown",
"id": "639f459f",
"metadata": {},
"source": [
"**É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é](https://qiskit.github.io/qiskit-serverless/function_features/experimental/manage_data_directory.html).\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "7265965f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['X_test.npy.tar', 'X_train.npy.tar', 'y_test.npy.tar', 'y_train.npy.tar']\n"
]
}
],
"source": [
"def make_tarfile(file_path, tar_file_name):\n",
" with tarfile.open(tar_file_name, \"w\") as tar:\n",
" tar.add(file_path, arcname=os.path.basename(file_path))\n",
"\n",
"\n",
"# save the training and test datasets on your local disk\n",
"np.save(\"X_train.npy\", X_train)\n",
"np.save(\"y_train.npy\", y_train)\n",
"np.save(\"X_test.npy\", X_test)\n",
"np.save(\"y_test.npy\", y_test)\n",
"\n",
"# create tar files for the datasets\n",
"make_tarfile(\"X_train.npy\", \"X_train.npy.tar\")\n",
"make_tarfile(\"y_train.npy\", \"y_train.npy.tar\")\n",
"make_tarfile(\"X_test.npy\", \"X_test.npy.tar\")\n",
"make_tarfile(\"y_test.npy\", \"y_test.npy.tar\")\n",
"\n",
"# upload the datasets to the shared data directory\n",
"catalog.file_upload(\"X_train.npy.tar\", singularity)\n",
"catalog.file_upload(\"y_train.npy.tar\", singularity)\n",
"catalog.file_upload(\"X_test.npy.tar\", singularity)\n",
"catalog.file_upload(\"y_test.npy.tar\", singularity)\n",
"\n",
"# view/enlist the uploaded files in the shared data directory\n",
"print(catalog.files(singularity))"
]
},
{
"cell_type": "markdown",
"id": "f52caa63",
"metadata": {},
"source": [
"**Étape 3.** Créez un classificateur optimisé par l'informatique quantique à l'aide de [`create`](/docs/api/functions/multiverse-computing-singularity#create) l'action.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "d56e1440",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'status': 'ok', 'message': 'Classifier created.', 'data': {}, 'metadata': {'resource_usage': {}}}\n"
]
}
],
"source": [
"job = singularity.run(\n",
" action=\"create\",\n",
" name=\"my_classifier\",\n",
" num_learners=10,\n",
" learners_types=[\n",
" \"DecisionTreeClassifier\",\n",
" \"KNeighborsClassifier\",\n",
" ],\n",
" learners_proportions=[0.5, 0.5],\n",
" learners_options=[{}, {}],\n",
" regularization=0.01,\n",
" weight_update_method=\"logarithmic\",\n",
" sample_scaling=True,\n",
" optimizer_options={\"simulator\": True},\n",
" voting=\"soft\",\n",
" prob_threshold=0.5,\n",
")\n",
"\n",
"print(job.result())"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "f5a54432",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'status': 'ok', 'message': 'Classifiers listed.', 'data': {'classifiers': ['my_classifier']}, 'metadata': {'resource_usage': {}}}\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"['X_test.npy.tar', 'X_train.npy.tar', 'my_classifier.pkl.tar', 'y_test.npy.tar', 'y_train.npy.tar']\n"
]
}
],
"source": [
"# list available classifiers using the list action\n",
"job = singularity.run(action=\"list\")\n",
"\n",
"print(job.result())\n",
"\n",
"# you can also find your classifiers in the shared data directory with a *.pkl.tar extension\n",
"print(catalog.files(singularity))"
]
},
{
"cell_type": "markdown",
"id": "504ddc09",
"metadata": {},
"source": [
"**Étape 4 :** Entraînez le classificateur amélioré par la mécanique quantique à l'aide de [`fit`](/docs/api/functions/multiverse-computing-singularity#fit) l'action.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "13699d25",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'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}}}}\n"
]
}
],
"source": [
"job = singularity.run(\n",
" action=\"fit\",\n",
" name=\"my_classifier\",\n",
" X=\"X_train.npy\", # you do not need to specify the tar extension\n",
" y=\"y_train.npy\", # you do not need to specify the tar extension\n",
")\n",
"\n",
"print(job.result())"
]
},
{
"cell_type": "markdown",
"id": "76ef149b",
"metadata": {},
"source": [
"**Étape 5.** Obtenez les prédictions et les probabilités du classificateur amélioré par la mécanique quantique à l'aide de [`predict`](/docs/api/functions/multiverse-computing-singularity#predict) l'action.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "92f35d5a",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Action result status: ok\n",
"Action result message: Classifier predicted.\n",
"Predictions (first five results): [0, 0, 1, 0, 1]\n",
"Probabilities (first five results): [[1.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 0.0], [0.0, 1.0]]\n"
]
}
],
"source": [
"job = singularity.run(\n",
" action=\"predict\",\n",
" name=\"my_classifier\",\n",
" X=\"X_test.npy\", # you do not need to specify the tar extension\n",
")\n",
"\n",
"result = job.result()\n",
"\n",
"print(\"Action result status: \", result[\"status\"])\n",
"print(\"Action result message: \", result[\"message\"])\n",
"print(\"Predictions (first five results):\", result[\"data\"][\"predictions\"][:5])\n",
"print(\n",
" \"Probabilities (first five results):\", result[\"data\"][\"probabilities\"][:5]\n",
")"
]
},
{
"cell_type": "markdown",
"id": "1980104c",
"metadata": {},
"source": [
"**Étape 6.** Supprimez le classificateur quantique à l'aide de [`delete`](/docs/api/functions/multiverse-computing-singularity#delete) l'action.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "c4705154",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'status': 'ok', 'message': 'Classifier deleted.', 'data': {}, 'metadata': {'resource_usage': {}}}\n"
]
}
],
"source": [
"job = singularity.run(\n",
" action=\"delete\",\n",
" name=\"my_classifier\",\n",
")\n",
"\n",
"# or you can delete from the shared data directory\n",
"# catalog.file_delete(\"my_classifier.pkl.tar\", singularity)\n",
"\n",
"print(job.result())"
]
},
{
"cell_type": "markdown",
"id": "30b34179",
"metadata": {},
"source": [
"**Etape 7.** Nettoyer les répertoires de données locaux et partagés.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "6c64ea2b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'Requested file was deleted.'"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# delete the numpy files from your local disk\n",
"os.remove(\"X_train.npy\")\n",
"os.remove(\"y_train.npy\")\n",
"os.remove(\"X_test.npy\")\n",
"os.remove(\"y_test.npy\")\n",
"\n",
"# delete the tar files from your local disk\n",
"os.remove(\"X_train.npy.tar\")\n",
"os.remove(\"y_train.npy.tar\")\n",
"os.remove(\"X_test.npy.tar\")\n",
"os.remove(\"y_test.npy.tar\")\n",
"\n",
"# delete the tar files from the shared data\n",
"catalog.file_delete(\"X_train.npy.tar\", singularity)\n",
"catalog.file_delete(\"y_train.npy.tar\", singularity)\n",
"catalog.file_delete(\"X_test.npy.tar\", singularity)\n",
"catalog.file_delete(\"y_test.npy.tar\", singularity)"
]
},
{
"cell_type": "markdown",
"id": "f25d06ee",
"metadata": {},
"source": [
"\n",
"\n",
"### `create_fit_predict`exemple\n",
"\n",
"L'exemple suivant illustre cette [`create_fit_predict`](/docs/api/functions/multiverse-computing-singularity#create_fit_predict) action.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "79cdedc0",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Job status: QUEUED\n",
"Action result status: ok\n",
"Action result message: Classifier created, fitted, and predicted.\n",
"Predictions (first five results): [0, 0, 1, 0, 0]\n",
"Probabilities (first five results): [[0.87119766531518, 0.1288023346848197], [0.87119766531518, 0.1288023346848197], [0.24470328446479797, 0.7552967155352032], [0.820524432250189, 0.17947556774981072], [0.6847610293419495, 0.31523897065805173]]\n",
"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}}\n"
]
}
],
"source": [
"# Import QiskitFunctionsCatalog to load the\n",
"# \"Singularity Machine Learning - Classification\" function by Multiverse Computing\n",
"from qiskit_ibm_catalog import QiskitFunctionsCatalog\n",
"\n",
"# Import the make_moons and the train_test_split functions from scikit-learn\n",
"# to create a synthetic dataset and split it into training and test datasets\n",
"from sklearn.datasets import make_moons\n",
"from sklearn.model_selection import train_test_split\n",
"\n",
"# authentication\n",
"# If you have not previously saved your credentials, follow instructions at\n",
"# /docs/guides/functions\n",
"# to authenticate with your API key.\n",
"catalog = QiskitFunctionsCatalog(channel=\"ibm_quantum_platform\")\n",
"\n",
"# load \"Singularity Machine Learning - Classification\" function by Multiverse Computing\n",
"singularity = catalog.load(\"multiverse/singularity\")\n",
"\n",
"# generate the synthetic dataset\n",
"X, y = make_moons(n_samples=1000)\n",
"\n",
"# split the data into training and test datasets\n",
"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)\n",
"\n",
"job = singularity.run(\n",
" action=\"create_fit_predict\",\n",
" num_learners=10,\n",
" regularization=0.01,\n",
" optimizer_options={\"simulator\": True},\n",
" X_train=X_train,\n",
" y_train=y_train,\n",
" X_test=X_test,\n",
" options={\"save\": False},\n",
")\n",
"\n",
"# get job status and result\n",
"status = job.status()\n",
"result = job.result()\n",
"\n",
"print(\"Job status: \", status)\n",
"print(\"Action result status: \", result[\"status\"])\n",
"print(\"Action result message: \", result[\"message\"])\n",
"print(\"Predictions (first five results): \", result[\"data\"][\"predictions\"][:5])\n",
"print(\n",
" \"Probabilities (first five results): \",\n",
" result[\"data\"][\"probabilities\"][:5],\n",
")\n",
"print(\"Usage metadata: \", result[\"metadata\"][\"resource_usage\"])"
]
},
{
"cell_type": "markdown",
"id": "5cc6f2b3",
"metadata": {},
"source": [
"\n",
"\n",
"## Tests de performances\n",
"\n",
"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.\n",
"\n",
"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\".\n",
"\n",
"| Problème | Taille de l'ensemble de données | Taille de l'ensemble | Nombre de Qubits | Précision classique | Précision quantique | Amélioration |\n",
"| ------------------- | ---------------------------------- | -------------------- | ---------------- | ------------------- | ------------------- | ------------ |\n",
"| Stabilité du réseau | 5000 exemples, 12 caractéristiques | 55 | 55 | 76 % | 91 % | 15 % |\n",
"| Stabilité du réseau | 5000 exemples, 12 caractéristiques | 65 | 65 | 76 % | 92 % | 16 % |\n",
"| Stabilité du réseau | 5000 exemples, 12 caractéristiques | 75 | 75 | 76 % | 94 % | 18 % |\n",
"| Stabilité du réseau | 5000 exemples, 12 caractéristiques | 85 | 85 | 76 % | 94 % | 18 % |\n",
"| Stabilité du réseau | 5000 exemples, 12 caractéristiques | 100 | 100 | 76 % | 95 % | 19 % |\n",
"\n",
"***\n",
"\n",
"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.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "cddff465",
"metadata": {},
"source": [
"\n",
"\n",
"## Journal des modifications\n",
"\n",
"\n",
"\n",
"### 4 juin 2025\n",
"\n",
"* Mise à jour de `QuantumEnhancedEnsembleClassifier` avec les mises à jour suivantes :\n",
" * Ajout d'une régularisation sur site/alpha. Vous pouvez spécifier que `regularization_type` est `onsite` ou `alpha`\n",
" * Ajout de l'auto-régularisation. Vous pouvez définir `regularization` sur `auto` pour utiliser l'auto-régularisation\n",
" * 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`\n",
" * Amélioration des performances globales\n",
"* Ajout d'un suivi détaillé de l'état des travaux en cours\n",
"\n",
"\n",
"\n",
"### 20 mai 2025\n",
"\n",
"* Gestion normalisée des erreurs\n",
"\n",
"\n",
"\n",
"### 18 mars 2025\n",
"\n",
"* Mise à jour de qiskit-serverless vers 0.20.0 et de l'image de base vers 0.20.1\n",
"\n",
"\n",
"\n",
"### 14 février 2025\n",
"\n",
"* Mise à jour de l'image de base vers 0.19.1\n",
"\n",
"\n",
"\n",
"### 6 février 2025\n",
"\n",
"* Mise à jour de qiskit-serverless vers 0.19.0 et de l'image de base vers 0.19.0\n",
"\n",
"\n",
"\n",
"### 13 novembre 2024\n",
"\n",
"* Publication de Singularity Machine Learning - Classification\n",
"\n",
"\n",
"\n",
"## Obtenir de l'aide\n",
"\n",
"Pour toute question, [contactez Multiverse Computing](mailto:singularity@multiversecomputing.com).\n",
"\n",
"Veillez à inclure les informations suivantes :\n",
"\n",
"* La fonction Qiskit Job ID (`job.job_id`)\n",
"* Une description détaillée du problème\n",
"* Tout message ou code d'erreur pertinent\n",
"* Etapes de reproduction du problème\n",
"\n",
"\n",
"\n",
"## Etapes suivantes\n",
"\n",
"\n",
" * Demander l'accès à la [fonction de classification des singularités de Multiverse Computing Machine Learning](/functions?id=multiverse-singularity).\n",
" * Consultez [la documentation de l'API](/docs/api/functions/multiverse-computing-singularity) relative à cette fonction Qiskit.\n",
" * Critique [Leclerc, L., et al. (2023). Gestion des risques financiers sur un processeur quantique atomique neutre. Physical Review Research, 5, 043117](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.5.043117).\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"id": "a1b8767d",
"source": "© IBM Corp., 2017-2026"
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3"
}
},
"nbformat": 4,
"nbformat_minor": 5
}