Orbit - une fonction Qiskit de Quantum Elements

Remarque

Les fonctions Qiskit sont une fonctionnalité expérimentale disponible uniquement pour les utilisateurs des plans IBM Quantum® Premium, Flex et On-Prem (via l'API IBM Quantum Platform). Elles sont en statut de version préliminaire et sujettes à modification.

Vue d'ensemble

Le matériel quantique continue de progresser, mais le bruit et la décohérence limitent encore la profondeur et la fiabilité des circuits quantiques pratiques. Parmi les approches disponibles, trois techniques complémentaires peuvent atténuer considérablement ces limitations : le découplage dynamique (DD), la transpilation optimisée et l'atténuation des erreurs de mesure (MEM). La transpilation optimisée réduit la profondeur des circuits et aligne mieux les circuits avec la connectivité du matériel cible, le DD supprime le bruit pendant les périodes d'inactivité grâce à des séquences de contrôle soigneusement conçues, et le MEM réduit les effets des erreurs de lecture et peut être appliqué lors du post-traitement.

Choisir une stratégie DD efficace n'est pas trivial, car de nombreuses familles de séquences sont disponibles, et une séquence performante pour un circuit ou un environnement de bruit donné peut ne pas l'être pour un autre. Les avantages de la transpilation, du DD et du MEM dépendent du problème, du matériel et de la charge de travail ; utilisés individuellement ou en combinaison, ils peuvent améliorer les performances, mais ils ne sont pas universellement bénéfiques dans toutes les configurations.

Orbit, une fonction Qiskit développée par Quantum Elements, combine de manière transparente ces trois composants en un seul flux de travail unifié, ce qui les rend faciles à utiliser pour améliorer l'exécution des circuits sur le matériel IBM Quantum. Dans sa forme principale, Orbit applique automatiquement des stratégies actives de suppression des erreurs qui protègent les états quantiques pendant les périodes d'inactivité, tout en préservant la logique originale du circuit. À noter, cela se fait sans introduire de temps de pré-traitement quantique ou classique supplémentaire, évitant ainsi des coûts ou des temps d'attente inutiles dans le flux de travail.

Plutôt que de fonctionner comme une boîte noire, Orbit permet aux utilisateurs d'évaluer et d'ajuster finement ses composants d'optimisation pour une expérience donnée. Les utilisateurs peuvent activer ou désactiver indépendamment la transpilation optimisée, le DD et le MEM ; comparer la sélection automatique du DD avec des séquences spécifiées par l'utilisateur ; et exécuter plusieurs configurations au sein du même flux de travail. En comparant chaque configuration au circuit brut, les utilisateurs peuvent déterminer quelles techniques apportent des avantages mesurables pour leur circuit et leur backend, identifier les interactions entre les différentes méthodes d'optimisation, et sélectionner la configuration qui répond le mieux à leur objectif expérimental. Ce processus aide les utilisateurs à comprendre d'où proviennent les gains de performance et à prendre des décisions plus éclairées lors de l'optimisation des circuits quantiques pour une charge de travail donnée.

Description

Orbit est conçu pour améliorer l'exécution des circuits quantiques sur les backends IBM Quantum. En mode automatisé, les utilisateurs peuvent appliquer facilement des séquences DD robustes d'ordre élevé sans avoir à les sélectionner ou à les configurer manuellement. Les utilisateurs avancés peuvent en revanche expérimenter avec les séquences d'ordre supérieur disponibles pour identifier et optimiser l'approche offrant les meilleures performances pour un circuit donné.

Orbit fournit également un MEM instantané sans nécessiter les tâches supplémentaires habituellement requises pour des flux de travail de calibration et d'atténuation séparés. Pour les charges de travail dans lesquelles la transpilation ne doit pas modifier la structure du circuit, comme les circuits de correction d'erreurs quantiques avec des mesures en cours de circuit ou les circuits dynamiques, Orbit peut appliquer le DD et le MEM sans interférer avec la stratégie de transpilation existante de l'utilisateur. Pour les utilisateurs qui n'ont pas déjà d'approche préférée, Orbit inclut également un transpileur intégré pour optimiser les circuits pour le matériel cible avant d'appliquer les techniques de suppression des erreurs et d'atténuation de la lecture.

Contrairement aux approches qui reposent sur un échantillonnage supplémentaire des circuits, l'extrapolation ou un post-traitement classique intensif, Orbit se concentre sur la suppression des erreurs pendant l'exécution. La fonction est conçue pour introduire une faible surcharge tout en préservant la logique originale du circuit. Les utilisateurs peuvent inspecter le circuit résultant et comparer directement les exécutions optimisées par Orbit avec les exécutions standard.

Un flux de travail Orbit pratique est le suivant :

Définis un circuit quantique et sélectionne Orbit via le catalogue de fonctions Qiskit.
Inclus le circuit sans Orbit en utilisant le mode « Brut » pour établir une référence de circuit brut.
Choisis les stratégies d'optimisation à appliquer, y compris les séquences DD automatisées ou choisies par l'utilisateur, le MEM et la transpilation optimisée.
Active ou désactive des méthodes individuelles, ou soumets plusieurs configurations, pour évaluer leurs effets séparés et combinés.

Orbit est particulièrement utile pour les circuits contenant des périodes d'inactivité ou des écarts de planification où les qubits ne participent pas activement à des portes. Il prend en charge les circuits statiques et dynamiques, y compris les flux de travail avec des mesures en cours de circuit et les expériences de calcul quantique tolérant aux fautes. Les applications typiques comprennent la correction d'erreurs quantiques, les expériences de code de surface sur des réseaux carrés et heavy-hex, les algorithmes oraculaires tels que Bernstein-Vazirani, les circuits de transformée de Fourier, les algorithmes quantiques variationnels, la simulation hamiltonienne, les expériences de benchmarking et l'optimisation de circuits adaptée au matériel.

En vue de l'ère de la tolérance aux fautes, Orbit est également compatible avec les flux de travail de calcul quantique tolérant aux fautes, car il peut être facilement combiné avec la correction d'erreurs quantiques. À long terme, Orbit ouvre la voie au découplage dynamique au niveau logique [1] comme approche d'avenir pour protéger les qubits logiques. Dans l'exemple ci-dessous, deux qubits logiques ont été intriqués pour créer un état de Bell logique sous détection d'erreurs quantiques. La détection d'erreurs quantiques seule a entraîné une décroissance de la fidélité de l'état de Bell à environ 44 % sur des dizaines de microsecondes, tandis que la détection d'erreurs quantiques combinée à une protection de type Orbit a maintenu la fidélité de l'état de Bell logique proche du sommet de l'échelle, atteignant environ 95,3 % sur la même fenêtre temporelle. Orbit Quantum Circuit Development Platform

Benchmarks

Les résultats suivants résument des exécutions représentatives d'Orbit sur du matériel IBM Quantum. Comme pour d'autres benchmarks matériels, les résultats dépendent du dispositif sélectionné, de l'état de calibration, du circuit et des paramètres d'exécution.

Exemple	Métrique	Qubits	QPU	Détails supplémentaires	Amélioration Orbit
Bernstein–Vazirani	Fidélité de la chaîne binaire cachée	26 60 70	Heron r3	Brut par rapport à Orbit complet, Transpilation seule par rapport à Orbit complet, Orbit complet uniquement	75x 66x N/A
QFT (unitaire)	Fidélité	10	Heron r2 Heron r3	Orbit par rapport au brut : ~44 % contre ~35 % ~67 % contre ~61 %	1,26x 1,09x
QFT (circuits dynamiques)	Fidélité	10 20	Heron r3	Orbit par rapport au brut : ~55 % contre ~2 % ~10 % contre ~0 %	27,51x N/A
État de Bell longue portée (circuits dynamiques)	Fidélité	30 60	Heron r2	N/A	1,78x 1,11x
Code de surface (réseau carré)	Probabilité d'erreur logique	25	Nighthawk r1	1 cycle 5 cycles 10 cycles	1,01x 1,15x 1,12x
Code de surface (heavy-hex)	Probabilité d'erreur logique	65	Heron r3	1 cycle 5 cycles 10 cycles	4,11x 2,04x 1,39x
VQE	Erreur absolue par rapport à l'énergie idéale	8	Heron r3	Orbit par rapport au brut : 56mHa contre 1342 mHa	24x
QAOA	Probabilité de succès	5	Heron r2	N/A	1,46x
Code `[[4,2,2]]` (suppression d'erreurs au niveau logique)	Fidélité logique de l'état de Bell intriqué	4	Heron r2	Fidélité moyenne sur 55 μs	1,63x

Définitions des métriques

Fidélité de la chaîne binaire cachée de Bernstein–Vazirani : Probabilité de mesurer la chaîne binaire cachée correcte. Cette métrique indique la fiabilité avec laquelle l'algorithme retrouve la solution recherchée à mesure que la taille du circuit augmente. Le tableau rapporte les trois plus grandes chaînes binaires cachées évaluées avec succès selon trois configurations différentes : (i) les circuits bruts sans Orbit, qui ont atteint 26 qubits ; (ii) les circuits avec transpilation uniquement, qui ont atteint 60 qubits ; et (iii) les circuits utilisant le flux de travail Orbit complet, qui ont atteint 70 qubits. Pour les circuits bruts (i), le facteur d'amélioration représente le gain de performance obtenu grâce au DD et au MEM par rapport aux circuits non modifiés. Pour la configuration transpilation uniquement (ii), il représente l'amélioration obtenue en ajoutant le DD et le MEM aux circuits transpilés de manière optimale. Pour la configuration Orbit complète (iii), aucun facteur d'amélioration de référence n'est rapporté, car une probabilité de succès non nulle n'a été obtenue que lorsque tous les composants d'Orbit (transpilation, DD et MEM) étaient activés. Un exemple illustratif est fourni ci-dessous.
Fidélité de la transformée de Fourier quantique : Pour les implémentations QFT unitaire et à circuits dynamiques [2], la fidélité mesure l'accord entre la transformation implémentée expérimentalement et le processus QFT idéal sur 20 états d'entrée différents. Les circuits dynamiques comportent des périodes d'inactivité importantes dues aux mesures en cours de circuit et à la rétroaction classique, pendant lesquelles le découplage dynamique peut supprimer la décohérence. L'amélioration rapportée compare la fidélité obtenue avec Orbit à la fidélité brute.
Préparation d'état de Bell longue portée : Création d'un état de Bell à l'aide de circuits dynamiques et d'opérations de rétroaction entre deux qubits séparés par jusqu'à 60 qubits intermédiaires, démontrant ainsi une intrication longue portée efficace sur du matériel quantique à connectivité locale [3]. Orbit identifie le meilleur routage des qubits, préserve les qubits pendant les mesures de rétroaction, et applique le MEM pour atténuer les erreurs de lecture.
Probabilité d'erreur logique du code de surface : Pour le code de surface heavy-hex [4] et le code de surface à réseau carré [5], des expériences de mémoire quantique ont été réalisées, dans lesquelles un état logique encodé a été préservé sur plusieurs cycles de correction d'erreurs. La probabilité d'erreur logique mesure la probabilité que les erreurs accumulées entraînent une récupération incorrecte de l'information encodée (une erreur plus faible est préférable). L'amélioration rapportée compare la probabilité d'erreur logique des circuits bruts à celle obtenue avec Orbit.
Erreur absolue du VQE : Utilisation du VQE avec un ansatz de cluster couplé unitaire optimisé pour estimer l'énergie de l'état fondamental de LiH [6]. L'énergie mesurée est comparée à l'énergie idéale correspondante obtenue à partir du circuit sans bruit. La métrique est la différence absolue entre les énergies mesurée et idéale (des valeurs plus faibles sont préférables). L'amélioration rapportée est :

\text{Improvement factor} = \frac{|E_{\mathrm{raw}}-E_{\mathrm{ideal}}|} {|E_{\mathrm{Orbit}}-E_{\mathrm{ideal}}|}.

Des valeurs supérieures à un indiquent qu'Orbit réduit l'erreur d'énergie par rapport à une exécution sans découplage dynamique.

Probabilité de succès du QAOA : Probabilité de mesurer une chaîne binaire correspondant à une solution optimale du problème d'optimisation défini sur le graphe papillon. L'amélioration rapportée compare la probabilité de succès obtenue avec Orbit à celle obtenue avec les circuits bruts.
Fidélité logique : Dans l'expérience de découplage dynamique logique [[4,2,2]] [1], deux qubits logiques ont été encodés dans quatre qubits physiques et préparés sous la forme d'un état de Bell logique intriqué. La fidélité logique mesure l'accord entre l'état encodé récupéré et l'état de Bell logique cible. L'amélioration rapportée compare la fidélité logique moyenne obtenue avec Orbit et la détection d'erreurs (capacité du code) à celle obtenue en utilisant uniquement le code seul.

Pour commencer

Authentifie-toi à l'aide de ta clé API IBM Quantum Platform, puis sélectionne la fonction Orbit comme suit. Cet extrait suppose que tu as déjà enregistré ton compte dans ton environnement local.

# Added by doQumentation — required packages for this notebook
!pip install -q matplotlib qiskit qiskit-ibm-catalog

from qiskit_ibm_catalog import QiskitFunctionsCatalog
from qiskit import QuantumCircuit

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")
# Verify that you have access to the function.
catalog.list()

[QiskitFunction(quantum-elements/orbit)]

# Load the function.
orbit = catalog.load("quantum-elements/orbit")

Exemple

L'exemple suivant construit un circuit de Bernstein-Vazirani et le soumet à Orbit de deux manières en une seule tâche : exécution brute et paramètres par défaut d'Orbit.

Utilise ce schéma lorsque tu veux comparer directement le brut et Orbit.

Construire un circuit de Bernstein-Vazirani

Choisis la chaîne binaire cachée et construis le circuit logique. Le qubit supplémentaire est la cible de l'oracle, tandis que les qubits d'entrée sont mesurés.

def create_bv_circuit(hidden_bitstring: str) -> QuantumCircuit:
    width = len(hidden_bitstring)
    circuit = QuantumCircuit(width + 1, width)

    circuit.x(width)
    circuit.h(range(width + 1))

    for input_qubit, bit in enumerate(reversed(hidden_bitstring)):
        if bit == "1":
            circuit.cx(input_qubit, width)

    circuit.barrier()
    circuit.h(range(width + 1))
    circuit.measure(range(width), range(width))
    return circuit

circuit_width = 50
hidden_bitstring = "1" * circuit_width
shots = 4096

bv_circuit = create_bv_circuit(hidden_bitstring)
bv_circuit.count_ops()

OrderedDict([('h', 102),
             ('cx', 50),
             ('measure', 50),
             ('x', 1),
             ('barrier', 1)])

Préparer la charge de travail Orbit

Crée un PUB Sampler, puis duplique-le pour les deux modes de comparaison. Orbit reçoit le circuit logique et le fait correspondre au backend sélectionné lors de l'exécution.

base_pub = (bv_circuit, None, shots)
comparison_labels = ["raw", "orbit"]
pubs = [base_pub] * len(comparison_labels)

Exécuter le mode brut et les paramètres par défaut d'Orbit

pub_options assigne le premier PUB au mode brut, qui ignore l'optimisation Orbit, le DD et le MEM, et assigne le second PUB aux paramètres par défaut d'Orbit, qui incluent la transpilation optimisée, l'insertion automatisée du découplage dynamique (DD) et l'atténuation des erreurs de mesure (MEM).

backend_name = "ibm_kingston"

job = orbit.run(
    primitive="sampler",
    pubs=pubs,
    backend_name=backend_name,
    options={
        "pub_options": [
            {"mode": "raw"},
            {"mode": "orbit"},
        ],
        "save_backend_info": True,
    },
)

# Check the job ID and status
print(job.job_id)
print(job.status())

c0f1b99c-8dfa-4ebb-9560-d9a37c990acc
QUEUED

Récupère le résultat et compare les circuits brut et amélioré par Orbit à l'aide des comptages. Pour les résultats Sampler, get_counts() sur le registre classique renvoyé fournit l'histogramme de sortie. Lorsque le MEM réussit pour le PUB Orbit, cet histogramme est déjà corrigé par le MEM ; les comptages non atténués restent disponibles dans les métadonnées Orbit sous measurementErrorMitigation["rawCounts"].

def extract_counts(pub_result) -> dict[str, int]:
    data = getattr(pub_result, "data", None)
    if data is None:
        raise TypeError("pub_result.data is missing")

    for name in dir(data):
        if name.startswith("_"):
            continue
        register = getattr(data, name)
        get_counts = getattr(register, "get_counts", None)
        if callable(get_counts):
            counts = get_counts()
            if counts:
                return counts

    raise TypeError(
        "No classical register with get_counts() found in pub_result.data"
    )

result = job.result()
if len(result) != len(comparison_labels):
    raise RuntimeError(
        f"Expected {len(comparison_labels)} PUB results, received {len(result)}."
    )

comparison_counts = {
    label: extract_counts(pub_result)
    for label, pub_result in zip(comparison_labels, result, strict=True)
}
correct_counts = {
    label: counts.get(hidden_bitstring, 0)
    for label, counts in comparison_counts.items()
}

print(
    {
        "hidden_bitstring": hidden_bitstring,
        "correct_counts": correct_counts,
        "shots": shots,
    }
)

{'hidden_bitstring': '11111111111111111111111111111111111111111111111111', 'correct_counts': {'raw': 0, 'orbit': 184}, 'shots': 4096}

Fais une comparaison visuelle des circuits brut et amélioré par Orbit.

import matplotlib.pyplot as plt

labels = list(correct_counts)
values = list(correct_counts.values())
fig, ax = plt.subplots(figsize=(7, 4))
bars = ax.bar(labels, values, width=0.55)
ax.bar_label(bars, labels=[f"{value:g}" for value in values], padding=3)
ax.set_xlabel("Circuit execution mode")
ax.set_ylabel("Correct hidden-bitstring count")
ax.set_title(f"{circuit_width}-qubit Bernstein-Vazirani on {backend_name}")
ax.set_ylim(0, max(1, 1.15 * max(values)))
ax.grid(axis="y", alpha=0.25)
fig.tight_layout()
plt.show()

Output of the previous code cell

Obtenir de l'aide

Contacte le support de Quantum Elements : info@quantumelements.ai

Veille à inclure les informations suivantes :

ID de tâche de la fonction Qiskit (qiskit-ibm-catalog), job.job_id
Nom du backend
pub_options d'Orbit utilisés pour les modes brut et Orbit
Une description détaillée du problème
Tout message ou code d'erreur pertinent
Les étapes pour reproduire le problème

Prochaines étapes

Recommandations

Essaie un backend différent, un autre nombre de qubits, ou une autre chaîne binaire cachée.
Lis notre tutoriel sur la transformée de Fourier quantique pour apprendre à définir des stratégies DD personnalisées compatibles avec Orbit, ainsi qu'à appliquer le DD à des circuits dynamiques avec des mesures en cours de circuit et des opérations de rétroaction.
Consulte la référence API pour une description détaillée de toutes les options d'Orbit.

Vue d'ensemble​

Description​

Benchmarks​

Définitions des métriques​

Pour commencer​

Exemple​

Construire un circuit de Bernstein-Vazirani​

Préparer la charge de travail Orbit​

Exécuter le mode brut et les paramètres par défaut d'Orbit​

Obtenir de l'aide​

Prochaines étapes​

Références​