Visualizza i dettagli del backend

• Versioni del pacchetto

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

  qiskit-ibm-runtime~=0.47.0
  

Questa pagina spiega come trovare informazioni sui backend disponibili.

Elenco o filtro dei backend

Elenco dei backend disponibili

È possibile utilizzare Qiskit o IBM Quantum Platform per visualizzare un elenco dei backend disponibili o per cercare un backend specifico.

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

service.backend("ibm_fez")

<IBMBackend('ibm_fez')>

Backend dei filtri

# Optionally pass in an instance, region, or both, to
# further filter the backends.
service = QiskitRuntimeService()

service.backends(simulator=False, operational=True, min_num_qubits=100)

[<IBMBackend('ibm_pittsburgh')>,
 <IBMBackend('ibm_boston')>,
 <IBMBackend('ibm_fez')>,
 <IBMBackend('ibm_miami')>,
 <IBMBackend('ibm_marrakesh')>,
 <IBMBackend('ibm_kingston')>]

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

<IBMBackend('ibm_fez')>

Informazioni statiche sul backend

Alcune informazioni relative al backend non cambiano regolarmente, come il nome, la versione, il numero di qubit, il tipo di processore (il nome della famiglia di processori, che indica la topologia e il numero approssimativo di qubit) e i tipi di funzionalità supportate. Queste informazioni sono disponibili come attributi backend dell'oggetto. Per un elenco completo degli attributi, consultare la IBMBackend documentazione API. Per ulteriori informazioni sul versioning, consultare la sezione dedicata al versioning QPU riportata di seguito.

La regione di un backend (la posizione del data center in cui saranno ospitati ed elaborati i dati e gli esperimenti) è elencata nella scheda informativa dettagliata nella pagina Risorse di calcolo su IBM Quantum Platform.

backend = service.backend("ibm_fez")

print(
    f"Name: {backend.name}\n"
    f"Version: {backend.backend_version}\n"
    f"No. of programmable qubits: {backend.num_qubits}\n"
    f"Processor type: {backend.processor_type}\n"
)

Name: ibm_fez
Version: 1.3.37
No. of programmable qubits: 156
Processor type: {'family': 'Heron', 'revision': '2'}

Versioni QPU

Ogni QPU ha un numero di versione nel formato X.Y.Z ( major.minor.revision ). Un circuito compilato per un determinato numero di versione è garantito per funzionare su quella QPU. Se il numero di revisione cambia, il circuito continuerà a funzionare. Se il numero maggiore o minore cambia, non è garantito che il circuito funzioni, anche se potrebbe farlo.

Il numero della versione di revisione aumenterà per le correzioni che non compromettono il circuito compilato esistente.

L'esempio di codice riportato in precedenza in questa sezione mostra come trovare la versione di un backend. In IBM Quantum Platform è possibile visualizzare la versione nella scheda delle informazioni dettagliate di una QPU (fare clic sul nome della QPU nella tabella Risorse di calcolo per aprire la scheda).

Le condizioni alle quali un numero di versione o di revisione può cambiare sono elencate nella tabella seguente.

Istruzioni supportate

Ogni famiglia di processori supporta in modo nativo un insieme limitato di istruzioni. Questo set include porte a uno e due qubit, nonché operazioni non unitarie quali misurazione e ripristino. Ogni gate nel circuito deve essere tradotto (dal transpiler) negli elementi del set di istruzioni supportato dalla QPU prima di poter essere eseguito sulla QPU.

È possibile visualizzare i set di istruzioni supportati per una QPU con Qiskit. La pagina Risorse di calcolo dell' IBM Quantum Platform elenca solo i gate unitari supportati (gate di base) per una QPU.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = service.backend("ibm_kingston")

print(f"Backend: {backend.name}")
print(f"    Processor type: {backend.processor_type}")
print(f"    Supported instructions: {backend.supported_instructions}")

