Singularity Machine Learning - Classification: A Qiskit Function by Multiverse Computing

See the API reference

Package versions

The code on this page was developed using the following requirements. We recommend using these versions or newer.

scikit-learn~=1.8.0

Notă

• Funcțiile Qiskit sunt o funcționalitate experimentală disponibilă doar utilizatorilor IBM Quantum® Premium Plan, Flex Plan și On-Prem (prin IBM Quantum Platform API) Plan. Acestea se află în stare de previzualizare și pot suferi modificări.

Prezentare generală

Cu funcția „Singularity Machine Learning - Classification" poți rezolva probleme reale de machine learning pe hardware cuantic fără a necesita expertiză cuantică. Această funcție applicație, bazată pe metode ensemble, este un clasificator hibrid. Utilizează metode clasice precum boosting, bagging și stacking pentru antrenarea inițială a ensemble-ului. Ulterior, se folosesc algoritmi cuantici precum variational quantum eigensolver (VQE) și quantum approximate optimization algorithm (QAOA) pentru a îmbunătăți diversitatea, capacitățile de generalizare și complexitatea globală a ensemble-ului antrenat.

Spre deosebire de alte soluții de quantum machine learning, această funcție este capabilă să gestioneze seturi de date la scară largă cu milioane de exemple și caracteristici, fără a fi limitată de numărul de qubiți din QPU-ul țintă. Numărul de qubiți determină doar dimensiunea ensemble-ului care poate fi antrenat. De asemenea, este extrem de flexibilă și poate fi utilizată pentru a rezolva probleme de clasificare într-o gamă largă de domenii, inclusiv finanțe, sănătate și securitate cibernetică. Obține în mod consistent acuratețe ridicată pe probleme clasic dificile, care implică seturi de date de înaltă dimensionalitate, zgomotoase și dezechilibrate. Este construită pentru:

1. Ingineri și oameni de știință din domeniul datelor din companii care caută să-și îmbunătățească oferta tehnologică integrând quantum machine learning în produsele și serviciile lor,
2. Cercetători din laboratoare de cercetare cuantică care explorează aplicații de quantum machine learning și doresc să valorifice calculul cuantic pentru sarcini de clasificare, și
3. Studenți și profesori din instituții de învățământ în cursuri precum machine learning, care caută să demonstreze avantajele calculului cuantic.

Următorul exemplu prezintă diversele funcționalități ale acesteia, inclusiv create, list, fit și predict, și demonstrează utilizarea sa într-o problemă sintetică ce cuprinde două semicercuri interconectate, o problemă notorie dificilă din cauza graniței sale de decizie neliniare.

Descrierea funcției

Această funcție Qiskit permite utilizatorilor să rezolve probleme de clasificare binară folosind clasificatorul ensemble îmbunătățit cuantic al Singularity. În spatele scenei, folosește o abordare hibridă pentru a antrena clasic un ensemble de clasificatoare pe setul de date etichetat, iar apoi îl optimizează pentru diversitate maximă și generalizare folosind Quantum Approximate Optimization Algorithm (QAOA) pe QPU-urile IBM®. Printr-o interfață prietenoasă cu utilizatorul, poți configura un clasificator conform cerințelor tale, îl antrenezi pe setul de date dorit și îl utilizezi pentru a face predicții pe un set de date nevăzut anterior.

Pentru a rezolva o problemă generică de clasificare:

1. Preprocesează setul de date și împarte-l în seturi de antrenare și testare. Opțional, poți împărți în continuare setul de antrenare în seturi de antrenare și validare. Acest lucru poate fi realizat folosind scikit-learn.
2. Dacă setul de antrenare este dezechilibrat, îl poți reeșantiona pentru a echilibra clasele folosind imbalanced-learn.
3. Încarcă seturile de antrenare, validare și testare separat în stocarea funcției folosind metoda file_upload a catalogului, pasând calea relevantă de fiecare dată.
4. Inițializează clasificatorul cuantic folosind acțiunea create a funcției, care acceptă hiperparametri precum numărul și tipurile de algoritmi de învățare, regularizarea (valoarea lambda) și opțiunile de optimizare, inclusiv numărul de straturi, tipul de optimizer clasic, Backend-ul cuantic și altele.
5. Antrenează clasificatorul cuantic pe setul de antrenare folosind acțiunea fit a funcției, pasând setul de antrenare etichetat și setul de validare dacă este aplicabil.
6. Realizează predicții pe setul de testare nevăzut anterior folosind acțiunea predict a funcției.

---

Primii pași

Autentifică-te folosind cheia ta de API IBM Quantum Platform și selectează Qiskit Function după cum urmează:

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit-ibm-catalog scikit-learn

from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

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

Exemple

Clasificarea unui set de date

În acest exemplu, vei folosi funcția „Singularity Machine Learning - Classification” pentru a clasifica un set de date format din două semicercuri interconectate în formă de lună. Setul de date este sintetic, bidimensional și etichetat cu etichete binare. Este creat pentru a fi dificil pentru algoritmi precum clustering bazat pe centroizi și clasificare liniară. Prin acest proces, vei învăța cum să creezi clasificatorul, să îl antrenezi pe datele de antrenament, să îl folosești pentru a face predicții pe datele de test și să îl ștergi când ai terminat. Înainte de a începe, trebuie să instalezi scikit-learn. Instalează-l folosind următoarea comandă:

python3 -m pip install scikit-learn

Efectuează pașii următori:

