하이브리드 양자 강화 앙상블 분류 (그리드 안정성 워크플로)

사용량 예상: Eagle r3 프로세서에서 각 작업당 QPU 시간 20분. (참고: 이는 예상치일 뿐이며, 실제 실행 시간은 다를 수 있습니다.)

배경

이 튜토리얼은 고전 앙상블을 양자 최적화 단계로 강화하는 하이브리드 양자-고전 워크플로를 시연합니다. Multiverse Computing의 "Singularity Machine Learning – Classification" (Qiskit 함수)을 사용하여, 기존 학습기 풀(예: 결정 트리, k-NN, 로지스틱 회귀)을 훈련한 다음 양자 레이어로 해당 풀을 정제하여 다양성과 일반화를 개선합니다. 목표는 실용적입니다: 실제 그리드 안정성 예측 작업에서, 동일한 데이터 분할 하에 강력한 고전 기준선과 양자 최적화 대안을 비교하여 양자 단계가 어디에 도움이 되는지, 그리고 그 비용이 무엇인지 확인할 수 있습니다.

이것이 중요한 이유: 많은 약한 학습기 중에서 좋은 부분 집합을 선택하는 것은 앙상블 크기가 커질수록 빠르게 증가하는 조합 문제입니다. 부스팅, 배깅, 스태킹과 같은 고전적 휴리스틱은 중간 규모에서는 잘 작동하지만, 대규모의 중복된 모델 라이브러리를 효율적으로 탐색하는 데는 어려움을 겪을 수 있습니다. 이 함수는 양자 알고리즘(특히 QAOA, 다른 구성에서는 선택적으로 VQE)을 통합하여 고전 학습기가 훈련된 후 해당 공간을 더 효과적으로 탐색하고, 더 잘 일반화되는 소형의 다양한 부분 집합을 찾을 가능성을 높입니다.

중요하게도, 데이터 규모는 Qubit에 의해 제한되지 않습니다. 데이터에 대한 주요 작업인 전처리, 학습기 풀 훈련, 평가는 고전적으로 유지되며 수백만 개의 예시를 처리할 수 있습니다. Qubit는 양자 선택 단계에서 사용되는 앙상블 크기만 결정합니다. 이러한 분리가 오늘날의 하드웨어에서 이 접근 방식을 실용적으로 만드는 요소입니다: 데이터 및 모델 훈련을 위해 익숙한 scikit-learn 워크플로를 유지하면서 Qiskit Functions의 깔끔한 액션 인터페이스를 통해 양자 단계를 호출할 수 있습니다.

실제로, 앙상블에 다양한 학습기 유형(예: 결정 트리, 로지스틱 회귀, k-NN)을 제공할 수 있지만, 결정 트리가 가장 좋은 성능을 보이는 경향이 있습니다. 최적화기는 일관되게 더 강한 앙상블 구성원을 선호하며, 이질적인 학습기가 제공되면 선형 회귀와 같은 약한 모델은 일반적으로 결정 트리와 같이 더 표현력 있는 모델에 의해 제거됩니다.

여기서 수행할 작업: 그리드 안정성 데이터셋을 준비하고 균형을 맞춥니다; 고전 AdaBoost 기준선을 수립합니다; 앙상블 너비와 정규화를 변화시키는 여러 양자 구성을 실행합니다; Qiskit Serverless를 통해 IBM® 시뮬레이터 또는 QPU에서 실행합니다; 그리고 모든 실행에 걸쳐 정확도, 정밀도, 재현율, F1을 비교합니다. 과정에서 함수의 액션 패턴(create, fit, predict, fit_predict, create_fit_predict)과 주요 제어 항목을 사용합니다:

• 정규화 유형: 직접 희소성을 위한 onsite (λ) 및 상호작용 항과 onsite 항 간의 비율 기반 트레이드오프를 위한 alpha
• 자동 정규화: 희소성을 자동으로 조정하기 위해 목표 선택 비율과 함께 regularization="auto" 설정
• 최적화기 옵션: 시뮬레이터 대 QPU, 반복 횟수, 고전 최적화기 및 해당 옵션, 트랜스파일 깊이, 런타임 Sampler/Estimator 설정

