Pengelasan ensemble hibrid dipertingkat kuantum (aliran kerja kestabilan grid)

Anggaran penggunaan: 20 minit masa QPU bagi setiap kerja pada pemproses Eagle r3. (NOTA: Ini hanya anggaran. Masa larian sebenar anda mungkin berbeza.)

Latar Belakang

Tutorial ini menunjukkan aliran kerja hibrid kuantum–klasik yang mempertingkat ensemble klasik dengan langkah pengoptimuman kuantum. Menggunakan "Singularity Machine Learning – Classification" dari Multiverse Computing (sebuah Fungsi Qiskit), kita melatih sekumpulan pemelajar konvensional (contohnya, pokok keputusan, k-NN, regresi logistik) kemudian memperhalusi kumpulan tersebut dengan lapisan kuantum untuk meningkatkan kepelbagaian dan generalisasi. Objektifnya praktikal: pada tugas ramalan kestabilan grid yang nyata, kita membandingkan garis asas klasik yang kukuh dengan alternatif dioptimumkan kuantum pada bahagian data yang sama, supaya anda dapat melihat di mana langkah kuantum membantu dan apa kos yang diperlukan.

Mengapa ini penting: memilih subset yang baik daripada banyak pemelajar lemah ialah masalah kombinatori yang berkembang pesat mengikut saiz ensemble. Heuristik klasik seperti boosting, bagging, dan stacking berprestasi baik pada skala sederhana tetapi boleh bergelut untuk meneroka perpustakaan model yang besar dan berlebihan dengan cekap. Fungsi ini mengintegrasikan algoritma kuantum — khususnya QAOA (dan secara pilihan VQE dalam konfigurasi lain) — untuk mencari ruang tersebut dengan lebih berkesan selepas pemelajar klasik dilatih, meningkatkan peluang untuk menemui subset yang padat dan pelbagai yang lebih bagus dalam generalisasi.

Yang penting, skala data tidak dihadkan oleh qubit. Kerja berat pada data — prapemprosesan, melatih kumpulan pemelajar, dan penilaian — kekal klasik dan boleh mengendalikan jutaan contoh. Qubit hanya menentukan saiz ensemble yang digunakan dalam langkah pemilihan kuantum. Penyahgandingan ini yang menjadikan pendekatan ini berdaya maju pada perkakasan hari ini: anda mengekalkan aliran kerja scikit-learn yang biasa untuk data dan latihan model sambil memanggil langkah kuantum melalui antara muka tindakan yang bersih dalam Qiskit Functions.

Dalam amalan, walaupun pelbagai jenis pemelajar boleh diberikan kepada ensemble (contohnya, pokok keputusan, regresi logistik, atau k-NN), Pokok Keputusan cenderung berprestasi terbaik. Pengoptimum secara konsisten memilih ahli ensemble yang lebih kuat — apabila pemelajar heterogen dibekalkan, model yang lebih lemah seperti pengresor linear biasanya dipangkas demi yang lebih ekspresif seperti Pokok Keputusan.

Apa yang akan anda lakukan di sini: sediakan dan seimbangkan dataset kestabilan grid; wujudkan garis asas AdaBoost klasik; jalankan beberapa konfigurasi kuantum yang mengubah lebar ensemble dan penggularisasian; laksanakan pada simulator IBM® atau QPU melalui Qiskit Serverless; dan bandingkan ketepatan, ketepatan, ingatan semula, dan F1 merentas semua larian. Sepanjang perjalanan, anda akan menggunakan corak tindakan fungsi (create, fit, predict, fit_predict, create_fit_predict) dan kawalan utama:

• Jenis penggularisasian: onsite (λ) untuk kekurangan langsung dan alpha untuk pertukaran berasaskan nisbah antara sebutan interaksi dan onsite
• Penggularisasian automatik: tetapkan regularization="auto" dengan nisbah pemilihan sasaran untuk menyesuaikan kekurangan secara automatik
• Pilihan pengoptimum: simulator berbanding QPU, pengulangan, pengoptimum klasik dan pilihan-pilihannya, kedalaman transpilasi, dan tetapan Sampler/Estimator runtime

Penanda aras dalam dokumentasi menunjukkan ketepatan bertambah baik apabila bilangan pemelajar (qubit) meningkat pada masalah yang mencabar, dengan pengelas kuantum menandingi atau melebihi ensemble klasik yang setanding. Dalam tutorial ini, anda akan menghasilkan semula aliran kerja dari hujung ke hujung dan meneliti bila peningkatan lebar ensemble atau bertukar kepada penggularisasian adaptif menghasilkan F1 yang lebih baik dengan penggunaan sumber yang munasabah. Hasilnya ialah pandangan yang berasas tentang bagaimana langkah pengoptimuman kuantum boleh melengkapi, bukannya menggantikan, pembelajaran ensemble klasik dalam aplikasi sebenar.

Keperluan

Sebelum memulakan tutorial ini, pastikan anda telah memasang pakej-pakej berikut dalam persekitaran Python anda:

• qiskit[visualization]~=2.1.0
• qiskit-serverless~=0.24.0
• qiskit-ibm-runtime v0.40.1
• qiskit-ibm-catalog~=0.8.0
• scikit-learn==1.5.2
• pandas>=2.0.0,<3.0.0
• imbalanced-learn~=0.12.3

Persediaan

Dalam bahagian ini, kita memulakan klien Qiskit Serverless dan memuatkan fungsi Singularity Machine Learning – Classification yang disediakan oleh Multiverse Computing. Dengan Qiskit Serverless, anda boleh menjalankan aliran kerja hibrid kuantum–klasik pada infrastruktur awan terurus IBM tanpa perlu risau tentang pengurusan sumber. Anda memerlukan kunci API IBM Quantum Platform dan nama sumber awan anda (CRN) untuk mengesahkan identiti dan mengakses Qiskit Functions.

Muat turun dataset

Untuk menjalankan tutorial ini, kita menggunakan dataset pengelasan kestabilan grid yang telah diprapemproses, mengandungi bacaan sensor sistem kuasa yang berlabel. Sel berikut secara automatik mencipta struktur folder yang diperlukan dan memuat turun kedua-dua fail latihan dan ujian terus ke dalam persekitaran anda menggunakan wget. Jika anda sudah mempunyai fail-fail ini secara tempatan, langkah ini akan menimpanya dengan selamat untuk memastikan konsistensi versi.

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

## Download dataset for Grid Stability Classification

# Create data directory if it doesn't exist
!mkdir -p data_tutorial/grid_stability

# Download the training and test sets from the official Qiskit documentation repo
!wget -q --show-progress -O data_tutorial/grid_stability/train.csv \
  https://raw.githubusercontent.com/Qiskit/documentation/main/datasets/tutorials/grid_stability/train.csv

!wget -q --show-progress -O data_tutorial/grid_stability/test.csv \
  https://raw.githubusercontent.com/Qiskit/documentation/main/datasets/tutorials/grid_stability/test.csv

