Orbit - una Qiskit Function de Quantum Elements

Nota

Las Qiskit Functions son una función experimental disponible solo para usuarios de los planes IBM Quantum® Premium Plan, Flex Plan y On-Prem (a través de la API de IBM Quantum Platform). Se encuentran en estado de lanzamiento preliminar (preview) y están sujetas a cambios.

Descripción general

El hardware cuántico sigue avanzando, pero el ruido y la decoherencia todavía limitan la profundidad y la fiabilidad de los circuitos cuánticos prácticos. Entre los enfoques disponibles, tres técnicas complementarias pueden mitigar sustancialmente estas limitaciones: el desacoplamiento dinámico (DD), la transpilación optimizada y la mitigación de errores de medición (MEM). La transpilación optimizada reduce la profundidad del circuito y alinea mejor los circuitos con la conectividad del hardware objetivo, DD suprime el ruido en tiempo de inactividad mediante secuencias de control cuidadosamente diseñadas, y MEM reduce los efectos de los errores de lectura y puede aplicarse durante el post-procesamiento.

Seleccionar una estrategia de DD eficaz es especialmente complejo porque hay disponibles numerosas familias de secuencias, y una secuencia que funciona bien para un circuito o entorno de ruido puede no funcionar bien para otro. Los beneficios de la transpilación, DD y MEM dependen del problema, el hardware y la carga de trabajo; usados individualmente o en combinación, pueden mejorar el rendimiento, pero no son universalmente beneficiosos en todas las configuraciones.

Orbit, una Qiskit Function desarrollada por Quantum Elements, combina sin problemas los tres componentes en un flujo de trabajo unificado, haciendo que sean fáciles de usar para mejorar la ejecución de circuitos en hardware de IBM Quantum. En su forma principal, Orbit aplica automáticamente estrategias activas de supresión de errores que protegen los estados cuánticos durante los períodos de inactividad, preservando al mismo tiempo la lógica original del circuito. Cabe destacar que lo hace sin introducir ningún tiempo adicional de pre-procesamiento cuántico o clásico, evitando así costes o tiempos de espera adicionales innecesarios dentro del flujo de trabajo.

En lugar de funcionar como una caja negra, Orbit permite a los usuarios evaluar y ajustar sus componentes de optimización para un experimento específico. Los usuarios pueden habilitar o deshabilitar de forma independiente la transpilación optimizada, DD y MEM; comparar la selección automatizada de DD con secuencias especificadas por el usuario; y ejecutar múltiples configuraciones dentro del mismo flujo de trabajo. Al comparar cada configuración con el circuito sin procesar, los usuarios pueden determinar qué técnicas proporcionan beneficios medibles para su circuito y backend, identificar interacciones entre los diferentes métodos de optimización, y seleccionar la configuración que mejor respalde su objetivo experimental. Este proceso guía a los usuarios a comprender de dónde provienen las mejoras de rendimiento y a tomar decisiones más informadas al optimizar circuitos cuánticos para una carga de trabajo determinada.

Descripción

Orbit está diseñado para mejorar la ejecución de circuitos cuánticos en backends de IBM Quantum. En modo automatizado, los usuarios pueden aplicar sin problemas secuencias de DD robustas de alto orden sin necesidad de seleccionarlas o configurarlas manualmente. Los usuarios avanzados pueden, en cambio, experimentar con las secuencias de orden superior disponibles para identificar y optimizar el enfoque que ofrece el mejor rendimiento para un circuito específico.

Orbit también proporciona MEM instantáneo sin requerir los trabajos adicionales que normalmente se necesitan para flujos de trabajo separados de calibración y mitigación. Para cargas de trabajo en las que la transpilación no debería alterar la estructura del circuito, como circuitos de corrección de errores cuánticos con mediciones en medio del circuito o circuitos dinámicos, Orbit puede aplicar DD y MEM sin interferir con la estrategia de transpilación existente del usuario. Para los usuarios que aún no tienen un enfoque preferido, Orbit también incluye un transpilador integrado para optimizar circuitos para el hardware objetivo antes de aplicar técnicas de supresión de errores y mitigación de lectura.

A diferencia de los enfoques que dependen de un muestreo de circuitos adicional, extrapolación o un extenso post-procesamiento clásico, Orbit se centra en suprimir errores durante la ejecución. La función está diseñada para introducir una sobrecarga baja mientras preserva la lógica original del circuito. Los usuarios pueden inspeccionar el circuito resultante y comparar directamente las ejecuciones optimizadas con Orbit con las ejecuciones estándar.

Un flujo de trabajo práctico de Orbit es:

Define un circuito cuántico y selecciona Orbit a través del Catálogo de Qiskit Functions.
Incluye el circuito sin Orbit usando el modo 'Raw' para establecer una línea base del circuito sin procesar.
Elige qué estrategias de optimización aplicar, incluidas las secuencias de DD automatizadas o seleccionadas por el usuario, MEM y transpilación optimizada.
Habilita o deshabilita métodos individuales, o envía múltiples configuraciones, para evaluar sus efectos separados y combinados.

Orbit es particularmente útil para circuitos que contienen períodos de inactividad o huecos de programación en los que los qubits no participan activamente en las compuertas. Admite circuitos estáticos y dinámicos, incluidos flujos de trabajo con mediciones en medio del circuito y experimentos de computación cuántica tolerante a fallos. Las aplicaciones típicas incluyen corrección de errores cuánticos, experimentos de código de superficie en redes cuadradas y de hexágonos pesados, algoritmos oraculares como Bernstein-Vazirani, circuitos de transformada de Fourier, algoritmos cuánticos variacionales, simulación hamiltoniana, experimentos de benchmarking y optimización de circuitos consciente del hardware.

Mirando hacia la era de la tolerancia a fallos, Orbit también es compatible con flujos de trabajo de computación cuántica tolerante a fallos, ya que puede combinarse sin problemas con la corrección de errores cuánticos. A largo plazo, Orbit apunta hacia el desacoplamiento dinámico a nivel lógico [1] como un camino orientado al futuro para proteger qubits lógicos. En el ejemplo siguiente, dos qubits lógicos se entrelazaron para crear un estado de Bell lógico bajo detección de errores cuánticos. La detección de errores cuánticos por sí sola hizo que la fidelidad del estado de Bell decayera a aproximadamente 44% durante decenas de microsegundos, mientras que QED combinado con la protección de estilo Orbit mantuvo la fidelidad del estado de Bell lógico cerca de la parte superior de la escala, alcanzando aproximadamente 95.3% en la misma ventana de tiempo. Orbit Quantum Circuit Development Platform

Benchmarks

Los siguientes resultados resumen ejecuciones representativas de Orbit en hardware de IBM Quantum. Como ocurre con otros benchmarks de hardware, los resultados dependen del dispositivo seleccionado, el estado de calibración, el circuito y la configuración de ejecución.

Ejemplo	Métrica	Qubits	QPU	Detalles adicionales	Mejora de Orbit
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

Definiciones de métricas

Fidelidad del bitstring oculto de Bernstein–Vazirani: Probabilidad de medir el bitstring oculto correcto. Esta métrica indica cuán fiablemente el algoritmo recupera la solución prevista a medida que aumenta el tamaño del circuito. La tabla informa los tres bitstrings ocultos más grandes evaluados con éxito bajo tres configuraciones diferentes: (i), circuitos sin procesar sin Orbit, que alcanzaron 26 qubits; (ii), circuitos solo con transpilación, que alcanzaron 60 qubits; y (iii), circuitos que usan el flujo de trabajo completo de Orbit, que alcanzaron 70 qubits. Para los circuitos sin procesar (i), el factor de mejora representa la ganancia de rendimiento lograda por DD y MEM en relación con los circuitos sin modificar. Para la configuración solo con transpilación (ii), representa la mejora lograda al añadir DD y MEM a los circuitos transpilados de forma óptima. Para la configuración completa de Orbit (iii), no se informa ningún factor de mejora de referencia porque solo se obtuvo una probabilidad de éxito distinta de cero cuando se habilitaron todos los componentes de Orbit (transpilación, DD y MEM). A continuación se proporciona un ejemplo ilustrativo.
Fidelidad de la transformada cuántica de Fourier: Tanto para las implementaciones de QFT unitaria como de circuito dinámico [2], la fidelidad mide la concordancia entre la transformación implementada experimentalmente y el proceso de QFT ideal en 20 estados de entrada diferentes. Los circuitos dinámicos contienen un tiempo de inactividad sustancial debido a las mediciones en medio del circuito y la retroalimentación clásica, durante el cual el desacoplamiento dinámico puede suprimir la decoherencia. La mejora reportada compara la fidelidad obtenida con Orbit con la fidelidad sin procesar.
Preparación de estado de Bell de largo alcance: Creación de un estado de Bell usando circuitos dinámicos y operaciones de retroalimentación entre dos qubits separados por hasta 60 qubits intermedios, demostrando así un entrelazamiento eficiente de largo alcance en hardware cuántico conectado localmente [3]. Orbit identifica el mejor enrutamiento de qubits, preserva los qubits durante las mediciones de retroalimentación, y aplica MEM para mitigar los errores de lectura.
Probabilidad de error lógico del código de superficie: Para el código de superficie de hexágono pesado [4] y el código de superficie de red cuadrada [5], se realizaron experimentos de memoria cuántica en los que se preservó un estado lógico codificado a lo largo de rondas repetidas de corrección de errores. La probabilidad de error lógico mide la probabilidad de que los errores acumulados causen que la información codificada se recupere incorrectamente (un error menor es mejor). La mejora reportada compara la probabilidad de error lógico de los circuitos sin procesar con la obtenida con Orbit.
Error absoluto de VQE: Uso de VQE con un ansatz de cúmulo acoplado unitario optimizado para estimar la energía del estado fundamental de LiH [6]. La energía medida se compara con la energía ideal correspondiente obtenida del circuito sin ruido. La métrica es la diferencia absoluta entre las energías medida e ideal (valores más bajos son mejores). La mejora reportada es:

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

