Pular para o conteúdo principal

Obter informações do backend com Qiskit

Versões dos pacotes

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

qiskit-ibm-runtime~=0.43.1

Esta página explica como usar o Qiskit para encontrar informações sobre seus backends disponíveis.

Listar backends​

Para visualizar os backends aos quais você tem acesso, você pode ver uma lista na página de recursos de computação, ou usar o método QiskitRuntimeService.backends(). Esse método retorna uma lista de instâncias IBMBackend:

Observações
  • Se você estiver conectado a uma instância ou região específica, ou se você inicializou o serviço com uma instância ou região específica usando QiskitRuntimeService(), apenas os backends disponíveis para você nessa instância ou região serão retornados. Caso contrário, todos os backends disponíveis para você em qualquer instância e em qualquer região serão retornados.
  • A lista de backends retornada pode não ser a mesma exibida na página de recursos de computação do IBM Quantum Platform. A lista na página de recursos de computação é sempre filtrada pela região selecionada no topo da página.

Para executar o código a seguir, certifique-se de que você já se autenticou no serviço. Consulte Configure sua conta IBM Cloud para mais detalhes.

# Added by doQumentation — required packages for this notebook
!pip install -q qiskit-ibm-runtime
# Initialize your account
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

service.backends()
[<IBMBackend('ibm_pittsburgh')>,
 <IBMBackend('ibm_boston')>,
 <IBMBackend('ibm_fez')>,
 <IBMBackend('ibm_miami')>,
 <IBMBackend('ibm_marrakesh')>,
 <IBMBackend('ibm_torino')>,
 <IBMBackend('ibm_kingston')>]

O método QiskitRuntimeService.backend() (observe que este é o singular: backend) recebe o nome do backend como parâmetro de entrada e retorna uma instância IBMBackend que representa aquele backend específico:

service.backend("ibm_fez")
<IBMBackend('ibm_fez')>

Filtrar backends​

Você também pode filtrar os backends disponíveis pelas suas propriedades. Para filtros mais gerais, defina o argumento filters como uma função que aceita um objeto de backend e retorna True se ele atender aos seus critérios. Consulte a documentação da API para mais detalhes.

O código a seguir retorna apenas os backends que atendem a estes critérios e estão disponíveis para você na instância atualmente selecionada:

  • São dispositivos quânticos reais (simulator=False)
  • Estão atualmente operacionais (operational=True)
  • Têm pelo menos 5 qubits (min_num_qubits=5)
# Optionally pass in an instance, region, or both, to
# further filter the backends.
service = QiskitRuntimeService()

service.backends(simulator=False, operational=True, min_num_qubits=5)
[<IBMBackend('ibm_pittsburgh')>,
 <IBMBackend('ibm_boston')>,
 <IBMBackend('ibm_fez')>,
 <IBMBackend('ibm_miami')>,
 <IBMBackend('ibm_marrakesh')>,
 <IBMBackend('ibm_torino')>,
 <IBMBackend('ibm_kingston')>]

Use esses argumentos de palavra-chave para filtrar por qualquer atributo na configuração do backend (esquema JSON) ou no status (esquema JSON). Um método similar é o QiskitRuntimeService.least_busy(), que aceita os mesmos filtros que backends(), mas retorna o backend que corresponde aos filtros e tem o menor número de jobs pendentes na fila:

service.least_busy(operational=True, min_num_qubits=5)
<IBMBackend('ibm_torino')>

Informações estáticas do backend​

Algumas informações sobre um backend não mudam com frequência, como o nome, a versão, o número de qubits e os tipos de recursos que ele suporta. Essas informações estão disponíveis como atributos do objeto backend.

A célula a seguir constrói uma descrição de um backend.

backend = service.backend("ibm_fez")

print(
    f"Name: {backend.name}\n"
    f"Version: {backend.version}\n"
    f"No. of qubits: {backend.num_qubits}\n"
)
Name: ibm_fez
Version: 2
No. of qubits: 156

Para uma lista completa de atributos, consulte a documentação da API IBMBackend.

Gates e operações nativas​

Cada família de processador possui um conjunto de gates nativo. Por padrão, os QPUs de cada família suportam apenas a execução dos gates e operações do conjunto nativo. Portanto, cada gate no Circuit deve ser traduzido (pelo Transpiler) para os elementos desse conjunto.

Você pode visualizar os gates e operações nativas de um QPU com o Qiskit ou na página de recursos de computação do IBM Quantum® Platform.


from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

for backend in service.backends():
    config = backend.configuration()
    if "simulator" in config.backend_name:
        continue
    print(f"Backend: {config.backend_name}")
    print(f"    Processor type: {config.processor_type}")
    print(f"    Supported instructions:")
    for instruction in config.supported_instructions:
        print(f"        {instruction}")
    print()

Informações dinâmicas do backend​

Os backends também podem ter propriedades que mudam sempre que o backend é calibrado, como a frequência do Qubit e as taxas de erro das operações. Os backends geralmente são calibrados a cada 24 horas, e suas propriedades são atualizadas após a conclusão da sequência de calibração. Essas propriedades podem ser usadas para otimizar circuitos quânticos ou para construir modelos de ruído para um simulador clássico.

Propriedades do Qubit​

