Classification hybride d'ensembles améliorée par la technologie quantique (flux de travail pour la stabilité du réseau)

Estimation de l'utilisation : 20 minutes de temps QPU pour chaque tâche sur un processeur Eagle r3. (NOTE : Il s'agit uniquement d'une estimation. Votre durée d'exécution peut varier.)

Arrière-plan

Ce tutoriel présente un processus hybride quantique-classique qui enrichit un ensemble classique d'une étape d'optimisation quantique. À l'aide de la fonction « Singularity Machine Learning –Classification » de Multiverse Computing (une fonction Qiskit), nous entraînons un ensemble d'algorithmes d'apprentissage classiques (par exemple, les arbres de décision, le k-NN, la régression logistique), puis nous affinons cet ensemble à l'aide d'une couche quantique afin d'améliorer la diversité et la généralisation. L'objectif est concret : dans le cadre d'une véritable tâche de prédiction de la stabilité du réseau, nous comparons une référence classique performante à une alternative optimisée par la mécanique quantique, en utilisant les mêmes découpages de données, afin que vous puissiez constater où l'approche quantique apporte un plus et quel en est le coût.

Pourquoi cela est important : la sélection d'un bon sous-ensemble parmi de nombreux apprenants faibles est un problème combinatoire qui croît rapidement avec la taille de l'ensemble. Les heuristiques classiques telles que le boosting, le bagging et le stacking donnent de bons résultats à des échelles modérées, mais peinent à explorer efficacement des bibliothèques de modèles redondantes et de grande taille. La fonction intègre des algorithmes quantiques - en particulier QAOA (et éventuellement VQE dans d'autres configurations) - pour rechercher cet espace plus efficacement après que les apprenants classiques ont été formés, ce qui augmente les chances de trouver un sous-ensemble compact et diversifié qui se généralise mieux.

Il est essentiel que l'échelle des données ne soit pas limitée par les qubits. Le gros du travail sur les données - prétraitement, formation du groupe d'apprenants et évaluation - reste classique et peut traiter des millions d'exemples. Les Qubits déterminent uniquement la taille de l'ensemble utilisé dans l'étape de sélection quantique. Ce découplage est ce qui rend l'approche viable sur le matériel d'aujourd'hui : vous conservez les flux de travail scikit-learn familiers pour les données et l'apprentissage du modèle tout en appelant l'étape quantique par le biais d'une interface d'action propre dans Qiskit Functions.

Dans la pratique, bien que différents types d'apprenants puissent être fournis à l'ensemble (par exemple, arbres de décision, régression logistique ou k-NN), les arbres de décision tendent à donner les meilleurs résultats. L'optimiseur favorise systématiquement les membres les plus forts de l'ensemble : lorsque des apprenants hétérogènes sont fournis, les modèles les plus faibles, tels que les régresseurs linéaires, sont généralement élagués au profit de modèles plus expressifs, tels que les arbres de décision.

Ce que vous ferez ici : préparer et équilibrer l'ensemble de données sur la stabilité de la grille; établir une base de référence classique AdaBoost; exécuter plusieurs configurations quantiques qui varient la largeur de l'ensemble et la régularisation; exécuter sur les simulateurs IBM® ou les QPU via Qiskit Serverless; et comparer l'exactitude, la précision, le rappel et F1 sur l'ensemble des exécutions. En cours de route, vous utiliserez le modèle d'action de la fonction (create, fit, predict, fit_predict, create_fit_predict) et les contrôles des touches :

• Types de régularisation : onsite (λ) pour l'éparpillement direct et alpha pour un compromis basé sur le ratio entre les termes d'interaction et les termes sur place
• Régularisation automatique : définir regularization="auto" avec un ratio de sélection cible pour adapter automatiquement la densité
• Options de l'optimiseur : simulateur ou QPU, nombre de répétitions, optimiseur classique et ses options, profondeur de transpilation, et paramètres de l'échantillonneur ou de l'estimateur « IBM Quantum »

Les repères figurant dans la documentation montrent que la précision s'améliore à mesure que le nombre d'apprenants (qubits) augmente sur des problèmes difficiles, le classificateur quantique égalant ou dépassant un ensemble classique comparable. Dans ce tutoriel, vous reproduirez le flux de travail de bout en bout et examinerez si l'augmentation de la largeur de l'ensemble ou le passage à la régularisation adaptative permet d'obtenir de meilleurs résultats sur le site F1 avec une utilisation raisonnable des ressources. Il en résulte une vision fondée de la manière dont une étape d'optimisation quantique peut compléter, plutôt que remplacer, l'apprentissage d'ensemble classique dans des applications réelles.

Exigences

Avant de commencer ce tutoriel, assurez-vous que les paquets suivants sont installés dans votre environnement 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

Configuration

Dans cette section, nous initialisons le client Qiskit Serverless et chargeons la fonction Singularity Machine Learning - Classification fournie par Multiverse Computing. Avec Qiskit Serverless, vous pouvez exécuter des flux de travail hybrides quantique-classique sur l'infrastructure cloud gérée IBM sans vous soucier de la gestion des ressources. Vous aurez besoin d'une clé API IBM Quantum Platform et de votre nom de ressource cloud (CRN) pour vous authentifier et accéder à Qiskit Functions.

Télécharger l'ensemble de données

Pour exécuter ce tutoriel, nous utilisons un ensemble de données prétraitées de classification de la stabilité du réseau contenant des relevés de capteurs de système électrique étiquetés. La cellule suivante crée automatiquement la structure de dossier requise et télécharge les fichiers de formation et de test directement dans votre environnement à l'aide de wget. Si vous avez déjà ces fichiers localement, cette étape les écrasera en toute sécurité pour assurer la cohérence des versions.

## 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
base_url = (
    "https://raw.githubusercontent.com/Qiskit/documentation/"
    "main/datasets/tutorials/grid_stability"
)
!wget -q --show-progress -O data_tutorial/grid_stability/train.csv {base_url}/train.csv

!wget -q --show-progress -O data_tutorial/grid_stability/test.csv {base_url}/test.csv

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

Output:

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

Importer les paquets requis

Dans cette section, nous importons tous les paquets Python et les modules Qiskit utilisés tout au long du tutoriel. Il s'agit notamment de bibliothèques scientifiques de base pour le traitement des données et l'évaluation des modèles - telles que NumPy, pandas, et scikit-learn - ainsi que d'outils de visualisation et de composants Qiskit pour l'exécution du modèle quantique. Nous importons également QiskitRuntimeService et QiskitFunctionsCatalog pour nous connecter aux services IBM Quantum® et accéder à la fonction Singularity Machine Learning.

from pprint import pprint
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 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")

Définir des variables constantes

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"

Connectez-vous à IBM Quantum et chargez la fonction Singularity

Ensuite, nous nous authentifions auprès des services IBM Quantum et nous chargeons la fonction Singularity Machine Learning - Classification à partir du site Qiskit Functions Catalog. Le site QiskitRuntimeService établit une connexion sécurisée avec IBM Quantum Platform à l'aide de votre jeton API et de votre CRN d'instance, ce qui permet d'accéder aux backends quantiques. Le site QiskitFunctionsCatalog est ensuite utilisé pour récupérer la fonction de singularité par son nom ("multiverse/singularity"), ce qui nous permet de l'appeler ultérieurement pour un calcul hybride quantique-classique. Si la configuration est réussie, vous verrez un message de confirmation indiquant que la fonction a été chargée correctement.

catalog = QiskitFunctionsCatalog(
    token=IBM_TOKEN,
    instance=IBM_INSTANCE_TEST,
    channel="ibm_quantum_platform",
)
backend = catalog.least_busy()

singularity = catalog.load(FUNCTION_NAME)
print(
    "Successfully connected to IBM Qiskit Serverless and "
    "loaded the Singularity function."
)
print("Catalog:", catalog)
print("Singularity function:", singularity)

Output:

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

Définir les fonctions d'aide

Avant de réaliser les principales expériences, nous définissons quelques petites fonctions utilitaires qui simplifient le chargement des données et l'évaluation des modèles.

• load_data() lit les fichiers CSV d'entrée dans les tableaux NumPy, en divisant les caractéristiques et les étiquettes pour assurer la compatibilité avec scikit-learn et les flux de travail quantiques.
• evaluate_predictions() calcule les principales mesures de performance - exactitude, précision, rappel et F1-score - et signale éventuellement la durée d'exécution si des informations temporelles sont fournies.

Ces fonctions d'aide simplifient les opérations répétées plus loin dans le carnet et garantissent un rapport métrique cohérent entre les classificateurs classiques et quantiques.

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

Étape 1 : Mettre en correspondance les entrées classiques avec un problème quantique

Nous commençons par préparer l'ensemble de données pour l'expérimentation hybride quantique-classique. L'objectif de cette étape est de convertir les données brutes relatives à la stabilité de la grille en des séquences équilibrées d'entraînement, de validation et de test qui peuvent être utilisées de manière cohérente par les flux de travail classiques et quantiques. Le maintien de divisions identiques garantit que les comparaisons ultérieures des performances sont équitables et reproductibles.

Chargement et prétraitement des données

Nous commençons par charger les fichiers CSV de formation et de test, nous créons une division de validation et nous équilibrons l'ensemble de données à l'aide d'un suréchantillonnage aléatoire. L'équilibrage permet d'éviter les biais en faveur de la classe majoritaire et fournit un signal d'apprentissage plus stable pour les modèles d'ensemble classiques et quantiques.

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

Output:

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

Référence classique : AdaBoost

Avant de procéder à l'optimisation quantique, nous formons une base classique solide - un classificateur standard AdaBoost - sur les mêmes données équilibrées. Cela fournit un point de référence reproductible pour une comparaison ultérieure, permettant de quantifier si l'optimisation quantique améliore la généralisation ou l'efficacité au-delà d'un ensemble classique bien réglé.

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

Output:

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

Étape 2 : Optimiser le problème pour l'exécution sur du matériel quantique

La tâche de sélection d'ensembles est formulée comme un problème d'optimisation combinatoire dans lequel chaque apprenant faible correspond à une variable de décision binaire, et où l'objectif consiste à trouver un équilibre entre précision et parcimonie grâce à un terme de régularisation. Le QuantumEnhancedEnsembleClassifier résout ce problème grâce à la méthode QAOA sur du matériel de type « IBM », tout en permettant toujours l'exploration par simulation. Le contrôle optimizer_options de la boucle hybride : simulator=False achemine les circuits vers le QPU sélectionné, num_solutions augmente l'étendue de la recherche et ( classical_optimizer_options pour l'optimiseur classique interne) régule la convergence; des valeurs avoisinant les 60 itérations constituent un bon compromis entre qualité et temps d'exécution. Les options de calcul quantique — telles qu'une profondeur de circuit modérée (reps) et un effort de transpilation standard — contribuent à garantir des performances stables sur l'ensemble des appareils. La configuration ci-dessous correspond au profil « best-results » que nous utiliserons pour les exécutions sur matériel; vous pouvez également créer une variante purement simulée en activant l'option simulator=True permettant d'exécuter le workflow en mode simulation sans consommer de temps de calcul sur le 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}")

