Orbit - Qiskit Function od Quantum Elements

Viz referenční dokumentace API

Poznámka

Qiskit Functions jsou experimentální funkce dostupné pouze pro uživatele IBM Quantum® Premium Plan, Flex Plan a On-Prem (prostřednictvím IBM Quantum Platform API) Plan. Nacházejí se ve stavu předběžného vydání a mohou se změnit.

Přehled

Kvantový hardware se stále vyvíjí, ale šum a dekoherence stále omezují hloubku a spolehlivost praktických kvantových obvodů. Mezi dostupnými přístupy mohou tato omezení výrazně zmírnit tři vzájemně se doplňující techniky: dynamické oddělení (DD), optimalizovaná transpilace a zmírnění chyb měření (MEM). Optimalizovaná transpilace snižuje hloubku obvodu a lépe přizpůsobuje obvody konektivitě cílového hardwaru, DD potlačuje šum v době nečinnosti pomocí pečlivě navržených řídicích sekvencí a MEM snižuje účinky chyb čtení a lze ji aplikovat během postprocessingu.

Výběr účinné strategie DD je obzvláště netriviální, protože je k dispozici mnoho rodin sekvencí a sekvence, která funguje dobře pro jeden obvod nebo šumové prostředí, nemusí fungovat dobře pro jiný. Přínosy transpilace, DD a MEM závisí na problému, hardwaru a pracovní zátěži; použité jednotlivě nebo v kombinaci mohou zlepšit výkon, ale nejsou univerzálně přínosné v každé konfiguraci.

Orbit, Qiskit Function vyvinutá společností Quantum Elements, bezešvě kombinuje všechny tři komponenty do jednotného pracovního postupu, díky čemuž jsou snadno použitelné pro zlepšení provádění obvodů na hardwaru IBM Quantum. Ve své primární formě Orbit automaticky aplikuje aktivní strategie potlačení chyb, které chrání kvantové stavy během period nečinnosti, přičemž zachovává původní logiku obvodu. Je pozoruhodné, že to dělá bez zavedení jakéhokoli dalšího kvantového nebo klasického předzpracování, čímž se vyhýbá zbytečným dodatečným nákladům nebo čekací době v rámci pracovního postupu.

Namísto fungování jako černá skříňka umožňuje Orbit uživatelům vyhodnocovat a doladit své optimalizační komponenty pro konkrétní experiment. Uživatelé mohou nezávisle povolit nebo zakázat optimalizovanou transpilaci, DD a MEM; porovnat automatický výběr DD s uživatelsky specifikovanými sekvencemi; a spustit více konfigurací v rámci stejného pracovního postupu. Porovnáním každé konfigurace se surovým obvodem mohou uživatelé určit, které techniky přinášejí měřitelné výhody pro jejich obvod a backend, identifikovat interakce mezi různými optimalizačními metodami a vybrat konfiguraci, která nejlépe podporuje jejich experimentální cíl. Tento proces vede uživatele k pochopení toho, odkud pocházejí zisky ve výkonu, a k informovanějším rozhodnutím při optimalizaci kvantových obvodů pro danou pracovní zátěž.

Popis

Orbit je navržen tak, aby vylepšil provádění kvantových obvodů na backendech IBM Quantum. V automatizovaném režimu mohou uživatelé bezešvě aplikovat robustní sekvence DD vyššího řádu bez nutnosti je ručně vybírat nebo konfigurovat. Pokročilí uživatelé mohou místo toho experimentovat s dostupnými sekvencemi vyššího řádu, aby identifikovali a optimalizovali přístup, který poskytuje nejlepší výkon pro konkrétní obvod.

Orbit také poskytuje okamžitou MEM bez potřeby dodatečných úloh, které jsou obvykle nutné pro oddělené pracovní postupy kalibrace a zmírnění. Pro pracovní zátěže, u kterých by transpilace neměla měnit strukturu obvodu, jako jsou obvody pro korekci kvantových chyb s měřeními uprostřed obvodu nebo dynamické obvody, může Orbit aplikovat DD a MEM bez zasahování do existující transpilační strategie uživatele. Pro uživatele, kteří ještě nemají preferovaný přístup, Orbit také obsahuje vestavěný transpiler pro optimalizaci obvodů pro cílový hardware před aplikací technik potlačení chyb a zmírnění čtení.

