Singularity Machine Learning - Classification: Fungsi Qiskit oleh Multiverse Computing

Lihat rujukan API

Versi pakej

Kod pada halaman ini dibangunkan menggunakan keperluan berikut. Kami mengesyorkan menggunakan versi ini atau yang lebih baharu.

scikit-learn~=1.8.0

Nota

• Fungsi Qiskit ialah ciri eksperimental yang hanya tersedia untuk pengguna Pelan Premium IBM Quantum®, Pelan Flex, dan Pelan On-Prem (melalui API Platform IBM Quantum). Ia berada dalam status pratonton dan tertakluk kepada perubahan.

Gambaran keseluruhan

Dengan fungsi "Singularity Machine Learning - Classification", anda boleh menyelesaikan masalah pembelajaran mesin dunia sebenar pada perkakasan kuantum tanpa memerlukan kepakaran kuantum. Fungsi Aplikasi ini, berasaskan kaedah ensemble, adalah pengelas hibrid. Ia memanfaatkan kaedah klasikal seperti boosting, bagging, dan stacking untuk latihan ensemble awal. Seterusnya, algoritma kuantum seperti variational quantum eigensolver (VQE) dan quantum approximate optimization algorithm (QAOA) digunakan untuk meningkatkan kepelbagaian, keupayaan generalisasi, dan kerumitan keseluruhan ensemble yang telah dilatih.

Tidak seperti penyelesaian pembelajaran mesin kuantum yang lain, fungsi ini mampu mengendalikan dataset berskala besar dengan jutaan contoh dan ciri tanpa terhad oleh bilangan qubit dalam QPU sasaran. Bilangan qubit hanya menentukan saiz ensemble yang boleh dilatih. Ia juga sangat fleksibel, dan boleh digunakan untuk menyelesaikan masalah klasifikasi merentasi pelbagai domain, termasuk kewangan, penjagaan kesihatan, dan keselamatan siber. Ia secara konsisten mencapai ketepatan tinggi pada masalah yang mencabar secara klasikal yang melibatkan dataset berdimensi tinggi, berderau, dan tidak seimbang. Ia dibina untuk:

1. Jurutera dan saintis data di syarikat yang ingin meningkatkan tawaran teknologi mereka dengan mengintegrasikan pembelajaran mesin kuantum ke dalam produk dan perkhidmatan mereka,
2. Penyelidik di makmal penyelidikan kuantum yang meneroka aplikasi pembelajaran mesin kuantum dan ingin memanfaatkan pengkomputeran kuantum untuk tugas klasifikasi, dan
3. Pelajar dan guru di institusi pendidikan dalam kursus seperti pembelajaran mesin, yang ingin menunjukkan kelebihan pengkomputeran kuantum.

Contoh berikut memperlihatkan pelbagai fungsinya, termasuk create, list, fit, dan predict, serta menunjukkan penggunaannya dalam masalah sintetik yang terdiri daripada dua separuh bulatan yang saling bersilang, masalah yang terkenal mencabar kerana sempadan keputusannya yang tidak linear.

Penerangan fungsi

Fungsi Qiskit ini membolehkan pengguna menyelesaikan masalah klasifikasi binari menggunakan pengelas ensemble yang dipertingkatkan dengan kuantum dari Singularity. Di sebalik tabir, ia menggunakan pendekatan hibrid untuk melatih ensemble pengelas secara klasikal pada dataset berlabel, kemudian mengoptimumkannya untuk kepelbagaian dan generalisasi maksimum menggunakan Quantum Approximate Optimization Algorithm (QAOA) pada QPU IBM®. Melalui antara muka yang mesra pengguna, pengguna boleh mengkonfigurasi pengelas mengikut keperluan mereka, melatihnya pada dataset pilihan mereka, dan menggunakannya untuk membuat ramalan pada dataset yang belum pernah dilihat sebelumnya.

Untuk menyelesaikan masalah klasifikasi umum:

