Singularity Machine Learning - Classification: Isang Qiskit Function ng Multiverse Computing

Tingnan ang API reference

Package versions

Ang code sa pahinang ito ay binuo gamit ang mga sumusunod na kinakailangan. Inirerekomenda namin ang paggamit ng mga bersyong ito o mas bago.

scikit-learn~=1.8.0

Paalala

• Ang Qiskit Functions ay isang experimental na feature na available lamang sa mga gumagamit ng IBM Quantum® Premium Plan, Flex Plan, at On-Prem (sa pamamagitan ng IBM Quantum Platform API) Plan. Nasa preview release status ito at maaaring magbago.

Pangkalahatang-ideya

Sa pamamagitan ng function na "Singularity Machine Learning - Classification", maaari kang malutas ng mga tunay na problema sa machine learning sa quantum hardware nang hindi kailangan ng kaalaman sa quantum. Ang Application function na ito, batay sa ensemble methods, ay isang hybrid classifier. Ginagamit nito ang mga klasikal na pamamaraan tulad ng boosting, bagging, at stacking para sa unang ensemble training. Pagkatapos, ginagamit ang mga quantum algorithm tulad ng variational quantum eigensolver (VQE) at quantum approximate optimization algorithm (QAOA) para mapahusay ang diversity, generalization capabilities, at kabuuang complexity ng na-train na ensemble.

Hindi tulad ng ibang quantum machine learning na solusyon, kaya ng function na ito na hawakan ang malalaking dataset na may milyun-milyong halimbawa at feature nang hindi nililimitahan ng bilang ng mga qubit sa target QPU. Ang bilang ng mga qubit ay nagtatakda lamang ng laki ng ensemble na maaaring i-train. Napaka-flexible din nito, at maaaring gamitin para malutas ang mga problema sa classification sa iba't ibang larangan, kabilang ang finance, healthcare, at cybersecurity. Palagi itong nakakamit ng mataas na accuracy sa mga klasikal na mahirap na problema na kinabibilangan ng high-dimensional, maingay, at imbalanced na dataset. Ginawa ito para sa:

1. Mga engineer at data scientist sa mga kumpanya na naghahanap na palawakin ang kanilang tech offerings sa pamamagitan ng pagsasama ng quantum machine learning sa kanilang mga produkto at serbisyo,
2. Mga mananaliksik sa mga quantum research lab na nag-eeksplora ng mga aplikasyon sa quantum machine learning at gustong gamitin ang quantum computing para sa mga gawain sa classification, at
3. Mga estudyante at guro sa mga institusyong pang-edukasyon sa mga kurso tulad ng machine learning, at gustong ipakita ang mga kalamangan ng quantum computing.

Ipinapakita ng sumusunod na halimbawa ang iba't ibang functionality nito, kabilang ang create, list, fit, at predict, at ipinapakita ang paggamit nito sa isang synthetic na problema na binubuo ng dalawang magkabaluktot na kalahating bilog, isang notoriously challenging na problema dahil sa nonlinear na hangganan ng desisyon nito.

Paglalarawan ng function

Ang Qiskit Function na ito ay nagbibigay-daan sa mga gumagamit na malutas ng mga problema sa binary classification gamit ang quantum-enhanced ensemble classifier ng Singularity. Sa likod ng eksena, gumagamit ito ng hybrid approach para klasikal na i-train ang isang ensemble ng mga classifier sa labeled na dataset, at pagkatapos ay i-optimize ito para sa maximum na diversity at generalization gamit ang Quantum Approximate Optimization Algorithm (QAOA) sa mga IBM® QPU. Sa pamamagitan ng user-friendly na interface, maaaring i-configure ng mga gumagamit ang isang classifier ayon sa kanilang mga pangangailangan, i-train ito sa dataset na kanilang pinili, at gamitin ito para gumawa ng mga hula sa isang dataset na hindi pa nakikita noon.

Para malutas ang isang generic na problema sa classification:

1. I-preprocess ang dataset, at hatiin ito sa mga training at testing set. Opsyonal, maaari mo ring hatiin ang training set sa mga training at validation set. Maaari itong makamit gamit ang scikit-learn.
2. Kung ang training set ay imbalanced, maaari mo itong i-resample para balansehin ang mga klase gamit ang imbalanced-learn.
3. I-upload ang mga training, validation, at test set nang hiwalay sa storage ng function gamit ang file_upload na paraan ng catalog, na ipinasa ang kaugnay na path sa bawat pagkakataon.
4. I-initialize ang quantum classifier sa pamamagitan ng paggamit ng create action ng function, na tumatanggap ng mga hyperparameter tulad ng bilang at uri ng mga learner, ang regularization (lambda value), at mga opsyon sa optimization kabilang ang bilang ng mga layer, uri ng klasikal na optimizer, ang quantum backend, at iba pa.
5. I-train ang quantum classifier sa training set gamit ang fit action ng function, ipinasa ang labeled na training set, at ang validation set kung naaangkop.
6. Gumawa ng mga hula sa dating hindi nakitang test set gamit ang predict action ng function.

---

Magsimula

Mag-authenticate gamit ang iyong IBM Quantum Platform API key, at piliin ang Qiskit Function tulad ng sumusunod:

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

Mga Halimbawa

I-classify ang isang dataset

Sa halimbawang ito, gagamitin mo ang function na "Singularity Machine Learning - Classification" para ma-classify ang isang dataset na binubuo ng dalawang magkasalubong na kalahating bilog na hugis-buwan. Ang dataset ay synthetic, dalawang-dimensional, at may mga binary na label. Ginawa ito upang maging mahirap para sa mga algorithm tulad ng centroid-based clustering at linear classification. Sa prosesong ito, matututunan mo kung paano gumawa ng classifier, i-fit ito sa training data, gamitin ito para mag-predict sa test data, at tanggalin ang classifier pagkatapos. Bago magsimula, kailangan mong i-install ang scikit-learn. I-install ito gamit ang sumusunod na command:

python3 -m pip install scikit-learn

Sundin ang mga sumusunod na hakbang:

1. Gumawa ng synthetic dataset gamit ang function na make_moons mula sa scikit-learn.
2. I-upload ang nabuong synthetic dataset sa shared data directory.
3. Gumawa ng quantum-enhanced classifier gamit ang action na create.
4. Ilista ang iyong mga classifier gamit ang action na list.
5. I-train ang classifier sa training data gamit ang action na fit.
6. Gamitin ang trained classifier para mag-predict sa test data gamit ang action na predict.
7. Tanggalin ang classifier gamit ang action na delete.
8. Linisin pagkatapos mong matapos. Hakbang 1. I-import ang mga kinakailangang module at buuin ang synthetic dataset, pagkatapos ay hatiin ito sa training at test datasets.

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

Hakbang 2. I-save ang mga may label na training at test datasets sa iyong lokal na disk, at pagkatapos ay i-upload ang mga ito sa shared data directory.

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

Hakbang 3. Gumawa ng quantum-enhanced classifier gamit ang action na 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']

Hakbang 4. I-train ang quantum-enhanced classifier gamit ang action na 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}}}}

Hakbang 5. Kumuha ng mga prediction at probability mula sa quantum-enhanced classifier gamit ang action na 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]]

Hakbang 6. Tanggalin ang quantum-enhanced classifier gamit ang action na 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': {}}}

Hakbang 7. Linisin ang lokal at shared data directories.

# 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.'

Halimbawa ng create_fit_predict

Ipinapakita ng sumusunod na halimbawa ang action na 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}}

Mga Benchmark

Ipinapakita ng mga benchmark na ito na kaya ng classifier na makamit ang napakataas na accuracy sa mga mahirap na problema. Ipinapakita rin nito na ang pagdaragdag ng bilang ng mga learner sa ensemble (bilang ng mga qubit) ay maaaring magdulot ng mas mataas na accuracy.