1. Creează setul de date sintetic folosind funcția make_moons din scikit-learn.
2. Încarcă setul de date sintetic generat în directorul de date partajate.
3. Creează clasificatorul îmbunătățit cuantic folosind acțiunea create.
4. Listează clasificatorii tăi folosind acțiunea list.
5. Antrenează clasificatorul pe datele de antrenament folosind acțiunea fit.
6. Folosește clasificatorul antrenat pentru a face predicții pe datele de test, utilizând acțiunea predict.
7. Șterge clasificatorul folosind acțiunea delete.
8. Fă curățenie după ce ai terminat. Pasul 1. Importă modulele necesare și generează setul de date sintetic, apoi împarte-l în seturi de antrenament și de 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])

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]

Pasul 2. Salvează seturile de date de antrenament și testare etichetate pe discul local, apoi încarcă-le în directorul de date partajate.

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

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

Pasul 3. Creează un clasificator îmbunătățit cuantic folosind acțiunea 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())

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

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

Pasul 4. Antrenează clasificatorul cu îmbunătățiri cuantice folosind acțiunea 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())

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

Pasul 5. Obține predicții și probabilități de la clasificatorul cu îmbunătățiri cuantice folosind acțiunea predict.

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

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

Pasul 6. Șterge clasificatorul cu îmbunătățiri cuantice folosind acțiunea 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())

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

Pasul 7. Curăță directoarele de date locale și partajate.

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

'Requested file was deleted.'

Exemplu create_fit_predict

Următorul exemplu demonstrează acțiunea 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"])

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

Aceste benchmark-uri arată că clasificatorul poate atinge acuratețe extrem de ridicată pe probleme dificile. De asemenea, demonstrează că mărirea numărului de learner-e din ansamblu (numărul de Qubiți) poate conduce la o acuratețe mai mare.

„Acuratețea clasică" se referă la acuratețea obținută folosind metoda clasică corespunzătoare de ultimă generație, care în acest caz este un clasificator AdaBoost bazat pe un ansamblu de dimensiune 75. „Acuratețea cuantică" se referă, pe de altă parte, la acuratețea obținută folosind „Singularity Machine Learning - Classification".

Problemă	Dimensiunea setului de date	Dimensiunea ansamblului	Numărul de Qubiți	Acuratețe clasică	Acuratețe cuantică	Îmbunătățire
Stabilitate rețea	5000 exemple, 12 caracteristici	55	55	76%	91%	15%
Stabilitate rețea	5000 exemple, 12 caracteristici	65	65	76%	92%	16%
Stabilitate rețea	5000 exemple, 12 caracteristici	75	75	76%	94%	18%
Stabilitate rețea	5000 exemple, 12 caracteristici	85	85	76%	94%	18%
Stabilitate rețea	5000 exemple, 12 caracteristici	100	100	76%	95%	19%

---

Pe măsură ce hardware-ul cuantic evoluează și se extinde, implicațiile pentru clasificatorul nostru cuantic devin din ce în ce mai semnificative. Deși numărul de Qubiți impune limitări asupra dimensiunii ansamblului care poate fi utilizat, acesta nu restricționează volumul de date ce pot fi procesate. Această capabilitate puternică permite clasificatorului să gestioneze eficient seturi de date ce conțin milioane de puncte de date și mii de caracteristici. Important de menționat este că limitările legate de dimensiunea ansamblului pot fi abordate prin implementarea unei versiuni la scară largă a clasificatorului. Prin valorificarea unei abordări iterative cu buclă exterioară, ansamblul poate fi extins dinamic, sporind flexibilitatea și performanța generală. Totuși, merită remarcat că această funcționalitate nu a fost încă implementată în versiunea actuală a clasificatorului.

Jurnal de modificări

4 iunie 2025

• Actualizat QuantumEnhancedEnsembleClassifier cu următoarele modificări:
  • Adăugată regularizare onsite/alpha. Poți specifica regularization_type ca onsite sau alpha
  • Adăugată auto-regularizare. Poți seta regularization la auto pentru a folosi auto-regularizarea
  • Adăugat parametrul optimization_data la metoda fit pentru a alege datele de optimizare pentru optimizarea cuantică. Poți folosi una dintre aceste opțiuni: train, validation sau both
  • Îmbunătățită performanța generală
• Adăugată urmărire detaliată a stării pentru job-urile în execuție

20 mai 2025

• Standardizată gestionarea erorilor

18 martie 2025

• Actualizat qiskit-serverless la 0.20.0 și imaginea de bază la 0.20.1

14 februarie 2025

• Actualizată imaginea de bază la 0.19.1

6 februarie 2025

• Actualizat qiskit-serverless la 0.19.0 și imaginea de bază la 0.19.0

13 noiembrie 2024

• Lansarea Singularity Machine Learning - Classification

Obține suport

Pentru orice întrebări, contactează Multiverse Computing.

Asigură-te că incluzi următoarele informații:

• ID-ul job-ului Qiskit Function (job.job_id)
• O descriere detaliată a problemei
• Orice mesaje de eroare sau coduri relevante
• Pașii pentru a reproduce problema

Pași următori

Recommendations

• Solicită acces la funcția Singularity Machine Learning Classification de la Multiverse Computing.
• Vizitează referința API pentru această funcție Qiskit.
• Consultă Leclerc, L., et al. (2023). Financial risk management on a neutral atom quantum processor. Physical Review Research, 5, 043117.