Přeskočit na hlavní obsah

Hybridní kvantově-posílená ensemble klasifikace (workflow stability elektrické sítě)

Odhad využití: 20 minut na QPU pro každý job na procesoru Eagle r3. (POZNÁMKA: Jedná se pouze o odhad. Tvůj skutečný čas může být jiný.)

Pozadí​

Tento tutoriál ukazuje hybridní kvantově-klasický workflow, který vylepší klasický ensemble o krok kvantové optimalizace. Pomocí funkce „Singularity Machine Learning – Classification" od Multiverse Computing (Qiskit Function) trénujeme skupinu konvenčních učitelů (například rozhodovací stromy, k-NN, logistická regrese) a poté tuto skupinu zdokonalíme kvantovou vrstvou, abychom zvýšili diverzitu a schopnost zobecňovat. Cíl je praktický: na reálné úloze predikce stability elektrické sítě porovnáme silnou klasickou základnu s kvantově-optimalizovanou alternativou na stejných datových rozděleních, takže uvidíš, kde kvantový krok pomáhá a co stojí.

Proč na tom záleží: výběr dobré podmnožiny z mnoha slabých učitelů je kombinatorický problém, který rychle roste s velikostí ensemblu. Klasické heuristiky jako boosting, bagging nebo stacking fungují dobře v středním měřítku, ale mohou mít potíže s efektivním prohledáváním velkých, redundantních knihoven modelů. Funkce integruje kvantové algoritmy – konkrétně QAOA (a volitelně VQE v jiných konfiguracích) – aby prohledávala tento prostor efektivněji po natrénování klasických učitelů, čímž se zvyšuje šance na nalezení kompaktní, diverzní podmnožiny, která lépe zobecňuje.

Klíčové je, že datové měřítko není omezeno qubity. Těžká práce s daty – předzpracování, trénování skupiny učitelů a vyhodnocení – zůstává klasická a zvládne miliony příkladů. Qubity určují pouze velikost ensemblu použitého v kroku kvantového výběru. Toto oddělení činí přístup životaschopným na dnešním hardwaru: pro data a trénování modelů používáš běžné scikit-learn workflow, zatímco kvantový krok voláš přes čisté rozhraní akcí v Qiskit Functions.

V praxi, ačkoli lze ensemblu poskytnout různé typy učitelů (např. rozhodovací stromy, logistická regrese nebo k-NN), rozhodovací stromy mívají nejlepší výsledky. Optimizátor konzistentně upřednostňuje silnější členy ensemblu – při dodání heterogenních učitelů jsou slabší modely, jako například lineární regressory, typicky odstraněny ve prospěch expresivnějších, jako jsou rozhodovací stromy.

Co zde budeš dělat: připravíš a vyvážíš dataset stability elektrické sítě; stanovíš klasickou základnu AdaBoost; spustíš několik kvantových konfigurací s různou šířkou ensemblu a regularizací; spustíš na IBM® simulátorech nebo QPU přes Qiskit Serverless; a porovnáš přesnost, preciznost, úplnost a F1 napříč všemi spuštěními. Při tom použiješ vzor akcí funkce (create, fit, predict, fit_predict, create_fit_predict) a klíčové ovládací prvky:

  • Typy regularizace: onsite (λ) pro přímou řídkost a alpha pro poměrový kompromis mezi interakčními a onsite členy
  • Automatická regularizace: nastav regularization="auto" s cílovým poměrem výběru, aby se řídkost přizpůsobovala automaticky
  • Možnosti optimizátoru: simulátor versus QPU, opakování, klasický optimizátor a jeho možnosti, hloubka transpilace a nastavení runtime Sampler/Estimator

Benchmarky v dokumentaci ukazují, že přesnost se zlepšuje s rostoucím počtem učitelů (qubitů) u náročných problémů, přičemž kvantový klasifikátor se vyrovná nebo překonává srovnatelný klasický ensemble. V tomto tutoriálu workflow celé end-to-end reprodukuješ a zkoumáš, kdy rozšíření ensemblu nebo přechod na adaptivní regularizaci přináší lepší F1 při přiměřené spotřebě zdrojů. Výsledkem je věcný pohled na to, jak může krok kvantové optimalizace doplnit – spíše než nahradit – klasické učení ensemblu v reálných aplikacích.

Požadavky​

Před zahájením tohoto tutoriálu se ujisti, že máš ve svém Python prostředí nainstalované následující balíčky:

  • 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

Nastavení​