O backend.properties().qubit_property() retorna informações sobre os atributos físicos dos qubits. Ele contém um dicionário com diversas propriedades do Qubit, cada uma acompanhada de seu valor e do timestamp da última calibração.

  • T1 (Tempo de Relaxamento): O tempo T1 representa a duração média em que um Qubit permanece em seu estado excitado ∣1⟩|1\rangle antes de decair para seu estado fundamental ∣0⟩|0\rangle devido à relaxação de energia. Esse parâmetro é usado para caracterizar o comportamento de relaxação de energia do Qubit e é expresso em unidades de segundos (s).

  • T2 (Tempo de Defasagem): O tempo T2 denota a escala de tempo na qual um Qubit mantém a coerência de fase de uma superposição entre os estados ∣0⟩|0\rangle e ∣1⟩|1\rangle. Ele considera tanto a relaxação de energia quanto os processos de defasagem pura, fornecendo informações sobre as propriedades de coerência do Qubit.

  • frequency: Este parâmetro especifica a frequência de ressonância do Qubit, indicando a diferença de energia entre os estados ∣0⟩|0\rangle e ∣1⟩|1\rangle, expressa em hertz (Hz).

  • anharmonicity: A anarmonicidade é a diferença de energia entre o primeiro e o segundo estados excitados do Qubit, também expressa em hertz (Hz).

  • readout_error: O erro de leitura quantifica a probabilidade média de medir incorretamente o estado de um Qubit. Geralmente é calculado como a média de prob_meas0_prep1 e prob_meas1_prep0, fornecendo uma métrica única para a fidelidade de medição.

  • prob_meas0_prep1: Este parâmetro indica a probabilidade de medir um Qubit no estado 0 quando ele deveria ter sido preparado no estado ∣1⟩|1\rangle, denotado como P(0∣1)P(0 | 1). Ele reflete erros de preparação de estado e medição (SPAM), particularmente erros de medição em qubits supercondutores.

  • prob_meas1_prep0: De forma similar, este parâmetro representa a probabilidade de medir um Qubit no estado 1 quando ele deveria ter sido preparado no estado ∣0⟩|0\rangle, denotado como P(1∣0)P(1 | 0). Assim como prob_meas0_prep1, ele reflete erros SPAM, sendo os erros de medição o principal contribuidor em qubits supercondutores.

  • readout_length: O readout_length especifica a duração da operação de leitura de um Qubit. Ele mede o tempo desde o início do pulso de medição até a conclusão da digitalização do sinal, após o qual o sistema está pronto para a próxima operação. Compreender esse parâmetro é crucial para otimizar a execução de circuitos, especialmente ao incorporar medições intermediárias no Circuit.

# fundamental physical properties of qubit 1
backend.qubit_properties(1)
QubitProperties(t1=0.00023160183954439313, t2=0.0002759670226087048, frequency=None)
# calibration data with detailed properties of qubit 0
backend.properties().qubit_property(0)
{'T1': (5.199156952582205e-05,
  datetime.datetime(2026, 1, 14, 16, 18, 26, tzinfo=tzlocal())),
 'T2': (2.253552085985709e-05,
  datetime.datetime(2026, 1, 14, 16, 19, 6, tzinfo=tzlocal())),
 'readout_error': (0.013916015625,
  datetime.datetime(2026, 1, 14, 21, 38, 31, tzinfo=tzlocal())),
 'prob_meas0_prep1': (0.026123046875,
  datetime.datetime(2026, 1, 14, 21, 38, 31, tzinfo=tzlocal())),
 'prob_meas1_prep0': (0.001708984375,
  datetime.datetime(2026, 1, 14, 21, 38, 31, tzinfo=tzlocal())),
 'readout_length': (1.56e-06,
  datetime.datetime(2026, 1, 14, 21, 38, 31, tzinfo=tzlocal()))}
# Retrieve qubit properties
qubit_index = 126  # Replace with your qubit index
qubit_props = backend.properties().qubit_property(qubit_index)

# Access specific properties
t1 = qubit_props.get("T1", (None,))[0]
t2 = qubit_props.get("T2", (None,))[0]
frequency = qubit_props.get("frequency", (None,))[0]
anharmonicity = qubit_props.get("anharmonicity", (None,))[0]
readout_error = qubit_props.get("readout_error", (None,))[0]
prob_meas0_prep1 = qubit_props.get("prob_meas0_prep1", (None,))[0]
prob_meas1_prep0 = qubit_props.get("prob_meas1_prep0", (None,))[0]
readout_length = qubit_props.get("readout_length", (None,))[0]

print(f"Qubit {qubit_index} Properties:")
print(f"  T1: {t1} seconds")
print(f"  T2: {t2} seconds")
print(f"  Frequency: {frequency} Hz")
print(f"  Anharmonicity: {anharmonicity} Hz")
print(f"  Readout Error: {readout_error}")
print(f"  P(0 | 1): {prob_meas0_prep1}")
print(f"  P(1 | 0): {prob_meas1_prep0}")
print(f"  Readout Length: {readout_length} seconds")
Qubit 126 Properties:
  T1: 9.563335658857979e-05 seconds
  T2: 6.570556299807121e-05 seconds
  Frequency: None Hz
  Anharmonicity: None Hz
  Readout Error: 0.006591796875
  P(0 | 1): 0.009765625
  P(1 | 0): 0.00341796875
  Readout Length: 1.56e-06 seconds

Propriedades das instruções​

O atributo backend.target é um objeto qiskit.transpiler.Target: um objeto que contém todas as informações necessárias para fazer o transpile de um Circuit para aquele backend. Isso inclui erros e durações das instruções. Por exemplo, a célula a seguir obtém as propriedades de um gate cz atuando entre os qubits 1 e 0.

backend.target["cz"][(1, 0)]
InstructionProperties(duration=6.8e-08, error=0.007831625819164134)

A célula a seguir exibe as propriedades de uma operação de medição (incluindo o erro de leitura) no qubit 0.

backend.target["measure"][(0,)]
InstructionProperties(duration=1.56e-06, error=0.013916015625)

Próximos passos​

Recomendações