1. Pra-proses dataset, dan bahagikannya kepada set latihan dan set pengujian. Secara pilihan, anda boleh membahagikan lagi set latihan kepada set latihan dan pengesahan. Ini boleh dicapai menggunakan scikit-learn.
2. Jika set latihan tidak seimbang, anda boleh mengambil semula sampel untuk mengimbangi kelas menggunakan imbalanced-learn.
3. Muat naik set latihan, pengesahan, dan pengujian secara berasingan ke storan fungsi menggunakan kaedah file_upload katalog, dengan menghantar laluan yang berkaitan setiap kali.
4. Mulakan pengelas kuantum menggunakan tindakan create fungsi, yang menerima hiperparameter seperti bilangan dan jenis pemelajar, penyelarasan (nilai lambda), dan pilihan pengoptimuman termasuk bilangan lapisan, jenis pengoptimum klasikal, Backend kuantum, dan sebagainya.
5. Latih pengelas kuantum pada set latihan menggunakan tindakan fit fungsi, dengan menghantar set latihan berlabel, dan set pengesahan jika berkaitan.
6. Buat ramalan pada set ujian yang belum pernah dilihat sebelumnya menggunakan tindakan predict fungsi.

---

Mulakan

Sahkan diri menggunakan kunci API Platform IBM Quantum anda, dan pilih Fungsi Qiskit seperti berikut:

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

Contoh

Klasifikasikan dataset

Dalam contoh ini, anda akan menggunakan fungsi "Singularity Machine Learning - Classification" untuk mengklasifikasikan dataset yang terdiri daripada dua separuh bulatan berbentuk bulan yang saling bersilang. Dataset ini adalah sintetik, dua dimensi, dan dilabelkan dengan label binari. Ia dicipta untuk mencabar algoritma seperti pengelompokan berasaskan centroid dan klasifikasi linear. Melalui proses ini, anda akan belajar cara mencipta pengelas, memasangkannya pada data latihan, menggunakannya untuk membuat ramalan pada data ujian, dan menghapus pengelas apabila selesai. Sebelum memulakan, anda perlu memasang scikit-learn. Pasangnya menggunakan arahan berikut:

python3 -m pip install scikit-learn

Laksanakan langkah-langkah berikut:

1. Cipta dataset sintetik menggunakan fungsi make_moons daripada scikit-learn.
2. Muat naik dataset sintetik yang dijana ke direktori data bersama.
3. Cipta pengelas yang dipertingkatkan kuantum menggunakan tindakan create.
4. Senaraikan pengelas anda menggunakan tindakan list.
5. Latih pengelas pada data latihan menggunakan tindakan fit.
6. Gunakan pengelas yang telah dilatih untuk membuat ramalan pada data ujian menggunakan tindakan predict.
7. Hapuskan pengelas menggunakan tindakan delete.
8. Bersihkan setelah selesai. Langkah 1. Import modul yang diperlukan dan jana dataset sintetik, kemudian bahagikannya kepada dataset latihan dan ujian.

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

Langkah 2. Simpan dataset latihan dan ujian berlabel pada cakera tempatan anda, kemudian muat naiknya ke direktori data bersama.

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

Langkah 3. Cipta pengelas yang dipertingkatkan kuantum menggunakan tindakan 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']

Langkah 4. Latih pengelas yang dipertingkatkan kuantum menggunakan tindakan 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}}}}

Langkah 5. Dapatkan ramalan dan kebarangkalian daripada pengelas yang dipertingkatkan kuantum menggunakan tindakan 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]]

Langkah 6. Hapuskan pengelas yang dipertingkatkan kuantum menggunakan tindakan 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': {}}}

Langkah 7. Bersihkan direktori data tempatan dan bersama.

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

Contoh create_fit_predict

Contoh berikut menunjukkan tindakan 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}}

Penanda aras

Penanda aras ini menunjukkan bahawa pengelas boleh mencapai ketepatan yang sangat tinggi pada masalah yang mencabar. Ia juga menunjukkan bahawa meningkatkan bilangan pemelajar dalam ensemble (bilangan qubit) boleh membawa kepada peningkatan ketepatan.