Output:

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

Étape 3 : Exécutez à l'aide d' Qiskit primitives

Nous exécutons maintenant le flux de travail complet en utilisant l'action create_fit_predict de la fonction Singularité pour former, optimiser et évaluer le QuantumEnhancedEnsembleClassifier de bout en bout sur l'infrastructure IBM. La fonction construit l'ensemble, applique l'optimisation quantique via Qiskit primitives, et renvoie à la fois les prédictions et les métadonnées du travail (y compris la durée d'exécution et l'utilisation des ressources). La répartition des données classiques de l'étape 1 est réutilisée à des fins de reproductibilité, les données de validation étant transmises à l'adresse fit_params afin que l'optimisation puisse ajuster les hyperparamètres en interne tout en conservant l'ensemble de test conservé.

Dans cette étape, nous explorons plusieurs configurations de l'ensemble quantique pour comprendre comment les paramètres clés - en particulier num_learners et regularization - affectent à la fois la qualité des résultats et l'utilisation de la QPU.

• num_learners détermine la largeur de l'ensemble (et implicitement le nombre de qubits), ce qui influe sur la capacité et le coût de calcul du modèle.
• regularization contrôle l'éparpillement et le surajustement, en déterminant le nombre d'apprenants qui restent actifs après l'optimisation.

