Singularity Machine Learning - Klasifikasi: Sebuah Qiskit Function oleh Multiverse Computing

Lihat API reference

Versi paket

Kode pada halaman ini dikembangkan menggunakan requirement berikut. Kami merekomendasikan menggunakan versi ini atau yang lebih baru.

scikit-learn~=1.8.0

Catatan

• Qiskit Functions adalah fitur eksperimental yang hanya tersedia untuk pengguna IBM Quantum® Premium Plan, Flex Plan, dan On-Prem (melalui IBM Quantum Platform API) Plan. Fitur ini masih dalam status rilis pratinjau dan dapat berubah sewaktu-waktu.

Ikhtisar

Dengan fungsi "Singularity Machine Learning - Klasifikasi", kamu bisa memecahkan masalah machine learning di dunia nyata menggunakan hardware kuantum tanpa perlu keahlian kuantum. Application function ini, yang didasarkan pada metode ensemble, adalah classifier hybrid. Fungsi ini memanfaatkan metode klasik seperti boosting, bagging, dan stacking untuk pelatihan ensemble awal. Selanjutnya, algoritma kuantum seperti variational quantum eigensolver (VQE) dan quantum approximate optimization algorithm (QAOA) digunakan untuk meningkatkan keberagaman, kemampuan generalisasi, dan kompleksitas keseluruhan ensemble yang telah dilatih.

Tidak seperti solusi quantum machine learning lainnya, fungsi ini mampu menangani dataset berskala besar dengan jutaan contoh dan fitur tanpa dibatasi oleh jumlah qubit pada QPU target. Jumlah qubit hanya menentukan ukuran ensemble yang dapat dilatih. Fungsi ini juga sangat fleksibel dan dapat digunakan untuk memecahkan masalah klasifikasi di berbagai domain, termasuk keuangan, kesehatan, dan keamanan siber. Fungsi ini secara konsisten mencapai akurasi tinggi pada masalah yang sulit secara klasik, melibatkan dataset berdimensi tinggi, berisik, dan tidak seimbang. Fungsi ini dibuat untuk:

1. Para engineer dan ilmuwan data di perusahaan yang ingin meningkatkan penawaran teknologi mereka dengan mengintegrasikan quantum machine learning ke dalam produk dan layanan mereka,
2. Para peneliti di laboratorium riset kuantum yang mengeksplorasi aplikasi quantum machine learning dan ingin memanfaatkan komputasi kuantum untuk tugas klasifikasi, serta
3. Mahasiswa dan pengajar di institusi pendidikan dalam mata kuliah seperti machine learning, yang ingin mendemonstrasikan keunggulan komputasi kuantum.

Contoh berikut menampilkan berbagai fungsinya, termasuk create, list, fit, dan predict, serta mendemonstrasikan penggunaannya pada masalah sintetis yang terdiri dari dua setengah lingkaran yang saling bersilangan — sebuah masalah yang terkenal sulit karena batas keputusannya yang nonlinier.

Deskripsi fungsi

Qiskit Function ini memungkinkan pengguna memecahkan masalah klasifikasi biner menggunakan classifier ensemble yang ditingkatkan kuantum dari Singularity. Di balik layar, fungsi ini menggunakan pendekatan hybrid untuk melatih ensemble classifier secara klasik pada dataset berlabel, lalu mengoptimalkannya untuk keberagaman dan generalisasi maksimal menggunakan Quantum Approximate Optimization Algorithm (QAOA) pada QPU IBM®. Melalui antarmuka yang ramah pengguna, pengguna dapat mengonfigurasi classifier sesuai kebutuhan mereka, melatihnya pada dataset pilihan, dan menggunakannya untuk membuat prediksi pada dataset yang belum pernah dilihat sebelumnya.

Untuk memecahkan masalah klasifikasi umum:

1. Praproses dataset, lalu bagi menjadi set pelatihan dan pengujian. Secara opsional, kamu bisa membagi lebih lanjut set pelatihan menjadi set pelatihan dan validasi. Hal ini dapat dilakukan menggunakan scikit-learn.
2. Jika set pelatihan tidak seimbang, kamu bisa melakukan resampling untuk menyeimbangkan kelas menggunakan imbalanced-learn.
3. Unggah set pelatihan, validasi, dan pengujian secara terpisah ke penyimpanan fungsi menggunakan metode file_upload dari catalog, dengan meneruskan path yang relevan setiap kali.
4. Inisialisasi classifier kuantum menggunakan aksi create dari fungsi, yang menerima hyperparameter seperti jumlah dan jenis learner, regularisasi (nilai lambda), serta opsi optimasi termasuk jumlah lapisan, jenis classical optimizer, quantum Backend, dan sebagainya.
5. Latih classifier kuantum pada set pelatihan menggunakan aksi fit dari fungsi, dengan meneruskan set pelatihan berlabel, dan set validasi jika ada.
6. Buat prediksi pada set pengujian yang belum pernah dilihat menggunakan aksi predict dari fungsi.

---

Mulai

Autentikasi menggunakan kunci API IBM Quantum Platform kamu, lalu pilih Qiskit Function 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

Mengklasifikasi sebuah dataset

Dalam contoh ini, kamu akan menggunakan fungsi "Singularity Machine Learning - Classification" untuk mengklasifikasi dataset yang terdiri dari dua setengah lingkaran berbentuk bulan yang saling terkait. Dataset ini bersifat sintetis, dua dimensi, dan diberi label biner. Dataset ini dirancang agar menantang bagi algoritma seperti clustering berbasis centroid dan klasifikasi linear. Melalui proses ini, kamu akan belajar cara membuat classifier, melatihnya pada data pelatihan, menggunakannya untuk memprediksi data uji, dan menghapus classifier setelah selesai. Sebelum mulai, kamu perlu menginstal scikit-learn. Instal menggunakan perintah berikut:

