Gerenciamento de desempenho: uma função Qiskit da Q-CTRL Fire Opal

Consulte a referência da API

• Versões do pacote

  O código nesta página foi desenvolvido utilizando os seguintes requisitos. Recomendamos usar essas versões ou mais recentes.

  qiskit[all]~=2.3.1
  qiskit-ibm-runtime~=0.45.1
  

Visão geral

O Fire Opal Performance Management simplifica para qualquer pessoa a obtenção de resultados significativos de computadores quânticos em escala, sem a necessidade de ser especialista em hardware quântico. Ao executar circuitos com o Fire Opal Performance Management, as técnicas de supressão de erros orientadas por IA são aplicadas automaticamente, permitindo o dimensionamento de problemas maiores com mais portas e qubits. Essa abordagem reduz o número de disparos necessários para chegar à resposta correta, sem acréscimo de sobrecarga, o que resulta em uma economia significativa de tempo e custo de computação.

O Gerenciamento de desempenho suprime os erros e aumenta a probabilidade de obter a resposta correta em um hardware com ruído. Em outras palavras, ele aumenta a relação sinal-ruído. A imagem a seguir mostra como o aumento da precisão possibilitado pelo Gerenciamento de Desempenho pode reduzir a necessidade de disparos adicionais no caso de um algoritmo de Transformada de Fourier Quântica de 10 qubits. Com apenas 30 disparos, o Q-CTRL atinge o limite de confiança de 99%, enquanto o padrão (QiskitRuntime Sampler, optimization_level=3 e resilience_level=1, ibm_sherbrooke) requer 170.000 disparos. Ao obter a resposta certa mais rapidamente, você economiza um tempo de execução de computação significativo.

A função de gerenciamento de desempenho pode ser usada com qualquer algoritmo, e você pode utilizá-la facilmente no lugar das primitivas padrão do Qiskit Runtime. Nos bastidores, várias técnicas de supressão de erros atuam em conjunto para evitar que erros ocorram durante a execução. Todos os métodos de pipeline do Fire Opal vêm pré-configurados e são independentes de algoritmos, o que significa que você sempre obtém o melhor desempenho desde o início.

Para obter acesso ao Performance Management, entre em contato com a Q-CTRL.

Descrição

O Fire Opal Performance Management tem duas opções de execução que são semelhantes às primitivas do site Qiskit Runtime, de modo que você pode facilmente trocar o Q-CTRL Sampler e o Estimator. O fluxo de trabalho geral para usar a função Gerenciamento de desempenho é o seguinte:

1. Defina seu circuito (e operadores no caso do Estimador).
2. Execute o circuito.
3. Recuperar os resultados.

Para reduzir o ruído do hardware, o Fire Opal emprega uma série de técnicas de supressão de erros orientadas por IA, descritas na imagem a seguir. Com o Fire Opal, todo o pipeline é totalmente automatizado, sem necessidade de configuração.

O pipeline do Fire Opal elimina a necessidade de sobrecarga adicional, como o aumento do tempo de execução quântico ou qubits físicos extras. Observe que o tempo de processamento clássico continua sendo um fator (consulte a seção Benchmarks para obter estimativas, em que "Tempo total" reflete o processamento clássico e quântico). Em contraste com a atenuação de erros, que requer sobrecarga na forma de amostragem, a supressão de erros do Fire Opal funciona nos níveis de porta e de pulso para lidar com várias fontes de ruído e evitar a probabilidade de ocorrência de um erro. Ao evitar erros, a necessidade de um pós-processamento caro é eliminada.

A imagem a seguir mostra os métodos de supressão de erros automatizados pelo Fire Opal Performance Management.

A função oferece duas primitivas, Sampler e Estimator, e as entradas e saídas de ambas ampliam a especificação implementada para as primitivas Qiskit Runtime V2.

Referências

Os resultados de benchmarking algorítmico publicados demonstram uma melhoria significativa no desempenho de vários algoritmos, incluindo Bernstein-Vazirani, transformada quântica de Fourier, busca de Grover, algoritmo de otimização quântica aproximada e eigensolver quântico variacional. O restante desta seção fornece mais detalhes sobre os tipos de algoritmos que podem ser executados, bem como o desempenho e os tempos de execução esperados.