V této části inicializujeme klienta Qiskit Serverless a načteme funkci Singularity Machine Learning – Classification poskytovanou Multiverse Computing. Pomocí Qiskit Serverless můžeš spouštět hybridní kvantově-klasické workflow na IBM spravované cloudové infrastruktuře bez starostí o správu zdrojů. Budeš potřebovat API klíč IBM Quantum Platform a název cloudového zdroje (CRN) pro ověření a přístup ke Qiskit Functions.

Stáhni dataset​

Pro spuštění tohoto tutoriálu používáme předzpracovaný dataset klasifikace stability elektrické sítě obsahující označená měření senzorů napájecí soustavy. Následující buňka automaticky vytvoří požadovanou strukturu složek a stáhne tréninkový i testovací soubor přímo do tvého prostředí pomocí wget. Pokud tyto soubory již máš lokálně, tento krok je bezpečně přepíše, aby zajistil konzistenci verzí.

# 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 potřebných balíčků​

V této části importujeme všechny Python balíčky a moduly Qiskit používané v celém tutoriálu. Zahrnují základní vědecké knihovny pro práci s daty a vyhodnocení modelů – jako NumPy, pandas a scikit-learn – spolu s vizualizačními nástroji a komponentami Qiskit pro spuštění kvantově-posíleného modelu. Importujeme také QiskitRuntimeService a QiskitFunctionsCatalog pro připojení ke službám IBM Quantum® a přístup k funkci 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")

Nastav konstantní proměnné​

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"

Připoj se k IBM Quantum a načti funkci Singularity​

Dále se ověříme pomocí služeb IBM Quantum a načteme funkci Singularity Machine Learning – Classification z katalogu Qiskit Functions Catalog. QiskitRuntimeService naváže zabezpečené spojení s IBM Quantum Platform pomocí tvého API tokenu a CRN instance, čímž umožní přístup ke kvantovým backendům. QiskitFunctionsCatalog se pak použije k načtení funkce Singularity podle názvu ("multiverse/singularity"), čímž nám umožní ji později volat pro hybridní kvantově-klasické výpočty. Pokud je nastavení úspěšné, zobrazí se potvrzovací zpráva indikující, že funkce byla správně načtena.

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)

Definuj pomocné funkce​

Před spuštěním hlavních experimentů definujeme několik malých pomocných funkcí, které zjednodušují načítání dat a vyhodnocení modelů.

  • load_data() čte vstupní CSV soubory do polí NumPy, přičemž odděluje příznaky a štítky pro kompatibilitu s scikit-learn a kvantovými workflow.
  • evaluate_predictions() vypočítá klíčové metriky výkonu – přesnost, preciznost, úplnost a F1-skóre – a volitelně hlásí dobu běhu, pokud jsou k dispozici informace o načasování.

Tyto pomocné funkce zjednodušují opakující se operace v dalších částech notebooku a zajišťují konzistentní hlášení metrik u klasických i kvantových klasifikátorů.

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

Krok 1: Mapování klasických vstupů na kvantový problém​

Začínáme přípravou datasetu pro hybridní kvantově-klasické experimenty. Cílem tohoto kroku je převést surová data stability elektrické sítě do vyvážených tréninkových, validačních a testovacích rozdělení, která mohou být konzistentně používána jak klasickými, tak kvantovými workflow. Zachování identických rozdělení zajišťuje, že pozdější porovnání výkonu bude spravedlivé a reprodukovatelné.

Načtení dat a předzpracování​

Nejprve načteme tréninkové a testovací CSV soubory, vytvoříme validační rozdělení a vyvážíme dataset pomocí náhodného over-samplingu. Vyvážení zabraňuje zkreslení ve prospěch majoritní třídy a poskytuje stabilnější učicí signál pro klasické i kvantové ensemble modely.

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

Klasická základna: reference AdaBoost​

Před spuštěním jakékoli kvantové optimalizace trénujeme silnou klasickou základnu – standardní klasifikátor AdaBoost – na stejných vyvážených datech. Tím získáme reprodukovatelný referenční bod pro pozdější porovnání, který pomáhá kvantifikovat, zda kvantová optimalizace zlepšuje zobecňování nebo efektivitu nad rámec dobře vyladěného klasického ensemblu.

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

Krok 2: Optimalizace problému pro spuštění na kvantovém hardwaru​

