{
"cells": [
{
"cell_type": "markdown",
"id": "fe74e692",
"metadata": {},
"source": [
"---\n",
"title: \"Singularity Machine Learning - Classificazione tramite calcolo multiversale\"\n",
"description: \"Una funzione Qiskit per creare e addestrare un classificatore ibrido di insiemi quantistici da più discenti e ottimizzarli per la diversità e la generalizzazione con QAOA\"\n",
"---\n",
"\n",
"{/* cspell:ignore hyperparameters, sparsify, sparsification, Leclerc */}\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "dde95705",
"metadata": {},
"source": [
"\n",
"\n",
"# Singularity Machine Learning - Classificazione: una funzione Qiskit di Multiverse Computing\n",
"\n",
"*Consulta la [documentazione dell'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",
" Il codice presente in questa pagina è stato sviluppato sulla base dei seguenti requisiti.\n",
" Si consiglia di utilizzare queste versioni o quelle più recenti.\n",
"\n",
" ```\n",
" scikit-learn~=1.8.0\n",
" ```\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "9985b8f4",
"metadata": {},
"source": [
"\n",
" * Le funzioni Qiskit sono una funzione sperimentale disponibile solo per gli utenti di IBM Quantum® Premium Plan, Flex Plan e On-Prem (tramite IBM Quantum Platform API) Plan. Sono in stato di anteprima e sono soggetti a modifiche.\n",
"\n",
"\n",
"\n",
"\n",
"## Panoramica\n",
"\n",
"Con la funzione \"Singularity Machine Learning - Classificazione\", è possibile risolvere problemi di apprendimento automatico del mondo reale su hardware quantistico senza richiedere competenze quantistiche. Questa funzione di applicazione, basata su metodi di ensemble, è un classificatore ibrido. Sfrutta metodi classici come boosting, bagging e stacking per la formazione iniziale dell'ensemble. Successivamente, vengono impiegati algoritmi quantistici come il variational quantum eigensolver (VQE) e il quantum approximate optimization algorithm (QAOA) per migliorare la diversità, la capacità di generalizzazione e la complessità complessiva dell'ensemble addestrato.\n",
"\n",
"A differenza di altre soluzioni di apprendimento automatico quantistico, questa funzione è in grado di gestire insiemi di dati su larga scala con milioni di esempi e caratteristiche senza essere limitata dal numero di qubit della QPU di destinazione. Il numero di qubit determina solo la dimensione dell'ensemble che può essere addestrato. È anche altamente flessibile e può essere utilizzata per risolvere problemi di classificazione in una vasta gamma di settori, tra cui finanza, sanità e sicurezza informatica.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "353e72a4",
"metadata": {},
"source": [
"Raggiunge costantemente alte precisioni su problemi classici che coinvolgono insiemi di dati altamente dimensionali, rumorosi e sbilanciati.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "339c5737",
"metadata": {},
"source": [
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "0639e5e5",
"metadata": {},
"source": [
"È costruito per:\n",
"\n",
"1. Ingegneri e data scientist di aziende che vogliono migliorare la loro offerta tecnologica integrando l'apprendimento automatico quantistico nei loro prodotti e servizi,\n",
"2. Ricercatori di laboratori di ricerca quantistica che esplorano applicazioni di apprendimento automatico quantistico e cercano di sfruttare il calcolo quantistico per compiti di classificazione, e\n",
"3. Studenti e insegnanti di istituti scolastici in corsi come l'apprendimento automatico e che vogliono dimostrare i vantaggi dell'informatica quantistica.\n",
"\n",
"L'esempio che segue illustra le sue varie funzionalità, tra cui `create`, `list`, `fit` e `predict`, e ne dimostra l'uso in un problema sintetico che comprende due semicerchi che si intersecano, un problema notoriamente difficile a causa del suo confine decisionale non lineare.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "ccf056e3",
"metadata": {},
"source": [
"{/* cspell:ignore quantumly */}\n",
"\n",
"\n",
"\n",
"## Descrizione funzione\n",
"\n",
"Questa funzione Qiskit consente agli utenti di risolvere problemi di classificazione binaria utilizzando il classificatore d'insieme potenziato da Singularity. Dietro le quinte, utilizza un approccio ibrido per addestrare classicamente un ensemble di classificatori sul set di dati etichettati e poi ottimizzarlo per ottenere la massima diversità e generalizzazione utilizzando l'algoritmo Quantum Approximate Optimization (QAOA) su IBM® QPU. Attraverso un'interfaccia intuitiva, gli utenti possono configurare un classificatore in base alle loro esigenze, addestrarlo su un set di dati di loro scelta e utilizzarlo per fare previsioni su un set di dati mai visto prima.\n",
"\n",
"Risolvere un problema generico di classificazione:\n",
"\n",
"1. Preelaborare il set di dati e dividerlo in set di allenamento e set di test. Opzionalmente, è possibile suddividere ulteriormente l'insieme di formazione in un insieme di formazione e in un insieme di validazione. Questo può essere ottenuto utilizzando [scikit-learn](https://scikit-learn.org/1.5/modules/generated/sklearn.model_selection.train_test_split.html).\n",
"2. Se l'insieme di allenamento è sbilanciato, è possibile ricampionarlo per bilanciare le classi usando [imbalanced-learn](https://imbalanced-learn.org/stable/introduction.html#problem-statement-regarding-imbalanced-data-sets).\n",
"3. Caricare separatamente i set di addestramento, convalida e test nella memoria della funzione usando il metodo `file_upload` del catalogo, passandogli ogni volta il percorso pertinente.\n",
"4. Inizializzare il classificatore quantistico utilizzando l'azione `create` della funzione, che accetta iperparametri come il numero e i tipi di apprendenti, la regolarizzazione (valore lambda) e le opzioni di ottimizzazione, tra cui il numero di strati, il tipo di ottimizzatore classico, il backend quantistico e così via.\n",
"5. Addestrare il classificatore quantistico sull'insieme di allenamento utilizzando l'azione `fit` della funzione, passandogli l'insieme di allenamento etichettato e l'insieme di validazione, se applicabile.\n",
"6. Effettuare previsioni sull'insieme di test non visto in precedenza, utilizzando l'azione `predict` della funzione.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "26472870",
"metadata": {},
"source": [
"***\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "73390a19",
"metadata": {},
"source": [
"\n",
"\n",
"## Introduzione\n",
"\n",
"Autenticatevi utilizzando la vostra [chiave API di IBM Quantum Platform](http://quantum.cloud.ibm.com/) e selezionate la funzione Qiskit come segue:\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",
"## Esempi\n",
"\n",
"\n",
"\n",
"### Classificare un set di dati\n",
"\n",
"In questo esempio, si utilizzerà la funzione \"Singolarità Machine Learning - Classificazione\" per classificare un set di dati costituito da due semicerchi a forma di luna che si intersecano. Il dataset è sintetico, bidimensionale ed etichettato con etichette binarie. È stato creato per essere una sfida per algoritmi come il clustering basato sui centroidi e la classificazione lineare.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "b12f9ee4",
"metadata": {},
"source": [
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "b3cedca5",
"metadata": {},
"source": [
"Attraverso questo processo, imparerete a creare il classificatore, ad adattarlo ai dati di addestramento, a usarlo per fare previsioni sui dati di test e a cancellare il classificatore quando avete finito.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "dba5a40e",
"metadata": {},
"source": [
"Prima di iniziare, è necessario installare [scikit-learn](https://scikit-learn.org/). Installatelo con il seguente comando:\n",
"\n",
"```sh\n",
"python3 -m pip install scikit-learn\n",
"```\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "ba982810",
"metadata": {},
"source": [
"Eseguire i passi riportati di seguito:\n",
"\n",
"1. Crea il set di dati sintetico utilizzando la [`make_moons`](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_moons.html) funzione di [scikit-learn](https://scikit-learn.org/).\n",
"2. Carica il set di dati sintetici generato nella [directory dei dati condivisa](https://qiskit.github.io/qiskit-serverless/function_features/experimental/manage_data_directory.html).\n",
"3. Crea il classificatore potenziato quantisticamente utilizzando [`create`](/docs/api/functions/multiverse-computing-singularity#create) l'azione.\n",
"4. Aggiungi i tuoi classificatori utilizzando l'azione [`list`](/docs/api/functions/multiverse-computing-singularity#list) .\n",
"5. Addestra il classificatore sui dati di addestramento utilizzando l'azione [`fit`](/docs/api/functions/multiverse-computing-singularity#fit) .\n",
"6. Utilizza il classificatore addestrato per effettuare previsioni sui dati di test utilizzando [`predict`](/docs/api/functions/multiverse-computing-singularity#predict) l'azione.\n",
"7. Elimina il classificatore utilizzando l'azione [`delete`](/docs/api/functions/multiverse-computing-singularity#delete) .\n",
"8. Pulite dopo aver finito.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "c1877f96",
"metadata": {},
"source": [
"**Passo 1.** Importare i moduli necessari e generare il dataset sintetico, quindi dividerlo in dataset di allenamento e di 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": [
"**Passo 2.** Salva i set di dati di addestramento e di verifica etichettati sul tuo disco locale, quindi caricali nella [directory dei dati condivisa](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": [
"**Passaggio 3.** Crea un classificatore potenziato quantisticamente utilizzando l'azione [`create`](/docs/api/functions/multiverse-computing-singularity#create) .\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": [
"**Passaggio 4.** Addestrare il classificatore potenziato quantisticamente utilizzando l'azione [`fit`](/docs/api/functions/multiverse-computing-singularity#fit) .\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": [
"**Passo 5.** Ottieni previsioni e probabilità dal classificatore potenziato quantisticamente utilizzando [`predict`](/docs/api/functions/multiverse-computing-singularity#predict) l'azione.\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": [
"**Passaggio 6.** Elimina il classificatore potenziato quantisticamente utilizzando l'azione [`delete`](/docs/api/functions/multiverse-computing-singularity#delete) .\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": [
"**Passo 7.** Pulire le directory di dati locali e condivise.\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` esempio\n",
"\n",
"L'esempio seguente illustra l'azione [`create_fit_predict`](/docs/api/functions/multiverse-computing-singularity#create_fit_predict) .\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",
"## Benchmark\n",
"\n",
"Questi benchmark dimostrano che il classificatore può ottenere precisioni estremamente elevate su problemi impegnativi. Dimostrano inoltre che l'aumento del numero di apprendenti nell'ensemble (numero di qubit) può portare a una maggiore precisione.\n",
"\n",
"per \"accuratezza classica\" si intende l'accuratezza ottenuta utilizzando il corrispondente stato dell'arte classico che, in questo caso, è un classificatore AdaBoost basato su un ensemble di dimensione 75. la \"precisione quantistica\", invece, si riferisce alla precisione ottenuta utilizzando la \"Singolarità Machine Learning - Classificazione\".\n",
"\n",
"| Problema | Dimensione del set di dati | Dimensione dell'ensemble | Numero di Qubit | Precisione classica | Precisione quantistica | Miglioramento |\n",
"| -------------------- | ------------------------------- | ------------------------ | --------------- | ------------------- | ---------------------- | ------------- |\n",
"| Stabilità della rete | 5000 esempi, 12 caratteristiche | 55 | 55 | Il 76% | Il 91% | 15% |\n",
"| Stabilità della rete | 5000 esempi, 12 caratteristiche | 65 | 65 | Il 76% | 92% | 16% |\n",
"| Stabilità della rete | 5000 esempi, 12 caratteristiche | 75 | 75 | Il 76% | 94% | 18% |\n",
"| Stabilità della rete | 5000 esempi, 12 caratteristiche | 85 | 85 | Il 76% | 94% | 18% |\n",
"| Stabilità della rete | 5000 esempi, 12 caratteristiche | 100 | 100 | Il 76% | 95% | 19% |\n",
"\n",
"***\n",
"\n",
"Con l'evoluzione e la scalabilità dell'hardware quantistico, le implicazioni per il nostro classificatore quantistico diventano sempre più significative. Sebbene il numero di qubit imponga dei limiti alla dimensione dell'insieme che può essere utilizzato, non limita il volume di dati che possono essere elaborati. Questa potente capacità consente al classificatore di gestire in modo efficiente insiemi di dati contenenti milioni di punti dati e migliaia di caratteristiche. È importante notare che i vincoli legati alle dimensioni dell'ensemble possono essere affrontati attraverso l'implementazione di una versione su larga scala del classificatore. Sfruttando un approccio iterativo ad anello esterno, l'ensemble può essere ampliato dinamicamente, migliorando la flessibilità e le prestazioni complessive. Tuttavia, è bene notare che questa funzione non è ancora stata implementata nella versione attuale del classificatore.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "cddff465",
"metadata": {},
"source": [
"\n",
"\n",
"## Log di modifica\n",
"\n",
"\n",
"\n",
"### 4 giugno 2025\n",
"\n",
"* Aggiornato `QuantumEnhancedEnsembleClassifier` con i seguenti aggiornamenti:\n",
" * Aggiunta regolarizzazione in loco/alfa. È possibile specificare che `regularization_type` sia `onsite` o `alpha`\n",
" * Aggiunta della regolarizzazione automatica. È possibile impostare `regularization` su `auto` per utilizzare la regolarizzazione automatica\n",
" * Aggiunto il parametro `optimization_data` al metodo `fit` per scegliere i dati di ottimizzazione per l'ottimizzazione quantistica. È possibile utilizzare una delle seguenti opzioni: `train`, `validation`, o `both`\n",
" * Miglioramento delle prestazioni complessive\n",
"* Aggiunto il monitoraggio dettagliato dello stato per i lavori in esecuzione\n",
"\n",
"\n",
"\n",
"### 20 maggio 2025\n",
"\n",
"* Gestione degli errori standardizzata\n",
"\n",
"\n",
"\n",
"### 18 marzo 2025\n",
"\n",
"* Aggiornato qiskit-serverless a 0.20.0 e l'immagine base a 0.20.1\n",
"\n",
"\n",
"\n",
"### 14 febbraio 2025\n",
"\n",
"* Aggiornata l'immagine di base a 0.19.1\n",
"\n",
"\n",
"\n",
"### 6 febbraio 2025\n",
"\n",
"* Aggiornato qiskit-serverless a 0.19.0 e l'immagine base a 0.19.0\n",
"\n",
"\n",
"\n",
"### 13 novembre 2024\n",
"\n",
"* Rilascio di Singularity Machine Learning - Classificazione\n",
"\n",
"\n",
"\n",
"## Ottenere supporto\n",
"\n",
"Per qualsiasi domanda, contattate [Multiverse Computing](mailto:singularity@multiversecomputing.com).\n",
"\n",
"Assicuratevi di includere le seguenti informazioni:\n",
"\n",
"* La funzione Qiskit ID lavoro (`job.job_id`)\n",
"* Una descrizione dettagliata del problema\n",
"* Eventuali messaggi o codici di errore rilevanti\n",
"* Passi per riprodurre il problema\n",
"\n",
"\n",
"\n",
"## Passi successivi\n",
"\n",
"\n",
" * Richiedete l'accesso alla [funzione di classificazione delle singolarità di Multiverse Computing Machine Learning](/functions?id=multiverse-singularity).\n",
" * Consulta la documentazione [di riferimento dell'API](/docs/api/functions/multiverse-computing-singularity) relativa a questa funzione di Qiskit.\n",
" * Recensione [Leclerc, L., et al. (2023). Gestione del rischio finanziario su un processore quantistico atomico neutro. 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
}