{ "cells": [ { "cell_type": "markdown", "id": "c8e557e7-e1f9-4429-80ad-2907871c704d", "metadata": {}, "source": [ "---\n", "title: \"Visualizza i dettagli del backend\"\n", "description: \"Elenca e filtra i backend disponibili e trova i dettagli della QPU, come i dati di configurazione e calibrazione.\"\n", "---\n", "\n", "\n", "\n", "# Visualizza i dettagli del backend\n", "\n" ] }, { "cell_type": "markdown", "id": "bb84ab8e-6db9-45d6-bb59-2f06f38d9965", "metadata": { "tags": [ "version-info" ] }, "source": [ "{/*\n", " DO NOT EDIT THIS CELL!!!\n", " This cell's content is generated automatically by a script. Anything you add\n", " here will be removed next time the notebook is run. To add new content, create\n", " a new cell before or after this one.\n", " */}\n", "\n", "\n", " \n", " Il codice presente in questa pagina è stato sviluppato utilizzando i seguenti requisiti.\n", " Si consiglia di utilizzare queste versioni o versioni più recenti.\n", "\n", " ```\n", " qiskit-ibm-runtime~=0.47.0\n", " ```\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "d76db591-d53c-4753-ab4f-8d6e80bbc39e", "metadata": {}, "source": [ "Questa pagina spiega come trovare informazioni sui backend disponibili.\n", "\n" ] }, { "cell_type": "markdown", "id": "1215b9ee-c32f-42db-a1e0-24d62175ab88", "metadata": {}, "source": [ "\n", "\n", "## Elenco o filtro dei backend\n", "\n", "\n", "\n", "\n", "\n", "### Elenco dei backend disponibili\n", "\n", "È possibile utilizzare Qiskit o IBM Quantum Platform per visualizzare un elenco dei backend disponibili o per cercare un backend specifico.\n", "\n", "\n", " Le QPU ospitate su IBM Cloud® hanno nomi che iniziano con `ibm_*`. A tutte le QPU viene assegnato il nome di una città, ad esempio `ibm_kingston`. Questo nome non indica dove è ospitato il QPU effettivo.\n", "\n", "\n", "\n", " \n", " Utilizza il [`QiskitRuntimeService.backends()`](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#backends) metodo, come mostrato nel blocco di codice successivo. Questo metodo restituisce un elenco di [`IBMBackend`](/docs/api/qiskit-ibm-runtime/ibm-backend) istanze.\n", "\n", " Per eseguire il codice seguente, assicurati di aver già effettuato l'autenticazione al servizio. Per ulteriori dettagli, consulta [la sezione Configura il tuo account IBM Cloud](/docs/guides/cloud-setup).\n", "\n", " \n", "\n", " Per cercare un backend specifico, utilizzare il [`QiskitRuntimeService.backend()`](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#backend) metodo (si noti che è singolare: *backend* ), che accetta il nome del backend come parametro di input e restituisce [`IBMBackend`](/docs/api/qiskit-ibm-runtime/ibm-backend) un'istanza che rappresenta quel particolare backend:\n", "\n", " \n", " \n", "\n", " \n", " Per visualizzare i backend a cui hai accesso, vai all'elenco dei backend nella [pagina Risorse di calcolo](/computers) (tieni presente che la regione selezionata potrebbe influire sui QPU elencati). Fai clic sull'icona del filtro e seleziona \"Tutte le mie istanze\" o il nome di un'istanza specifica per visualizzare le QPU disponibili.\n", " \n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "068f58ca-bff4-4138-8b75-b6a67e1e9e37", "metadata": { "tags": [ "id-initialize" ] }, "outputs": [ { "data": { "text/plain": [ "[,\n", " ,\n", " ,\n", " ,\n", " ,\n", " ]" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Initialize your account\n", "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", "service = QiskitRuntimeService()\n", "\n", "service.backends()" ] }, { "cell_type": "code", "execution_count": 2, "id": "0fc28230-3036-44ea-b933-8a9dda548b38", "metadata": { "tags": [ "id-search" ] }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "service.backend(\"ibm_fez\")" ] }, { "cell_type": "code", "execution_count": 3, "id": "3a28c031-e306-4cd2-aacb-f007b564ce96", "metadata": { "tags": [ "id-filter" ] }, "outputs": [ { "data": { "text/plain": [ "[,\n", " ,\n", " ,\n", " ,\n", " ,\n", " ]" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Optionally pass in an instance, region, or both, to\n", "# further filter the backends.\n", "service = QiskitRuntimeService()\n", "\n", "service.backends(simulator=False, operational=True, min_num_qubits=100)" ] }, { "cell_type": "markdown", "id": "aefe61eb-27fd-4689-b16e-458a9681c066", "metadata": {}, "source": [ "\n", " Se hai effettuato l'accesso a un'istanza o a una regione specifica, oppure se hai inizializzato il servizio con un'istanza o una regione specifica utilizzando `QiskitRuntimeService()`, verranno restituiti solo i backend disponibili su tale istanza o regione.\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "e6d4dafc-33f1-4010-a8fa-33bf37e7f98f", "metadata": {}, "source": [ "\n", "\n", "### Backend dei filtri\n", "\n", "\n", " \n", " È possibile filtrare i backend disponibili in base [alla](/docs/api/qiskit-ibm-runtime/models-backend-configuration) loro configurazione o [al](/docs/api/qiskit-ibm-runtime/models-backend-status) loro stato. Per filtri più generici, impostare `filters` l'argomento su una funzione che accetta un oggetto backend e restituisce `True` se soddisfa i criteri specificati. Per ulteriori dettagli, consultare la [documentazione API](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#backends).\n", "\n", " Il codice seguente restituisce solo i backend che soddisfano questi criteri e sono disponibili *sull'istanza attualmente selezionata* :\n", "\n", " * Sono veri dispositivi quantistici (`simulator=False`)\n", " * Sono attualmente operativi (`operational=True`)\n", " * Avere almeno un centinaio di qubit (`min_num_qubits=100`)\n", "\n", " \n", "\n", " Un metodo simile è [`QiskitRuntimeService.least_busy()`](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#least_busy), che utilizza gli stessi filtri di `backends()` ma restituisce il backend che corrisponde ai filtri e ha il minor numero di lavori in sospeso nella coda:\n", "\n", " \n", " \n", "\n", " \n", " Per visualizzare i backend a cui hai accesso, consulta la tabella nella [pagina Risorse di calcolo](/computers). Clicca sull'icona del filtro per visualizzare le opzioni di filtro. È possibile filtrare per tipo di processore e stato. Si noti inoltre che è possibile ordinare la tabella in base a qualsiasi colonna passando con il mouse sul titolo della colonna e facendo clic sulle frecce che compaiono.\n", " \n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "7493d247-ade9-4dd2-8bdf-11e332bd6939", "metadata": { "tags": [ "id-least-jobs" ] }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "service.least_busy(operational=True, min_num_qubits=100)" ] }, { "cell_type": "markdown", "id": "1a0c9cbe-48e6-499e-bfb2-ed8bbdbeb38e", "metadata": {}, "source": [ "\n", "\n", "## Informazioni statiche sul backend\n", "\n", "Alcune informazioni relative al backend non cambiano regolarmente, come il nome, [la versione](#qpu-versioning), il numero di qubit, il tipo di processore (il nome della famiglia di processori, che indica la [topologia](#coupling-map) 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](/docs/api/qiskit-ibm-runtime/ibm-backend). Per ulteriori informazioni sul versioning, consultare la sezione dedicata [al versioning QPU](#qpu-versioning) riportata di seguito.\n", "\n", "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](/computers) su IBM Quantum Platform.\n", "\n", "\n", " \n", " \n", " \n", "\n", " \n", " Accedere alla pagina [Risorse di calcolo](/computers) per visualizzare una tabella di tutte le QPU, quindi fare clic sul nome di una QPU qualsiasi per aprire la scheda con le informazioni dettagliate. Trova le informazioni di backend nella sezione Dettagli della scheda.\n", " \n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "c15c53ef-301e-47b6-9931-bb5ae1f200dd", "metadata": { "tags": [ "id-version" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Name: ibm_fez\n", "Version: 1.3.37\n", "No. of programmable qubits: 156\n", "Processor type: {'family': 'Heron', 'revision': '2'}\n", "\n" ] } ], "source": [ "backend = service.backend(\"ibm_fez\")\n", "\n", "print(\n", " f\"Name: {backend.name}\\n\"\n", " f\"Version: {backend.backend_version}\\n\"\n", " f\"No. of programmable qubits: {backend.num_qubits}\\n\"\n", " f\"Processor type: {backend.processor_type}\\n\"\n", ")" ] }, { "cell_type": "markdown", "id": "99f2db6d-9d77-4330-9e3c-293153cd2f80", "metadata": {}, "source": [ "\n", "\n", "### Versioni QPU\n", "\n", "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.\n", "\n", "Il numero della versione di revisione aumenterà per le correzioni che non compromettono il circuito compilato esistente.\n", "\n", "L'esempio di codice riportato in precedenza in [questa sezione](#static-backend-information) 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](/computers) per aprire la scheda).\n", "\n", "Le condizioni alle quali un numero di versione o di revisione può cambiare sono elencate nella tabella seguente.\n", "\n", "| Versione principale | Versione secondaria | Versione revisionata |\n", "| -------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- |\n", "| Esempi di modifiche | Cicli di riscaldamento/defaticamento | Aggiornamenti software QPU |\n", "| Modifiche significative all'elettronica di controllo | Sostituzione di alcuni componenti elettronici, se la sostituzione influisce in modo significativo sul funzionamento | Calibrazioni manuali per migliorare la fedeltà |\n", "| Spostamento della QPU in una nuova posizione, se ne derivano cambiamenti significativi nel comportamento | Abbassamento di un cancello per un certo periodo di tempo a causa di problemi di calibrazione e impossibilità di effettuare correzioni tramite software | Piccole modifiche elettroniche che non influiscono sul funzionamento |\n", "| | Cambiare la direzione di un gate CNOT | |\n", "\n" ] }, { "cell_type": "markdown", "id": "42d83190-198e-4696-acb6-9cc5e57c49ab", "metadata": {}, "source": [ "\n", "\n", "\n", "\n", "### Istruzioni supportate\n", "\n", "Ogni [famiglia di processori](/docs/guides/processor-types) 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.\n", "\n", "È 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.\n", "\n", "\n", " \n", " \n", " \n", "\n", " \n", " Accedere alla pagina [Risorse di calcolo](/computers) per visualizzare una tabella di tutte le QPU, quindi fare clic sul nome di una QPU qualsiasi per aprire la scheda con le informazioni dettagliate. I gate di base per quella QPU sono elencati nella sezione Dettagli.\n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "### Tabella delle istruzioni supportate\n", "\n", "| Categoria operativa | Nome |\n", "| :---------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |\n", "| Porte a singolo qubit | [`RZ`](/docs/api/qiskit/qiskit.circuit.library.RZGate), [`SX`](/docs/api/qiskit/qiskit.circuit.library.SXGate), [`X`](/docs/api/qiskit/qiskit.circuit.library.XGate), [`ID`](/docs/api/qiskit/qiskit.circuit.library.IGate), [`delay`](/docs/api/qiskit/circuit#qiskit.circuit.Delay) |\n", "| Porte a due qubit | [`CZ`](/docs/api/qiskit/qiskit.circuit.library.CZGate), [`ECR`](/docs/api/qiskit/qiskit.circuit.library.ECRGate) |\n", "| Porte frazionarie | [`RX`](/docs/api/qiskit/qiskit.circuit.library.RXGate) (qubit singolo), [`RZZ`](/docs/api/qiskit/qiskit.circuit.library.RZZGate) (due qubit) |\n", "| Istruzioni non unitarie | [`measure`](/docs/api/qiskit/circuit#qiskit.circuit.Measure), [`reset`](/docs/api/qiskit/circuit#qiskit.circuit.Reset), [`measure_*`](/docs/guides/execute-dynamic-circuits#midcircuit), [`delay`](/docs/api/qiskit/circuit#delay) |\n", "| Flusso di controllo | [`if_else`](/docs/api/qiskit/qiskit.circuit.IfElseOp) (feedforward classico) |\n", "\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "1471a0cb-faf5-419d-9437-b9ecc9a87541", "metadata": { "tags": [ "id-gates" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Backend: ibm_kingston\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ " Processor type: {'family': 'Heron', 'revision': '2'}\n", " Supported instructions: ['cz', 'id', 'delay', 'measure', 'measure_2', 'reset', 'rz', 'sx', 'x', 'if_else', 'store']\n" ] } ], "source": [ "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", "service = QiskitRuntimeService()\n", "backend = service.backend(\"ibm_kingston\")\n", "\n", "print(f\"Backend: {backend.name}\")\n", "print(f\" Processor type: {backend.processor_type}\")\n", "print(f\" Supported instructions: {backend.supported_instructions}\")" ] }, { "cell_type": "markdown", "id": "693a91b6-5bd0-411f-ba83-be72d3732402", "metadata": {}, "source": [ "\n", "\n", "## Informazioni dinamiche sul backend\n", "\n", "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](/docs/guides/calibration-jobs).\n", "\n", "Su IBM Quantum Platform è possibile scaricare i dati di calibrazione come file CSV. Fare clic su una QPU nella pagina [Risorse di calcolo](/computers) per visualizzare la scheda informativa dettagliata, quindi fare clic sull'icona di download nell'angolo in alto a destra della sezione Dati di calibrazione.\n", "\n", "\n", " È possibile recuperare i dati storici delle proprietà del backend in Qiskit con il seguente codice:\n", "\n", " ```python\n", " backend.properties(datetime=)\n", " ```\n", "\n", "\n", "\n", "\n", "### Proprietà dei qubit\n", "\n", "[Vai all'elenco delle proprietà dei qubit](#view-qubit-properties)\n", "\n", "`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.\n", "\n", "I seguenti esempi di codice mostrano come elencare tutte le proprietà o recuperare proprietà specifiche di un particolare qubit.\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "#### Visualizza le proprietà dei qubit\n", "\n", "\n", "\n", "\n", " \n", " 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).\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "
Visualizza con Qiskit`backend.properties().t1()`
Visualizza su IBM Quantum PlatformSezione dei dati di calibrazione: menu a tendina “Qubit”; individuare il valore *mediano dell’ $T_1$ e nella sezione “Dettagli”*
\n", " \n", "\n", " \n", "\n", " \n", " 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.\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "
Visualizza con Qiskit`backend.properties().t2()`
Visualizza su IBM Quantum PlatformSezione dei dati di calibrazione: menu a tendina “Qubit”; individuare il valore *mediano dell’ $T_2$ e nella sezione “Dettagli”*
\n", " \n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "852d47b7-50c6-4fde-9d59-603825b3ec97", "metadata": { "tags": [ "id-properties" ] }, "outputs": [ { "data": { "text/plain": [ "QubitProperties(t1=0.00019233494213807877, t2=0.00023593910973864878, frequency=None)" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# fundamental physical properties of qubit 1\n", "\n", "backend = service.backend(\"ibm_fez\")\n", "\n", "backend.qubit_properties(1)" ] }, { "cell_type": "code", "execution_count": 8, "id": "6ec8f609-9542-4f9e-8a68-0829627211b7", "metadata": { "tags": [ "id-properties2" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Qubit 126 Properties:\n", " T1: 1.6203279905573543e-05 seconds\n", " T2: 2.7965850265833494e-05 seconds\n", " Readout Error: 0.0601806640625\n", " P(0 | 1): 0.0908203125\n", " P(1 | 0): 0.029541015625\n", " Readout Length: 1.66e-06 seconds\n" ] } ], "source": [ "# Retrieve qubit properties\n", "qubit_index = 126 # Replace with your qubit index\n", "qubit_props = backend.properties().qubit_property(qubit_index)\n", "\n", "# Access specific properties\n", "t1 = qubit_props.get(\"T1\", (None,))[0]\n", "t2 = qubit_props.get(\"T2\", (None,))[0]\n", "readout_error = qubit_props.get(\"readout_error\", (None,))[0]\n", "prob_meas0_prep1 = qubit_props.get(\"prob_meas0_prep1\", (None,))[0]\n", "prob_meas1_prep0 = qubit_props.get(\"prob_meas1_prep0\", (None,))[0]\n", "readout_length = qubit_props.get(\"readout_length\", (None,))[0]\n", "\n", "print(f\"Qubit {qubit_index} Properties:\")\n", "print(f\" T1: {t1} seconds\")\n", "print(f\" T2: {t2} seconds\")\n", "print(f\" Readout Error: {readout_error}\")\n", "print(f\" P(0 | 1): {prob_meas0_prep1}\")\n", "print(f\" P(1 | 0): {prob_meas1_prep0}\")\n", "print(f\" Readout Length: {readout_length} seconds\")" ] }, { "cell_type": "markdown", "id": "2d045537-c8f4-4297-852f-b26311d4640d", "metadata": {}, "source": [ "\n", "\n", "### Proprietà delle istruzioni\n", "\n", "[Vai all'elenco delle proprietà delle istruzioni](#view-instruction-properties)\n", "\n", "L'attributo `backend.target` è un [`qiskit.transpiler.Target`](/docs/api/qiskit/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](/docs/api/qiskit/qiskit.circuit.library.CZGate) che agisce tra i qubit 1 e 0.\n", "\n", "\n", "\n", "La cella seguente mostra le proprietà di un'operazione di misurazione (compreso l'errore di lettura) sul qubit 0.\n", "\n", "\n", "\n", "\n", "\n", "#### Visualizza le proprietà delle istruzioni\n", "\n", "\n", " \n", "\n", " \n", " 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.\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "
Visualizza con Qiskit`backend.properties().qubit_property(, 'prob_meas0_prep1')`
Visualizza su IBM Quantum PlatformSezione dei dati di calibrazione: menu a tendina \"Qubit\"
\n", " \n", "\n", " \n", "\n", " \n", " 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.\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "
Visualizza con Qiskit`backend.properties().qubit_property(, 'prob_meas0_prep0')`
Visualizza su IBM Quantum PlatformSezione dei dati di calibrazione: menu a tendina \"Qubit\"
\n", " \n", "\n", " \n", "\n", " \n", " L'errore a due qubit per bordo dallo stesso lotto di misurazioni utilizzato per calcolare l'errore [mediano dell' 2Q](#2q-error-median). **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.\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "
Visualizza con Qiskit`backend.target[''][, ]`
Visualizza su IBM Quantum PlatformSezione 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
\n", " \n", "\n", " \n", "\n", " \n", " [Fedeltà media del gate](/docs/api/qiskit/quantum_info#average_gate_fidelity) 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.\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "
Calcola con QiskitSegui l'esempio riportato in questo [notebook della comunità Qiskit GitHub](https://github.com/qiskit-community/qiskit-device-benchmarking/blob/main/notebooks/device_rb_w_lf.ipynb)
Visualizza su IBM Quantum PlatformSezione Dettagli; trova anche i dati per bordo nella sezione Dati di calibrazione
\n", " \n", "\n", " \n", "\n", " \n", " 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](https://arxiv.org/abs/2311.05933) (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.\n", "\n", " 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.\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "
Calcola con QiskitSegui l'esempio riportato in questo [notebook della comunità Qiskit GitHub](https://github.com/qiskit-community/qiskit-device-benchmarking/blob/main/notebooks/layer_fidelity_single_chain.ipynb)
Visualizza su IBM Quantum PlatformSezione Dettagli e una vista ampliata nella sezione Errore di gate a due qubit (a strati)
\n", " \n", "\n", " \n", "\n", " \n", " Errore nel gate RZZ mediato sugli angoli RZZ utilizzando una variante del benchmarking randomizzato per unitaries arbitrari.\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "
Visualizza con QiskitImportante: assicurati di aver impostato `use_fractional_gates=True` quando carichi il backend, quindi puoi utilizzare `backend.target['rzz'][, ]`
Visualizza su IBM Quantum PlatformSezione 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
\n", " \n", "\n", " \n", "\n", " \n", " 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.\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "
Visualizza con Qiskit`backend.target[''][,]`
Visualizza su IBM Quantum PlatformSezione Calibrazione: menu a tendina Qubit
\n", " \n", "\n", " \n", "\n", " \n", " [Fedeltà media](/docs/api/qiskit/quantum_info#average_gate_fidelity) 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.\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
Visualizza su IBM Quantum PlatformSezione dettagli
\n", " \n", "\n", " \n", "\n", " \n", " Errore nel gate virtuale RZ. Segnalati come tutti 0 poiché vengono eseguiti nel software.\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "
Visualizza con Qiskit `backend.target[''][,]`
Visualizza su IBM Quantum PlatformSezione Calibrazione: menu a tendina Connessione
\n", " \n", "\n", " \n", "\n", " \n", " 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à.\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "
Visualizza con Qiskit`backend.properties().readout_error()`
Visualizza su IBM Quantum PlatformSezione dei dati di calibrazione: menu a tendina \"Qubit\"
\n", " \n", "\n", " \n", "\n", " \n", " 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.\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
Visualizza su IBM Quantum PlatformSezione \"Dati di calibrazione\": Sezione \"Dettagli\"
\n", " \n", "\n", " \n", "\n", " \n", " 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.\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "
Visualizza con Qiskit`backend.target[''][,].duration`
Visualizza su IBM Quantum PlatformSezione Calibrazione: menu a tendina Qubit
\n", " \n", "\n", " \n", "\n", " \n", " 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.\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "
Visualizza con Qiskit`backend.target[''][, ].duration`
Visualizza su IBM Quantum PlatformSezione Calibrazione: menu a tendina Qubit
\n", " \n", "\n", " \n", "\n", " \n", " 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.\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "
Visualizza con Qiskit
  • Per `measure`: `backend.properties().readout_length()`
  • Per `measure_2`: `backend.target['measure_2'][,].duration`
Visualizza su IBM Quantum PlatformSezione dei dati di calibrazione: menu a tendina \"Qubit\"
\n", " \n", "\n", " \n", "\n", " \n", " 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,](/docs/guides/repetition-rate-execution) quando l'esperimento precedente aveva preparato il qubit nello stato $|1\\rangle$. Si noti che questa grandezza è leggermente diversa dalla [`prob_meas1_prep0`](#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.\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "
Visualizza con Qiskit`backend.properties().qubit_property(, 'init_error')`
Visualizza su IBM Quantum PlatformSezione dei dati di calibrazione: menu a tendina \"Qubit\"
\n", " \n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "af5e4fc7-8c6c-4f8a-acc9-2a40802d2fa9", "metadata": { "tags": [ "id-instructions" ] }, "outputs": [ { "data": { "text/plain": [ "InstructionProperties(duration=6.8e-08, error=0.007988386842696815)" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "backend.target[\"cz\"][(1, 0)]" ] }, { "cell_type": "code", "execution_count": 10, "id": "9837a240-b649-4117-b795-22c47c2a9b6a", "metadata": { "tags": [ "id-instructions1" ] }, "outputs": [ { "data": { "text/plain": [ "InstructionProperties(duration=1.66e-06, error=0.00927734375)" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "backend.target[\"measure\"][(0,)]" ] }, { "cell_type": "markdown", "id": "251f8748-7a6d-4e87-b0f5-8acb91048b36", "metadata": {}, "source": [ "\n", "\n", "### Proprietà aggiuntive\n", "\n", "\n", "\n", "\n", " \n", " 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.\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "
Visualizza con Qiskit`mcps = backend.configuration().mcps`
Visualizza su IBM Quantum PlatformSezione dettagli
\n", " \n", "\n", " \n", "\n", " \n", " 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.\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "
Calcola con QiskitTrova il [codice CLOPS](https://github.com/qiskit-community/qiskit-device-benchmarking/tree/main/qiskit_device_benchmarking/clops#readme) nella comunità Qiskit GitHub
Visualizza su IBM Quantum PlatformSezione dettagli
\n", " \n", "\n", " \n", "\n", " \n", " Con [`BackendStatus`](/docs/api/qiskit-ibm-runtime/models-backend-status), è possibile trovare lo stato della QPU (ad esempio, `Active`, `Paused`, `Offline`) e il numero di lavori in sospeso.\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "
Visualizza con Qiskit`print(backend.status().status_msg)`, `print(backend.status().pending_jobs)`
Visualizza su IBM Quantum PlatformSezione dettagli
\n", " \n", "\n", " \n", "\n", " \n", " 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.\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", "
Visualizza con Qiskit`from qiskit.visualization import plot_gate_map` allora `plot_gate_map(backend)`
Visualizza su IBM Quantum PlatformSezione dati di calibrazione; clicca su Espandi per ingrandire la visualizzazione
\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "b054f39f-d3fc-4060-81c6-6ceba4bf8045", "metadata": {}, "source": [ "\n", " Se il benchmarking di un qubit o di un bordo non va a buon fine nel corso di diversi giorni, a causa della scarsa qualità dei dati o di altri fattori interni, il valore di errore segnalato viene considerato obsoleto e verrà riportato come 1. Ciò non significa che il qubit o il bordo siano necessariamente non funzionanti o che l'errore sia 1; piuttosto, l'errore è considerato indefinito e occorre procedere con cautela quando si utilizza quel qubit o gate.\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "ddeb876a-5260-4b32-83d6-b954c1bd2b9f", "metadata": {}, "source": [ "\n", "\n", "## Passi successivi\n", "\n", "\n", " * Impara a [costruire modelli di rumore](/docs/guides/build-noise-models) per eseguire simulazioni classiche rumorose.\n", " * Consulta l'argomento [Fasi del](/docs/guides/transpiler-stages) transpiler per scoprire come il transpiler utilizza le proprietà del backend per l'ottimizzazione dei circuiti.\n", " * Consulta la guida di riferimento [dell'API backend](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#backend) di QiskitRuntime.\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "id": "a1b8767d", "source": "© IBM Corp., 2017-2026" } ], "metadata": { "in_page_toc_max_heading_level": 2, "in_page_toc_min_heading_level": 2, "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3" } }, "nbformat": 4, "nbformat_minor": 4 }