Singularitäts Machine Learning – Klassifizierung: Eine Qiskit-Funktion von Multiverse Computing

Siehe API-Referenz

• Paketversionen

  Der Code auf dieser Seite wurde unter Berücksichtigung der folgenden Anforderungen entwickelt. Wir empfehlen, diese Versionen oder neuere zu verwenden.

  scikit-learn~=1.8.0
  

Übersicht

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.

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.

Es erzielt durchweg hohe Genauigkeiten bei klassisch anspruchsvollen Problemen mit hochdimensionalen, verrauschten und unausgewogenen Datensätzen.

Es ist für gebaut:

1. Ingenieure und Datenwissenschaftler in Unternehmen, die ihr technisches Angebot durch die Integration von maschinellem Lernen in ihre Produkte und Dienstleistungen verbessern möchten,
2. Forscher in Quantenforschungslabors, die Anwendungen des maschinellen Lernens mit Hilfe von Quantencomputern für Klassifizierungsaufgaben untersuchen, und
3. Studenten und Lehrer an Bildungseinrichtungen in Kursen wie maschinelles Lernen, die die Vorteile des Quantencomputings demonstrieren wollen.

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.

Funktionsbeschreibung

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.

Ein allgemeines Klassifizierungsproblem zu lösen:

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 erreicht werden.
2. Wenn der Trainingssatz unausgewogen ist, können Sie ihn mit imbalanced-learn neu abfragen, um die Klassen auszugleichen.
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.
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.
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.
6. Machen Sie Vorhersagen für die zuvor nicht gesehene Testmenge, indem Sie die predict Aktion der Funktion verwenden.

Erste Schritte

Authentifizieren Sie sich mit Ihrem IBM Quantum Platform API-Schlüssel, und wählen Sie die Qiskit-Funktion wie folgt aus:

from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

# Verify that you have access to the function
catalog.list()

Output:

[QiskitFunction(qunova/hivqe-chemistry),
 QiskitFunction(global-data-quantum/quantum-portfolio-optimizer),
 QiskitFunction(algorithmiq/tem),
 QiskitFunction(qedma/qesem),
 QiskitFunction(multiverse/singularity),
 QiskitFunction(ibm/circuit-function),
 QiskitFunction(q-ctrl/optimization-solver),
 QiskitFunction(colibritd/quick-pde),
 QiskitFunction(q-ctrl/performance-management),
 QiskitFunction(kipu-quantum/iskay-quantum-optimizer)]

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

Beispiele

Einen Datensatz klassifizieren

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.

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.

Bevor Sie beginnen, müssen Sie scikit-learn installieren. Installieren Sie es mit dem folgenden Befehl:

python3 -m pip install scikit-learn

Führen Sie die folgenden Schritte aus:

1. Erstellen Sie den synthetischen Datensatz mithilfe der make_moons Funktion aus scikit-learn.
2. Laden Sie den generierten synthetischen Datensatz in das gemeinsame Datenverzeichnis hoch.
3. Erstellen Sie den quantenverstärkten Klassifikator mithilfe der create Aktion.
4. Registrieren Sie Ihre Klassifikatoren mithilfe der list Aktion.
5. Trainieren Sie den Klassifikator anhand der Trainingsdaten mithilfe der fit Aktion.
6. Verwenden Sie den trainierten Klassifikator, um anhand der Testdaten Vorhersagen zu treffen, indem Sie die predict Aktion nutzen.
7. Löschen Sie den Klassifikator mithilfe der delete Aktion.
8. Räumen Sie auf, wenn Sie fertig sind.

Schritt 1. Importieren Sie die erforderlichen Module und erzeugen Sie einen synthetischen Datensatz, den Sie dann in einen Trainings- und einen Testdatensatz aufteilen.

# 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])

Output:

Features: [[ 0.84757037 -0.48831433]
 [ 0.98132552  0.19235443]
 [-0.71626723  0.6978261 ]
 [ 1.18957848 -0.48186557]
 [ 0.52118982 -0.37791846]
 [ 0.81115408  0.58483251]
 [ 0.48706462  0.87336593]
 [-0.81880144  0.57407682]
 [ 1.67335408 -0.23932015]
 [ 0.50181306  0.8649761 ]]