문서의 벤치마크에 따르면 어려운 문제에서 학습기(Qubit) 수가 증가할수록 정확도가 향상되며, 양자 분류기는 비교 가능한 고전 앙상블과 동등하거나 이를 능가합니다. 이 튜토리얼에서는 워크플로를 처음부터 끝까지 재현하고, 앙상블 너비를 늘리거나 적응형 정규화로 전환하는 것이 합리적인 자원 사용으로 더 나은 F1을 제공하는 시점을 살펴봅니다. 결과는 양자 최적화 단계가 실제 응용 프로그램에서 고전 앙상블 학습을 대체하는 것이 아니라 보완할 수 있는 방법에 대한 기반 있는 관점을 제공합니다.

요구 사항

이 튜토리얼을 시작하기 전에 Python 환경에 다음 패키지가 설치되어 있는지 확인하세요:

• 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

설정

이 섹션에서는 Qiskit Serverless 클라이언트를 초기화하고 Multiverse Computing에서 제공하는 Singularity Machine Learning – Classification 함수를 로드합니다. Qiskit Serverless를 사용하면 리소스 관리에 대한 걱정 없이 IBM 관리형 클라우드 인프라에서 하이브리드 양자-고전 워크플로를 실행할 수 있습니다. 인증하고 Qiskit Functions에 액세스하려면 IBM Quantum Platform API 키와 클라우드 리소스 이름(CRN)이 필요합니다.

데이터셋 다운로드

이 튜토리얼을 실행하려면 레이블이 지정된 전력 시스템 센서 판독값이 포함된 전처리된 그리드 안정성 분류 데이터셋을 사용합니다. 다음 셀은 필요한 폴더 구조를 자동으로 생성하고 wget을 사용하여 훈련 및 테스트 파일을 환경에 직접 다운로드합니다. 이 파일이 이미 로컬에 있는 경우, 이 단계는 버전 일관성을 보장하기 위해 안전하게 덮어씁니다.

# 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

필요한 패키지 가져오기

이 섹션에서는 튜토리얼 전반에 걸쳐 사용되는 모든 Python 패키지와 Qiskit 모듈을 가져옵니다. 여기에는 데이터 처리 및 모델 평가를 위한 핵심 과학 라이브러리(NumPy, pandas, scikit-learn 등)와 시각화 도구, 그리고 양자 강화 모델을 실행하기 위한 Qiskit 컴포넌트가 포함됩니다. 또한 IBM Quantum® 서비스에 연결하고 Singularity Machine Learning 함수에 액세스하기 위해 QiskitRuntimeService와 QiskitFunctionsCatalog를 가져옵니다.

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

상수 변수 설정

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"

IBM Quantum에 연결하고 Singularity 함수 로드

다음으로 IBM Quantum 서비스를 인증하고 Qiskit Functions Catalog에서 Singularity Machine Learning – Classification 함수를 로드합니다. QiskitRuntimeService는 API 토큰과 인스턴스 CRN을 사용하여 IBM Quantum Platform에 보안 연결을 설정하여 양자 Backend에 대한 액세스를 허용합니다. 그런 다음 QiskitFunctionsCatalog를 사용하여 이름("multiverse/singularity")으로 Singularity 함수를 검색하여 나중에 하이브리드 양자-고전 계산을 위해 호출할 수 있습니다. 설정이 성공하면 함수가 올바르게 로드되었음을 나타내는 확인 메시지가 표시됩니다.

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)

헬퍼 함수 정의

주요 실험을 실행하기 전에, 데이터 로딩과 모델 평가를 간소화하는 몇 가지 소규모 유틸리티 함수를 정의합니다.

• load_data()는 입력 CSV 파일을 NumPy 배열로 읽어 scikit-learn 및 양자 워크플로와의 호환성을 위해 특성과 레이블을 분리합니다.
• evaluate_predictions()는 주요 성능 지표인 정확도, 정밀도, 재현율, F1-점수를 계산하고 타이밍 정보가 제공되면 선택적으로 런타임을 보고합니다.

이러한 헬퍼 함수는 나중에 노트북에서 반복되는 작업을 단순화하고 고전 및 양자 분류기 모두에서 일관된 지표 보고를 보장합니다.

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

