Singularity Machine Learning - Classificazione: una funzione Qiskit di Multiverse Computing

Consulta la documentazione dell'API

• Versioni del pacchetto

  Il codice presente in questa pagina è stato sviluppato sulla base dei seguenti requisiti. Si consiglia di utilizzare queste versioni o quelle più recenti.

  scikit-learn~=1.8.0
  

Panoramica

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.

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.

Raggiunge costantemente alte precisioni su problemi classici che coinvolgono insiemi di dati altamente dimensionali, rumorosi e sbilanciati.

È costruito per:

1. Ingegneri e data scientist di aziende che vogliono migliorare la loro offerta tecnologica integrando l'apprendimento automatico quantistico nei loro prodotti e servizi,
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
3. Studenti e insegnanti di istituti scolastici in corsi come l'apprendimento automatico e che vogliono dimostrare i vantaggi dell'informatica quantistica.

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.

Descrizione funzione

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.

Risolvere un problema generico di classificazione:

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.
2. Se l'insieme di allenamento è sbilanciato, è possibile ricampionarlo per bilanciare le classi usando imbalanced-learn.
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.
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.
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.
6. Effettuare previsioni sull'insieme di test non visto in precedenza, utilizzando l'azione predict della funzione.

Introduzione

Autenticatevi utilizzando la vostra chiave API di IBM Quantum Platform e selezionate la funzione Qiskit come segue:

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

Esempi

Classificare un set di dati

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.

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.

Prima di iniziare, è necessario installare scikit-learn. Installatelo con il seguente comando:

python3 -m pip install scikit-learn

Eseguire i passi riportati di seguito:

1. Crea il set di dati sintetico utilizzando la make_moons funzione di scikit-learn.
2. Carica il set di dati sintetici generato nella directory dei dati condivisa.
3. Crea il classificatore potenziato quantisticamente utilizzando create l'azione.
4. Aggiungi i tuoi classificatori utilizzando l'azione list .
5. Addestra il classificatore sui dati di addestramento utilizzando l'azione fit .
6. Utilizza il classificatore addestrato per effettuare previsioni sui dati di test utilizzando predict l'azione.
7. Elimina il classificatore utilizzando l'azione delete .
8. Pulite dopo aver finito.

Passo 1. Importare i moduli necessari e generare il dataset sintetico, quindi dividerlo in dataset di allenamento e di test.

# import the necessary modules for this example
import os
import tarfile
import numpy as np

# Import the make_moons and the train_test_split functions from scikit-learn
# to create a synthetic dataset and split it into training and test datasets
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split

# generate the synthetic dataset
X, y = make_moons(n_samples=10000)

# split the data into training and test datasets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# print the first 10 samples of the training dataset
print("Features:", X_train[:10, :])
print("Targets:", y_train[:10])

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]

Passo 2. Salva i set di dati di addestramento e di verifica etichettati sul tuo disco locale, quindi caricali nella directory dei dati condivisa.

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

Passaggio 3. Crea un classificatore potenziato quantisticamente utilizzando l'azione create .

job = singularity.run(
    action="create",
    name="my_classifier",
    num_learners=10,
    learners_types=[
        "DecisionTreeClassifier",
        "KNeighborsClassifier",
    ],
    learners_proportions=[0.5, 0.5],
    learners_options=[{}, {}],
    regularization=0.01,
    weight_update_method="logarithmic",
    sample_scaling=True,
    optimizer_options={"simulator": True},
    voting="soft",
    prob_threshold=0.5,
)

print(job.result())

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

Passaggio 4. Addestrare il classificatore potenziato quantisticamente utilizzando l'azione fit .

job = singularity.run(
    action="fit",
    name="my_classifier",
    X="X_train.npy",  # you do not need to specify the tar extension
    y="y_train.npy",  # you do not need to specify the tar extension
)

print(job.result())

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

Passo 5. Ottieni previsioni e probabilità dal classificatore potenziato quantisticamente utilizzando predict l'azione.

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

Passaggio 6. Elimina il classificatore potenziato quantisticamente utilizzando l'azione delete .

job = singularity.run(
    action="delete",
    name="my_classifier",
)

# or you can delete from the shared data directory
# catalog.file_delete("my_classifier.pkl.tar", singularity)

print(job.result())

Output:

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

Passo 7. Pulire le directory di dati locali e condivise.

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

L'esempio seguente illustra l'azione create_fit_predict .

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

Benchmark

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.

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

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.

Log di modifica

4 giugno 2025

• Aggiornato QuantumEnhancedEnsembleClassifier con i seguenti aggiornamenti:
  • Aggiunta regolarizzazione in loco/alfa. È possibile specificare che regularization_type sia onsite o alpha
  • Aggiunta della regolarizzazione automatica. È possibile impostare regularization su auto per utilizzare la regolarizzazione automatica
  • 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
  • Miglioramento delle prestazioni complessive
• Aggiunto il monitoraggio dettagliato dello stato per i lavori in esecuzione

20 maggio 2025

• Gestione degli errori standardizzata

18 marzo 2025

• Aggiornato qiskit-serverless a 0.20.0 e l'immagine base a 0.20.1

14 febbraio 2025

• Aggiornata l'immagine di base a 0.19.1

6 febbraio 2025

• Aggiornato qiskit-serverless a 0.19.0 e l'immagine base a 0.19.0

13 novembre 2024

• Rilascio di Singularity Machine Learning - Classificazione

Ottenere supporto

Per qualsiasi domanda, contattate Multiverse Computing.

Assicuratevi di includere le seguenti informazioni:

• La funzione Qiskit ID lavoro (job.job_id)
• Una descrizione dettagliata del problema
• Eventuali messaggi o codici di errore rilevanti
• Passi per riprodurre il problema

Passi successivi