Úloha výběru ensemblu je formulována jako kombinatorický optimalizační problém, kde každý slabý učitel je binární rozhodovací proměnná a cíl vyvažuje přesnost s řídkostí prostřednictvím regularizačního členu. QuantumEnhancedEnsembleClassifier řeší tuto úlohu pomocí QAOA na IBM hardwaru, přičemž stále umožňuje průzkum na základě simulátoru. optimizer_options řídí hybridní smyčku: simulator=False směruje Circuit na vybraný QPU, num_solutions rozšiřuje rozsah hledání a classical_optimizer_options (pro vnitřní klasický optimizátor) řídí konvergenci; hodnoty kolem 60 iterací jsou dobrou rovnováhou mezi kvalitou a dobou běhu. Možnosti runtime – jako střední hloubka Circuit (reps) a standardní transpilační úsilí – pomáhají zajistit robustní výkon napříč zařízeními. Níže uvedená konfigurace je profil „nejlepších výsledků", který použijeme pro hardware; pro suché spuštění workflow bez spotřeby QPU času můžeš také vytvořit čistě simulovanou variantu přepnutím simulator=True.

# 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

Krok 3: Spuštění pomocí Qiskit primitiv​

Nyní spustíme celý pracovní postup pomocí akce create_fit_predict funkce Singularity, která trénuje, optimalizuje a vyhodnocuje QuantumEnhancedEnsembleClassifier od začátku do konce na infrastruktuře IBM. Funkce sestaví ensemble, aplikuje kvantovou optimalizaci prostřednictvím Qiskit primitiv a vrátí jak predikce, tak metadata úlohy (včetně doby běhu a využití prostředků). Rozdělení klasických dat z kroku 1 je znovu použito pro reprodukovatelnost; validační data jsou předána přes fit_params, aby optimalizace mohla ladit hyperparametry interně, zatímco testovací sada zůstane nedotčena.

V tomto kroku prozkoumáme několik konfigurací kvantového ensemblu, abychom pochopili, jak klíčové parametry — konkrétně num_learners a regularization — ovlivňují jak kvalitu výsledků, tak využití QPU.

  • num_learners určuje šířku ensemblu (a implicitně počet qubitů), čímž ovlivňuje kapacitu modelu a výpočetní náklady.
  • regularization řídí řídkost a přetrénování a určuje, kolik learnerů zůstane aktivních po optimalizaci.

Variací těchto parametrů vidíme, jak spolu interagují šířka ensemblu a regularizace: zvyšování šířky obvykle zlepšuje F1, ale stojí více času na QPU, zatímco silnější nebo adaptivní regularizace může zlepšit generalizaci při přibližně stejných nárocích na hardware. Následující podsekce procházejí třemi reprezentativními konfiguracemi, které tyto efekty ilustrují.

Základní konfigurace​

Tato konfigurace používá num_learners = 10 a regularization = 7.

  • num_learners řídí šířku ensemblu — efektivně počet slabých learnerů kombinovaných dohromady a na kvantovém hardware počet potřebných qubitů. Větší hodnota rozšiřuje kombinatorický prohledávací prostor a může zlepšit přesnost a recall, ale také zvyšuje šířku Circuit, čas kompilace a celkové využití QPU.
  • regularization nastavuje sílu penalizace za zahrnutí dalších learnerů. S výchozí regularizací „onsite" vyšší hodnoty vynucují větší řídkost (méně learnerů zůstane), zatímco nižší hodnoty umožňují složitější ensembly.

Tato konfigurace poskytuje nízkonákladovou základní linii a ukazuje, jak se chová malý ensemble před škálováním šířky nebo laděním řídkosti.

# 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

Zvýšení počtu learnerů​

Zde zvýšíme num_learners z 10 → 30 při zachování regularization = 7.

  • Více learnerů rozšiřuje hypotézový prostor a umožňuje modelu zachytit jemnější vzory, což může mírně zvýšit F1.
  • Ve většině případů není rozdíl v době běhu mezi 10 a 30 learnery podstatný, což naznačuje, že přidaná šířka Circuit výrazně nezvyšuje náklady na spuštění.
  • Zlepšení kvality stále sleduje křivku klesajících výnosů: brzké zisky se objevují, jak ensemble roste, ale plateau nastává, jakmile další learnery přinášejí méně nových informací.

Tento experiment zdůrazňuje kompromis mezi kvalitou a efektivitou — zvyšování šířky ensemblu může přinést malé zisky přesnosti bez výrazné penalizace doby běhu, v závislosti na podmínkách Backend a transpilace.

# 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

Regularizace​