Os estudos independentes a seguir demonstram como o Gerenciamento de Desempenho da Q-CTRL permite a pesquisa algorítmica em escala recorde:

• Kernels quânticos parametrizados com eficiência energética para diagnóstico de falhas em serviços de rede - aprendizado de kernel quântico de até 50 qubits
• Estimativa de diferença de fase quântica baseada em tensor para demonstração em larga escala - estimativa de fase quântica de até 33 qubits
• Aprendizado hierárquico para ML quântico: nova técnica de treinamento para circuitos quânticos variacionais de larga escala - carregamento de dados quânticos de até 21 qubits

A tabela a seguir fornece um guia aproximado sobre a precisão e os tempos de execução de execuções anteriores de benchmarking em ibm_fez. O desempenho em outros dispositivos pode variar. O tempo de uso é baseado em uma suposição de 10.000 disparos por circuito. O "Número de qubits" indicado não é uma limitação rígida, mas representa limites aproximados em que você pode esperar uma precisão de solução extremamente consistente. Problemas de tamanhos maiores foram resolvidos com sucesso, e os testes além desses limites são incentivados.

Definição da precisão da medição de um valor de expectativa - a métrica $A$ é definida da seguinte forma:

em que $\epsilon^{ideal}$ = valor esperado ideal, $\epsilon^{meas}$ = valor esperado medido, $\epsilon^{ideal}_{max}$ = valor máximo ideal e $\epsilon^{ideal}_{min}$ = valor mínimo ideal. $A_{mean}$ é simplesmente a média do valor de $A$ em várias medições.

Essa métrica é usada porque é invariável a mudanças globais e escalonamento no intervalo de valores atingíveis. Em outras palavras, independentemente de você mudar o intervalo de possíveis valores de expectativa para cima ou para baixo ou aumentar o spread, o valor de $A$ deve permanecer consistente.

Introdução

O Fire Opal Performance Management utiliza o Qiskit v2.0.0, que é a versão recomendada. As versões compatíveis são Qiskit >=v2.0.0. Autentique-se usando sua chave de API IBM Quantum Platform e selecione a função Qiskit da seguinte forma. (Este trecho pressupõe que você já tenha salvo sua conta no seu ambiente local.)

from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

# verify that you have access to the function
catalog.list()

Output:

[QiskitFunction(qunova/hivqe-chemistry),
 QiskitFunction(global-data-quantum/quantum-portfolio-optimizer),
 QiskitFunction(algorithmiq/tem),
 QiskitFunction(qedma/qesem),
 QiskitFunction(multiverse/singularity),
 QiskitFunction(ibm/circuit-function),
 QiskitFunction(q-ctrl/optimization-solver),
 QiskitFunction(colibritd/quick-pde),
 QiskitFunction(q-ctrl/performance-management),
 QiskitFunction(kipu-quantum/iskay-quantum-optimizer)]

# Access Function
perf_mgmt = catalog.load("q-ctrl/performance-management")

Estimador primitivo

Exemplo de estimador

Use a primitiva Estimator do Fire Opal Performance Management para determinar o valor esperado de um único par circuito-observável.

Além dos pacotes qiskit-ibm-catalog e qiskit , você também usará o pacote numpy para executar este exemplo. Você pode instalar esse pacote descomentando a célula a seguir se estiver executando este exemplo em um notebook usando o kernel IPython.

# %pip install numpy

1. Criar o circuito

Como exemplo, gere um operador Hermitiano aleatório e um observável para inserir na função Performance Management.

import numpy as np
from qiskit.circuit.library import iqp
from qiskit.quantum_info import random_hermitian, SparsePauliOp

n_qubits = 50

# Generate a random circuit
mat = np.real(random_hermitian(n_qubits, seed=1234))
circuit = iqp(mat)
circuit.measure_all()

# Define observables as a string
observable = SparsePauliOp("Z" * n_qubits)

# Create PUB tuple
estimator_pubs = [(circuit, observable)]