Backend: ibm_kingston

    Processor type: {'family': 'Heron', 'revision': '2'}
    Supported instructions: ['cz', 'id', 'delay', 'measure', 'measure_2', 'reset', 'rz', 'sx', 'x', 'if_else', 'store']

Tabella delle istruzioni supportate

Informazioni dinamiche sul backend

I backend hanno anche proprietà che cambiano ogni volta che il backend viene calibrato, come la durata dei qubit e i tassi di errore operativi. Le proprietà del backend vengono aggiornate al termine della sequenza di calibrazione. Queste proprietà possono essere utilizzate per ottimizzare i circuiti quantistici o per costruire modelli di rumore per un simulatore classico. Per ulteriori informazioni, consultare la guida alle operazioni di calibrazione.

Su IBM Quantum Platform è possibile scaricare i dati di calibrazione come file CSV. Fare clic su una QPU nella pagina Risorse di calcolo per visualizzare la scheda informativa dettagliata, quindi fare clic sull'icona di download nell'angolo in alto a destra della sezione Dati di calibrazione.

backend.properties(datetime=<datetime>)

Proprietà dei qubit

Vai all'elenco delle proprietà dei qubit

backend.properties().qubit_property() restituisce informazioni sulle caratteristiche fisiche dei qubit. Contiene un dizionario delle varie proprietà del qubit, ciascuna abbinata al proprio valore e al timestamp dell'ultima calibrazione.

I seguenti esempi di codice mostrano come elencare tutte le proprietà o recuperare proprietà specifiche di un particolare qubit.

# fundamental physical properties of qubit 1

backend = service.backend("ibm_fez")

backend.qubit_properties(1)

Output:

QubitProperties(t1=0.00019233494213807877, t2=0.00023593910973864878, frequency=None)

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

Output:

Qubit 126 Properties:
  T1: 1.6203279905573543e-05 seconds
  T2: 2.7965850265833494e-05 seconds
  Readout Error: 0.0601806640625
  P(0 | 1): 0.0908203125
  P(1 | 0): 0.029541015625
  Readout Length: 1.66e-06 seconds

Visualizza le proprietà dei qubit

• T1 (Tempo di relax)

  Il tempo di transizione di un qubit ( $T_1$ ) rappresenta la durata media durante la quale 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 utilizzato per caratterizzare il comportamento di rilassamento energetico del qubit ed è espresso in secondi (s).

  Visualizza con Qiskit	backend.properties().t1(<qubit>)
  Visualizza su IBM Quantum Platform	Sezione dei dati di calibrazione: menu a tendina “Qubit”; individuare il valore mediano dell’ $T_1$ e nella sezione “Dettagli”

• T2 (Tempo di defasamento)

  Il tempo di coerenza ( $T_2$ ) indica il periodo di tempo durante il quale un qubit mantiene la coerenza di fase di una sovrapposizione tra gli stati $|0\rangle$ e $|1\rangle$. Tiene conto sia dei processi di rilassamento energetico che di quelli di puro sfasamento, fornendo informazioni sulle proprietà di coerenza del qubit. L' $T_2$ e è riportato da una sequenza di eco di Hahn.

  Visualizza con Qiskit	backend.properties().t2(<qubit>)
  Visualizza su IBM Quantum Platform	Sezione dei dati di calibrazione: menu a tendina “Qubit”; individuare il valore mediano dell’ $T_2$ e nella sezione “Dettagli”

Proprietà delle istruzioni

Vai all'elenco delle proprietà delle istruzioni

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

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

Output:

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

La cella seguente mostra le proprietà di un'operazione di misurazione (compreso l'errore di lettura) sul qubit 0.

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

Output:

InstructionProperties(duration=1.66e-06, error=0.00927734375)

Visualizza le proprietà delle istruzioni