Step 1: 고전 입력을 양자 문제로 매핑

하이브리드 양자-고전 실험을 위해 데이터셋을 준비하는 것으로 시작합니다. 이 단계의 목표는 원시 그리드 안정성 데이터를 고전 및 양자 워크플로 모두에서 일관되게 사용할 수 있는 균형 잡힌 훈련, 검증, 테스트 분할로 변환하는 것입니다. 동일한 분할을 유지하면 나중의 성능 비교가 공정하고 재현 가능합니다.

데이터 로딩 및 전처리

먼저 훈련 및 테스트 CSV 파일을 로드하고, 검증 분할을 생성하고, 무작위 오버 샘플링을 사용하여 데이터셋을 균형 있게 맞춥니다. 균형을 맞추면 다수 클래스에 대한 편향을 방지하고 고전 및 양자 앙상블 모델 모두에 더 안정적인 학습 신호를 제공합니다.

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

고전 기준선: AdaBoost 참조

양자 최적화를 실행하기 전에 동일한 균형 잡힌 데이터에서 강력한 고전 기준선인 표준 AdaBoost 분류기를 훈련합니다. 이는 나중의 비교를 위한 재현 가능한 참조점을 제공하여 양자 최적화가 잘 조정된 고전 앙상블을 넘어 일반화 또는 효율성을 개선하는지 정량화하는 데 도움이 됩니다.

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

Step 2: 양자 하드웨어 실행을 위한 문제 최적화

앙상블 선택 작업은 각 약한 학습기가 이진 결정 변수인 조합 최적화 문제로 구성되며, 목적 함수는 정규화 항을 통해 정확도와 희소성의 균형을 맞춥니다. QuantumEnhancedEnsembleClassifier는 IBM 하드웨어에서 QAOA로 이 문제를 해결하면서도 시뮬레이터 기반 탐색을 허용합니다. optimizer_options는 하이브리드 루프를 제어합니다: simulator=False는 Circuit를 선택한 QPU로 라우팅하고, num_solutions는 탐색 범위를 넓히며, classical_optimizer_options(내부 고전 최적화기용)는 수렴을 제어합니다; 약 60회 반복 값이 품질과 런타임의 균형에 좋습니다. 런타임 옵션(적당한 Circuit 깊이(reps) 및 표준 트랜스파일 노력 등)은 장치 전반에 걸쳐 강건한 성능을 보장하는 데 도움이 됩니다. 아래 구성은 하드웨어 실행에 사용할 "최적 결과" 프로파일입니다; simulator=True로 전환하여 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

3단계: Qiskit 프리미티브를 사용한 실행

이제 Singularity 함수의 create_fit_predict 액션을 사용하여 전체 워크플로를 실행합니다. 이 액션은 IBM 인프라에서 QuantumEnhancedEnsembleClassifier를 엔드투엔드로 훈련, 최적화, 평가합니다. 함수는 앙상블을 구성하고 Qiskit 프리미티브를 통해 양자 최적화를 적용한 후, 예측 결과와 작업 메타데이터(런타임 및 리소스 사용량 포함)를 반환합니다. 재현성을 위해 1단계의 고전적 데이터 분할을 재사용하며, fit_params를 통해 검증 데이터를 전달하여 보류된 테스트 세트를 건드리지 않고 내부적으로 하이퍼파라미터를 조정할 수 있습니다.

이 단계에서는 양자 앙상블의 여러 구성을 탐색하여 주요 파라미터인 num_learners와 regularization이 결과 품질과 QPU 사용량에 어떤 영향을 미치는지 살펴봅니다.

• num_learners는 앙상블의 너비(및 암묵적으로 큐비트 수)를 결정하며, 모델의 용량과 계산 비용에 영향을 줍니다.
• regularization은 희소성과 과적합을 제어하여 최적화 후 활성 학습기의 수를 조절합니다.

이 파라미터들을 변화시킴으로써 앙상블 너비와 정규화가 어떻게 상호작용하는지 확인할 수 있습니다. 너비를 늘리면 일반적으로 F1이 향상되지만 QPU 시간이 더 소요되며, 더 강하거나 적응적인 정규화는 거의 동일한 하드웨어 사용량으로 일반화 성능을 향상시킬 수 있습니다. 다음 하위 섹션들에서는 이러한 효과를 설명하기 위해 세 가지 대표적인 구성을 살펴봅니다.