En faisant varier ces paramètres, nous pouvons voir comment la largeur de l'ensemble et la régularisation interagissent : l'augmentation de la largeur améliore généralement F1 mais coûte plus de temps au QPU, tandis qu'une régularisation plus forte ou adaptative peut améliorer la généralisation à peu près au même niveau d'encombrement matériel. Les sous-sections suivantes présentent trois configurations représentatives pour illustrer ces effets.

Ligne de base

Cette configuration utilise num_learners = 10 et regularization = 7.

• num_learners contrôle la largeur de l'ensemble, c'est-à-dire le nombre d'apprenants faibles combinés et, sur le matériel quantique, le nombre de qubits requis. Une valeur plus élevée élargit l'espace de recherche combinatoire et peut améliorer la précision et le rappel, mais augmente également la largeur du circuit, le temps de compilation et l'utilisation globale du QPU.
• regularization définit la force de la pénalité pour l'inclusion d'apprenants supplémentaires. Avec la régularisation par défaut "onsite", les valeurs les plus élevées renforcent l'éparpillement (moins d'apprenants conservés), tandis que les valeurs les plus faibles permettent des ensembles plus complexes.

Cette configuration constitue une base de référence peu coûteuse, montrant le comportement d'un petit ensemble avant d'en augmenter la largeur ou d'en régler l'éparpillement.