• prob-meas0-prep1

  Questo parametro indica la probabilità di misurare un qubit nello stato $|0\rangle$ quando si intendeva prepararlo nello stato $|1\rangle$, indicato come $P(0 | 1)$. Esso riflette gli errori nella preparazione e nella misurazione dello stato (SPAM), in particolare gli errori di misurazione nei qubit superconduttori.

  Visualizza con Qiskit	backend.properties().qubit_property(<qubit>, 'prob_meas0_prep1')
  Visualizza su IBM Quantum Platform	Sezione dei dati di calibrazione: menu a tendina "Qubit"

• prob-meas1-prep0

  Analogamente, questo parametro rappresenta la probabilità di misurare un qubit nello stato $|1\rangle$ quando si intendeva prepararlo nello stato $|0\rangle$, indicato con $P(1 | 0)$. Come prob_meas0_prep1, riflette gli errori SPAM, con gli errori di misurazione che costituiscono il fattore predominante nei qubit superconduttori.

  Visualizza con Qiskit	backend.properties().qubit_property(<qubit>, 'prob_meas0_prep0')
  Visualizza su IBM Quantum Platform	Sezione dei dati di calibrazione: menu a tendina "Qubit"

• 2Q errore (Heron e Nighthawk: CZ, Eagle: ECR)

  L'errore a due qubit per bordo dallo stesso lotto di misurazioni utilizzato per calcolare l'errore mediano dell' 2Q. 2Q L'errore (migliore) si riferisce all'errore più basso a due qubit su qualsiasi bordo del dispositivo, anch'esso ricavato da questa serie di misurazioni.

  Visualizza con Qiskit	backend.target['<instruction>'][<qubit 1>, <qubit 2>]
  Visualizza su IBM Quantum Platform	Sezione Calibrazione: passa con il mouse sopra la connessione qubit nella vista Mappa oppure trova il valore nella vista Tabella sotto la colonna Errore CZ (Heron e Nighthawk) o Errore ECR (Eagle); trova il valore per l'errore dell' 2Q e (migliore) nella sezione Dettagli

• Errore mediano dell' 2Q e (Heron: CZ, Eagle: ECR)

  Fedeltà media del gate dell'operazione a due qubit dal benchmarking randomizzato. Misurato in "isolamento": batch con una separazione minima di due qubit tra i bordi. Questo benchmarking randomizzato utilizza strati alternati di Clifford a singolo qubit e gate a due qubit, pertanto il valore finale dell'errore dell' 2Q e include l'errore dello strato di Clifford a singolo qubit.

  Calcola con Qiskit	Segui l'esempio riportato in questo notebook della comunità Qiskit GitHub
  Visualizza su IBM Quantum Platform	Sezione Dettagli; trova anche i dati per bordo nella sezione Dati di calibrazione

• Errore 2Q (a strati)

  Errore medio per gate stratificato (EPLG) in una catena di 100 qubit. L'EPLG medio misura l'errore medio di gate in una catena stratificata di qubit dell' $N$ (in questo caso $N$ =100). È derivato da una quantità simile nota come fedeltà di strato (LF), dove EPLG $_{100}$ = 4/5(1-LF $^{\frac{1}{99}}$ ) e la fedeltà di strato è la fedeltà di processo della catena stratificata di qubit $N$. Per ulteriori dettagli, consultare il documento Benchmarking quantum processor performance at scale (Analisi comparativa delle prestazioni dei processori quantistici su larga scala). Si noti che nel documento EPLG è definito per l'errore di processo, ma per coerenza con gli errori di gate riportati individualmente qui è citato per l'errore medio di gate, quindi il fattore 4/5.

  Su IBM Quantum Platform, la scheda informativa dettagliata per ciascuna QPU presenta una sezione denominata Errore di gate a due qubit (a livelli), che fornisce una visione ampliata del valore più basso two-qubit gate error (layered) misurato in funzione del numero di qubit nella catena. Il valore finale, con una lunghezza della catena pari a 100, è il valore presentato nella sezione Dettagli. In pratica, vengono misurate sei catene da 100 qubit (preselezionate in base alle prestazioni ottimali previste) e il valore riportato per il numero di qubit N è l'errore più basso riscontrato in una catena di N lunghezza sottoinsieme che ricerca tra le sei catene da 100 qubit.

  Calcola con Qiskit	Segui l'esempio riportato in questo notebook della comunità Qiskit GitHub
  Visualizza su IBM Quantum Platform	Sezione Dettagli e una vista ampliata nella sezione Errore di gate a due qubit (a strati)