Targets: [1 0 0 1 1 0 0 0 1 0]

Schritt 2. Speichern Sie die beschrifteten Trainings- und Testdatensätze auf Ihrer lokalen Festplatte und laden Sie sie anschließend in das gemeinsame Datenverzeichnis hoch.

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

Output:

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

Schritt 3. Erstellen Sie mithilfe der create Aktion einen quantenoptimierten Klassifikator.

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

Output:

{'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))

Output:

{'status': 'ok', 'message': 'Classifiers listed.', 'data': {'classifiers': ['my_classifier']}, 'metadata': {'resource_usage': {}}}

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

Schritt 4. Trainieren Sie den quantenverstärkten Klassifikator mithilfe der fit Aktion.

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

Output:

{'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}}}}

Schritt 5. Rufen Sie mithilfe der predict Aktion Vorhersagen und Wahrscheinlichkeiten vom quantenverstärkten Klassifikator ab.

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

Output:

Action result status:  ok
Action result message:  Classifier predicted.
Predictions (first five results): [0, 0, 1, 0, 1]
Probabilities (first five results): [[1.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 0.0], [0.0, 1.0]]

Schritt 6. Löschen Sie den quantenverstärkten Klassifikator mithilfe der delete Aktion.

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

Output:

{'status': 'ok', 'message': 'Classifier deleted.', 'data': {}, 'metadata': {'resource_usage': {}}}

Schritt 7. Bereinigung von lokalen und gemeinsamen Datenverzeichnissen.

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

Output:

'Requested file was deleted.'

create_fit_predict Beispiel

Das folgende Beispiel veranschaulicht die create_fit_predict Aktion.

# 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"])

Output:

Job status:  QUEUED
Action result status:  ok
Action result message:  Classifier created, fitted, and predicted.
Predictions (first five results):  [0, 0, 1, 0, 0]
Probabilities (first five results):  [[0.87119766531518, 0.1288023346848197], [0.87119766531518, 0.1288023346848197], [0.24470328446479797, 0.7552967155352032], [0.820524432250189, 0.17947556774981072], [0.6847610293419495, 0.31523897065805173]]
Usage metadata:  {'RUNNING: MAPPING': {'CPU_TIME': 10.967791318893433}, 'RUNNING: WAITING_QPU': {'CPU_TIME': 59.91712307929993}, 'RUNNING: POST_PROCESSING': {'CPU_TIME': 59.097386837005615}, 'RUNNING: EXECUTING_QPU': {'QPU_TIME': 56.93338203430176}}

Benchmarks

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.

"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.

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.

Änderungsprotokoll

4. Juni 2025

• Aktualisiert QuantumEnhancedEnsembleClassifier mit den folgenden Updates:
  • Vor-Ort-/Alpha-Regularisierung hinzugefügt. Sie können regularization_type angeben, um onsite oder alpha
  • Automatische Regulierung hinzugefügt. Sie können regularization auf auto setzen, um die automatische Regulierung zu verwenden
  • 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
  • Verbesserte Gesamtleistung
• Detaillierte Statusverfolgung für laufende Aufträge hinzugefügt

20. Mai 2025

• Standardisierte Fehlerbehandlung

18. März 2025

• Upgrade von qiskit-serverless auf 0.20.0 und Basis-Image auf 0.20.1

14. Februar 2025

• Aktualisiertes Basis-Image auf 0.19.1

6. Februar 2025

• Upgrade von qiskit-serverless auf 0.19.0 und Basis-Image auf 0.19.0

13. November 2024

• Veröffentlichung von Singularity Machine Learning - Klassifizierung

Unterstützung anfordern

Bei Fragen wenden Sie sich bitte an Multiverse Computing.

Achten Sie darauf, dass Sie die folgenden Informationen angeben:

• Die Qiskit-Funktion Job ID (job.job_id)
• Eine detaillierte Beschreibung des Problems
• Alle relevanten Fehlermeldungen oder Codes
• Schritte zum Reproduzieren des Problems

Nächste Schritte