# 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:")
pprint(result_1.get("metadata"))
qeec_pred_job_1 = np.array(result_1["data"]["predictions"])
_ = evaluate_predictions(qeec_pred_job_1, y_test)

Output:

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

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

Output:

Quantum job status: DONE

Augmenter le nombre d'apprenants

Ici, nous augmentons num_learners de 10 → 30 tout en conservant regularization = 7.

• Un plus grand nombre d'apprenants élargit l'espace d'hypothèses, ce qui permet au modèle de saisir des modèles plus subtils, ce qui peut améliorer légèrement F1.
• Dans la plupart des cas, la différence de durée d'exécution entre 10 et 30 apprenants n'est pas substantielle, ce qui indique que la largeur de circuit supplémentaire n'augmente pas de manière significative le coût d'exécution.
• L'amélioration de la qualité suit toujours une courbe à rendement décroissant : les premiers gains apparaissent au fur et à mesure que l'ensemble grandit, mais ils plafonnent à mesure que les apprenants supplémentaires apportent moins de nouvelles informations.

Cette expérience met en évidence le compromis qualité-efficacité - l'augmentation de la largeur de l'ensemble peut offrir de faibles gains de précision sans pénalité majeure en termes de temps d'exécution, en fonction des conditions du backend et de la transpilation.

# 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:")
pprint(result_2.get("metadata"))
qeec_pred_job_2 = np.array(result_2["data"]["predictions"])
_ = evaluate_predictions(qeec_pred_job_2, y_test)

Output:

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

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

Output:

Quantum job status: DONE

Régularisation

Dans cette configuration, nous passons à num_learners = 60 et introduisons une régularisation adaptative afin de gérer la rareté de manière plus intuitive.

• Avec regularization = "auto", l'optimiseur trouve automatiquement une force de régularisation appropriée qui sélectionne environ regularization_ratio * num_learners apprenants faibles pour l'ensemble final, plutôt que de fixer la pénalité manuellement. Il s'agit d'une interface plus pratique pour gérer l'équilibre entre l'éparpillement et la taille de l'ensemble.
• regularization_type = "alpha" définit la manière dont la pénalité est appliquée. Contrairement à onsite, qui est non borné [0, ∞], alpha est borné entre [0, 1], ce qui le rend plus facile à régler et à interpréter. Ce paramètre contrôle le compromis entre les pénalités individuelles et les pénalités par paire, ce qui permet d'obtenir une gamme de configurations plus homogène.
• regularization_desired_ratio ≈ 0.82 spécifie la proportion cible d'apprenants à garder actifs après la régularisation - ici, environ 82% des apprenants sont retenus, en éliminant automatiquement les 18% les plus faibles.

Si la régularisation adaptative simplifie la configuration et aide à maintenir un ensemble équilibré, elle ne garantit pas nécessairement des performances meilleures ou plus stables. La qualité réelle dépend de la sélection d'un paramètre de régularisation approprié, et son réglage fin par validation croisée peut être coûteux sur le plan informatique. Le principal avantage réside dans l'amélioration de la facilité d'utilisation et d'interprétation plutôt que dans les gains de précision directs.