V této konfiguraci zvýšíme na num_learners = 60 a zavedeme adaptivní regularizaci pro intuitivnější správu řídkosti.

  • S regularization = "auto" optimalizátor automaticky najde vhodnou sílu regularizace, která vybere přibližně regularization_ratio * num_learners slabých learnerů pro finální ensemble, místo ručního nastavování penalizace. To poskytuje pohodlnější rozhraní pro správu rovnováhy mezi řídkostí a velikostí ensemblu.
  • regularization_type = "alpha" definuje způsob aplikace penalizace. Na rozdíl od onsite, které je neomezené [0, ∞], je alpha ohraničeno hodnotami [0, 1], což usnadňuje ladění a interpretaci. Parametr řídí kompromis mezi individuálními a párovými penalizacemi a nabízí plynulejší konfigurační rozsah.
  • regularization_desired_ratio ≈ 0.82 specifikuje cílový podíl learnerů, kteří zůstanou aktivní po regularizaci — zde je zachováno přibližně 82 % learnerů a nejslabších 18 % je automaticky odstraněno.

Ačkoli adaptivní regularizace zjednodušuje konfiguraci a pomáhá udržovat vyvážený ensemble, nezaručuje nutně lepší nebo stabilnější výkon. Skutečná kvalita závisí na výběru vhodného parametru regularizace a jeho doladění prostřednictvím křížové validace může být výpočetně nákladné. Hlavní výhoda spočívá ve zlepšené použitelnosti a interpretovatelnosti, nikoli v přímých ziscích přesnosti.

# 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

Krok 4: Post-processing a vrácení výsledku v požadovaném klasickém formátu​

Nyní post-procesujeme výstupy z klasického i kvantového běhu a převedeme je do konzistentního formátu pro následné vyhodnocení. Tento krok porovnává prediktivní kvalitu pomocí standardních metrik — přesnosti (accuracy), precision, recall a F1 — a analyzuje, jak šířka ansámblu (num_learners) a kontrola řídkosti (regularization) ovlivňují výkon i výpočetní chování.

Klasický baseline AdaBoost poskytuje kompaktní a stabilní referenci pro učení v malém měřítku. Dobře si vede s omezenými ansámbly a zanedbatelnou výpočetní režií, což odráží sílu tradičního boostingu, dokud je prostor hypotéz stále zvládnutelný. Kvantové konfigurace (qeec_pred_job_1, qeec_pred_job_2 a qeec_pred_job_3) tento baseline rozšiřují tím, že vkládají proces výběru ansámblu do variačního kvantového optimalizačního cyklu. To systému umožňuje prozkoumávat exponenciálně velké podmnožiny learnerů současně v superpozici, čímž se kombinatorická povaha výběru ansámblu řeší efektivněji při rostoucím měřítku.

Výsledky ukazují, že zvyšování num_learners z 10 na 30 zlepšuje recall a F1, což potvrzuje, že širší ansámbl zachycuje bohatší interakce mezi slabými learnery. Přírůstek je na současném hardwaru sublineární — každý další learner přináší menší přírůstky přesnosti — ale základní chování škálování zůstává příznivé, protože kvantový optimalizátor může prohledávat širší konfigurační prostory bez exponenciálního růstu typického pro klasický výběr podmnožin. Regularizace přidává další nuanci: pevné λ=7 vynucuje konzistentní řídkost a stabilizuje konvergenci, zatímco adaptivní α-regularizace automaticky ladí řídkost na základě korelací mezi learnery. Toto dynamické prořezávání často dosahuje mírně vyššího F1 pro stejnou šířku Qubitů, přičemž vyvažuje složitost modelu a generalizaci.

Při přímém porovnání s baselineem AdaBoost nejmenší kvantová konfigurace (L=10) reprodukuje podobnou přesnost, čímž ověřuje správnost hybridního pipeline. Při větších šířkách kvantové varianty — zejména s auto-regularizací — začínají klasický baseline mírně překonávat, přičemž vykazují lepší recall a F1 bez lineárního růstu výpočetních nákladů. Tato zlepšení neznamenají okamžitou „kvantovou výhodu", ale spíše efektivitu škálování: kvantový optimalizátor udržuje zvládnutelný výkon při rozšiřování ansámblu, zatímco klasický přístup by čelil exponenciálnímu růstu složitosti výběru podmnožin.

V praxi:

  • Používej klasický baseline pro rychlou validaci a benchmarking na malých datasetech.
  • Nasaď kvantové ansámbly, když roste šířka modelu nebo složitost příznaků — hledání založené na QAOA se v těchto režimech škáluje přirozeněji.
  • Využij adaptivní α-regularizaci k udržení řídkosti a generalizace bez zvyšování šířky Circuit.
  • Monitoruj čas QPU a hloubku Circuit, abys vyvažoval/a přínosy kvality oproti omezením hardwaru blízkého budoucnosti.

Dohromady tyto experimenty ukazují, že kvantově optimalizované ansámbly doplňují klasické metody: při malém měřítku reprodukují přesnost baseline a zároveň nabízejí cestu k efektivnímu škálování na větší, kombinatorické problémy učení. S vývojem hardwaru se očekává, že tyto výhody škálování se budou násobit, čímž se rozšíří proveditelná velikost a hloubka modelů založených na ansámblech nad rámec toho, co je klasicky praktické.