기준선

이 구성은 num_learners = 10과 regularization = 7을 사용합니다.

• num_learners는 앙상블 너비, 즉 결합되는 약한 학습기의 수를 제어하며, 양자 하드웨어에서는 필요한 큐비트 수를 결정합니다. 값이 클수록 조합 탐색 공간이 넓어져 정확도와 재현율이 향상될 수 있지만, Circuit 너비, 컴파일 시간, 전체 QPU 사용량도 증가합니다.
• regularization은 추가 학습기를 포함하는 데 대한 패널티 강도를 설정합니다. 기본 "온사이트" 정규화에서는 값이 높을수록 강한 희소성을 강제하여 더 적은 학습기를 유지하고, 낮은 값은 더 복잡한 앙상블을 허용합니다.

이 설정은 낮은 비용의 기준선을 제공하여 너비를 확장하거나 희소성을 조정하기 전에 소규모 앙상블의 동작을 확인할 수 있습니다.

# 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

학습기 수 증가

여기서는 regularization = 7을 유지하면서 num_learners를 10 → 30으로 늘립니다.

• 더 많은 학습기는 가설 공간을 확장하여 모델이 더 미묘한 패턴을 포착할 수 있게 하며, F1을 소폭 향상시킬 수 있습니다.
• 대부분의 경우 학습기 10개와 30개 사이의 런타임 차이는 크지 않으며, 이는 Circuit 너비 증가가 실행 비용을 크게 늘리지 않음을 나타냅니다.
• 품질 향상은 여전히 수확 체감 곡선을 따릅니다. 앙상블이 성장할수록 초기 이득이 나타나지만, 추가 학습기가 새로운 정보를 덜 제공함에 따라 평탄해집니다.

이 실험은 품질-효율성 트레이드오프를 부각시킵니다. Backend 및 트랜스파일 조건에 따라 앙상블 너비를 늘리면 주요 런타임 패널티 없이 작은 정확도 이득을 제공할 수 있습니다.

# 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

정규화

이 구성에서는 num_learners = 60으로 늘리고 적응적 정규화를 도입하여 희소성을 보다 직관적으로 관리합니다.

• regularization = "auto"를 사용하면 옵티마이저가 패널티를 수동으로 고정하는 대신 최종 앙상블에서 약 regularization_ratio * num_learners개의 약한 학습기를 선택하는 적절한 정규화 강도를 자동으로 찾습니다. 이는 희소성과 앙상블 크기 간의 균형을 관리하는 더 편리한 인터페이스를 제공합니다.
• regularization_type = "alpha"는 패널티 적용 방식을 정의합니다. 무한 범위 [0, ∞]인 onsite와 달리 alpha는 [0, 1] 사이로 제한되어 조정 및 해석이 더 용이합니다. 이 파라미터는 개별 패널티와 쌍별 패널티 간의 트레이드오프를 제어하며, 더 부드러운 구성 범위를 제공합니다.
• regularization_desired_ratio ≈ 0.82는 정규화 후 활성 상태로 유지할 학습기의 목표 비율을 지정합니다. 여기서는 학습기의 약 82%가 유지되고, 가장 약한 18%가 자동으로 제거됩니다.

적응적 정규화는 구성을 단순화하고 균형 잡힌 앙상블 유지에 도움이 되지만, 반드시 더 좋거나 안정적인 성능을 보장하지는 않습니다. 실제 품질은 적절한 정규화 파라미터 선택에 달려 있으며, 교차 검증을 통한 미세 조정은 계산 비용이 많이 들 수 있습니다. 주요 장점은 직접적인 정확도 향상보다는 사용성과 해석 가능성 향상에 있습니다.

# 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

4단계: 결과를 원하는 고전적 형식으로 후처리하여 반환

이제 고전적 실행과 양자 실행의 결과를 후처리하여 다운스트림 평가를 위한 일관된 형식으로 변환합니다. 이 단계에서는 정확도, 정밀도, 재현율, F1 등의 표준 지표를 사용하여 예측 품질을 비교하고, 앙상블 너비(num_learners)와 희소성 제어(regularization)가 성능과 계산 동작에 어떤 영향을 미치는지 분석합니다.

