Orbit – une fonction Qiskit développée par Quantum Elements

Consultez la documentation de l'API

Présentation

Le matériel quantique ne cesse de progresser, mais le bruit et la décohérence continuent de limiter la complexité et la fiabilité des circuits quantiques concrets. Parmi les approches disponibles, trois techniques complémentaires permettent d'atténuer considérablement ces limites : 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 permet de mieux les adapter à la connectivité du matériel cible; la technique DD supprime le bruit lié aux temps morts grâce à des séquences de contrôle soigneusement conçues; enfin, la technique MEM atténue les effets des erreurs de lecture et peut être appliquée lors du post-traitement.

Le choix d'une stratégie de DD efficace n'est pas une mince affaire, car il existe de nombreuses familles de séquences, et une séquence qui donne de bons résultats pour un circuit ou un environnement de bruit donné peut ne pas être aussi performante dans un autre contexte. 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 séparément ou en combinaison, ils peuvent améliorer les performances, mais ils ne sont pas systématiquement bénéfiques dans toutes les configurations.

Orbit, une fonction Qiskit développée par Quantum Elements, intègre de manière transparente ces trois composants dans un flux de travail unifié, ce qui facilite leur utilisation pour optimiser l'exécution des circuits sur le matériel d' IBM Quantum. Dans sa forme de base, 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 initiale du circuit. Il convient notamment de noter que cela se fait sans ajouter de temps de prétraitement quantique ou classique supplémentaire, ce qui permet d'éviter des coûts supplémentaires inutiles ou des temps d'attente dans le flux de travail.

Loin d'être une « boîte noire », Orbit permet aux utilisateurs d'évaluer et d'ajuster ses composants d'optimisation en fonction d'une expérience spécifique. Les utilisateurs peuvent activer ou désactiver à leur guise la transpilation optimisée, le DD et le MEM; comparer la sélection automatique du DD avec les séquences spécifiées par l'utilisateur; et exécuter plusieurs configurations au sein d'un même flux de travail. En comparant chaque configuration au circuit brut, les utilisateurs peuvent déterminer quelles techniques apportent des avantages mesurables à leur circuit et à leur backend, identifier les interactions entre les différentes méthodes d'optimisation et sélectionner la configuration la mieux adaptée à 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 lorsqu'ils optimisent des circuits quantiques pour une charge de travail donnée.

Description

Orbit est conçu pour optimiser l'exécution de circuits quantiques sur des backends d' IBM Quantum. En mode automatisé, les utilisateurs peuvent appliquer en toute transparence des séquences DD robustes d'ordre élevé sans avoir à les sélectionner ni à les configurer manuellement. Les utilisateurs avancés peuvent, quant à eux, tester les séquences d'ordre supérieur disponibles afin d'identifier et d'optimiser l'approche offrant les meilleures performances pour un circuit donné.

Orbit fournit également des données MEM en temps réel, sans nécessiter les tâches supplémentaires généralement requises pour les processus distincts d'étalonnage et d'atténuation. 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 mesures en cours de calcul ou les circuits dynamiques, Orbit peut appliquer les méthodes DD et MEM sans interférer avec la stratégie de transpilation existante de l'utilisateur. Pour les utilisateurs qui n'ont pas encore d'approche privilégiée, Orbit intègre également un transcompilateur permettant d'optimiser les circuits pour le matériel cible avant d'appliquer des techniques de suppression des erreurs et d'atténuation des problèmes de lecture.

Contrairement aux approches qui reposent sur un échantillonnage supplémentaire des circuits, sur l'extrapolation ou sur un post-traitement classique intensif, Orbit vise à réduire les erreurs dès l'exécution. Cette fonction est conçue pour réduire la charge tout en préservant la logique initiale du circuit. Les utilisateurs peuvent examiner le circuit obtenu et comparer directement les exécutions optimisées par Orbit avec les exécutions standard.

Voici un exemple concret de workflow Orbit :

1. Définissez un circuit quantique et sélectionnez « Orbit » via l’ Qiskit Functions Catalog.
2. Intégrez le circuit sans Orbit en utilisant le mode « Raw » afin d'établir une référence du circuit brut.
3. Choisissez les stratégies d'optimisation à appliquer, notamment les séquences DD automatisées ou sélectionnées par l'utilisateur, la méthode MEM et la transpilation optimisée.
4. Activez ou désactivez des méthodes individuelles, ou soumettez plusieurs configurations, afin d'évaluer leurs effets respectifs et combinés.