python3 -m pip install scikit-learn

Lakukan langkah-langkah berikut:

1. Buat dataset sintetis menggunakan fungsi make_moons dari scikit-learn.
2. Unggah dataset sintetis yang dihasilkan ke direktori data bersama.
3. Buat classifier yang ditingkatkan secara kuantum menggunakan aksi create.
4. Daftarkan classifier kamu menggunakan aksi list.
5. Latih classifier pada data pelatihan menggunakan aksi fit.
6. Gunakan classifier yang sudah dilatih untuk memprediksi data uji menggunakan aksi predict.
7. Hapus classifier menggunakan aksi delete.
8. Bersihkan setelah selesai. Langkah 1. Import modul yang diperlukan dan buat dataset sintetis, lalu bagi menjadi dataset pelatihan dan uji.

# 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 pelatihan dan uji yang sudah diberi label ke disk lokal kamu, lalu unggah 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. Buat classifier yang ditingkatkan secara kuantum menggunakan aksi 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 classifier yang ditingkatkan secara kuantum menggunakan aksi 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 prediksi dan probabilitas dari classifier yang ditingkatkan secara kuantum menggunakan aksi 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. Hapus classifier yang ditingkatkan secara kuantum menggunakan aksi 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 lokal 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 mendemonstrasikan aksi 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}}

Tolok Ukur

Tolok ukur ini menunjukkan bahwa classifier mampu mencapai akurasi yang sangat tinggi pada masalah-masalah yang menantang. Tolok ukur ini juga menunjukkan bahwa menambah jumlah learner dalam ensemble (jumlah qubit) dapat meningkatkan akurasi.

"Akurasi klasik" merujuk pada akurasi yang diperoleh menggunakan metode klasik terkini yang setara, yaitu classifier AdaBoost berbasis ensemble berukuran 75. Sementara itu, "akurasi kuantum" merujuk pada akurasi yang diperoleh menggunakan "Singularity Machine Learning - Classification".

Masalah	Ukuran Dataset	Ukuran Ensemble	Jumlah qubit	Akurasi Klasik	Akurasi Kuantum	Peningkatan
Stabilitas jaringan	5000 contoh, 12 fitur	55	55	76%	91%	15%
Stabilitas jaringan	5000 contoh, 12 fitur	65	65	76%	92%	16%
Stabilitas jaringan	5000 contoh, 12 fitur	75	75	76%	94%	18%
Stabilitas jaringan	5000 contoh, 12 fitur	85	85	76%	94%	18%
Stabilitas jaringan	5000 contoh, 12 fitur	100	100	76%	95%	19%

---

Seiring dengan berkembang dan meningkatnya perangkat keras kuantum, implikasinya bagi classifier kuantum kita menjadi semakin signifikan. Meskipun jumlah qubit memang membatasi ukuran ensemble yang dapat digunakan, hal ini tidak membatasi volume data yang dapat diproses. Kemampuan yang hebat ini memungkinkan classifier menangani dataset yang berisi jutaan titik data dan ribuan fitur secara efisien. Yang penting, kendala terkait ukuran ensemble dapat diatasi melalui implementasi versi skala besar dari classifier. Dengan memanfaatkan pendekatan outer-loop iteratif, ensemble dapat diperluas secara dinamis, meningkatkan fleksibilitas dan kinerja secara keseluruhan. Namun, perlu dicatat bahwa fitur ini belum diimplementasikan dalam versi classifier saat ini.

Catatan Perubahan

4 Juni 2025

• Meningkatkan QuantumEnhancedEnsembleClassifier dengan pembaruan berikut:
  • Menambahkan regularisasi onsite/alpha. Kamu bisa menentukan regularization_type sebagai onsite atau alpha
  • Menambahkan auto-regularisasi. Kamu bisa mengatur regularization ke auto untuk menggunakan auto-regularisasi
  • Menambahkan parameter optimization_data ke metode fit untuk memilih data optimasi pada optimasi kuantum. Kamu bisa menggunakan salah satu opsi berikut: train, validation, atau both
  • Peningkatan kinerja secara keseluruhan
• Menambahkan pelacakan status detail untuk job yang sedang berjalan

20 Mei 2025

• Standarisasi penanganan error

18 Maret 2025

• Meningkatkan qiskit-serverless ke 0.20.0 dan base image ke 0.20.1

14 Februari 2025

• Meningkatkan base image ke 0.19.1

6 Februari 2025

• Meningkatkan qiskit-serverless ke 0.19.0 dan base image ke 0.19.0

13 November 2024

• Rilis Singularity Machine Learning - Classification

Dapatkan dukungan

Untuk pertanyaan apa pun, hubungi Multiverse Computing.

Pastikan untuk menyertakan informasi berikut:

• ID Job Qiskit Function (job.job_id)
• Deskripsi masalah yang mendetail
• Pesan atau kode error yang relevan
• Langkah-langkah untuk mereproduksi masalah

Langkah selanjutnya

Rekomendasi

• Minta akses ke fungsi Singularity Machine Learning Classification milik Multiverse Computing.
• Kunjungi API reference untuk Qiskit Function ini.
• Tinjau Leclerc, L., et al. (2023). Financial risk management on a neutral atom quantum processor. Physical Review Research, 5, 043117.