Na rozdíl od přístupů, které se spoléhají na dodatečné vzorkování obvodů, extrapolaci nebo rozsáhlé klasické postprocessing, se Orbit zaměřuje na potlačení chyb během provádění. Funkce je navržena tak, aby vnesla nízkou režii při zachování původní logiky obvodu. Uživatelé mohou zkontrolovat výsledný obvod a přímo porovnat provádění optimalizovaná pomocí Orbitu se standardním prováděním.

Praktický pracovní postup Orbitu je:

1. Definuj kvantový obvod a vyber Orbit prostřednictvím katalogu Qiskit Functions.

2. Zahrň obvod bez Orbitu pomocí režimu 'Raw', abys stanovil základní hodnotu surového obvodu.

3. Vyber, které optimalizační strategie se mají použít, včetně automatizovaných nebo uživatelem zvolených sekvencí DD, MEM a optimalizované transpilace.

4. Povol nebo zakaž jednotlivé metody, nebo předlož více konfigurací, abys vyhodnotil jejich samostatné a kombinované účinky.

Orbit je obzvláště užitečný pro obvody obsahující období nečinnosti nebo mezery v plánování, kdy se qubity aktivně nepodílejí na hradlech. Podporuje statické i dynamické obvody, včetně pracovních postupů s měřeními uprostřed obvodu a experimentů s odolným kvantovým výpočtem vůči chybám. Typické aplikace zahrnují korekci kvantových chyb, experimenty s povrchovým kódem na čtvercových a heavy-hex mřížkách, orákulové algoritmy jako Bernstein-Vazirani, obvody Fourierovy transformace, variační kvantové algoritmy, simulaci hamiltoniánu, benchmarkové experimenty a optimalizaci obvodů s ohledem na hardware.

S výhledem na éru odolnosti vůči chybám je Orbit také kompatibilní s pracovními postupy odolného kvantového výpočtu, protože jej lze bezešvě kombinovat s korekcí kvantových chyb. Z dlouhodobého hlediska ukazuje Orbit směrem k dynamickému oddělení na logické úrovni [1] jako perspektivní cestě pro ochranu logických qubitů. V níže uvedeném příkladu byly dva logické qubity provázány, aby vytvořily logický Bellův stav pod detekcí kvantových chyb. Samotná detekce kvantových chyb vedla k poklesu věrnosti Bellova stavu na přibližně 44 % během desítek mikrosekund, zatímco QED v kombinaci s ochranou ve stylu Orbitu udržela logickou věrnost Bellova stavu blízko horní hranice škály, přičemž dosáhla přibližně 95,3 % ve stejném časovém okně.

Benchmarky

Následující výsledky shrnují reprezentativní běhy Orbitu na hardwaru IBM Quantum. Stejně jako u jiných hardwarových benchmarků závisí výsledky na vybraném zařízení, stavu kalibrace, obvodu a nastavení provádění.

Example	Metric	Qubits	QPU	Additional details	Orbit Improvement
Bernstein–Vazirani	Hidden-bitstring fidelity	26 60 70	Heron r3	Raw versus Full Orbit, Transpilation only versus Full Orbit, Full Orbit Only	75x 66x N/A
QFT (unitary)	Fidelity	10	Heron r2 Heron r3	Orbit versus raw: ~44% versus ~35% ~67% versus ~61%	1.26x 1.09x
QFT (dynamic circuits)	Fidelity	10 20	Heron r3	Orbit versus raw: ~55% versus ~2% ~10% versus ~0%	27.51x N/A
Long-range Bell state (dynamic circuits)	Fidelity	30 60	Heron r2	N/A	1.78x 1.11x
Surface code (square lattice)	Logical error probability	25	Nighthawk r1	1 round 5 rounds 10 rounds	1.01x 1.15x 1.12x
Surface code (heavy-hex)	Logical error probability	65	Heron r3	1 round 5 rounds 10 rounds	4.11x 2.04x 1.39x
VQE	Absolute error relative to the ideal energy	8	Heron r3	Orbit versus raw: 56mHa versus 1342 mHa	24x
QAOA	Success probability	5	Heron r2	N/A	1.46x
[[4,2,2]] code (logical-level error suppression)	Entangled Bell-state logical fidelity	4	Heron r2	Average fidelity over 55 μs	1.63x