고전적 AdaBoost 기준선은 소규모 학습에 있어 간결하고 안정적인 참조점을 제공합니다. 제한된 앙상블로도 성능이 좋고 계산 오버헤드가 무시할 수 있는 수준이며, 이는 가설 공간이 여전히 처리 가능한 수준일 때 전통적인 부스팅의 강점을 보여줍니다. 양자 구성(qeec_pred_job_1, qeec_pred_job_2, qeec_pred_job_3)은 앙상블 선택 과정을 변분 양자 최적화 루프에 내장하여 이 기준선을 확장합니다. 이를 통해 시스템은 중첩 상태에서 지수적으로 많은 학습기 부분집합을 동시에 탐색하여, 규모가 커질수록 앙상블 선택의 조합적 특성을 더 효율적으로 처리할 수 있습니다.

결과에 따르면 num_learners를 10에서 30으로 늘리면 재현율과 F1이 향상되어 더 넓은 앙상블이 약한 학습기 간의 더 풍부한 상호작용을 포착함을 확인할 수 있습니다. 현재 하드웨어에서의 향상은 준선형적입니다. 즉, 추가 학습기마다 더 작은 정확도 증가를 보이지만, 양자 옵티마이저가 지수적 폭발 없이 더 넓은 구성 공간을 탐색할 수 있기 때문에 기본 스케일링 동작은 여전히 유리합니다. 정규화는 추가적인 뉘앙스를 도입합니다. 고정된 λ=7은 일관된 희소성을 강제하고 수렴을 안정화하는 반면, 적응적 α-정규화는 학습기 간의 상관관계를 기반으로 희소성을 자동으로 조정합니다. 이 동적 가지치기는 동일한 큐비트 너비로 약간 더 높은 F1을 달성하여 모델 복잡도와 일반화 간의 균형을 맞춥니다.

AdaBoost 기준선과 직접 비교했을 때, 가장 작은 양자 구성(L=10)은 유사한 정확도를 재현하여 하이브리드 파이프라인의 정확성을 검증합니다. 더 넓은 너비에서 양자 변형들은, 특히 자동 정규화를 사용할 때, 계산 비용의 선형 증가 없이 향상된 재현율과 F1을 보이며 고전적 기준선을 소폭 능가하기 시작합니다. 이러한 향상이 즉각적인 "양자 우위"를 나타내는 것은 아니지만, 스케일링 효율성을 보여줍니다. 즉, 고전적 접근법이 부분집합 선택 복잡도의 지수적 증가에 직면하는 상황에서도 양자 옵티마이저는 앙상블이 확장됨에 따라 처리 가능한 성능을 유지합니다.

실용적인 측면에서:

• 소규모 데이터셋에서 빠른 검증 및 벤치마킹에는 고전적 기준선을 사용하세요.
• 모델 너비나 특성 복잡도가 증가할 때 양자 앙상블을 적용하세요. QAOA 기반 탐색은 이러한 경우 더 우아하게 확장됩니다.
• 적응적 α-정규화를 사용하여 Circuit 너비를 늘리지 않고 희소성과 일반화를 유지하세요.
• 품질 향상과 근기간 하드웨어 제약 간의 균형을 맞추기 위해 QPU 시간과 깊이를 모니터링하세요.

종합하면, 이러한 실험들은 양자 최적화 앙상블이 고전적 방법을 보완함을 보여줍니다. 소규모에서 기준선 정확도를 재현하면서도 더 크고 조합적인 학습 문제에서 효율적인 확장을 위한 경로를 제공합니다. 하드웨어가 발전함에 따라 이러한 스케일링 장점이 복합적으로 증가하여, 고전적으로 실용적인 범위를 넘어 앙상블 기반 모델의 실행 가능한 크기와 깊이를 확장할 것으로 기대됩니다.

각 구성에 대한 지표 평가