# 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:")
pprint(result_3.get("metadata"))
qeec_pred_job_3 = np.array(result_3["data"]["predictions"])
_ = evaluate_predictions(qeec_pred_job_3, y_test)

Output:

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

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

Output:

Quantum job status: DONE

Étape 4 : Post-traitement et restitution du résultat dans le format classique souhaité

Nous traitons maintenant les résultats des essais classiques et quantiques, en les convertissant dans un format cohérent pour l'évaluation en aval. Cette étape compare la qualité prédictive à l'aide de mesures standard - exactitude, précision, rappel et F1 - et analyse la manière dont la largeur de l'ensemble (num_learners) et le contrôle de l'éparpillement (regularization) influencent à la fois les performances et le comportement informatique.

La ligne de base classique AdaBoost constitue une référence compacte et stable pour l'apprentissage à petite échelle. Il donne de bons résultats avec des ensembles limités et un surcoût de calcul négligeable, ce qui reflète la force du boosting traditionnel lorsque l'espace d'hypothèses est encore traçable. Les configurations quantiques (qeec_pred_job_1, qeec_pred_job_2, et qeec_pred_job_3) étendent cette ligne de base en intégrant le processus de sélection d'ensemble dans une boucle d'optimisation quantique variationnelle. Cela permet au système d'explorer simultanément des sous-ensembles d'apprenants de taille exponentielle en superposition, en tenant compte de la nature combinatoire de la sélection d'ensemble de manière plus efficace à mesure que l'échelle augmente.

Les résultats montrent que l'augmentation de num_learners de 10 à 30 améliore le rappel et F1, confirmant qu'un ensemble plus large capture des interactions plus riches entre les apprenants faibles. Le gain est sous-linéaire sur le matériel actuel - chaque apprenant supplémentaire produit des incréments de précision plus petits - mais le comportement d'échelle sous-jacent reste favorable parce que l'optimiseur quantique peut rechercher des espaces de configuration plus larges sans l'explosion exponentielle typique de la sélection classique de sous-ensembles. La régularisation introduit une nuance supplémentaire : un λ=7 fixe renforce la densité cohérente et stabilise la convergence, tandis que la régularisation α adaptative ajuste automatiquement la densité en fonction des corrélations entre les apprenants. Cet élagage dynamique permet souvent d'obtenir une adresse F1 légèrement plus élevée pour la même largeur de qubit, ce qui permet d'équilibrer la complexité du modèle et la généralisation.

Lorsqu'elle est comparée directement à la ligne de base AdaBoost, la plus petite configuration quantique ( L=10 ) reproduit une précision similaire, ce qui valide l'exactitude du pipeline hybride. À des largeurs plus importantes, les variantes quantiques - en particulier avec l'auto-régularisation - commencent à surpasser modestement la ligne de base classique, montrant une amélioration du rappel et de F1 sans croissance linéaire du coût de calcul. Ces améliorations n'indiquent pas un "avantage quantique" immédiat, mais plutôt une efficacité de mise à l'échelle : l'optimiseur quantique conserve des performances acceptables à mesure que l'ensemble s'étend, alors qu'une approche classique serait confrontée à une croissance exponentielle de la complexité de la sélection des sous-ensembles.

En pratique :

• Utilisez la ligne de base classique pour une validation rapide et une évaluation comparative sur de petits ensembles de données.
• Appliquer les ensembles quantiques lorsque la largeur du modèle ou la complexité des caractéristiques augmente - la recherche basée sur la méthode QAOA s'adapte mieux à ces régimes.
• Employer une α-régularisation adaptative pour maintenir la rareté et la généralisation sans augmenter la largeur du circuit.
• Contrôler le temps et la profondeur de la QPU pour équilibrer les gains de qualité avec les contraintes matérielles à court terme.

L'ensemble de ces expériences montre que les ensembles optimisés au niveau quantique complètent les méthodes classiques : ils reproduisent la précision de base à petite échelle tout en offrant une voie vers une mise à l'échelle efficace pour les problèmes d'apprentissage combinatoires plus importants. Au fur et à mesure que le matériel s'améliore, ces avantages de mise à l'échelle devraient s'accentuer, étendant la taille et la profondeur des modèles basés sur l'ensemble au-delà de ce qui est classiquement pratique.

Évaluer les indicateurs pour chaque configuration

