{
"cells": [
{
"cell_type": "markdown",
"id": "fe74e692",
"metadata": {},
"source": [
"---\n",
"title: \"Singularity Machine Learning – Klassifizierung mittels Multiverse Computing\"\n",
"description: \"Eine Qiskit-Funktion zum Erstellen und Trainieren eines hybriden Quanten-Ensemble-Klassifikators aus mehreren Lernenden und zur Optimierung dieser hinsichtlich Diversität und Generalisierung mit QAOA\"\n",
"---\n",
"\n",
"{/* cspell:ignore hyperparameters, sparsify, sparsification, Leclerc */}\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "dde95705",
"metadata": {},
"source": [
"\n",
"\n",
"# Singularitäts Machine Learning – Klassifizierung: Eine Qiskit-Funktion von Multiverse Computing\n",
"\n",
"*Siehe [API-Referenz](/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",
" Der Code auf dieser Seite wurde unter Berücksichtigung der folgenden Anforderungen entwickelt.\n",
" Wir empfehlen, diese Versionen oder neuere zu verwenden.\n",
"\n",
" ```\n",
" scikit-learn~=1.8.0\n",
" ```\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "9985b8f4",
"metadata": {},
"source": [
"\n",
" * Qiskit-Funktionen sind eine experimentelle Funktion, die nur für Benutzer des IBM Quantum® Premium Plan, Flex Plan und On-Prem (über IBM Quantum Platform API) Plan verfügbar ist. Sie befinden sich im Status einer Vorabversion und können sich noch ändern.\n",
"\n",
"\n",
"\n",
"\n",
"## Übersicht\n",
"\n",
"Mit der Funktion \"Singularity Machine Learning - Classification\" können Sie reale Probleme des maschinellen Lernens auf Quanten-Hardware lösen, ohne dass Sie über Quantenkenntnisse verfügen müssen. Diese Anwendungsfunktion, die auf Ensemble-Methoden basiert, ist ein hybrider Klassifikator. Es nutzt klassische Methoden wie Boosting, Bagging und Stacking für das anfängliche Ensemble-Training. Anschließend werden Quantenalgorithmen wie der Variational Quantum Eigensolver (VQE) und der Quantum Approximate Optimization Algorithm (QAOA) eingesetzt, um die Diversität, Generalisierungsfähigkeit und Gesamtkomplexität des trainierten Ensembles zu verbessern.\n",
"\n",
"Im Gegensatz zu anderen Lösungen für maschinelles Lernen mit Quantencomputern ist diese Funktion in der Lage, große Datensätze mit Millionen von Beispielen und Merkmalen zu verarbeiten, ohne durch die Anzahl der Qubits in der Ziel-QPU begrenzt zu sein. Die Anzahl der Qubits bestimmt nur die Größe des Ensembles, das trainiert werden kann. Darüber hinaus ist es äußerst flexibel und kann zur Lösung von Klassifizierungsproblemen in einer Vielzahl von Bereichen eingesetzt werden, einschließlich Finanzwesen, Gesundheitswesen und Cybersicherheit.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "353e72a4",
"metadata": {},
"source": [
"Es erzielt durchweg hohe Genauigkeiten bei klassisch anspruchsvollen Problemen mit hochdimensionalen, verrauschten und unausgewogenen Datensätzen.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "339c5737",
"metadata": {},
"source": [
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "0639e5e5",
"metadata": {},
"source": [
"Es ist für gebaut:\n",
"\n",
"1. Ingenieure und Datenwissenschaftler in Unternehmen, die ihr technisches Angebot durch die Integration von maschinellem Lernen in ihre Produkte und Dienstleistungen verbessern möchten,\n",
"2. Forscher in Quantenforschungslabors, die Anwendungen des maschinellen Lernens mit Hilfe von Quantencomputern für Klassifizierungsaufgaben untersuchen, und\n",
"3. Studenten und Lehrer an Bildungseinrichtungen in Kursen wie maschinelles Lernen, die die Vorteile des Quantencomputings demonstrieren wollen.\n",
"\n",
"Das folgende Beispiel zeigt die verschiedenen Funktionalitäten, einschließlich `create`, `list`, `fit` und `predict`, und demonstriert die Verwendung in einem synthetischen Problem, das aus zwei ineinandergreifenden Halbkreisen besteht, einem notorisch schwierigen Problem aufgrund seiner nichtlinearen Entscheidungsgrenze.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "ccf056e3",
"metadata": {},
"source": [
"{/* cspell:ignore quantumly */}\n",
"\n",
"\n",
"\n",
"## Funktionsbeschreibung\n",
"\n",
"Mit dieser Qiskit-Funktion können Benutzer binäre Klassifizierungsprobleme mit dem quantenverstärkten Ensemble-Klassifikator von Singularity lösen. Hinter den Kulissen wird ein hybrider Ansatz verwendet, um ein Ensemble von Klassifikatoren auf dem markierten Datensatz klassisch zu trainieren und dann mit dem Quantum Approximate Optimization Algorithm (QAOA) auf IBM® QPUs für maximale Diversität und Generalisierung zu optimieren. Über eine benutzerfreundliche Schnittstelle können die Benutzer einen Klassifikator nach ihren Anforderungen konfigurieren, ihn auf einem Datensatz ihrer Wahl trainieren und ihn für Vorhersagen auf einem zuvor nicht gesehenen Datensatz verwenden.\n",
"\n",
"Ein allgemeines Klassifizierungsproblem zu lösen:\n",
"\n",
"1. Verarbeiten Sie den Datensatz vor und teilen Sie ihn in einen Trainings- und einen Testsatz auf. Optional können Sie die Trainingsmenge weiter in Trainings- und Validierungsmengen aufteilen. Dies kann mit [Scikit-Learn](https://scikit-learn.org/1.5/modules/generated/sklearn.model_selection.train_test_split.html) erreicht werden.\n",
"2. Wenn der Trainingssatz unausgewogen ist, können Sie ihn mit [imbalanced-learn](https://imbalanced-learn.org/stable/introduction.html#problem-statement-regarding-imbalanced-data-sets) neu abfragen, um die Klassen auszugleichen.\n",
"3. Laden Sie die Trainings-, Validierungs- und Testsets separat in den Funktionsspeicher hoch, indem Sie die Methode `file_upload` des Katalogs verwenden und jedes Mal den entsprechenden Pfad übergeben.\n",
"4. Initialisieren Sie den Quantenklassifikator mit Hilfe der Aktion `create` , die Hyperparameter wie die Anzahl und den Typ der Lerner, die Regularisierung (Lambda-Wert) und Optimierungsoptionen wie die Anzahl der Schichten, den Typ des klassischen Optimierers, das Quanten-Backend usw. akzeptiert.\n",
"5. Trainieren Sie den Quantum-Klassifikator auf der Trainingsmenge unter Verwendung der `fit` -Aktion der Funktion und übergeben Sie ihm die beschriftete Trainingsmenge und ggf. die Validierungsmenge.\n",
"6. Machen Sie Vorhersagen für die zuvor nicht gesehene Testmenge, indem Sie die `predict` Aktion der Funktion verwenden.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "26472870",
"metadata": {},
"source": [
"***\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "73390a19",
"metadata": {},
"source": [
"\n",
"\n",
"## Erste Schritte\n",
"\n",
"Authentifizieren Sie sich mit Ihrem [IBM Quantum Platform API-Schlüssel](http://quantum.cloud.ibm.com/), und wählen Sie die Qiskit-Funktion wie folgt aus:\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",
"## Beispiele\n",
"\n",
"\n",
"\n",
"### Einen Datensatz klassifizieren\n",
"\n",
"In diesem Beispiel verwenden Sie die Funktion \"Singularität Machine Learning - Klassifizierung\", um einen Datensatz zu klassifizieren, der aus zwei ineinander verschachtelten, mondförmigen Halbkreisen besteht. Der Datensatz ist synthetisch, zweidimensional und mit binären Bezeichnungen versehen. Sie ist so konzipiert, dass sie eine Herausforderung für Algorithmen wie zentrumsbasiertes Clustering und lineare Klassifizierung darstellt.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "b12f9ee4",
"metadata": {},
"source": [
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "b3cedca5",
"metadata": {},
"source": [
"Auf diese Weise lernen Sie, wie Sie den Klassifikator erstellen, ihn an die Trainingsdaten anpassen, ihn zur Vorhersage von Testdaten verwenden und den Klassifikator am Ende löschen.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "dba5a40e",
"metadata": {},
"source": [
"Bevor Sie beginnen, müssen Sie [scikit-learn](https://scikit-learn.org/) installieren. Installieren Sie es mit dem folgenden Befehl:\n",
"\n",
"```sh\n",
"python3 -m pip install scikit-learn\n",
"```\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "ba982810",
"metadata": {},
"source": [
"Führen Sie die folgenden Schritte aus:\n",
"\n",
"1. Erstellen Sie den synthetischen Datensatz mithilfe der [`make_moons`](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_moons.html) Funktion aus [scikit-learn](https://scikit-learn.org/).\n",
"2. Laden Sie den generierten synthetischen Datensatz in das [gemeinsame Datenverzeichnis](https://qiskit.github.io/qiskit-serverless/function_features/experimental/manage_data_directory.html) hoch.\n",
"3. Erstellen Sie den quantenverstärkten Klassifikator mithilfe der [`create`](/docs/api/functions/multiverse-computing-singularity#create) Aktion.\n",
"4. Registrieren Sie Ihre Klassifikatoren mithilfe der [`list`](/docs/api/functions/multiverse-computing-singularity#list) Aktion.\n",
"5. Trainieren Sie den Klassifikator anhand der Trainingsdaten mithilfe der [`fit`](/docs/api/functions/multiverse-computing-singularity#fit) Aktion.\n",
"6. Verwenden Sie den trainierten Klassifikator, um anhand der Testdaten Vorhersagen zu treffen, indem Sie die [`predict`](/docs/api/functions/multiverse-computing-singularity#predict) Aktion nutzen.\n",
"7. Löschen Sie den Klassifikator mithilfe der [`delete`](/docs/api/functions/multiverse-computing-singularity#delete) Aktion.\n",
"8. Räumen Sie auf, wenn Sie fertig sind.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "c1877f96",
"metadata": {},
"source": [
"**Schritt 1.** Importieren Sie die erforderlichen Module und erzeugen Sie einen synthetischen Datensatz, den Sie dann in einen Trainings- und einen Testdatensatz aufteilen.\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": [
"**Schritt 2.** Speichern Sie die beschrifteten Trainings- und Testdatensätze auf Ihrer lokalen Festplatte und laden Sie sie anschließend in das [gemeinsame Datenverzeichnis](https://qiskit.github.io/qiskit-serverless/function_features/experimental/manage_data_directory.html) hoch.\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": [
"**Schritt 3.** Erstellen Sie mithilfe der [`create`](/docs/api/functions/multiverse-computing-singularity#create) Aktion einen quantenoptimierten Klassifikator.\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": [
"**Schritt 4.** Trainieren Sie den quantenverstärkten Klassifikator mithilfe der [`fit`](/docs/api/functions/multiverse-computing-singularity#fit) Aktion.\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": [
"**Schritt 5.** Rufen Sie mithilfe der [`predict`](/docs/api/functions/multiverse-computing-singularity#predict) Aktion Vorhersagen und Wahrscheinlichkeiten vom quantenverstärkten Klassifikator ab.\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": [
"**Schritt 6.** Löschen Sie den quantenverstärkten Klassifikator mithilfe der [`delete`](/docs/api/functions/multiverse-computing-singularity#delete) Aktion.\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": [
"**Schritt 7.** Bereinigung von lokalen und gemeinsamen Datenverzeichnissen.\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` Beispiel\n",
"\n",
"Das folgende Beispiel veranschaulicht die [`create_fit_predict`](/docs/api/functions/multiverse-computing-singularity#create_fit_predict) Aktion.\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",
"## Benchmarks\n",
"\n",
"Diese Benchmarks zeigen, dass der Klassifikator bei anspruchsvollen Problemen extrem hohe Genauigkeiten erreichen kann. Sie zeigen auch, dass eine Erhöhung der Anzahl der Lernenden im Ensemble (Anzahl der Qubits) zu einer höheren Genauigkeit führen kann.\n",
"\n",
"\"Klassische Genauigkeit\" bezieht sich auf die Genauigkeit, die mit dem entsprechenden klassischen Stand der Technik erzielt wird, in diesem Fall einem AdaBoost Klassifikator, der auf einem Ensemble der Größe 75 basiert. die \"Quantengenauigkeit\" hingegen bezieht sich auf die Genauigkeit, die mit der \"Singularität Machine Learning - Klassifizierung\" erzielt wird.\n",
"\n",
"| Fehler | Größe des Datensatzes | Größe des Ensembles | Anzahl der Qubits | Klassische Genauigkeit | Quantengenauigkeit | Verbesserung |\n",
"| --------------------- | --------------------------- | ------------------- | ----------------- | ---------------------- | ------------------ | ------------ |\n",
"| Stabilität des Netzes | 5000 Beispiele, 12 Merkmale | 55 | 55 | 76 % | 91 % | 15 % |\n",
"| Stabilität des Netzes | 5000 Beispiele, 12 Merkmale | 65 | 65 | 76 % | 92 % | 16 % |\n",
"| Stabilität des Netzes | 5000 Beispiele, 12 Merkmale | 75 | 75 | 76 % | 94 % | 18 % |\n",
"| Stabilität des Netzes | 5000 Beispiele, 12 Merkmale | 85 | 85 | 76 % | 94 % | 18 % |\n",
"| Stabilität des Netzes | 5000 Beispiele, 12 Merkmale | 100 | 100 | 76 % | 95 % | 19°% |\n",
"\n",
"***\n",
"\n",
"Mit der Weiterentwicklung und Skalierung von Quanten-Hardware werden die Auswirkungen auf unseren Quantenklassifikator immer bedeutender. Die Anzahl der Qubits schränkt zwar die Größe des nutzbaren Ensembles ein, nicht aber die Menge der zu verarbeitenden Daten. Diese leistungsstarke Fähigkeit ermöglicht es dem Klassifikator, Datensätze mit Millionen von Datenpunkten und Tausenden von Merkmalen effizient zu verarbeiten. Wichtig ist, dass die Einschränkungen in Bezug auf die Größe des Ensembles durch die Implementierung einer groß angelegten Version des Klassifikators gelöst werden können. Durch den Einsatz eines iterativen Ansatzes für die äußere Schleife kann das Ensemble dynamisch erweitert werden, was die Flexibilität und die Gesamtleistung erhöht. Es ist jedoch anzumerken, dass diese Funktion in der aktuellen Version des Klassifikators noch nicht implementiert worden ist.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "cddff465",
"metadata": {},
"source": [
"\n",
"\n",
"## Änderungsprotokoll\n",
"\n",
"\n",
"\n",
"### 4. Juni 2025\n",
"\n",
"* Aktualisiert `QuantumEnhancedEnsembleClassifier` mit den folgenden Updates:\n",
" * Vor-Ort-/Alpha-Regularisierung hinzugefügt. Sie können `regularization_type` angeben, um `onsite` oder `alpha`\n",
" * Automatische Regulierung hinzugefügt. Sie können `regularization` auf `auto` setzen, um die automatische Regulierung zu verwenden\n",
" * Der `fit` Methode wurde der Parameter `optimization_data` hinzugefügt, um Optimierungsdaten für die Quantenoptimierung auszuwählen. Sie können eine der folgenden Optionen verwenden: `train`, `validation`, oder `both`\n",
" * Verbesserte Gesamtleistung\n",
"* Detaillierte Statusverfolgung für laufende Aufträge hinzugefügt\n",
"\n",
"\n",
"\n",
"### 20. Mai 2025\n",
"\n",
"* Standardisierte Fehlerbehandlung\n",
"\n",
"\n",
"\n",
"### 18. März 2025\n",
"\n",
"* Upgrade von qiskit-serverless auf 0.20.0 und Basis-Image auf 0.20.1\n",
"\n",
"\n",
"\n",
"### 14. Februar 2025\n",
"\n",
"* Aktualisiertes Basis-Image auf 0.19.1\n",
"\n",
"\n",
"\n",
"### 6. Februar 2025\n",
"\n",
"* Upgrade von qiskit-serverless auf 0.19.0 und Basis-Image auf 0.19.0\n",
"\n",
"\n",
"\n",
"### 13. November 2024\n",
"\n",
"* Veröffentlichung von Singularity Machine Learning - Klassifizierung\n",
"\n",
"\n",
"\n",
"## Unterstützung anfordern\n",
"\n",
"Bei Fragen wenden Sie sich bitte [an Multiverse Computing](mailto:singularity@multiversecomputing.com).\n",
"\n",
"Achten Sie darauf, dass Sie die folgenden Informationen angeben:\n",
"\n",
"* Die Qiskit-Funktion Job ID (`job.job_id`)\n",
"* Eine detaillierte Beschreibung des Problems\n",
"* Alle relevanten Fehlermeldungen oder Codes\n",
"* Schritte zum Reproduzieren des Problems\n",
"\n",
"\n",
"\n",
"## Nächste Schritte\n",
"\n",
"\n",
" * Beantragen Sie Zugang zur [Singularitätsklassifizierungsfunktion von Multiverse Computing Machine Learning](/functions?id=multiverse-singularity).\n",
" * Rufen Sie die [API-Referenz](/docs/api/functions/multiverse-computing-singularity) für diese Qiskit-Funktion auf.\n",
" * Rezension [Leclerc, L., et al. (2023). Finanzrisikomanagement auf einem neutralen Atom-Quantenprozessor. 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
}