이제 evaluate_predictions 헬퍼를 사용하여 고전적 AdaBoost 기준선과 세 가지 양자 앙상블을 포함한 모든 구성을 동일한 테스트 세트에서 정확도, 정밀도, 재현율, F1로 평가합니다. 이 비교는 양자 최적화가 고전적 접근법에 비해 어떻게 스케일링되는지를 명확히 합니다. 작은 너비에서는 두 방법 모두 유사하게 수행되지만, 앙상블이 커질수록 양자 방법이 더 큰 가설 공간을 더 효율적으로 탐색할 수 있습니다. 결과 표는 이러한 경향을 일관되고 정량적인 형태로 보여줍니다.

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

구성별 품질 경향 시각화

아래의 그룹 막대 차트는 고전적 기준선과 양자 앙상블(L=10, L=30, L=60 auto-α)에 걸친 정확도와 F1을 비교합니다. 이 차트는 양자 앙상블 너비가 증가함에 따라 정확도가 안정화되는 동안 F1이 점진적으로 향상되는 방식을 보여주며, 하이브리드 방법이 고전적 부분집합 선택의 지수적 비용 증가 없이 성능 스케일링을 유지함을 보여줍니다.

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

해석

이 플롯은 예상된 스케일링 패턴을 확인합니다. 고전적 AdaBoost는 소규모 앙상블에서 강력하게 수행되지만, 약한 학습기 수가 증가함에 따라 부분집합 선택 문제가 조합적으로 확장되어 스케일링 비용이 점점 높아집니다. 양자 강화 모델은 낮은 너비에서 고전적 정확도를 복제하고 앙상블 크기가 증가함에 따라, 특히 적응적 α-정규화 하에서, 이를 능가하기 시작합니다. 이는 양자 옵티마이저가 중첩을 통해 많은 후보 부분집합을 병렬로 샘플링하고 평가하는 능력을 반영하며, 높은 너비에서도 처리 가능한 탐색을 유지합니다. 현재 하드웨어 오버헤드가 이론적 이득의 일부를 상쇄하지만, 이 경향은 양자 공식의 스케일링 효율성 장점을 보여줍니다. 실용적으로는 고전적 방법이 경량 벤치마크에 여전히 선호되지만, 모델 차원과 앙상블 크기가 확장됨에 따라 양자 강화 앙상블이 유리해지며, 정확도, 일반화, 계산 성장 간의 더 나은 트레이드오프를 제공합니다.

부록: 스케일링 이점과 향상

QuantumEnhancedEnsembleClassifier의 스케일링 장점은 앙상블 선택 과정이 양자 최적화에 어떻게 매핑되는지에서 비롯됩니다. AdaBoost나 랜덤 포레스트 같은 고전적 앙상블 학습 방법은 약한 학습기 수가 증가함에 따라 계산 비용이 높아지는데, 최적의 부분집합 선택이 지수적으로 확장되는 조합적 문제이기 때문입니다.

이와 대조적으로, 양자 공식(여기서는 양자 근사 최적화 알고리즘(QAOA)을 통해 구현됨)은 중첩 상태에서 여러 구성을 동시에 평가함으로써 이러한 지수적으로 큰 탐색 공간을 더 효율적으로 탐색할 수 있습니다. 결과적으로 훈련 시간이 학습기 수에 따라 크게 증가하지 않아, 앙상블 너비가 늘어나도 모델이 효율적으로 유지될 수 있습니다.

현재 하드웨어는 일부 노이즈와 깊이 제한을 도입하지만, 이 워크플로는 고전적 및 양자 컴포넌트가 협력하는 근기간 하이브리드 접근법을 보여줍니다. 양자 옵티마이저는 고전적 루프에 더 나은 초기화 환경을 제공하여 수렴과 최종 모델 품질을 향상시킵니다. 양자 프로세서가 발전함에 따라 이러한 스케일링 이점은 더 큰 데이터셋, 더 넓은 앙상블, 더 깊은 Circuit 깊이로 확장될 것으로 기대됩니다.

참고 문헌

1. Qiskit 함수 소개
2. Multiverse Computing Singularity 머신 러닝

튜토리얼 설문

이 튜토리얼에 대한 피드백을 제공하는 데 잠깐 시간을 내주세요. 여러분의 의견은 콘텐츠 및 사용자 경험 개선에 도움이 됩니다.

설문 링크

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.