Definice metrik

• Věrnost skrytého bitového řetězce Bernstein–Vazirani: Pravděpodobnost naměření správného skrytého bitového řetězce. Tato metrika ukazuje, jak spolehlivě algoritmus obnovuje zamýšlené řešení se zvětšující se velikostí obvodu. Tabulka uvádí tři největší skryté bitové řetězce úspěšně vyhodnocené za tří různých konfigurací: (i) surové obvody bez Orbitu, které dosáhly 26 qubitů; (ii) obvody pouze s transpilací, které dosáhly 60 qubitů; a (iii) obvody používající úplný pracovní postup Orbit, které dosáhly 70 qubitů. U surových obvodů (i) představuje faktor zlepšení nárůst výkonu dosažený pomocí DD a MEM oproti nezměněným obvodům. U konfigurace pouze s transpilací (ii) představuje zlepšení dosažené přidáním DD a MEM k optimálně transpilovaným obvodům. U úplné konfigurace Orbit (iii) není uveden žádný základní faktor zlepšení, protože nenulová pravděpodobnost úspěchu byla dosažena pouze tehdy, když byly povoleny všechny komponenty Orbitu (transpilace, DD a MEM). Ilustrativní příklad je uveden níže.

• Věrnost kvantové Fourierovy transformace: Pro unitární i dynamické implementace QFT [2] měří věrnost shodu mezi experimentálně provedenou transformací a ideálním procesem QFT přes 20 různých vstupních stavů. Dynamické obvody obsahují podstatnou dobu nečinnosti kvůli měřením uprostřed obvodu a klasické zpětné vazbě, během níž může dynamické oddělení potlačit dekoherenci. Uvedené zlepšení porovnává věrnost dosaženou s Orbitem se surovou věrností.

• Příprava dlouhodosahového Bellova stavu: Vytvoření Bellova stavu pomocí dynamických obvodů a operací zpětné vazby mezi dvěma qubity oddělenými až 60 mezilehlými qubity, čímž se demonstruje efektivní dlouhodosahová provázanost na lokálně propojeném kvantovém hardwaru [3]. Orbit identifikuje nejlepší směrování qubitů, zachovává qubity během měření zpětné vazby a aplikuje MEM ke zmírnění chyb čtení.

• Pravděpodobnost logické chyby povrchového kódu: Pro heavy-hex povrchový kód [4] a povrchový kód se čtvercovou mřížkou [5] byly provedeny experimenty s kvantovou pamětí, ve kterých byl kódovaný logický stav zachován během opakovaných kol korekce chyb. Pravděpodobnost logické chyby měří pravděpodobnost, že nashromážděné chyby způsobí nesprávné obnovení kódované informace (nižší chyba je lepší). Uvedené zlepšení porovnává pravděpodobnost logické chyby ze surových obvodů s pravděpodobností dosaženou s Orbitem.

• Absolutní chyba VQE: Použití VQE s optimalizovaným unitárním coupled-cluster ansatzem k odhadu energie základního stavu LiH [6]. Naměřená energie je porovnána s odpovídající ideální energií získanou z bezešumového obvodu. Metrikou je absolutní rozdíl mezi naměřenou a ideální energií (nižší hodnoty jsou lepší). Uvedené zlepšení je:

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

Hodnoty větší než jedna znamenají, že Orbit snižuje chybu energie ve srovnání s prováděním bez dynamického oddělení.

• Pravděpodobnost úspěchu QAOA: Pravděpodobnost naměření bitového řetězce odpovídajícího optimálnímu řešení optimalizačního problému definovaného na motýlkovém grafu. Uvedené zlepšení porovnává pravděpodobnost úspěchu dosaženou s Orbitem s pravděpodobností dosaženou ze surových obvodů.