• Errore RZZ (Heron)

  Errore nel gate RZZ mediato sugli angoli RZZ utilizzando una variante del benchmarking randomizzato per unitaries arbitrari.

  Visualizza con Qiskit	Importante: assicurati di aver impostato use_fractional_gates=True quando carichi il backend, quindi puoi utilizzare backend.target['rzz'][<qubit 1>, <qubit 2>]
  Visualizza su IBM Quantum Platform	Sezione Calibrazione: selezionare RZZ nel menu a tendina Connessione e passare con il mouse sulla connessione qubit nella vista Mappa. È anche possibile selezionare l'errore RZZ nel menu a tendina Output grafico nella vista Grafico, oppure trovare il valore nella vista Tabella nella colonna Errore RZZ

• Errore ID / errore √x (sx) / errore Pauli-X / errore RX

  Errore nei gate discreti a durata finita a un qubit, misurato da benchmarking randomizzati. La sequenza di benchmarking randomizzata include i gate SX, ID e X, e si presume che i loro errori siano gli stessi. Il gate ID è un ritardo di durata pari alla durata dei gate √X e X. Il gate RX ha anche la stessa durata dei gate √X e X con ampiezza variabile, quindi viene segnalato come avente lo stesso errore di questi gate.

  Visualizza con Qiskit	backend.target['<instruction>'][<qubit 1>,]
  Visualizza su IBM Quantum Platform	Sezione Calibrazione: menu a tendina Qubit

• Errore SX (mediana)

  Fedeltà media del gate √X (SX) ottenuta da benchmarking randomizzato, misurata simultaneamente su tutti i qubit. La sequenza di benchmarking randomizzata include i gate SX, ID e X, e si presume che i loro errori siano gli stessi.

  Visualizza su IBM Quantum Platform	Sezione dettagli

• Errore di rotazione dell'asse Z (RZ)

  Errore nel gate virtuale RZ. Segnalati come tutti 0 poiché vengono eseguiti nel software.

  Visualizza con Qiskit	backend.target['<instruction>'][<qubit 1>,]
  Visualizza su IBM Quantum Platform	Sezione Calibrazione: menu a tendina Connessione

• Errore di lettura

  L'errore di lettura quantifica la probabilità media di misurare in modo errato lo stato di un qubit. È comunemente calcolato come media di prob_meas0_prep1 e prob_meas1_prep0, fornendo un unico parametro per misurare la fedeltà.

  Visualizza con Qiskit	backend.properties().readout_error(<qubit>)
  Visualizza su IBM Quantum Platform	Sezione dei dati di calibrazione: menu a tendina "Qubit"

• Errore di lettura (mediana)

  Affidabilità dell'operazione di lettura. L'errore di lettura viene misurato preparando il qubit nello stato $|0\rangle$ ( $|1\rangle$ ) e misurando la probabilità di ottenere un risultato nello stato $|1\rangle$ ( $|0\rangle$ ). Il valore riportato corrisponde alla media di questi due errori. La mediana viene calcolata considerando tutti i qubit.

  Visualizza su IBM Quantum Platform	Sezione "Dati di calibrazione": Sezione "Dettagli"

• Lunghezza del gate a singolo qubit

  Durata di un'operazione gate su un singolo qubit. Si noti che i valori indicati su IBM Quantum Platform sono espressi in nanosecondi. I valori restituiti in Qiskit sono espressi in secondi.

  Visualizza con Qiskit	backend.target['<instruction>'][<qubit 1>,].duration
  Visualizza su IBM Quantum Platform	Sezione Calibrazione: menu a tendina Qubit