Nous évaluons maintenant toutes les configurations - la ligne de base classique AdaBoost et les trois ensembles quantiques - en utilisant l'aide evaluate_predictions pour calculer l'exactitude, la précision, le rappel et F1 sur le même ensemble de test. Cette comparaison clarifie la manière dont l'optimisation quantique évolue par rapport à l'approche classique : à petite échelle, les deux méthodes fonctionnent de manière similaire; à mesure que les ensembles se développent, la méthode quantique peut explorer plus efficacement des espaces d'hypothèses plus vastes. Le tableau qui en résulte présente ces tendances sous une forme quantitative cohérente.

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

Output:

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

Visualisez les tendances en matière de qualité pour toutes les configurations

Le graphique à barres groupées ci-dessous compare la précision et F1 entre la ligne de base classique et les ensembles quantiques (L=10, L=30, et L=60 auto-α ). Il montre comment la précision se stabilise tandis que F1 s'améliore progressivement à mesure que la largeur de l'ensemble quantique augmente, démontrant que la méthode hybride permet de maintenir l'échelle des performances sans la croissance exponentielle des coûts typique de la sélection classique de sous-ensembles.

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:

Interprétation

Le graphique confirme le modèle d'échelle attendu. La méthode classique AdaBoost donne de bons résultats pour les petits ensembles, mais devient de plus en plus coûteuse à mettre à l'échelle lorsque le nombre d'apprenants faibles augmente, car son problème de sélection de sous-ensembles prend de l'ampleur sur le plan combinatoire. Les modèles améliorés par les quanta reproduisent la précision classique à des largeurs faibles et commencent à la dépasser lorsque la taille de l'ensemble augmente, en particulier dans le cadre d'une α-régularisation adaptative. Cela reflète la capacité de l'optimiseur quantique à échantillonner et à évaluer de nombreux sous-ensembles candidats en parallèle grâce à la superposition, ce qui permet de maintenir une recherche traçable même à des largeurs plus importantes. Bien que la surcharge matérielle actuelle compense une partie des gains théoriques, la tendance illustre l'avantage de l'efficacité de la mise à l'échelle de la formulation quantique. En termes pratiques, la méthode classique reste préférable pour les repères légers, tandis que les ensembles quantiques deviennent avantageux lorsque la dimensionnalité du modèle et la taille de l'ensemble augmentent, offrant de meilleurs compromis entre la précision, la généralisation et la croissance des calculs.

Annexe : Avantages et améliorations liés à la mise à l'échelle

L'avantage de l'extensibilité du site QuantumEnhancedEnsembleClassifier provient de la façon dont le processus de sélection d'ensemble s'adapte à l'optimisation quantique. Les méthodes classiques d'apprentissage d'ensemble, telles que AdaBoost ou les forêts aléatoires, deviennent coûteuses en termes de calcul lorsque le nombre d'apprenants faibles augmente, car la sélection du sous-ensemble optimal est un problème combinatoire qui s'étend de manière exponentielle.

En revanche, la formulation quantique - mise en œuvre ici via l'algorithme d'optimisation approximative quantique (QAOA) - peut explorer plus efficacement ces espaces de recherche de taille exponentielle en évaluant plusieurs configurations en superposition. Par conséquent, le temps de formation n'augmente pas de manière significative avec le nombre d'apprenants, ce qui permet au modèle de rester efficace même lorsque la taille de l'ensemble augmente.

Bien que le matériel actuel présente certaines limitations en termes de bruit et de profondeur, ce flux de travail démontre une approche hybride à court terme dans laquelle les composants classiques et quantiques coopèrent : l'optimiseur quantique fournit un meilleur paysage d'initialisation pour la boucle classique, améliorant ainsi la convergence et la qualité du modèle final. Au fur et à mesure de l'évolution des processeurs quantiques, ces avantages en termes d'évolutivité devraient s'étendre à des ensembles de données plus importants, à des ensembles plus vastes et à des circuits plus profonds.

Références

1. Introduction à la Qiskit Functions
2. Multivers Informatique Singularité Machine Learning

Enquête tutorielle

Veuillez prendre une minute pour nous faire part de vos commentaires sur ce tutoriel. Vos commentaires nous aideront à améliorer nos offres de contenu et l'expérience des utilisateurs.

Lien vers l'enquête