• Logická věrnost: V experimentu logického dynamického oddělení [[4,2,2]] [1] byly dva logické qubity zakódovány do čtyř fyzických qubitů a připraveny jako provázaný logický Bellův stav. Logická věrnost měří shodu mezi obnoveným kódovaným stavem a cílovým logickým Bellovým stavem. Uvedené zlepšení porovnává průměrnou logickou věrnost dosaženou s Orbitem a detekcí chyb (schopnost kódu) s věrností dosaženou při použití pouze samotného kódu.

Začínáme

Ověř se pomocí svého API klíče IBM Quantum Platform a vyber funkci Orbit následujícím způsobem. Tento úryvek předpokládá, že jsi již uložil svůj účet do svého lokálního prostředí.

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

Příklad

Následující příklad sestaví obvod Bernstein-Vazirani a odešle jej do Orbitu dvěma způsoby v jedné úloze: surové provedení a výchozí nastavení Orbitu.

Tento vzor použij, pokud chceš přímé porovnání surového provedení a Orbitu.

Sestavení obvodu Bernstein-Vazirani

Vyber skrytý bitový řetězec a sestav logický obvod. Extra qubit je cíl orákula, zatímco vstupní qubity jsou měřeny.

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

Příprava pracovní zátěže Orbitu

Vytvoř jeden Sampler PUB a poté ho duplikuj pro dva srovnávací režimy. Orbit obdrží logický obvod a namapuje ho na vybraný backend během provádění.

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

Spuštění surového obvodu a výchozích nastavení Orbitu

pub_options přiřadí první PUB surovému režimu, který přeskočí optimalizaci Orbitu, DD a MEM, a přiřadí druhý PUB výchozím nastavením Orbitu, která zahrnují optimalizovanou transpilaci, automatizované vkládání dynamického oddělení (DD) a zmírnění chyb měření (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

Získej výsledek a porovnej surový obvod s obvodem vylepšeným Orbitem pomocí počtů. U výsledků Sampleru poskytuje get_counts() na vráceném klasickém registru výstupní histogram. Když se MEM u PUBu Orbitu podaří, tento histogram je již opravený pomocí MEM; nezmírněné počty zůstávají dostupné v metadatech Orbitu pod 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}

Proveď vizuální porovnání surového obvodu a obvodu vylepšeného Orbitem.

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

Získání podpory

Kontaktuj podporu Quantum Elements: info@quantumelements.ai

Nezapomeň uvést následující informace:

• ID úlohy Qiskit Function (qiskit-ibm-catalog), job.job_id

• Název backendu

• pub_options Orbitu použité pro surový režim a režim Orbit

• Podrobný popis problému

• Jakékoli relevantní chybové zprávy nebo kódy

• Kroky k reprodukci problému

Další kroky

Doporučení

• Vyzkoušej jiný backend, počet qubitů nebo jiný skrytý bitový řetězec.

• Přečti si náš tutoriál o kvantové Fourierově transformaci, abys se naučil, jak definovat vlastní strategie DD s podporou Orbitu, a jak aplikovat DD na dynamické obvody s měřeními uprostřed obvodu a operacemi zpětné vazby.

• Navštiv referenční dokumentaci API pro podrobný popis všech možností Orbitu.

Odkazy

1. Potlačení chyb na logické úrovni v kombinaci s detekcí kvantových chyb, Nature Communications (2026)

2. Kvantová Fourierova transformace pomocí dynamických obvodů, Physical Review Letters (2024)

3. Efektivní dlouhodosahová provázanost pomocí dynamických obvodů, PRX Quantum (2024)

4. Experimenty se škálováním povrchového kódu na IBM Heron s heavy-hex konektivitou, arXiv:2510.18847

5. Experimenty s povrchovým kódem na IBM Nighthawk se čtvercovou mřížkovou konektivitou, arXiv:2606.11496

6. Referenční benchmark VQE, Nature Physics (2024)