Orbit - uma Qiskit Function da Quantum Elements

Nota

As Qiskit Functions são um recurso experimental disponível apenas para usuários dos planos IBM Quantum® Premium Plan, Flex Plan e On-Prem (via IBM Quantum Platform API). Elas estão em status de lançamento prévio (preview) e sujeitas a alterações.

Visão geral

O hardware quântico continua avançando, mas o ruído e a decoerência ainda restringem a profundidade e a confiabilidade dos circuitos quânticos práticos. Entre as abordagens disponíveis, três técnicas complementares podem mitigar substancialmente essas limitações: desacoplamento dinâmico (DD), transpilação otimizada e mitigação de erros de medição (MEM). A transpilação otimizada reduz a profundidade do circuito e alinha melhor os circuitos com a conectividade do hardware de destino, o DD suprime o ruído de tempo ocioso por meio de sequências de controle cuidadosamente projetadas, e o MEM reduz os efeitos dos erros de leitura e pode ser aplicado durante o pós-processamento.

Selecionar uma estratégia de DD eficaz é particularmente não trivial porque numerosas famílias de sequências estão disponíveis, e uma sequência que tem bom desempenho para um circuito ou ambiente de ruído pode não ter bom desempenho para outro. Os benefícios da transpilação, do DD e do MEM dependem do problema, do hardware e da carga de trabalho; usados individualmente ou em combinação, eles podem melhorar o desempenho, mas não são universalmente benéficos em todas as configurações.

Orbit, uma Qiskit Function desenvolvida pela Quantum Elements, combina perfeitamente os três componentes em um fluxo de trabalho unificado, tornando-os fáceis de usar para melhorar a execução de circuitos no hardware do IBM Quantum. Em sua forma primária, o Orbit aplica automaticamente estratégias ativas de supressão de erros que protegem os estados quânticos durante períodos ociosos, preservando a lógica original do circuito. Notavelmente, ele faz isso sem introduzir qualquer tempo adicional de pré-processamento quântico ou clássico, evitando assim custos adicionais desnecessários ou tempo de espera dentro do fluxo de trabalho.

Em vez de operar como uma caixa preta, o Orbit permite que os usuários avaliem e ajustem finamente seus componentes de otimização para um experimento específico. Os usuários podem habilitar ou desabilitar independentemente a transpilação otimizada, o DD e o MEM; comparar a seleção automatizada de DD com sequências especificadas pelo usuário; e executar múltiplas configurações dentro do mesmo fluxo de trabalho. Ao comparar cada configuração com o circuito bruto, os usuários podem determinar quais técnicas fornecem benefícios mensuráveis para seu circuito e backend, identificar interações entre os diferentes métodos de otimização e selecionar a configuração que melhor suporta seu objetivo experimental. Esse processo orienta os usuários a entender de onde vêm os ganhos de desempenho e a tomar decisões mais informadas ao otimizar circuitos quânticos para uma determinada carga de trabalho.

Descrição

O Orbit foi projetado para aprimorar a execução de circuitos quânticos em backends do IBM Quantum. No modo automatizado, os usuários podem aplicar perfeitamente sequências de DD robustas e de alta ordem sem precisar selecioná-las ou configurá-las manualmente. Usuários avançados podem, em vez disso, experimentar as sequências de alta ordem disponíveis para identificar e otimizar a abordagem que oferece o melhor desempenho para um circuito específico.

O Orbit também fornece MEM instantâneo sem exigir os jobs adicionais tipicamente necessários para fluxos de trabalho separados de calibração e mitigação. Para cargas de trabalho nas quais a transpilação não deve alterar a estrutura do circuito, como circuitos de correção de erros quânticos com medições mid-circuit ou circuitos dinâmicos, o Orbit pode aplicar DD e MEM sem interferir na estratégia de transpilação existente do usuário. Para usuários que ainda não têm uma abordagem preferida, o Orbit também inclui um transpiler integrado para otimizar circuitos para o hardware de destino antes de aplicar técnicas de supressão de erros e mitigação de leitura.

Ao contrário de abordagens que dependem de amostragem adicional de circuitos, extrapolação ou pós-processamento clássico extensivo, o Orbit se concentra em suprimir erros durante a execução. A function foi projetada para introduzir baixo overhead, preservando a lógica original do circuito. Os usuários podem inspecionar o circuito resultante e comparar diretamente execuções otimizadas pelo Orbit com execuções padrão.

Um fluxo de trabalho prático do Orbit é:

Defina um circuito quântico e selecione o Orbit através do Qiskit Functions Catalog.
Inclua o circuito sem o Orbit usando o modo 'Raw' para estabelecer uma linha de base de circuito bruto.
Escolha quais estratégias de otimização aplicar, incluindo sequências de DD automatizadas ou selecionadas pelo usuário, MEM e transpilação otimizada.
Ative ou desative métodos individuais, ou envie múltiplas configurações, para avaliar seus efeitos separados e combinados.

O Orbit é particularmente útil para circuitos que contêm períodos ociosos ou lacunas de agendamento onde os qubits não estão participando ativamente de portas. Ele oferece suporte a circuitos estáticos e dinâmicos, incluindo fluxos de trabalho com medições no meio do circuito e experimentos de computação quântica tolerante a falhas. Aplicações típicas incluem correção de erros quânticos, experimentos de código de superfície em redes quadradas e heavy-hex, algoritmos oraculares como Bernstein-Vazirani, circuitos de transformada de Fourier, algoritmos quânticos variacionais, simulação hamiltoniana, experimentos de benchmarking e otimização de circuitos com reconhecimento de hardware.

Olhando para a era da tolerância a falhas, o Orbit também é compatível com fluxos de trabalho de computação quântica tolerante a falhas, pois pode ser combinado perfeitamente com correção de erros quânticos. No longo prazo, o Orbit aponta para o desacoplamento dinâmico em nível lógico [1] como um caminho voltado para o futuro para proteger qubits lógicos. No exemplo abaixo, dois qubits lógicos foram emaranhados para criar um estado de Bell lógico sob detecção de erros quânticos. A detecção de erros quânticos sozinha fez com que a fidelidade do estado de Bell decaísse para aproximadamente 44% ao longo de dezenas de microssegundos, enquanto a QED combinada com a proteção no estilo Orbit manteve a fidelidade do estado de Bell lógico próxima ao topo da escala, alcançando aproximadamente 95,3% na mesma janela de tempo. Orbit Quantum Circuit Development Platform

Benchmarks

Os resultados a seguir resumem execuções representativas do Orbit em hardware da IBM Quantum. Como acontece com outros benchmarks de hardware, os resultados dependem do dispositivo selecionado, do estado de calibração, do circuito e das configurações de execução.

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

Definições de métricas

Fidelidade da string de bits oculta de Bernstein–Vazirani: Probabilidade de medir a string de bits oculta correta. Essa métrica indica quão confiavelmente o algoritmo recupera a solução pretendida à medida que o tamanho do circuito aumenta. A tabela relata as três maiores strings de bits ocultas avaliadas com sucesso sob três configurações diferentes: (i) circuitos raw sem Orbit, que alcançou 26 qubits; (ii) circuitos com apenas transpilação, que alcançou 60 qubits; e (iii) circuitos usando o fluxo de trabalho completo do Orbit, que alcançou 70 qubits. Para os circuitos raw (i), o fator de melhoria representa o ganho de desempenho alcançado pelo DD e MEM em relação aos circuitos não modificados. Para a configuração apenas com transpilação (ii), representa a melhoria alcançada ao adicionar DD e MEM aos circuitos transpilados de forma otimizada. Para a configuração completa do Orbit (iii), nenhum fator de melhoria de referência é relatado porque uma probabilidade de sucesso diferente de zero foi obtida apenas quando todos os componentes do Orbit (transpilação, DD e MEM) estavam habilitados. Um exemplo ilustrativo é fornecido abaixo.
Fidelidade da transformada de Fourier quântica: Para ambas as implementações da QFT unitária e de circuito dinâmico [2], a fidelidade mede a concordância entre a transformação implementada experimentalmente e o processo de QFT ideal em 20 estados de entrada diferentes. Circuitos dinâmicos contêm tempo ocioso substancial devido a medições no meio do circuito e feedforward clássico, durante o qual o desacoplamento dinâmico pode suprimir a decoerência. A melhoria relatada compara a fidelidade obtida com o Orbit com a fidelidade raw.
Preparação de estado de Bell de longo alcance: Criação de um estado de Bell usando circuitos dinâmicos e operações de feedforward entre dois qubits separados por até 60 qubits intermediários, demonstrando assim emaranhamento eficiente de longo alcance em hardware quântico conectado localmente [3]. O Orbit identifica o melhor roteamento de qubits, preserva os qubits durante as medições de feedforward e aplica MEM para mitigar erros de leitura.
Probabilidade de erro lógico do código de superfície: Para o código de superfície heavy-hex [4] e o código de superfície de rede quadrada [5], foram realizados experimentos de memória quântica nos quais um estado lógico codificado foi preservado ao longo de rodadas repetidas de correção de erros. A probabilidade de erro lógico mede a probabilidade de que erros acumulados façam com que a informação codificada seja recuperada incorretamente (menor erro é melhor). A melhoria relatada compara a probabilidade de erro lógico de circuitos raw com aquela obtida com o Orbit.
Erro absoluto do VQE: Usando VQE com um ansatz de cluster acoplado unitário otimizado para estimar a energia do estado fundamental do LiH [6]. A energia medida é comparada com a energia ideal correspondente obtida do circuito sem ruído. A métrica é a diferença absoluta entre as energias medida e ideal (valores menores são melhores). A melhoria relatada é:

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