Orbit s'avère particulièrement utile pour les circuits comportant des périodes d'inactivité ou des intervalles de planification durant lesquels les qubits ne participent pas activement aux portes logiques. Il prend en charge les circuits statiques et dynamiques, y compris les flux de travail comportant des mesures en cours de circuit et les expériences de calcul quantique tolérantes aux pannes. Parmi les applications typiques, on peut citer la correction d'erreurs quantiques, les expériences sur les codes de surface sur des réseaux carrés et hexagonaux lourds, les algorithmes oraculaires tels que Bernstein-Vazirani, les circuits à transformée de Fourier, les algorithmes quantiques variationnels, la simulation hamiltonienne, les expériences de benchmarking et l'optimisation de circuits tenant compte du matériel.

Dans la perspective de l'ère de la tolérance aux pannes, Orbit est également compatible avec les flux de travail de calcul quantique tolérants aux pannes, car il peut être combiné de manière transparente avec la correction d'erreurs quantiques. À long terme, Orbit considère le découplage dynamique au niveau logique [1] comme une voie d'avenir pour la protection des qubits logiques. Dans l'exemple ci-dessous, deux qubits logiques ont été mis en intrication afin de créer un état de Bell logique dans le cadre de la détection d'erreurs quantiques. La détection quantique d’erreurs à elle seule a entraîné une dégradation de la fidélité de l’état de Bell jusqu’à environ 44 % en l’espace de quelques dizaines de microsecondes, tandis que la QED, associée à une protection de type « Orbit », a permis de maintenir la fidélité logique de l’état de Bell près du maximum de l’échelle, atteignant environ 95.3 % sur la même fenêtre temporelle.

Tests de performances

Les résultats suivants résument des exécutions représentatives d'Orbit sur le matériel d' IBM Quantum. Comme pour les autres tests de performance matérielle, les résultats dépendent du périphérique sélectionné, de l'état d'étalonnage, du circuit et des paramètres d'exécution.

Définitions de métrique

• Fidélité de Bernstein-Vazirani pour une chaîne de bits cachée : probabilité de mesurer la chaîne de bits cachée correcte. Cet indicateur mesure la fiabilité avec laquelle l'algorithme parvient à retrouver la solution recherchée à mesure que la taille du circuit augmente. Le tableau présente les trois plus longues chaînes de bits cachées évaluées avec succès dans le cadre de trois configurations différentes : (i) des circuits bruts sans Orbit, qui ont atteint 26 qubits; (ii) des circuits utilisant uniquement la transpilation, qui ont atteint 60 qubits; et (iii) des circuits utilisant l'ensemble du workflow Orbit, qui ont atteint 70 qubits. Pour les circuits bruts (i), le facteur d'amélioration représente le gain de performance obtenu par DD et MEM par rapport aux circuits non modifiés. Pour la configuration « transpilation uniquement » (ii), cela correspond à l'amélioration obtenue en ajoutant DD et MEM aux circuits transpilés de manière optimale. Pour la configuration complète d'Orbit (iii), aucun facteur d'amélioration par rapport à la configuration de référence n'est indiqué, car une probabilité de réussite non nulle n'a été obtenue que lorsque tous les composants d'Orbit (transpilation, DD et MEM) étaient activés. Vous trouverez ci-dessous un exemple illustratif.

• Fidélité de la transformée de Fourier quantique : tant pour les implémentations unitaires que pour celles utilisant des circuits dynamiques [2], la fidélité mesure la concordance entre la transformation réalisée expérimentalement et le processus idéal de transformée de Fourier quantique, pour 20 états d'entrée différents. Les circuits dynamiques comportent des temps morts importants dus aux mesures effectuées en cours de circuit et à la projection vers l'avant classique, pendant lesquels le découplage dynamique peut supprimer la décohérence. L'amélioration constatée résulte de la comparaison entre la fidélité obtenue avec Orbit et la fidélité brute.

• Préparation d'un état de Bell à longue portée : création d'un état de Bell à l'aide de circuits dynamiques et d'opérations de transmission directe entre deux qubits séparés par jusqu'à 60 qubits intermédiaires, démontrant ainsi l'existence d'un enchevêtrement efficace à longue portée sur un matériel quantique connecté localement [3]. Orbit détermine le meilleur acheminement des qubits, préserve ces derniers pendant les mesures en feedforward et utilise la technique MEM pour atténuer les erreurs de lecture.