Los valores mayores que uno indican que Orbit reduce el error de energía en relación con la ejecución sin desacoplamiento dinámico.

Probabilidad de éxito de QAOA: Probabilidad de medir un bitstring correspondiente a una solución óptima del problema de optimización definido en el grafo mariposa. La mejora reportada compara la probabilidad de éxito obtenida con Orbit con la obtenida a partir de los circuitos sin procesar.
Fidelidad lógica: En el experimento de desacoplamiento dinámico a nivel lógico [[4,2,2]] [1], dos qubits lógicos se codificaron en cuatro qubits físicos y se prepararon como un estado de Bell lógico entrelazado. La fidelidad lógica mide la concordancia entre el estado codificado recuperado y el estado de Bell lógico objetivo. La mejora reportada compara la fidelidad lógica promedio obtenida con Orbit y detección de errores (capacidad del código) con la obtenida cuando solo se usa el código por sí solo.

Primeros pasos

Autentícate usando tu clave API de IBM Quantum Platform, y selecciona la función Orbit como se indica a continuación. Este fragmento asume que ya has guardado tu cuenta en tu entorno 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")

Ejemplo

El siguiente ejemplo construye un circuito de Bernstein-Vazirani y lo envía a Orbit de dos formas en un solo job: ejecución sin procesar y valores predeterminados de Orbit.

Usa este patrón cuando quieras una comparación directa entre sin procesar y Orbit.

Construir un circuito de Bernstein-Vazirani

Elige el bitstring oculto y construye el circuito lógico. El qubit adicional es el objetivo del oráculo, mientras que los qubits de entrada se miden.

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

Preparar la carga de trabajo de Orbit

Crea un Sampler PUB, luego duplícalo para los dos modos de comparación. Orbit recibe el circuito lógico y lo asigna al backend seleccionado durante la ejecución.

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

Ejecutar sin procesar y valores predeterminados de Orbit

pub_options asigna el primer PUB al modo sin procesar, que omite la optimización de Orbit, DD y MEM, y asigna el segundo PUB a los valores predeterminados de Orbit, que incluyen transpilación optimizada, inserción automatizada de desacoplamiento dinámico (DD) y mitigación de errores de medición (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

Recupera el resultado y compara los circuitos sin procesar y mejorados con Orbit usando counts. Para los resultados del Sampler, get_counts() en el registro clásico devuelto proporciona el histograma de salida. Cuando MEM tiene éxito para el PUB de Orbit, este histograma ya está corregido con MEM; los counts sin mitigar siguen disponibles en los metadatos de Orbit bajo 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}

Haz una comparación visual de los circuitos sin procesar y mejorados con 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

Obtener soporte

Ponte en contacto con el soporte de Quantum Elements: info@quantumelements.ai

Asegúrate de incluir la siguiente información:

ID del Job de la Qiskit Function (qiskit-ibm-catalog), job.job_id
Nombre del backend
pub_options de Orbit usadas para los modos sin procesar y Orbit
Una descripción detallada del problema
Cualquier mensaje o código de error relevante
Pasos para reproducir el problema

Próximos pasos

Recomendaciones

Prueba con un backend diferente, un número de qubit distinto, u otro bitstring oculto.
Lee nuestro tutorial sobre la transformada cuántica de Fourier para aprender a definir estrategias de DD personalizadas habilitadas por Orbit, así como a aplicar DD a circuitos dinámicos con mediciones en medio del circuito y operaciones de retroalimentación.
Visita la referencia de la API para obtener una descripción detallada de todas las opciones de Orbit.

Descripción general​

Descripción​

Benchmarks​

Definiciones de métricas​

Primeros pasos​

Ejemplo​

Construir un circuito de Bernstein-Vazirani​

Preparar la carga de trabajo de Orbit​

Ejecutar sin procesar y valores predeterminados de Orbit​

Obtener soporte​

Próximos pasos​

Referencias​