# Check the files have been downloaded
!echo "Dataset files downloaded:"
!ls -lh data_tutorial/grid_stability/*.csv

data_tutorial/grid_ 100%[===================>] 612.94K  --.-KB/s    in 0.01s
data_tutorial/grid_ 100%[===================>] 108.19K  --.-KB/s    in 0.006s
Dataset files downloaded:
-rw-r--r-- 1 coder coder 109K Nov  8 18:50 data_tutorial/grid_stability/test.csv
-rw-r--r-- 1 coder coder 613K Nov  8 18:50 data_tutorial/grid_stability/train.csv

Import pakej yang diperlukan

Dalam bahagian ini, kita mengimport semua pakej Python dan modul Qiskit yang digunakan sepanjang tutorial. Ini termasuk perpustakaan saintifik teras untuk pengendalian data dan penilaian model — seperti NumPy, pandas, dan scikit-learn — bersama alat visualisasi dan komponen Qiskit untuk menjalankan model dipertingkat kuantum. Kita juga mengimport QiskitRuntimeService dan QiskitFunctionsCatalog untuk bersambung dengan perkhidmatan IBM Quantum® dan mengakses fungsi Singularity Machine Learning.

from typing import Tuple
import warnings

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from imblearn.over_sampling import RandomOverSampler
from qiskit_ibm_catalog import QiskitFunctionsCatalog
from qiskit_ibm_runtime import QiskitRuntimeService
from sklearn.ensemble import AdaBoostClassifier
from sklearn.metrics import (
    accuracy_score,
    f1_score,
    precision_score,
    recall_score,
)
from sklearn.model_selection import train_test_split

warnings.filterwarnings("ignore")

Tetapkan pemboleh ubah tetap

IBM_TOKEN = ""
IBM_INSTANCE_TEST = ""
IBM_INSTANCE_QUANTUM = ""
FUNCTION_NAME = "multiverse/singularity"
RANDOM_STATE: int = 123
TRAIN_PATH = "data_tutorial/grid_stability/train.csv"
TEST_PATH = "data_tutorial/grid_stability/test.csv"

Sambung ke IBM Quantum dan muatkan fungsi Singularity

Seterusnya, kita mengesahkan identiti dengan perkhidmatan IBM Quantum dan memuatkan fungsi Singularity Machine Learning – Classification daripada Katalog Fungsi Qiskit. QiskitRuntimeService mewujudkan sambungan selamat ke IBM Quantum Platform menggunakan token API dan CRN instance anda, membolehkan akses kepada Backend kuantum. QiskitFunctionsCatalog kemudian digunakan untuk mendapatkan semula fungsi Singularity mengikut nama ("multiverse/singularity"), membolehkan kita memanggilnya kemudian untuk pengiraan hibrid kuantum–klasik. Jika persediaan berjaya, anda akan melihat mesej pengesahan yang menunjukkan fungsi telah dimuatkan dengan betul.

service = QiskitRuntimeService(
    token=IBM_TOKEN,
    channel="ibm_quantum_platform",
    instance=IBM_INSTANCE_QUANTUM,
)

backend = service.least_busy()
catalog = QiskitFunctionsCatalog(
    token=IBM_TOKEN,
    instance=IBM_INSTANCE_TEST,
    channel="ibm_quantum_platform",
)
singularity = catalog.load(FUNCTION_NAME)
print(
    "Successfully connected to IBM Qiskit Serverless and loaded the Singularity function."
)
print("Catalog:", catalog)
print("Singularity function:", singularity)

Successfully connected to IBM Qiskit Serverless and loaded the Singularity function.
Catalog: <QiskitFunctionsCatalog>
Singularity function: QiskitFunction(multiverse/singularity)

Takrifkan fungsi pembantu

Sebelum menjalankan eksperimen utama, kita mentakrifkan beberapa fungsi utiliti kecil yang memperlancar pemuatan data dan penilaian model.

• load_data() membaca fail CSV input ke dalam tatasusunan NumPy, memisahkan ciri dan label untuk keserasian dengan scikit-learn dan aliran kerja kuantum.
• evaluate_predictions() mengira metrik prestasi utama — ketepatan, presisi, ingatan semula, dan skor F1 — dan secara pilihan melaporkan masa larian jika maklumat masa disediakan.

Fungsi pembantu ini memudahkan operasi berulang kemudian dalam buku nota dan memastikan pelaporan metrik yang konsisten merentas kedua-dua pengelas klasik dan kuantum.

def load_data(data_path: str) -> Tuple[np.ndarray, np.ndarray]:
    """Load data from the given path to X and y arrays."""
    df: pd.DataFrame = pd.read_csv(data_path)
    return df.iloc[:, :-1].values, df.iloc[:, -1].values

def evaluate_predictions(predictions, y_true):
    """Compute and print accuracy, precision, recall, and F1 score."""
    accuracy = accuracy_score(y_true, predictions)
    precision = precision_score(y_true, predictions)
    recall = recall_score(y_true, predictions)
    f1 = f1_score(y_true, predictions)
    print("Accuracy:", accuracy)
    print("Precision:", precision)
    print("Recall:", recall)
    print("F1:", f1)
    return accuracy, precision, recall, f1

Langkah 1: Petakan input klasik kepada masalah kuantum

Kita mulakan dengan menyediakan dataset untuk eksperimen hibrid kuantum–klasik. Matlamat langkah ini ialah menukar data kestabilan grid mentah kepada bahagian latihan, pengesahan, dan ujian yang seimbang yang boleh digunakan secara konsisten oleh kedua-dua aliran kerja klasik dan kuantum. Mengekalkan bahagian yang sama memastikan perbandingan prestasi kemudian adalah adil dan boleh dihasilkan semula.

Pemuatan dan prapemprosesan data

Kita mula-mula memuatkan fail CSV latihan dan ujian, mencipta bahagian pengesahan, dan mengimbangi dataset menggunakan pensampelan semula berlebihan rawak. Pengimbangan mencegah berat sebelah ke arah kelas majoriti dan memberikan isyarat pembelajaran yang lebih stabil untuk kedua-dua model ensemble klasik dan kuantum.

# Load and upload the data
X_train, y_train = load_data(TRAIN_PATH)
X_test, y_test = load_data(TEST_PATH)
X_train, X_val, y_train, y_val = train_test_split(
    X_train, y_train, test_size=0.2, random_state=RANDOM_STATE
)

# Balance the dataset through over-sampling of the positive class
ros = RandomOverSampler(random_state=RANDOM_STATE)
X_train_bal, y_train_bal = ros.fit_resample(X_train, y_train)

print("Shapes:")
print("  X_train_bal:", X_train_bal.shape)
print("  y_train_bal:", y_train_bal.shape)
print("  X_val:", X_val.shape)
print("  y_val:", y_val.shape)
print("  X_test:", X_test.shape)
print("  y_test:", y_test.shape)

Shapes:
  X_train_bal: (5104, 12)
  y_train_bal: (5104,)
  X_val: (850, 12)
  y_val: (850,)
  X_test: (750, 12)
  y_test: (750,)

Garis asas klasik: Rujukan AdaBoost

Sebelum menjalankan sebarang pengoptimuman kuantum, kita melatih garis asas klasik yang kukuh — pengelas AdaBoost standard — pada data seimbang yang sama. Ini menyediakan titik rujukan yang boleh dihasilkan semula untuk perbandingan kemudian, membantu mengukur sama ada pengoptimuman kuantum meningkatkan generalisasi atau kecekapan melebihi ensemble klasik yang diselaraskan dengan baik.

# ----- Classical baseline: AdaBoost -----
baseline = AdaBoostClassifier(n_estimators=60, random_state=RANDOM_STATE)
baseline.fit(X_train_bal, y_train_bal)
baseline_pred = baseline.predict(X_test)
print("Classical AdaBoost baseline:")
_ = evaluate_predictions(baseline_pred, y_test)

Classical AdaBoost baseline:
Accuracy: 0.7893333333333333
Precision: 1.0
Recall: 0.7893333333333333
F1: 0.8822652757078987

Langkah 2: Optimumkan masalah untuk pelaksanaan perkakasan kuantum

Tugas pemilihan ensemble diformulasikan sebagai masalah pengoptimuman kombinatori di mana setiap pemelajar lemah ialah pemboleh ubah keputusan binari, dan objektif mengimbangi ketepatan dengan kekurangan melalui sebutan penggularisasian. QuantumEnhancedEnsembleClassifier menyelesaikan ini dengan QAOA pada perkakasan IBM, sambil tetap membenarkan penerokaan berasaskan simulator. optimizer_options mengawal gelung hibrid: simulator=False menghalakan litar ke QPU yang dipilih, num_solutions meningkatkan keluasan carian, dan classical_optimizer_options (untuk pengoptimum klasik dalaman) mengawal penumpuan; nilai sekitar 60 lelaran adalah keseimbangan yang baik antara kualiti dan masa larian. Pilihan runtime — seperti kedalaman litar sederhana (reps) dan usaha transpilasi standard — membantu memastikan prestasi yang kukuh merentas peranti. Konfigurasi di bawah ialah profil "keputusan terbaik" yang akan kita gunakan untuk larian perkakasan; anda juga boleh mencipta varian yang disimulasi sepenuhnya dengan togol simulator=True untuk menguji aliran kerja tanpa menggunakan masa QPU.

# QAOA / runtime configuration for best results on hardware
optimizer_options = {
    "simulator": False,  # set True to test locally without QPU
    "num_solutions": 100_000,  # broaden search over candidate ensembles
    "reps": 3,  # QAOA depth (circuit layers)
    "optimization_level": 3,  # transpilation effort
    "num_transpiler_runs": 30,  # explore multiple layouts
    "classical_optimizer": "COBYLA",  # robust default for this landscape
    "classical_optimizer_options": {
        "maxiter": 60  # practical convergence budget
    },
    # You can pass backend-specific options; leaving None uses least-busy routing
    "estimator_options": None,
    "sampler_options": None,
}

print("Configured hardware optimization profile:")
for key, value in optimizer_options.items():
    print(f"  {key}: {value}")

Configured hardware optimization profile:
  simulator: False
  num_solutions: 100000
  reps: 3
  optimization_level: 3
  num_transpiler_runs: 30
  classical_optimizer: COBYLA
  classical_optimizer_options: {'maxiter': 60}
  estimator_options: None
  sampler_options: None

Langkah 3: Laksanakan menggunakan primitif Qiskit

Kita kini melaksanakan aliran kerja penuh menggunakan tindakan create_fit_predict fungsi Singularity untuk melatih, mengoptimumkan, dan menilai QuantumEnhancedEnsembleClassifier dari hujung ke hujung pada infrastruktur IBM. Fungsi ini membina ensemble, menggunakan pengoptimuman kuantum melalui primitif Qiskit, dan mengembalikan kedua-dua ramalan dan metadata kerja (termasuk masa larian dan penggunaan sumber). Bahagian data klasik dari Langkah 1 digunakan semula untuk kebolehhasilan semula, dengan data pengesahan dihantar melalui fit_params supaya pengoptimuman boleh menyetel hiperparameter secara dalaman sambil mengekalkan set ujian yang tidak disentuh.

Dalam langkah ini, kita meneroka beberapa konfigurasi ensemble kuantum untuk memahami bagaimana parameter utama — khususnya num_learners dan regularization — mempengaruhi kualiti keputusan dan penggunaan QPU.

• num_learners menentukan lebar ensemble (dan secara tersirat, bilangan qubit), mempengaruhi kapasiti model dan kos pengiraan.
• regularization mengawal kekurangan dan overfitting, membentuk berapa banyak pemelajar yang kekal aktif selepas pengoptimuman.

Dengan mengubah parameter-parameter ini, kita dapat melihat bagaimana lebar ensemble dan penggularisasian berinteraksi: peningkatan lebar biasanya meningkatkan F1 tetapi memerlukan lebih masa QPU, manakala penggularisasian yang lebih kuat atau adaptif boleh meningkatkan generalisasi dengan jejak perkakasan yang lebih kurang sama. Subseksyen seterusnya menelusuri tiga konfigurasi wakil untuk menggambarkan kesan-kesan ini.

Garis asas

Konfigurasi ini menggunakan num_learners = 10 dan regularization = 7.

• num_learners mengawal lebar ensemble — secara berkesan bilangan pemelajar lemah yang digabungkan dan, pada perkakasan kuantum, bilangan qubit yang diperlukan. Nilai yang lebih besar mengembangkan ruang carian kombinatori dan boleh meningkatkan ketepatan dan ingatan semula, tetapi juga meningkatkan lebar litar, masa kompilasi, dan keseluruhan penggunaan QPU.
• regularization menetapkan kekuatan penalti untuk menyertakan pemelajar tambahan. Dengan penggularisasian "onsite" lalai, nilai yang lebih tinggi menguatkuasakan kekurangan yang lebih kuat (lebih sedikit pemelajar dikekalkan), manakala nilai yang lebih rendah membenarkan ensemble yang lebih kompleks.

Persediaan ini menyediakan garis asas berkos rendah, menunjukkan bagaimana ensemble kecil berkelakuan sebelum menaikkan lebar atau menyetel kekurangan.

# Problem scale and regularization
NUM_LEARNERS = 10
REGULARIZATION = 7

# ----- Quantum-enhanced ensemble on IBM hardware -----
print("\n-- Submitting quantum-enhanced ensemble job --")
job_1 = singularity.run(
    action="create_fit_predict",
    name="grid_stability_qeec",
    quantum_classifier="QuantumEnhancedEnsembleClassifier",
    num_learners=NUM_LEARNERS,
    regularization=REGULARIZATION,
    optimizer_options=optimizer_options,  # from Step 2
    backend_name=backend,  # least-busy compatible backend
    instance=IBM_INSTANCE_QUANTUM,
    random_state=RANDOM_STATE,
    X_train=X_train_bal,
    y_train=y_train_bal,
    X_test=X_test,
    fit_params={"validation_data": (X_val, y_val)},
    options={"save": False},
)
result_1 = job_1.result()
print("Action status:", result_1.get("status"))
print("Action message:", result_1.get("message"))
print("Metadata:", result_1.get("metadata"))
qeec_pred_job_1 = np.array(result_1["data"]["predictions"])
_ = evaluate_predictions(qeec_pred_job_1, y_test)

-- Submitting quantum-enhanced ensemble job --
Action status: ok
Action message: Classifier created, fitted, and predicted.
Metadata: {'resource_usage': {'RUNNING: MAPPING': {'CPU_TIME': 267.05158376693726}, 'RUNNING: WAITING_QPU': {'CPU_TIME': 3336.8785166740417}, 'RUNNING: POST_PROCESSING': {'CPU_TIME': 152.4274561405182}, 'RUNNING: EXECUTING_QPU': {'QPU_TIME': 1550.1889700889587}}}
Accuracy: 0.868
Precision: 1.0
Recall: 0.868
F1: 0.9293361884368309

status_1 = job_1.status()
print("\nQuantum job status:", status_1)

Quantum job status: DONE

Tingkatkan bilangan pemelajar

Di sini kita meningkatkan num_learners daripada 10 → 30 sambil mengekalkan regularization = 7.

• Lebih banyak pemelajar mengembangkan ruang hipotesis, membolehkan model menangkap corak yang lebih halus, yang boleh sedikit meningkatkan F1.
• Dalam kebanyakan kes, perbezaan masa larian antara 10 dan 30 pemelajar tidaklah ketara, menunjukkan bahawa lebar litar yang bertambah tidak meningkatkan kos pelaksanaan dengan ketara.
• Peningkatan dalam kualiti masih mengikuti keluk pulangan yang semakin berkurangan: keuntungan awal muncul apabila ensemble berkembang, tetapi ia mendatar apabila pemelajar tambahan menyumbang lebih sedikit maklumat baru.

Eksperimen ini menonjolkan pertukaran kualiti–kecekapan — peningkatan lebar ensemble mungkin menawarkan keuntungan ketepatan kecil tanpa penalti masa larian yang besar, bergantung pada keadaan Backend dan transpilasi.

# Problem scale and regularization
NUM_LEARNERS = 30
REGULARIZATION = 7

# ----- Quantum-enhanced ensemble on IBM hardware -----
print("\n-- Submitting quantum-enhanced ensemble job --")
job_2 = singularity.run(
    action="create_fit_predict",
    name="grid_stability_qeec",
    quantum_classifier="QuantumEnhancedEnsembleClassifier",
    num_learners=NUM_LEARNERS,
    regularization=REGULARIZATION,
    optimizer_options=optimizer_options,  # from Step 2
    backend_name=backend,  # least-busy compatible backend
    instance=IBM_INSTANCE_QUANTUM,
    random_state=RANDOM_STATE,
    X_train=X_train_bal,
    y_train=y_train_bal,
    X_test=X_test,
    fit_params={"validation_data": (X_val, y_val)},
    options={"save": False},
)
result_2 = job_2.result()
print("Action status:", result_2.get("status"))
print("Action message:", result_2.get("message"))
print("QPU Time:", result_2.get("metadata"))
qeec_pred_job_2 = np.array(result_2["data"]["predictions"])
_ = evaluate_predictions(qeec_pred_job_2, y_test)

-- Submitting quantum-enhanced ensemble job --
Action status: ok
Action message: Classifier created, fitted, and predicted.
QPU Time: {'resource_usage': {'RUNNING: MAPPING': {'CPU_TIME': 680.2116754055023}, 'RUNNING: WAITING_QPU': {'CPU_TIME': 80.80395102500916}, 'RUNNING: POST_PROCESSING': {'CPU_TIME': 154.4466371536255}, 'RUNNING: EXECUTING_QPU': {'QPU_TIME': 1095.822762966156}}}
Accuracy: 0.8946666666666667
Precision: 1.0
Recall: 0.8946666666666667
F1: 0.944405348346235

status_2 = job_2.status()
print("\nQuantum job status:", status_2)

Quantum job status: DONE

Penggularisasian

Dalam konfigurasi ini, kita meningkat kepada num_learners = 60 dan memperkenalkan penggularisasian adaptif untuk mengurus kekurangan dengan lebih intuitif.

• Dengan regularization = "auto", pengoptimum secara automatik mencari kekuatan penggularisasian yang sesuai yang memilih kira-kira regularization_ratio * num_learners pemelajar lemah untuk ensemble akhir, bukannya menetapkan penalti secara manual. Ini menyediakan antara muka yang lebih mudah untuk mengurus keseimbangan antara kekurangan dan saiz ensemble.
• regularization_type = "alpha" mentakrifkan cara penalti digunakan. Tidak seperti onsite, yang tidak terbatas [0, ∞], alpha dibatasi antara [0, 1], menjadikannya lebih mudah diselaraskan dan ditafsirkan. Parameter mengawal pertukaran antara penalti individu dan berpasangan, menawarkan julat konfigurasi yang lebih lancar.
• regularization_desired_ratio ≈ 0.82 menentukan nisbah sasaran pemelajar yang akan dikekalkan aktif selepas penggularisasian — di sini, kira-kira 82% pemelajar dikekalkan, memangkas 18% yang paling lemah secara automatik.

Walaupun penggularisasian adaptif memudahkan konfigurasi dan membantu mengekalkan ensemble yang seimbang, ia tidak semestinya menjamin prestasi yang lebih baik atau lebih stabil. Kualiti sebenar bergantung pada pemilihan parameter penggularisasian yang sesuai, dan menyetelnya melalui pengesahan silang boleh memerlukan kos pengiraan yang tinggi. Kelebihan utama terletak pada kebolehgunaan dan kebolehertian yang lebih baik, bukannya keuntungan ketepatan langsung.

# Problem scale and regularization
NUM_LEARNERS = 60
REGULARIZATION = "auto"
REGULARIZATION_TYPE = "alpha"
REGULARIZATION_RATIO = 0.82

# ----- Quantum-enhanced ensemble on IBM hardware -----
print("\n-- Submitting quantum-enhanced ensemble job --")
job_3 = singularity.run(
    action="create_fit_predict",
    name="grid_stability_qeec",
    quantum_classifier="QuantumEnhancedEnsembleClassifier",
    num_learners=NUM_LEARNERS,
    regularization=REGULARIZATION,
    regularization_type=REGULARIZATION_TYPE,
    regularization_desired_ratio=REGULARIZATION_RATIO,
    optimizer_options=optimizer_options,  # from Step 2
    backend_name=backend,  # least-busy compatible backend
    instance=IBM_INSTANCE_QUANTUM,
    random_state=RANDOM_STATE,
    X_train=X_train_bal,
    y_train=y_train_bal,
    X_test=X_test,
    fit_params={"validation_data": (X_val, y_val)},
    options={"save": False},
)
result_3 = job_3.result()
print("Action status:", result_3.get("status"))
print("Action message:", result_3.get("message"))
print("Metadata:", result_3.get("metadata"))
qeec_pred_job_3 = np.array(result_3["data"]["predictions"])
_ = evaluate_predictions(qeec_pred_job_3, y_test)

-- Submitting quantum-enhanced ensemble job --
Action status: ok
Action message: Classifier created, fitted, and predicted.
Metadata: {'resource_usage': {'RUNNING: MAPPING': {'CPU_TIME': 1387.7451872825623}, 'RUNNING: WAITING_QPU': {'CPU_TIME': 95.41597843170166}, 'RUNNING: POST_PROCESSING': {'CPU_TIME': 171.78878355026245}, 'RUNNING: EXECUTING_QPU': {'QPU_TIME': 1146.5584812164307}}}
Accuracy: 0.908
Precision: 1.0
Recall: 0.908
F1: 0.9517819706498952

status_3 = job_3.status()
print("\nQuantum job status:", status_3)

Quantum job status: DONE

Langkah 4: Proses pasca dan kembalikan hasil dalam format klasikal yang dikehendaki

Kita sekarang akan memproses output daripada kedua-dua jalaran klasikal dan kuantum, mengubahnya kepada format yang konsisten untuk penilaian hiliran. Langkah ini membandingkan kualiti ramalan menggunakan metrik piawai — ketepatan, presisi, ingatan semula, dan F1 — serta menganalisis bagaimana lebar ensemble (num_learners) dan kawalan jarangnya (regularization) mempengaruhi prestasi dan tingkah laku pengiraan.

Garis asas AdaBoost klasikal menyediakan rujukan yang padat dan stabil untuk pembelajaran berskala kecil. Ia berprestasi baik dengan ensemble terhad dan overhead pengiraan yang boleh diabaikan, mencerminkan kekuatan boosting tradisional apabila ruang hipotesis masih mudah diuruskan. Konfigurasi kuantum (qeec_pred_job_1, qeec_pred_job_2, dan qeec_pred_job_3) melanjutkan garis asas ini dengan membenamkan proses pemilihan ensemble dalam gelung pengoptimuman kuantum variasi. Ini membolehkan sistem meneroka subset peramal yang terlalu besar secara serentak dalam superposisi, menangani sifat kombinatorial pemilihan ensemble dengan lebih cekap apabila skala meningkat.

Hasil menunjukkan bahawa meningkatkan num_learners daripada 10 kepada 30 meningkatkan ingatan semula dan F1, mengesahkan bahawa ensemble yang lebih lebar menangkap interaksi yang lebih kaya antara peramal lemah. Keuntungan itu adalah sublinear pada perkakasan semasa — setiap peramal tambahan menghasilkan kenaikan ketepatan yang lebih kecil — tetapi tingkah laku penskalaan asas kekal menggalakkan kerana pengoptimum kuantum boleh mencari ruang konfigurasi yang lebih luas tanpa letupan eksponen yang biasa berlaku dalam pemilihan subset klasikal. Pengaturan semula memperkenalkan nuansa tambahan: λ=7 yang tetap menguatkuasakan jarangnya yang konsisten dan menstabilkan penumpuan, manakala pengaturan semula α-adaptif secara automatik menala jarangnya berdasarkan korelasi antara peramal. Pemangkasan dinamik ini sering mencapai F1 yang sedikit lebih tinggi untuk lebar qubit yang sama, mengimbangi kerumitan model dan generalisasi.

Berbanding terus dengan garis asas AdaBoost, konfigurasi kuantum terkecil (L=10) menghasilkan semula ketepatan yang serupa, mengesahkan ketepatan saluran paip hibrid. Pada lebar yang lebih besar, varian kuantum — terutamanya dengan pengaturan semula auto — mula melampaui garis asas klasikal secara sederhana, menunjukkan ingatan semula dan F1 yang lebih baik tanpa pertumbuhan linear dalam kos pengiraan. Peningkatan ini tidak menunjukkan "kelebihan kuantum" serta-merta tetapi sebaliknya kecekapan penskalaan: pengoptimum kuantum mengekalkan prestasi yang boleh diuruskan apabila ensemble berkembang, di mana pendekatan klasikal akan menghadapi pertumbuhan eksponen dalam kerumitan pemilihan subset.

Dalam praktik:

• Gunakan garis asas klasikal untuk pengesahan cepat dan penanda aras pada set data kecil.
• Gunakan ensemble kuantum apabila lebar model atau kerumitan ciri meningkat — carian berasaskan QAOA berskala dengan lebih baik dalam kes sebegitu.
• Gunakan α-pengaturan semula adaptif untuk mengekalkan jarangnya dan generalisasi tanpa meningkatkan lebar Circuit.
• Pantau masa QPU dan kedalaman untuk mengimbangi keuntungan kualiti dengan kekangan perkakasan jangka hampir.

Bersama-sama, eksperimen ini menunjukkan bahawa ensemble yang dioptimumkan secara kuantum melengkapi kaedah klasikal: ia menghasilkan semula ketepatan garis asas pada skala kecil sambil menawarkan laluan kepada penskalaan yang cekap pada masalah pembelajaran kombinatorial yang lebih besar. Apabila perkakasan bertambah baik, kelebihan penskalaan ini dijangka akan berlipat ganda, melanjutkan saiz dan kedalaman model berasaskan ensemble yang boleh dilaksanakan melebihi apa yang boleh dilakukan secara klasikal.

Nilai metrik untuk setiap konfigurasi

Kita sekarang menilai semua konfigurasi — garis asas AdaBoost klasikal dan tiga ensemble kuantum — menggunakan pembantu evaluate_predictions untuk mengira ketepatan, presisi, ingatan semula, dan F1 pada set ujian yang sama. Perbandingan ini menjelaskan bagaimana pengoptimuman kuantum berskala berbanding pendekatan klasikal: pada lebar kecil, kedua-duanya berprestasi serupa; apabila ensemble berkembang, kaedah kuantum boleh meneroka ruang hipotesis yang lebih besar dengan lebih cekap. Jadual yang terhasil merakam trend ini dalam bentuk kuantitatif yang konsisten.

results = []

# Classical baseline
acc_b, prec_b, rec_b, f1_b = evaluate_predictions(baseline_pred, y_test)
results.append(
    {
        "Config": "AdaBoost (Classical)",
        "Accuracy": acc_b,
        "Precision": prec_b,
        "Recall": rec_b,
        "F1": f1_b,
    }
)

# Quantum runs
for label, preds in [
    ("QEEC L=10, reg=7", qeec_pred_job_1),
    ("QEEC L=30, reg=7", qeec_pred_job_2),
    (f"QEEC L=60, reg=auto (α={REGULARIZATION_RATIO})", qeec_pred_job_3),
]:
    acc, prec, rec, f1 = evaluate_predictions(preds, y_test)
    results.append(
        {
            "Config": label,
            "Accuracy": acc,
            "Precision": prec,
            "Recall": rec,
            "F1": f1,
        }
    )

df_results = pd.DataFrame(results)
df_results

Accuracy: 0.7893333333333333
Precision: 1.0
Recall: 0.7893333333333333
F1: 0.8822652757078987
Accuracy: 0.868
Precision: 1.0
Recall: 0.868
F1: 0.9293361884368309
Accuracy: 0.8946666666666667
Precision: 1.0
Recall: 0.8946666666666667
F1: 0.944405348346235
Accuracy: 0.908
Precision: 1.0
Recall: 0.908
F1: 0.9517819706498952

Config  Accuracy  Precision    Recall        F1
0          AdaBoost (Classical)  0.789333        1.0  0.789333  0.882265
1              QEEC L=10, reg=7  0.868000        1.0  0.868000  0.929336
2              QEEC L=30, reg=7  0.894667        1.0  0.894667  0.944405
3  QEEC L=60, reg=auto (α=0.82)  0.908000        1.0  0.908000  0.951782

Visualisasikan trend kualiti merentasi konfigurasi

Carta bar berkumpulan di bawah membandingkan Ketepatan dan F1 merentasi garis asas klasikal dan ensemble kuantum (L=10, L=30, dan L=60 auto-α). Ia menggambarkan bagaimana ketepatan stabil manakala F1 secara beransur-ansur bertambah baik apabila lebar ensemble kuantum meningkat, menunjukkan bahawa kaedah hibrid mengekalkan penskalaan prestasi tanpa pertumbuhan kos eksponen yang biasa berlaku dalam pemilihan subset klasikal.

x = np.arange(len(df_results))
width = 0.35
plt.figure(figsize=(7.6, 4.6))
plt.bar(x - width / 2, df_results["Accuracy"], width=width, label="Accuracy")
plt.bar(x + width / 2, df_results["F1"], width=width, label="F1")
plt.xticks(x, df_results["Config"], rotation=10)
plt.ylabel("Score")
plt.title("Classical vs Quantum ensemble performance")
plt.legend()
plt.ylim(0, 1.0)
plt.tight_layout()
plt.show()

Interpretasi

Plot ini mengesahkan corak penskalaan yang dijangkakan. AdaBoost klasikal berprestasi kukuh untuk ensemble yang lebih kecil tetapi menjadi semakin mahal untuk diskala apabila bilangan peramal lemah bertambah, kerana masalah pemilihan subsetnya berkembang secara kombinatorial. Model yang dipertingkatkan kuantum menghasilkan semula ketepatan klasikal pada lebar rendah dan mula melampauinya apabila saiz ensemble meningkat, terutamanya di bawah α-pengaturan semula adaptif. Ini mencerminkan keupayaan pengoptimum kuantum untuk mensampling dan menilai banyak calon subset secara selari melalui superposisi, mengekalkan carian yang boleh diuruskan walaupun pada lebar yang lebih tinggi. Walaupun overhead perkakasan semasa mengimbangi sebahagian daripada keuntungan teori, trend ini menggambarkan kelebihan kecekapan penskalaan formulasi kuantum. Dalam istilah praktik, kaedah klasikal kekal lebih disukai untuk penanda aras ringan, manakala ensemble yang dipertingkatkan kuantum menjadi lebih menguntungkan apabila dimensi model dan saiz ensemble berkembang, menawarkan pertukaran yang lebih baik antara ketepatan, generalisasi, dan pertumbuhan pengiraan.

Lampiran: Manfaat penskalaan dan peningkatan

Kelebihan skalabiliti QuantumEnhancedEnsembleClassifier timbul daripada cara proses pemilihan ensemble dipetakan kepada pengoptimuman kuantum. Kaedah pembelajaran ensemble klasikal, seperti AdaBoost atau hutan rawak, menjadi mahal dari segi pengiraan apabila bilangan peramal lemah meningkat kerana memilih subset optimum adalah masalah kombinatorial yang berskala secara eksponen.

Sebaliknya, formulasi kuantum — dilaksanakan di sini melalui Algoritma Pengoptimuman Anggaran Kuantum (QAOA) — boleh meneroka ruang carian yang terlalu besar dengan lebih cekap dengan menilai pelbagai konfigurasi dalam superposisi. Hasilnya, masa latihan tidak berkembang dengan ketara bersama bilangan peramal, membolehkan model kekal cekap walaupun lebar ensemble meningkat.

Walaupun perkakasan semasa memperkenalkan beberapa hingar dan had kedalaman, aliran kerja ini menunjukkan pendekatan hibrid jangka hampir di mana komponen klasikal dan kuantum bekerjasama: pengoptimum kuantum menyediakan landskap permulaan yang lebih baik untuk gelung klasikal, meningkatkan penumpuan dan kualiti model akhir. Apabila pemproses kuantum berkembang, manfaat skalabiliti ini dijangka akan meliputi set data yang lebih besar, ensemble yang lebih luas, dan kedalaman Circuit yang lebih dalam.

Rujukan

1. Pengenalan kepada Qiskit Functions
2. Multiverse Computing Singularity Machine Learning

Tinjauan tutorial

Sila luangkan masa sebentar untuk memberi maklum balas tentang tutorial ini. Pandangan anda akan membantu kami menambah baik kandungan dan pengalaman pengguna kami.

Pautan ke tinjauan

Note: This survey is provided by IBM Quantum and relates to the original English content. To give feedback on doQumentation's website, translations, or code execution, please open a GitHub issue.