Vyhodnocení metrik pro každou konfiguraci​

Nyní vyhodnotíme všechny konfigurace — klasický baseline AdaBoost a tři kvantové ansámbly — pomocí pomocné funkce evaluate_predictions, abychom vypočítali přesnost (accuracy), precision, recall a F1 na stejné testovací sadě. Toto porovnání objasňuje, jak se kvantová optimalizace škáluje oproti klasickému přístupu: při malých šířkách si oba vedou podobně; s rostoucím ansámblem může kvantová metoda efektivněji prozkoumávat větší prostory hypotéz. Výsledná tabulka zachycuje tyto trendy v konzistentní, kvantitativní formě.

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

Seskupený sloupcový graf níže porovnává přesnost (Accuracy) a F1 napříč klasickým baselineem a kvantovými ansámbly (L=10, L=30 a L=60 auto-α). Ilustruje, jak se přesnost stabilizuje, zatímco F1 se postupně zlepšuje s rostoucí šířkou kvantového ansámblu, a demonstruje, že hybridní metoda udržuje škálování výkonu bez exponenciálního růstu nákladů typického pro klasický výběr podmnožin.

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

Output of the previous code cell

Interpretace​

Graf potvrzuje očekávaný vzorec škálování. Klasický AdaBoost si dobře vede při menších ansámblech, ale škálování se stává stále nákladnějším s rostoucím počtem slabých learnerů, protože problém výběru podmnožin se rozrůstá kombinatoricky. Kvantově vylepšené modely při nízkých šířkách replikují klasickou přesnost a začínají ji překonávat s rostoucí velikostí ansámblu, zejména pod adaptivní α-regularizací. To odráží schopnost kvantového optimalizátoru vzorkovat a vyhodnocovat mnoho kandidátních podmnožin paralelně prostřednictvím superpozice, přičemž udržuje zvládnutelné prohledávání i při vyšších šířkách. Zatímco současná hardwarová režie kompenzuje část teoretických přínosů, trend ilustruje výhodu škálování kvantové formulace. V praxi zůstává klasická metoda preferovaná pro lehké benchmarky, zatímco kvantově vylepšené ansámbly se stávají výhodnými s rostoucí dimenzionalitou modelu a velikostí ansámblu, nabízejí lepší kompromisy mezi přesností, generalizací a výpočetním růstem.

Příloha: Výhody škálování a vylepšení​

Výhoda škálovatelnosti QuantumEnhancedEnsembleClassifier vychází z toho, jak se proces výběru ansámblu mapuje na kvantovou optimalizaci. Klasické metody ansámblového učení, jako jsou AdaBoost nebo náhodné lesy, se stávají výpočetně nákladnými s rostoucím počtem slabých learnerů, protože výběr optimální podmnožiny je kombinatorický problém, který se škáluje exponenciálně.

Naproti tomu kvantová formulace — implementovaná zde prostřednictvím Quantum Approximate Optimization Algorithm (QAOA) — dokáže tyto exponenciálně velké prohledávací prostory prozkoumávat efektivněji tím, že vyhodnocuje více konfigurací v superpozici. Výsledkem je, že trénovací čas s počtem learnerů výrazně neroste, což modelu umožňuje zůstat efektivní i s rostoucí šířkou ansámblu.

Přestože současný hardware přináší určitý šum a omezení hloubky, tento workflow demonstruje hybridní přístup blízkého budoucnosti, kde klasické a kvantové komponenty spolupracují: kvantový optimalizátor poskytuje lepší inicializační krajinu pro klasickou smyčku, čímž zlepšuje konvergenci a konečnou kvalitu modelu. S vývojem kvantových procesorů se očekává, že tyto výhody škálovatelnosti se rozšíří na větší datasety, širší ansámbly a hlubší hloubky Circuit.

Reference​

  1. Úvod do Qiskit Functions
  2. Multiverse Computing Singularity Machine Learning

Průzkum k tutoriálu​

Věnuj prosím minutu zpětné vazbě k tomuto tutoriálu. Tvoje postřehy nám pomohou zlepšit obsah a uživatelský zážitek.

Odkaz na průzkum

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.

Zdroj: IBM Quantum docs — aktualizováno 15. 5. 2026
Anglická verze na doQumentation — aktualizováno 15. 5. 2026
Tento překlad vychází z anglické verze ze dne 9. 4. 2026
Problém s webem nebo překladem?Problém v obsahu? Upravit v IBM Quantum docs