• Probabilité d'erreur logique dans les codes de surface : pour le code de surface « heavy-hex » [4] et le code de surface à réseau carré [5], des expériences sur la mémoire quantique ont été menées, au cours desquelles un état logique codé a été préservé au fil de cycles répétés 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 codée (une probabilité d'erreur faible est préférable). L'amélioration constatée résulte de la comparaison entre la probabilité d'erreur logique des circuits bruts et celle obtenue avec Orbit.

• Erreur absolue de la méthode VQE : utilisation de la méthode VQE avec une approche unitaire « coupled-cluster » optimisée pour estimer l'énergie de l'état fondamental de l' LiH e [6]. L'énergie mesurée est comparée à l'énergie idéale correspondante obtenue à partir du circuit sans bruit. Cet indicateur correspond à la différence absolue entre l'énergie mesurée et l'énergie idéale (les valeurs les plus faibles sont les meilleures). L'amélioration constatée est la suivante :

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

• Probabilité de réussite de la méthode QAOA : probabilité d'obtenir une chaîne de bits correspondant à une solution optimale du problème d'optimisation défini sur le graphe papillon. L'amélioration constatée résulte de la comparaison entre la probabilité de réussite obtenue avec Orbit et celle obtenue à partir des circuits bruts.

• Fidélité logique : Dans l'expérience [n° 1] de découplage dynamique logique [ [4,2,2] ], deux qubits logiques ont été codés dans quatre qubits physiques et préparés sous la forme d'un état logique de Bell intriqué. La fidélité logique mesure la concordance entre l'état codé récupéré et l'état logique de Bell cible. L'amélioration constatée résulte de la comparaison entre la fidélité logique moyenne obtenue avec Orbit et la détection d'erreurs (capacité du code) et celle obtenue en utilisant uniquement le code.

Premiers pas

Authentifiez-vous à l'aide de votre clé API IBM Quantum Platform et sélectionnez la fonction Orbit comme suit. Cet extrait de code part du principe que vous avez déjà enregistré votre compte dans votre environnement local.

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

Output:

[QiskitFunction(quantum-elements/orbit)]

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

Exemple

L'exemple suivant permet de créer un circuit Bernstein-Vazirani et de le soumettre à Orbit de deux manières différentes au sein d'une même tâche : exécution brute et paramètres par défaut d'Orbit.

Utilisez ce modèle lorsque vous souhaitez effectuer une comparaison directe entre « raw » et « Orbit ».

Construire un circuit de Bernstein-Vazirani

Choisissez la chaîne binaire cachée et construisez le circuit logique. Le qubit supplémentaire sert de cible à 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()

Output:

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

Préparer la charge de travail Orbit

Créez un échantillonneur PUB, puis dupliquez-le pour les deux modes de comparaison. Orbit reçoit le circuit logique et le mappe vers le 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 sans paramètres et utiliser les paramètres par défaut d'Orbit

pub_options attribue au premier PUB le mode « raw », qui ignore l'optimisation Orbit, le DD et le MEM, et attribue au second PUB les paramètres par défaut d'Orbit, qui comprennent 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())

Output:

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

Récupérez le résultat et comparez les circuits bruts et ceux optimisés par Orbit à l'aide des comptages. Pour les résultats du Sampler, get_counts() le registre classique renvoyé fournit l'histogramme de sortie. Lorsque la correction MEM est appliquée avec succès aux données d' PUB d'Orbit, cet histogramme est déjà corrigé par MEM; les comptages non corrigés restent disponibles dans les métadonnées d'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,
    }
)

Output:

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

Comparez visuellement les schémas de circuit bruts et ceux optimisés 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:

Obtenir de l'aide

Contactez le service d'assistance de Quantum Elements : [email protected]

Veillez à inclure les informations suivantes :

• ID de tâche de la fonction Qiskit (qiskit-ibm-catalog), job.job_id
• Nom du back-end
• Orbit pub_options utilisé pour les modes « raw » et « Orbit »
• Une description détaillée du problème
• Tout message d'erreur ou code pertinent
• Etapes de reproduction du problème

Etapes suivantes

Références

1. Suppression des erreurs au niveau logique associée à la détection quantique d'erreurs, Nature Communications (2026)
2. Transformée de Fourier quantique à l'aide de circuits dynamiques, Physical Review Letters (2024)
3. « Intrication à longue portée efficace à l'aide de circuits dynamiques », PRX Quantum (2024)
4. Expériences de mise à l'échelle du code de surface sur un héron « IBM » avec une connectivité «heavy-hex», arXiv:2510.18847
5. Expériences de code de surface sur un « Nighthawk » d’ IBM, avec une connectivité en réseau carré, arXiv:2606.11496
6. Référence VQE, Nature Physics (2024)