Ottenere informazioni sul backend con Qiskit

Versioni dei pacchetti

Il codice in questa pagina è stato sviluppato utilizzando i seguenti requisiti. Si consiglia di usare queste versioni o versioni più recenti.

qiskit-ibm-runtime~=0.43.1

Questa pagina spiega come usare Qiskit per trovare informazioni sui backend disponibili.

Elencare i backend

Per visualizzare i backend a cui hai accesso, puoi consultare l'elenco nella pagina Compute resources, oppure usare il metodo QiskitRuntimeService.backends(). Questo metodo restituisce un elenco di istanze IBMBackend:

Note

Se hai effettuato l'accesso a un'istanza o una regione specifica, o se hai inizializzato il servizio con un'istanza o una regione specifica tramite QiskitRuntimeService(), vengono restituiti solo i backend disponibili per quell'istanza o regione. In caso contrario, vengono restituiti tutti i backend disponibili su qualsiasi istanza e in qualsiasi regione.
L'elenco dei backend restituito potrebbe non coincidere con quello mostrato nella pagina Compute resources di IBM Quantum Platform. L'elenco nella pagina Compute resources è sempre filtrato in base alla regione selezionata in cima alla pagina.

Per eseguire il codice seguente, assicurati di aver già effettuato l'autenticazione al servizio. Consulta Configura il tuo account IBM Cloud per maggiori dettagli.

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

Il metodo QiskitRuntimeService.backend() (nota che è al singolare: backend) accetta il nome del backend come parametro di input e restituisce un'istanza IBMBackend che rappresenta quel particolare backend:

service.backend("ibm_fez")

<IBMBackend('ibm_fez')>

Filtrare i backend

Puoi anche filtrare i backend disponibili in base alle loro proprietà. Per filtri più generali, imposta l'argomento filters su una funzione che accetta un oggetto backend e restituisce True se soddisfa i tuoi criteri. Consulta la documentazione API per maggiori dettagli.

Il codice seguente restituisce solo i backend che soddisfano questi criteri e sono disponibili per te sull'istanza attualmente selezionata:

Sono dispositivi quantistici reali (simulator=False)
Sono attualmente operativi (operational=True)
Hanno almeno 5 qubit (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')>]

Usa questi argomenti keyword per filtrare in base a qualsiasi attributo nella configurazione del backend (JSON schema) o nello stato (JSON schema). Un metodo simile è QiskitRuntimeService.least_busy(), che accetta gli stessi filtri di backends() ma restituisce il backend che corrisponde ai filtri e ha il minor numero di job in coda:

service.least_busy(operational=True, min_num_qubits=5)

<IBMBackend('ibm_torino')>

Informazioni statiche sul backend

Alcune informazioni su un backend non cambiano regolarmente, come il nome, la versione, il numero di qubit e i tipi di funzionalità supportate. Queste informazioni sono disponibili come attributi dell'oggetto backend.

La cella seguente costruisce una descrizione di un 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

Per un elenco completo degli attributi, consulta la documentazione API di IBMBackend.

gate e operazioni native

Ogni famiglia di processori ha un insieme di gate nativi. Per impostazione predefinita, le QPU di ciascuna famiglia supportano solo l'esecuzione dei gate e delle operazioni dell'insieme nativo. Pertanto, ogni gate nel circuito deve essere tradotto (dal transpiler) negli elementi di questo insieme.

Puoi visualizzare i gate e le operazioni native per una QPU sia con Qiskit, sia nella pagina Compute resources di 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()

Informazioni dinamiche sul backend

I backend possono avere anche proprietà che cambiano ogni volta che vengono calibrati, come la frequenza dei qubit e i tassi di errore delle operazioni. I backend vengono solitamente calibrati ogni 24 ore e le loro proprietà si aggiornano al termine della sequenza di calibrazione. Queste proprietà possono essere usate per ottimizzare i circuiti quantistici o per costruire modelli di rumore per un simulatore classico.

Proprietà dei qubit

backend.properties().qubit_property() restituisce informazioni sugli attributi fisici dei qubit. Contiene un dizionario di varie proprietà del qubit, ciascuna abbinata al suo valore e al timestamp dell'ultima calibrazione.

T1 (Relaxation Time): Il tempo T1 rappresenta la durata media per cui un qubit rimane nel suo stato eccitato $|1\rangle$ prima di decadere al suo stato fondamentale $|0\rangle$ a causa del rilassamento energetico. Questo parametro viene usato per caratterizzare il comportamento di rilassamento energetico del qubit ed è espresso in secondi (s).
T2 (Dephasing Time): Il tempo T2 indica la scala temporale su cui un qubit mantiene la coerenza di fase di una sovrapposizione tra gli stati $|0\rangle$ e $|1\rangle$ . Tiene conto sia del rilassamento energetico sia dei processi di dephasazione pura, fornendo informazioni sulle proprietà di coerenza del qubit.
frequency: Questo parametro specifica la frequenza di risonanza del qubit, indicando la differenza di energia tra gli stati $|0\rangle$ e $|1\rangle$ , espressa in hertz (Hz).
anharmonicity: L'anarmonicità è la differenza di energia tra il primo e il secondo stato eccitato del qubit, anch'essa espressa in hertz (Hz).
readout_error: L'errore di readout quantifica la probabilità media di misurare incorrettamente lo stato di un qubit. Viene comunemente calcolato come la media di prob_meas0_prep1 e prob_meas1_prep0, fornendo una singola metrica per la fedeltà di misura.
prob_meas0_prep1: Questo parametro indica la probabilità di misurare un qubit nello stato 0 quando era previsto che fosse preparato nello stato $|1\rangle$ , indicata come $P(0 | 1)$ . Riflette gli errori di preparazione e misura dello stato (SPAM), in particolare gli errori di misura nei qubit superconduttori.
prob_meas1_prep0: Analogamente, questo parametro rappresenta la probabilità di misurare un qubit nello stato 1 quando era previsto che fosse preparato nello stato $|0\rangle$ , indicata come $P(1 | 0)$ . Come prob_meas0_prep1, riflette gli errori SPAM, con gli errori di misura come contributo predominante nei qubit superconduttori.
readout_length: Il parametro readout_length specifica la durata dell'operazione di readout per un qubit. Misura il tempo dall'avvio del pulse di misura al completamento della digitalizzazione del segnale, dopo di che il sistema è pronto per l'operazione successiva. Comprendere questo parametro è fondamentale per ottimizzare l'esecuzione dei circuiti, specialmente quando si incorporano misure a metà circuito.

# 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

Proprietà delle istruzioni

L'attributo backend.target è un oggetto qiskit.transpiler.Target: un oggetto che contiene tutte le informazioni necessarie per transpilare un circuito per quel backend. Include errori e durate delle istruzioni. Ad esempio, la cella seguente ottiene le proprietà per un gate cz che agisce tra i qubit 1 e 0.

backend.target["cz"][(1, 0)]

InstructionProperties(duration=6.8e-08, error=0.007831625819164134)

La cella seguente mostra le proprietà per un'operazione di misura (incluso l'errore di readout) sul qubit 0.

backend.target["measure"][(0,)]

InstructionProperties(duration=1.56e-06, error=0.013916015625)

Passi successivi

Raccomandazioni

Prova il tutorial sull'algoritmo di Grover.
Consulta la documentazione di riferimento delle API backend di QiskitRuntime.

Elencare i backend​

Filtrare i backend​

Informazioni statiche sul backend​

gate e operazioni native​

Informazioni dinamiche sul backend​

Proprietà dei qubit​

Proprietà delle istruzioni​

Passi successivi​