Valores maiores que um indicam que o Orbit reduz o erro de energia em relação à execução sem desacoplamento dinâmico.

Probabilidade de sucesso do QAOA: Probabilidade de medir uma string de bits correspondente a uma solução ótima do problema de otimização definido no grafo borboleta. A melhoria relatada compara a probabilidade de sucesso obtida com o Orbit com aquela obtida dos circuitos raw.
Fidelidade lógica: No experimento de desacoplamento dinâmico em nível lógico [[4,2,2]] [1], dois qubits lógicos foram codificados em quatro qubits físicos e preparados como um estado de Bell lógico emaranhado. A fidelidade lógica mede a concordância entre o estado codificado recuperado e o estado de Bell lógico alvo. A melhoria relatada compara a fidelidade lógica média obtida com o Orbit e a detecção de erros (capacidade do código) com aquela obtida usando apenas o código.

Comece agora

Autentique-se usando sua chave de API do IBM Quantum Platform e selecione a função Orbit da seguinte forma. Este trecho assume que você já salvou sua conta no seu ambiente 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")

Exemplo

O exemplo a seguir cria um circuito Bernstein-Vazirani e o envia ao Orbit de duas formas em um único job: execução raw e padrões do Orbit.

Use esse padrão quando quiser uma comparação direta entre raw e Orbit.

Criar um circuito Bernstein-Vazirani

Escolha a string de bits oculta e construa o circuito lógico. O qubit extra é o alvo do oráculo, enquanto os qubits de entrada são medidos.

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 a carga de trabalho do Orbit

Crie um PUB do Sampler e depois duplique-o para os dois modos de comparação. O Orbit recebe o circuito lógico e o mapeia para o backend selecionado durante a execução.

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

Executar raw e padrões do Orbit

pub_options atribui o primeiro PUB ao modo raw, que ignora a otimização do Orbit, o DD e a MEM, e atribui o segundo PUB aos padrões do Orbit, que incluem transpilação otimizada, inserção automatizada de desacoplamento dinâmico (DD) e mitigação de erros de medição (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

Recupere o resultado e compare os circuitos raw e aprimorados pelo Orbit usando contagens. Para resultados do Sampler, get_counts() no registro clássico retornado fornece o histograma de saída. Quando a MEM é bem-sucedida para o PUB do Orbit, esse histograma já está corrigido pela MEM; as contagens não mitigadas permanecem disponíveis nos metadados do Orbit em 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}

Faça uma comparação visual dos circuitos raw e aprimorados pelo 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

Obter suporte

Entre em contato com o suporte da Quantum Elements: info@quantumelements.ai

Certifique-se de incluir as seguintes informações:

ID do job da Qiskit Function (qiskit-ibm-catalog), job.job_id
Nome do backend
pub_options do Orbit usados para os modos raw e Orbit
Uma descrição detalhada do problema
Quaisquer mensagens ou códigos de erro relevantes
Passos para reproduzir o problema

Próximos passos

Recomendações

Experimente um backend diferente, um número de qubits diferente ou outra string de bits oculta.
Leia nosso tutorial sobre a transformada de Fourier quântica para aprender a definir estratégias de DD personalizadas habilitadas pelo Orbit, bem como aplicar DD a circuitos dinâmicos com medições no meio do circuito e operações de feedforward.
Visite a referência da API para uma descrição detalhada de todas as opções do Orbit.

Visão geral​

Descrição​

Benchmarks​

Definições de métricas​

Comece agora​

Exemplo​

Criar um circuito Bernstein-Vazirani​

Preparar a carga de trabalho do Orbit​

Executar raw e padrões do Orbit​

Obter suporte​

Próximos passos​

Referências​