"Ketepatan klasikal" merujuk kepada ketepatan yang diperoleh menggunakan keadaan seni klasikal yang berkaitan yang, dalam kes ini, adalah pengelas AdaBoost berasaskan ensemble bersaiz 75. "Ketepatan kuantum", sebaliknya, merujuk kepada ketepatan yang diperoleh menggunakan "Singularity Machine Learning - Classification".

Masalah	Saiz Dataset	Saiz Ensemble	Bilangan qubit	Ketepatan Klasikal	Ketepatan Kuantum	Peningkatan
Kestabilan grid	5000 contoh, 12 ciri	55	55	76%	91%	15%
Kestabilan grid	5000 contoh, 12 ciri	65	65	76%	92%	16%
Kestabilan grid	5000 contoh, 12 ciri	75	75	76%	94%	18%
Kestabilan grid	5000 contoh, 12 ciri	85	85	76%	94%	18%
Kestabilan grid	5000 contoh, 12 ciri	100	100	76%	95%	19%

---

Apabila perkakasan kuantum berkembang dan berskala, implikasinya terhadap pengelas kuantum kami menjadi semakin ketara. Walaupun bilangan qubit memang mengenakan had pada saiz ensemble yang boleh digunakan, ia tidak menyekat jumlah data yang boleh diproses. Keupayaan yang hebat ini membolehkan pengelas mengendalikan dataset yang mengandungi jutaan titik data dan ribuan ciri dengan cekap. Yang penting, kekangan berkaitan saiz ensemble boleh diatasi melalui pelaksanaan versi berskala besar pengelas. Dengan memanfaatkan pendekatan gelung luar berulang, ensemble boleh dikembangkan secara dinamik, meningkatkan fleksibiliti dan prestasi keseluruhan. Walau bagaimanapun, perlu diambil perhatian bahawa ciri ini belum lagi dilaksanakan dalam versi pengelas semasa.

Log perubahan

4 Jun 2025

• Menaik taraf QuantumEnhancedEnsembleClassifier dengan kemas kini berikut:
  • Menambah regularisasi onsite/alpha. Anda boleh menentukan regularization_type sebagai onsite atau alpha
  • Menambah auto-regularization. Anda boleh menetapkan regularization kepada auto untuk menggunakan auto-regularization
  • Menambah parameter optimization_data kepada kaedah fit untuk memilih data pengoptimuman untuk pengoptimuman kuantum. Anda boleh menggunakan salah satu daripada pilihan ini: train, validation, atau both
  • Meningkatkan prestasi keseluruhan
• Menambah penjejakan status terperinci untuk kerja yang sedang berjalan

20 Mei 2025

• Menstandarkan pengendalian ralat

18 Mac 2025

• Menaik taraf qiskit-serverless kepada 0.20.0 dan imej asas kepada 0.20.1

14 Februari 2025

• Menaik taraf imej asas kepada 0.19.1

6 Februari 2025

• Menaik taraf qiskit-serverless kepada 0.19.0 dan imej asas kepada 0.19.0

13 November 2024

• Pelancaran Singularity Machine Learning - Classification

Dapatkan sokongan

Untuk sebarang pertanyaan, hubungi Multiverse Computing.

Pastikan anda menyertakan maklumat berikut:

• ID Kerja Fungsi Qiskit (job.job_id)
• Penerangan terperinci tentang isu tersebut
• Sebarang mesej atau kod ralat yang berkaitan
• Langkah-langkah untuk menghasilkan semula isu

Langkah seterusnya

Cadangan

• Minta akses kepada fungsi Singularity Machine Learning Classification Multiverse Computing.
• Lawati rujukan API untuk Fungsi Qiskit ini.
• Semak Leclerc, L., et al. (2023). Financial risk management on a neutral atom quantum processor. Physical Review Research, 5, 043117.