• Lunghezza del gate (gate 2Q )

  Durata dell'operazione del gate a due qubit. Si noti che i valori indicati su IBM Quantum Platform sono espressi in nanosecondi. I valori restituiti in Qiskit sono espressi in secondi.

  Visualizza con Qiskit	backend.target['<instruction>'][<qubit 1>, <qubit 2>].duration
  Visualizza su IBM Quantum Platform	Sezione Calibrazione: menu a tendina Qubit

• Lunghezza di lettura

  La lunghezza di lettura specifica la durata dell'operazione di lettura per un qubit. Misura il tempo che intercorre tra l'inizio dell'impulso di misurazione e il completamento della digitalizzazione del segnale, dopodiché il sistema è pronto per l'operazione successiva. Comprendere questo parametro è fondamentale per ottimizzare l'esecuzione dei circuiti, specialmente quando si incorporano misurazioni a metà circuito.

  Visualizza con Qiskit	Per measure: backend.properties().readout_length(<qubit>) Per measure_2: backend.target['measure_2'][<qubit 1>,].duration
  Visualizza su IBM Quantum Platform	Sezione dei dati di calibrazione: menu a tendina "Qubit"

• Errore di inizializzazione

  L'errore di inizializzazione quantifica la percentuale della popolazione che si trova nello stato $|1\rangle$ dopo il ritardo di ripetizione predefinito e la procedura di inizializzazione del qubit, quando l'esperimento precedente aveva preparato il qubit nello stato $|1\rangle$. Si noti che questa grandezza è leggermente diversa dalla prob_meas1_prep0, che misura la percentuale delle misurazioni assegnate allo stato “ $|1\rangle$ ”. Quest’ultimo è un parametro che misura sia l’errore di inizializzazione sia la procedura di discriminazione tra gli stati “ $|0\rangle$ ” e “ $|1\rangle$ ”. Nel limite di una misurazione perfetta, le due grandezze coincidono.

  Visualizza con Qiskit	backend.properties().qubit_property(<qubit>, 'init_error')
  Visualizza su IBM Quantum Platform	Sezione dei dati di calibrazione: menu a tendina "Qubit"

Proprietà aggiuntive

• Numero massimo di circuiti al secondo (MCPS)

  Il numero massimo di circuiti al secondo (MCPS) comprende la misurazione, il reset e la reinizializzazione di un circuito con una porta di Hadamard e una singola misurazione.

  Visualizza con Qiskit	mcps = backend.configuration().mcps
  Visualizza su IBM Quantum Platform	Sezione dettagli

• CLOPS (o CLOPS_h)

  Le operazioni al secondo a livello di circuito (CLOPS) sono una misura del numero di livelli di un circuito hardware-aware ( 100x100 ) che una QPU è in grado di eseguire per unità di tempo.

  Calcola con Qiskit	Trova il codice CLOPS nella comunità Qiskit GitHub
  Visualizza su IBM Quantum Platform	Sezione dettagli

• Stato

  Con BackendStatus, è possibile trovare lo stato della QPU (ad esempio, Active, Paused, Offline) e il numero di lavori in sospeso.

  Visualizza con Qiskit	print(backend.status().status_msg), print(backend.status().pending_jobs)
  Visualizza su IBM Quantum Platform	Sezione dettagli

• Diagramma topologico o mappa di accoppiamento

  Un diagramma che indica le coppie di qubit che supportano operazioni di gate a due qubit tra loro. Questo è anche chiamato mappa di accoppiamento o connettività. I qubit sono rappresentati come cerchi e le operazioni di gate a due qubit supportate sono visualizzate come linee che collegano i qubit.

  Visualizza con Qiskit	from qiskit.visualization import plot_gate_map allora plot_gate_map(backend)
  Visualizza su IBM Quantum Platform	Sezione dati di calibrazione; clicca su Espandi per ingrandire la visualizzazione

Passi successivi