Ang "Classical accuracy" ay tumutukoy sa accuracy na nakuha gamit ang katumbas na klasikal na pinakamahusay na pamamaraan na, sa kasong ito, ay isang AdaBoost classifier batay sa ensemble na may sukat na 75. Ang "Quantum accuracy" naman ay tumutukoy sa accuracy na nakuha gamit ang "Singularity Machine Learning - Classification".

Problema	Laki ng Dataset	Laki ng Ensemble	Bilang ng mga Qubit	Classical Accuracy	Quantum Accuracy	Pagpapabuti
Grid stability	5000 halimbawa, 12 feature	55	55	76%	91%	15%
Grid stability	5000 halimbawa, 12 feature	65	65	76%	92%	16%
Grid stability	5000 halimbawa, 12 feature	75	75	76%	94%	18%
Grid stability	5000 halimbawa, 12 feature	85	85	76%	94%	18%
Grid stability	5000 halimbawa, 12 feature	100	100	76%	95%	19%

---

Habang umuunlad at lumalaki ang quantum hardware, nagiging mas malaki ang epekto nito sa ating quantum classifier. Bagama't ang bilang ng mga qubit ay naglalagay ng limitasyon sa laki ng ensemble na maaaring gamitin, hindi nito nililimitahan ang dami ng data na maaaring iproseso. Ang makapangyarihang kakayahang ito ay nagbibigay-daan sa classifier na mahusay na hawakan ang mga dataset na naglalaman ng milyun-milyong data point at libu-libong feature. Mahalaga ring tandaan na ang mga hadlang na may kaugnayan sa laki ng ensemble ay maaaring matugunan sa pamamagitan ng pagpapatupad ng large-scale na bersyon ng classifier. Sa pamamagitan ng paggamit ng iterative outer-loop approach, maaaring dynamic na palawakin ang ensemble, na nagpapahusay ng flexibility at pangkalahatang performance. Gayunpaman, kapansin-pansin na ang feature na ito ay hindi pa naipapatupad sa kasalukuyang bersyon ng classifier.

Changelog

4 Hunyo 2025

• Na-upgrade ang QuantumEnhancedEnsembleClassifier na may mga sumusunod na pagbabago:
  • Idinagdag ang onsite/alpha regularization. Maaari mong itakda ang regularization_type na maging onsite o alpha
  • Idinagdag ang auto-regularization. Maaari mong itakda ang regularization sa auto para gamitin ang auto-regularization
  • Idinagdag ang parameter na optimization_data sa fit method para pumili ng optimization data para sa quantum optimization. Maaari kang gumamit ng isa sa mga opsyong ito: train, validation, o both
  • Pinahusay ang pangkalahatang performance
• Idinagdag ang detalyadong status tracking para sa mga tumatakbong job

20 Mayo 2025

• Na-standardize ang error handling

18 Marso 2025

• Na-upgrade ang qiskit-serverless sa 0.20.0 at base image sa 0.20.1

14 Pebrero 2025

• Na-upgrade ang base image sa 0.19.1

6 Pebrero 2025

• Na-upgrade ang qiskit-serverless sa 0.19.0 at base image sa 0.19.0

13 Nobyembre 2024

• Inilabas ang Singularity Machine Learning - Classification

Makakuha ng suporta

Para sa anumang katanungan, makipag-ugnayan sa Multiverse Computing.

Tiyaking isama ang sumusunod na impormasyon:

• Ang Qiskit Function Job ID (job.job_id)
• Isang detalyadong paglalarawan ng isyu
• Anumang kaugnay na mensahe o code ng error
• Mga hakbang para muling likhain ang isyu

Mga susunod na hakbang

Mga Rekomendasyon

• Humiling ng access sa Multiverse Computing's Singularity Machine Learning Classification function.
• Bisitahin ang API reference para sa Qiskit Function na ito.
• Suriin ang Leclerc, L., et al. (2023). Financial risk management on a neutral atom quantum processor. Physical Review Research, 5, 043117.