2. Executar o circuito

Execute o circuito e, opcionalmente, defina o backend e o número de disparos.

# Run the circuit using Estimator
qctrl_estimator_job = perf_mgmt.run(
    primitive="estimator",
    pubs=estimator_pubs,
    backend_name=backend_name,
)

Você pode usar as conhecidas APIs do Qiskit Serverless para verificar o status da sua carga de trabalho do Qiskit Function:

qctrl_estimator_job.status()

Output:

'QUEUED'

3. Recuperar o resultado

# Retrieve the counts from the result list
result = qctrl_estimator_job.result()

Os resultados têm o mesmo formato que os resultados do Estimator:

import numpy

result_str = str(result)

with numpy.printoptions(threshold=200):
    print(
        f"The result of the submitted job had {len(result)} PUB "
        f"and has a value:\n {result[0]}\n"
    )

print("The associated PubResult of this job has the following DataBins:")
print(f"{result[0].data}\n")

print(f"And this DataBin has attributes: {result[0].data.keys()}")

print("The expectation values measured from this PUB are:")
print(f"{result[0].data.evs}")

Output:

The result of the submitted job had 1 PUB
The result of the submitted job had 1 PUB and has a value:
 PubResult(data=DataBin(evs=0.0195, stds=0.9998098569228051), metadata={'precision': None})

The associated PubResult of this job has the following DataBins:
DataBin(evs=0.0195, stds=0.9998098569228051)

And this DataBin has attributes: dict_keys(['evs', 'stds'])
The expectation values measured from this PUB are:
0.0195

Primitiva Sampler

Exemplo de amostrador

Use a primitiva Sampler do Fire Opal Performance Management para executar um circuito Bernstein-Vazirani. Esse algoritmo, usado para encontrar uma cadeia oculta a partir das saídas de uma função de caixa preta, é um algoritmo de benchmarking comum porque há uma única resposta correta.

1. Criar o circuito

Defina a resposta correta para o algoritmo, a cadeia de bits oculta e o circuito Bernstein-Vazirani. Você pode ajustar a largura do circuito simplesmente alterando o endereço circuit_width.

import qiskit

circuit_width = 35
hidden_bitstring = "1" * circuit_width

# Create circuit, reserving one qubit for BV oracle
bv_circuit = qiskit.QuantumCircuit(circuit_width + 1, circuit_width)
bv_circuit.x(circuit_width)
bv_circuit.h(range(circuit_width + 1))
for input_qubit, bit in enumerate(reversed(hidden_bitstring)):
    if bit == "1":
        bv_circuit.cx(input_qubit, circuit_width)
bv_circuit.barrier()
bv_circuit.h(range(circuit_width + 1))
bv_circuit.barrier()
for input_qubit in range(circuit_width):
    bv_circuit.measure(input_qubit, input_qubit)

# Create PUB tuple
sampler_pubs = [(bv_circuit,)]

2. Executar o circuito

Execute o circuito e, opcionalmente, defina o backend e o número de disparos.

# Run the circuit using Sampler
qctrl_sampler_job = perf_mgmt.run(
    primitive="sampler",
    pubs=sampler_pubs,
    backend_name=backend_name,
)

Verifique o status da sua carga de trabalho do Qiskit Function ou obtenha os resultados da seguinte maneira:

# Print the ID so you can use it later, if necessary
print(qctrl_sampler_job.job_id)

qctrl_sampler_job.status()

Output:

60fe2fa1-a860-43e4-8615-c6ac4180f93b

'QUEUED'

3. Recuperar o resultado

# Retrieve the job results
sampler_result = qctrl_sampler_job.result()

# Get results for the first (and only) PUB
pub_result = sampler_result[0]
counts = pub_result.data.c.get_counts()

print("Counts for the meas output register (limited to 30 results):")
for i, (bitstring, count) in enumerate(counts.items()):
    if i >= 50:
        print(f"  ... ({len(counts) - 30} more items)")
        break
    print(f"  {bitstring}: {count}")

Output:

Counts for the meas output register (limited to 30 results):
  11111111111111111111111111111111111: 1661
  11111111111111111111111111110111111: 60
  11111111111111111111111111111101111: 54
  11111111111111111111111111111110111: 54
  11111111111111011111111111111111111: 46
  11111111111111111110111111111111111: 44
  11111111111111111111111101111111111: 42
  11111111111111111111111110111111111: 42
  11111111111111110111111111111111111: 41
  11111111111111111111111111111111101: 39
  11111111111111111111101111111111111: 38
  11111111111111111111110111111111111: 38
  11111111111111111111111111101111111: 37
  11111111111111111111111111111111110: 36
  11111111111110111111111111111111111: 35
  11111111111111111111111111111011111: 32
  11111111111111101111111111111111111: 32
  01111111111111111111111111111111111: 27
  11111111111111111011111111111111111: 23
  11111111101111111111111111111111111: 22
  11111111111111111111111111111111011: 21
  11111111011111111111111111111111111: 20
  00000000000000011111111111111111111: 18
  11111111111111111111110101111111111: 18
  00000001111111111111111111111111111: 17
  11111111001111111111111111111111111: 16
  11101111111111111111111111111111111: 16
  11111111111101111111111111111111111: 16
  00000101111111111111111111111111111: 13
  11111111111111111111111011111111111: 13
  11111111111111111111111110101111111: 13
  11111111111111111101111111111111111: 12
  10111111111111111111111111111111111: 12
  11111111111111111111111110001111111: 12
  00000000000000000011111111111111111: 11
  11111111111111111111111111111110110: 10
  00000000000000000000000001111111111: 10
  11111111111011111111111111111111111: 9
  11111111111111101011111111111111111: 9
  00000000011111111111111111111111111: 8
  10101111111111111111111111111111111: 8
  00000000000000000000000001011111111: 8
  11111111111111111111111111111111001: 8
  00000111111111111111111111111111111: 7
  11111111111111111111111111111101110: 7
  11111111110111111111111111111111111: 7
  00000000000001011111111111111111111: 6
  00000000000000001111111111111111111: 6
  00000000000000000001011111111111111: 6
  11111111111111111111111111011111111: 6
  ... (1050 more items)

3. Plotar as principais cadeias de bits

Trace o bitstring com as contagens mais altas para ver se o bitstring oculto era o modo.

import matplotlib.pyplot as plt


def plot_top_bitstrings(counts_dict, hidden_bitstring=None):
    # Sort and take the top 100 bitstrings
    top_100 = sorted(counts_dict.items(), key=lambda x: x[1], reverse=True)[
        :100
    ]
    if not top_100:
        print("No bitstrings found in the input dictionary.")
        return

    # Unzip the bitstrings and their counts
    bitstrings, counts = zip(*top_100)

    # Assign colors: purple if the bitstring matches hidden_bitstring,
    # otherwise gray
    colors = [
        "#680CE9" if bit == hidden_bitstring else "gray" for bit in bitstrings
    ]

    # Create the bar plot
    plt.figure(figsize=(15, 8))
    plt.bar(
        range(len(bitstrings)), counts, tick_label=bitstrings, color=colors
    )

    # Rotate the bitstrings for better readability
    plt.xticks(rotation=90, fontsize=8)
    plt.xlabel("Bitstrings")
    plt.ylabel("Counts")
    plt.title("Top 100 Bitstrings by Counts")

    # Show the plot
    plt.tight_layout()
    plt.show()

A bitstring oculta é destacada em roxo e deve ser a bitstring com o maior número de contagens.

plot_top_bitstrings(counts, hidden_bitstring)

Output:

Log de mudanças

• 2026-02-20: Aviso de descontinuação - o campo provider_job_ids de metadados será descontinuado em 30 dias na versão 0.13.0. Os usuários podem acessar o ID da tarefa por meio job_id() do método do serviço de tempo de execução.
• 11/02/2026: Agora oferecemos suporte para ibm_miamie adicionamos metadados de execução ao PubResult.

Obtenha suporte

Em caso de dúvidas ou problemas, entre em contato com a Q-CTRL.

Próximas etapas