{
"cells": [
{
"cell_type": "markdown",
"id": "fad91a68",
"metadata": {},
"source": [
"---\n",
"title: \"Mitigazione degli errori\"\n",
"description: \"Nel corso di questa lezione, esamineremo il rumore e come può essere mitigato sui computer quantistici.\"\n",
"---\n",
"\n",
"\n",
"\n",
"# Rumore quantistico e mitigazione degli errori\n",
"\n",
"\n",
" Toshinari Itoko (28 giugno 2024)\n",
"\n",
" [Scarica il pdf](https://ibm.ent.box.com/public/static/a0zgies7bh91hm2lwev9o0bfeybxc6n6.zip) della lezione originale. Si noti che alcuni frammenti di codice potrebbero diventare deprecati, poiché si tratta di immagini statiche.\n",
"\n",
" *Il tempo approssimativo della QPU per eseguire questo esperimento è di 1 m 40 s.*\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "e936adb0-bc31-41a8-b988-02ce7e68b902",
"metadata": {},
"source": [
"\n",
"\n",
"## 1. Introduzione\n",
"\n",
"Nel corso di questa lezione esamineremo il rumore e il modo in cui può essere attenuato nei computer quantistici. Inizieremo ad analizzare gli effetti del rumore utilizzando un simulatore che può simulare il rumore in vari modi, tra cui l'utilizzo di profili di rumore provenienti da computer quantistici reali. Poi passeremo ai veri computer quantistici, nei quali il rumore è intrinseco. Verranno esaminati gli effetti della mitigazione degli errori, comprese le combinazioni di elementi come l'estrapolazione a rumore zero (ZNE) e il gate-twirling.\n",
"\n",
"Inizieremo caricando alcuni pacchetti.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "38cf024b",
"metadata": {},
"outputs": [],
"source": [
"# !pip install qiskit qiskit_aer qiskit_ibm_runtime\n",
"# !pip install jupyter\n",
"# !pip install matplotlib pylatexenc"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "897008ea",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'2.0.2'"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import qiskit\n",
"\n",
"qiskit.__version__"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "486b4d35",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'0.17.1'"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import qiskit_aer\n",
"\n",
"qiskit_aer.__version__"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "994c44e5",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'0.40.1'"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import qiskit_ibm_runtime\n",
"\n",
"qiskit_ibm_runtime.__version__"
]
},
{
"cell_type": "markdown",
"id": "ee48a826-fda3-4fb4-b50b-d69c38eb887f",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": "slide"
},
"tags": []
},
"source": [
"\n",
"\n",
"## 2. Simulazione rumorosa senza mitigazione degli errori\n",
"\n",
"Qiskit Aer è un simulatore classico per il calcolo quantistico. Può simulare non solo l'esecuzione ideale, ma anche l'esecuzione rumorosa di circuiti quantistici. Questo notebook mostra come eseguire una simulazione rumorosa utilizzando Qiskit Aer:\n",
"\n",
"1. Costruire un modello di rumore\n",
"2. Costruire un campionatore rumoroso (simulatore) con il modello di rumore\n",
"3. Eseguire un circuito quantistico sul campionatore rumoroso\n",
"\n",
"```\n",
"noise_model = NoiseModel()\n",
"...\n",
"noisy_sampler = Sampler(options={\"backend_options\": {\"noise_model\": noise_model}})\n",
"job = noisy_sampler.run([circuit])\n",
"```\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "d1490ab8",
"metadata": {},
"source": [
"\n",
"\n",
"### 2.1 Costruisci un circuito di prova\n",
"\n",
"Consideriamo circuiti giocattolo a 1 qubit che ripetono semplicemente X porte `d` volte (`d`=0... 100) e misurare l'osservabile `Z` .\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "b4863c66",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"from qiskit.circuit import QuantumCircuit\n",
"\n",
"MAX_DEPTH = 100\n",
"circuits = []\n",
"for d in range(MAX_DEPTH + 1):\n",
" circ = QuantumCircuit(1)\n",
" for _ in range(d):\n",
" circ.x(0)\n",
" circ.barrier(0)\n",
" circ.measure_all()\n",
" circuits.append(circ)\n",
"\n",
"display(circuits[3].draw(output=\"mpl\"))"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "a366502c",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"SparsePauliOp(['Z'],\n",
" coeffs=[1.+0.j])"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.quantum_info import SparsePauliOp\n",
"\n",
"obs = SparsePauliOp.from_list([(\"Z\", 1.0)])\n",
"obs"
]
},
{
"cell_type": "markdown",
"id": "6200c2ed",
"metadata": {},
"source": [
"\n",
"\n",
"### 2.2 Costruire un modello di rumore\n",
"\n",
"Per effettuare una simulazione rumorosa, è necessario specificare `NoiseModel`. In questa sezione mostriamo come costruire `NoiseModel` .\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "dae0c070",
"metadata": {},
"source": [
"Occorre innanzitutto definire gli errori quantistici (o di lettura) da aggiungere a un modello di rumore.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "1e0f1c12",
"metadata": {},
"outputs": [],
"source": [
"from qiskit_aer.noise.errors import (\n",
" coherent_unitary_error,\n",
" amplitude_damping_error,\n",
" ReadoutError,\n",
")\n",
"from qiskit.circuit.library import RXGate\n",
"\n",
"# Coherent (unitary) error: Over X-rotation error\n",
"# https://qiskit.github.io/qiskit-aer/stubs/qiskit_aer.noise.coherent_unitary_error.html#qiskit_aer.noise.coherent_unitary_error\n",
"OVER_ROTATION_ANGLE = 0.05\n",
"coherent_error = coherent_unitary_error(RXGate(OVER_ROTATION_ANGLE).to_matrix())\n",
"\n",
"# Incoherent error: Amplitude dumping error\n",
"# https://qiskit.github.io/qiskit-aer/stubs/qiskit_aer.noise.amplitude_damping_error.html#qiskit_aer.noise.amplitude_damping_error\n",
"AMPLITUDE_DAMPING_PARAM = 0.02 # in [0, 1] (0: no error)\n",
"incoherent_error = amplitude_damping_error(AMPLITUDE_DAMPING_PARAM)\n",
"\n",
"# Readout (measurement) error: Readout error\n",
"# https://qiskit.github.io/qiskit-aer/stubs/qiskit_aer.noise.ReadoutError.html#qiskit_aer.noise.ReadoutError\n",
"PREP0_MEAS1 = 0.03 # P(1|0): Probability of preparing 0 and measuring 1\n",
"PREP1_MEAS0 = 0.08 # P(0|1): Probability of preparing 1 and measuring 0\n",
"readout_error = ReadoutError(\n",
" [[1 - PREP0_MEAS1, PREP0_MEAS1], [PREP1_MEAS0, 1 - PREP1_MEAS0]]\n",
")"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "e23c26ba",
"metadata": {},
"outputs": [],
"source": [
"from qiskit_aer.noise import NoiseModel\n",
"\n",
"noise_model = NoiseModel()\n",
"noise_model.add_quantum_error(coherent_error.compose(incoherent_error), \"x\", (0,))\n",
"noise_model.add_readout_error(readout_error, (0,))"
]
},
{
"cell_type": "markdown",
"id": "5a786224",
"metadata": {},
"source": [
"\n",
"\n",
"### 2.3 Costruisci un campionatore rumoroso con il modello di rumore\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "f8aded6f",
"metadata": {},
"outputs": [],
"source": [
"from qiskit_aer.primitives import SamplerV2 as Sampler\n",
"\n",
"noisy_sampler = Sampler(options={\"backend_options\": {\"noise_model\": noise_model}})"
]
},
{
"cell_type": "markdown",
"id": "922ba1ac",
"metadata": {},
"source": [
"\n",
"\n",
"### 2.4 Esegui circuiti quantistici sul campionatore rumoroso\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "4ae504e7",
"metadata": {},
"outputs": [],
"source": [
"job = noisy_sampler.run(circuits, shots=400)"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "3b2fff25",
"metadata": {},
"outputs": [],
"source": [
"result = job.result()"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "4dc12337",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'0': 389, '1': 11}"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"result[0].data.meas.get_counts()"
]
},
{
"cell_type": "markdown",
"id": "7e654c5e",
"metadata": {},
"source": [
"\n",
"\n",
"### 2.5 Risultati del grafico\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1a25e394",
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"\n",
"plt.title(\"Noisy simulation\")\n",
"ds = list(range(MAX_DEPTH + 1))\n",
"plt.plot(\n",
" ds,\n",
" [result[d].data.meas.expectation_values([\"Z\"]) for d in ds],\n",
" color=\"gray\",\n",
" linestyle=\"-\",\n",
")\n",
"plt.scatter(ds, [result[d].data.meas.expectation_values([\"Z\"]) for d in ds], marker=\"o\")\n",
"plt.hlines(0, xmin=0, xmax=MAX_DEPTH, colors=\"black\")\n",
"plt.ylim(-1, 1)\n",
"plt.xlabel(\"Circuit depth\")\n",
"plt.ylabel(\"Measured \")\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "09ef68bb",
"metadata": {},
"source": [
"\n",
"\n",
"### 2.6 Simulazione ideale\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "041abc81",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"ideal_sampler = Sampler()\n",
"job_ideal = ideal_sampler.run(circuits)\n",
"result_ideal = job_ideal.result()\n",
"plt.title(\"Ideal simulation\")\n",
"ds = list(range(MAX_DEPTH + 1))\n",
"plt.plot(\n",
" ds,\n",
" [result_ideal[d].data.meas.expectation_values([\"Z\"]) for d in ds],\n",
" color=\"gray\",\n",
" linestyle=\"-\",\n",
")\n",
"plt.scatter(\n",
" ds, [result_ideal[d].data.meas.expectation_values([\"Z\"]) for d in ds], marker=\"o\"\n",
")\n",
"plt.hlines(0, xmin=0, xmax=MAX_DEPTH, colors=\"black\")\n",
"plt.xlabel(\"Circuit depth\")\n",
"plt.ylabel(\"Measured \")\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "a1e1b6e6",
"metadata": {},
"source": [
"\n",
"\n",
"### 2.7 Esercizio fisico\n",
"\n",
"Modificando il codice sottostante,\n",
"\n",
"* [ ] Provare 25x numero di scatti (= 10\\_000 scatti) e assicurarsi che si ottenga un grafico più omogeneo\n",
"* [ ] Modificare i parametri del rumore (OVER\\_ROTATION\\_ANGLE, AMPLITUDE\\_DAMPING\\_PARAM, PREP0\\_MEAS1, o PREP1\\_MEAS0 ) e vedere come cambia il grafico\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "502b9cfe",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"OVER_ROTATION_ANGLE = 0.05\n",
"coherent_error = coherent_unitary_error(RXGate(OVER_ROTATION_ANGLE).to_matrix())\n",
"AMPLITUDE_DAMPING_PARAM = 0.02 # in [0, 1] (0: no error)\n",
"incoherent_error = amplitude_damping_error(AMPLITUDE_DAMPING_PARAM)\n",
"PREP0_MEAS1 = 0.1 # P(1|0): Probability of preparing 0 and measuring 1\n",
"PREP1_MEAS0 = 0.05 # P(0|1): Probability of preparing 1 and measuring 0\n",
"readout_error = ReadoutError(\n",
" [[1 - PREP0_MEAS1, PREP0_MEAS1], [PREP1_MEAS0, 1 - PREP1_MEAS0]]\n",
")\n",
"noise_model = NoiseModel()\n",
"noise_model.add_quantum_error(coherent_error.compose(incoherent_error), \"x\", (0,))\n",
"noise_model.add_readout_error(readout_error, (0,))\n",
"options = {\n",
" \"backend_options\": {\"noise_model\": noise_model},\n",
"}\n",
"noisy_sampler = Sampler(options=options)\n",
"job = noisy_sampler.run(circuits, shots=400)\n",
"result = job.result()\n",
"plt.title(\"Noisy simulation\")\n",
"ds = list(range(MAX_DEPTH + 1))\n",
"plt.plot(\n",
" ds,\n",
" [result[d].data.meas.expectation_values([\"Z\"]) for d in ds],\n",
" marker=\"o\",\n",
" linestyle=\"-\",\n",
")\n",
"plt.hlines(0, xmin=0, xmax=MAX_DEPTH, colors=\"black\")\n",
"plt.ylim(-1, 1)\n",
"plt.xlabel(\"Depth\")\n",
"plt.ylabel(\"Measured \")\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "3cfe1a93",
"metadata": {},
"source": [
"\n",
"\n",
"### 2.8 Simulazione rumorosa più realistica\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8d607bb5",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit_aer import AerSimulator\n",
"from qiskit_ibm_runtime import SamplerV2 as Sampler, QiskitRuntimeService\n",
"\n",
"service = QiskitRuntimeService()\n",
"real_backend = service.least_busy(\n",
" operational=True, simulator=False, min_num_qubits=127\n",
") # Eagle"
]
},
{
"cell_type": "code",
"execution_count": 19,
"id": "81a67f2f",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"aer = AerSimulator.from_backend(real_backend)\n",
"noisy_sampler = Sampler(mode=aer)\n",
"job = noisy_sampler.run(circuits)\n",
"result = job.result()\n",
"plt.title(\"Noisy simulation with noise model from real backend\")\n",
"ds = list(range(MAX_DEPTH + 1))\n",
"plt.plot(\n",
" ds,\n",
" [result[d].data.meas.expectation_values([\"Z\"]) for d in ds],\n",
" marker=\"o\",\n",
" linestyle=\"-\",\n",
")\n",
"plt.hlines(0, xmin=0, xmax=MAX_DEPTH, colors=\"black\")\n",
"plt.ylim(-1, 1)\n",
"plt.xlabel(\"Depth\")\n",
"plt.ylabel(\"Measured \")\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "567d30e9",
"metadata": {},
"source": [
"\n",
"\n",
"## 3. Calcolo quantistico reale con mitigazione degli errori\n",
"\n",
"In questa parte, dimostriamo come ottenere risultati mitigati dall'errore (valori di aspettativa) utilizzando Qiskit Estimator.\n",
"Consideriamo circuiti trotterizzati a 6-qubit per simulare l'evoluzione temporale del modello di Ising unidimensionale e vediamo come l'errore scala rispetto al numero di passi temporali.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "2d301499",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"backend = service.least_busy(\n",
" operational=True, simulator=False, min_num_qubits=127\n",
") # Eagle\n",
"backend"
]
},
{
"cell_type": "code",
"execution_count": 21,
"id": "6c90b89c",
"metadata": {},
"outputs": [],
"source": [
"NUM_QUBITS = 6\n",
"NUM_TIME_STEPS = list(range(8))\n",
"RX_ANGLE = 0.1\n",
"RZZ_ANGLE = 0.1"
]
},
{
"cell_type": "markdown",
"id": "b1489739",
"metadata": {},
"source": [
"\n",
"\n",
"### 3.1 Costruire circuiti\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"id": "1a77956e",
"metadata": {},
"outputs": [],
"source": [
"# Build circuits with different number of time steps\n",
"circuits = []\n",
"for n_steps in NUM_TIME_STEPS:\n",
" circ = QuantumCircuit(NUM_QUBITS)\n",
" for i in range(n_steps):\n",
" # rx layer\n",
" for q in range(NUM_QUBITS):\n",
" circ.rx(RX_ANGLE, q)\n",
" # 1st rzz layer\n",
" for q in range(1, NUM_QUBITS - 1, 2):\n",
" circ.rzz(RZZ_ANGLE, q, q + 1)\n",
" # 2nd rzz layer\n",
" for q in range(0, NUM_QUBITS - 1, 2):\n",
" circ.rzz(RZZ_ANGLE, q, q + 1)\n",
" circ.barrier() # need not to optimize the circuit\n",
" # Uncompute stage\n",
" for i in range(n_steps):\n",
" for q in range(0, NUM_QUBITS - 1, 2):\n",
" circ.rzz(-RZZ_ANGLE, q, q + 1)\n",
" for q in range(1, NUM_QUBITS - 1, 2):\n",
" circ.rzz(-RZZ_ANGLE, q, q + 1)\n",
" for q in range(NUM_QUBITS):\n",
" circ.rx(-RX_ANGLE, q)\n",
" circuits.append(circ)"
]
},
{
"cell_type": "markdown",
"id": "94eb9062",
"metadata": {},
"source": [
"Per conoscere in anticipo l'uscita ideale, utilizziamo circuiti di calcolo-non calcolo che consistono in un primo stadio in cui viene applicato il circuito originale $U$ e in un secondo stadio in cui viene invertito $U^\\dagger$. Si noti che il risultato ideale di tali circuiti sarà banalmente lo stato di ingresso $|000000\\rangle$, che ha i valori di aspettativa banali per qualsiasi osservabile di Pauli, ad esempio $\\langle IIIIIZ \\rangle = 1$.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 23,
"id": "20296b5a",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Print the circuit with 2 time steps\n",
"circuits[2].draw(output=\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "cde8d3ea",
"metadata": {},
"source": [
"Nota: come mostrato sopra, il circuito con $k$ passi temporali avrà $4k$ strati di gate a due-qubit.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 24,
"id": "af0d03e9",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"SparsePauliOp(['IIIIIZ'],\n",
" coeffs=[1.+0.j])"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"obs = SparsePauliOp.from_sparse_list([(\"Z\", [0], 1.0)], num_qubits=NUM_QUBITS)\n",
"obs"
]
},
{
"cell_type": "markdown",
"id": "ebd6ea9b",
"metadata": {},
"source": [
"\n",
"\n",
"### 3.2 Traspila i circuiti\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "8eaa552e",
"metadata": {},
"source": [
"Trasponiamo i circuiti per il backend con l'ottimizzazione (`optimization_level=1`).\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 25,
"id": "87b861e2",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n",
"\n",
"pm = generate_preset_pass_manager(optimization_level=1, backend=backend)\n",
"isa_circuits = pm.run(circuits)\n",
"display(isa_circuits[2].draw(\"mpl\", idle_wires=False, fold=-1))"
]
},
{
"cell_type": "markdown",
"id": "743ad427",
"metadata": {},
"source": [
"\n",
"\n",
"### 3.3 Eseguire utilizzando Estimator (con diversi livelli di resilienza)\n",
"\n",
"Impostare il livello di resilienza (`estimator.options.resilience_level`) è il modo più semplice per applicare la mitigazione degli errori quando si utilizza Qiskit Estimator. Estimator supporta i seguenti livelli di resilienza (al 28/06/2024). Per ulteriori dettagli, consulta la guida [alla](/docs/guides/error-mitigation-and-suppression-techniques) configurazione della mitigazione degli errori.\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 27,
"id": "328f71f2",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Job ID (rl=0): d146vcnmya70008emprg\n",
"Job ID (rl=1): d146vdnqf56g0081sva0\n",
"Job ID (rl=2): d146ven5z6q00087c61g\n"
]
}
],
"source": [
"from qiskit_ibm_runtime import Batch\n",
"from qiskit_ibm_runtime import EstimatorV2 as Estimator\n",
"\n",
"jobs = []\n",
"job_ids = []\n",
"with Batch(backend=backend):\n",
" for resilience_level in [0, 1, 2]:\n",
" estimator = Estimator()\n",
" estimator.options.resilience_level = resilience_level\n",
" job = estimator.run(\n",
" [(circ, obs.apply_layout(circ.layout)) for circ in isa_circuits]\n",
" )\n",
" job_ids.append(job.job_id())\n",
" print(f\"Job ID (rl={resilience_level}): {job.job_id()}\")\n",
" jobs.append(job)"
]
},
{
"cell_type": "code",
"execution_count": 31,
"id": "1dd804e4-0d7d-4782-9559-7b3796cab121",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"DONE\n",
"DONE\n",
"DONE\n"
]
}
],
"source": [
"# check job status\n",
"for job in jobs:\n",
" print(job.status())"
]
},
{
"cell_type": "code",
"execution_count": 32,
"id": "d138e1e9",
"metadata": {},
"outputs": [],
"source": [
"# REPLACE WITH YOUR OWN JOB IDS\n",
"jobs = [service.job(job_id) for job_id in job_ids]"
]
},
{
"cell_type": "code",
"execution_count": 33,
"id": "ea820e98",
"metadata": {},
"outputs": [],
"source": [
"# Get results\n",
"results = [job.result() for job in jobs]"
]
},
{
"cell_type": "markdown",
"id": "e3691462",
"metadata": {},
"source": [
"\n",
"\n",
"### 3.4 Risultati del grafico\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 34,
"id": "7527976e",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plt.title(\"Error mitigation with different resilience levels\")\n",
"labels = [\"0 (No mitigation)\", \"1 (TREX)\", \"2 (ZNE + Gate twirling)\"]\n",
"steps = NUM_TIME_STEPS\n",
"for result, label in zip(results, labels):\n",
" plt.errorbar(\n",
" x=steps,\n",
" y=[result[s].data.evs for s in steps],\n",
" yerr=[result[s].data.stds for s in steps],\n",
" marker=\"o\",\n",
" linestyle=\"-\",\n",
" capsize=4,\n",
" label=label,\n",
" )\n",
"plt.hlines(\n",
" 1.0, min(steps), max(steps), linestyle=\"dashed\", label=\"Ideal\", colors=\"black\"\n",
")\n",
"plt.xlabel(\"Time steps\")\n",
"plt.ylabel(\"Mitigated \")\n",
"plt.legend()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "e4def30b",
"metadata": {},
"source": [
"\n",
"\n",
"## 4. (Facoltativo) Personalizza le opzioni di mitigazione degli errori\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "f099e16c",
"metadata": {},
"source": [
"È possibile personalizzare l'applicazione delle tecniche di mitigazione degli errori tramite le opzioni illustrate di seguito.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 35,
"id": "a22e6b8c",
"metadata": {},
"outputs": [],
"source": [
"# TREX\n",
"estimator.options.twirling.enable_measure = True\n",
"estimator.options.twirling.num_randomizations = \"auto\"\n",
"estimator.options.twirling.shots_per_randomization = \"auto\"\n",
"\n",
"# Gate twirling\n",
"estimator.options.twirling.enable_gates = True\n",
"# ZNE\n",
"estimator.options.resilience.zne_mitigation = True\n",
"estimator.options.resilience.zne.noise_factors = [1, 3, 5]\n",
"estimator.options.resilience.zne.extrapolator = (\"exponential\", \"linear\")\n",
"\n",
"# Dynamical decoupling\n",
"estimator.options.dynamical_decoupling.enable = True # Default: False\n",
"estimator.options.dynamical_decoupling.sequence_type = \"XX\"\n",
"\n",
"# Other options\n",
"estimator.options.default_shots = 10_000"
]
},
{
"cell_type": "markdown",
"id": "79dd06fb",
"metadata": {},
"source": [
"Per i dettagli sulle opzioni di attenuazione degli errori, consultare le seguenti guide e il riferimento API.\n",
"\n",
"* [Configurare la mitigazione degli errori](/docs/guides/error-mitigation-and-suppression-techniques)\n",
"* [Introduzione alle opzioni](/docs/guides/runtime-options-overview)\n",
"* [EstimatorOptions](/docs/api/qiskit-ibm-runtime/options-estimator-options)\n",
"* [SamplerOptions](/docs/api/qiskit-ibm-runtime/options-sampler-options)\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"id": "a1b8767d",
"source": "© IBM Corp., 2017-2026"
}
],
"metadata": {
"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"
},
"widgets": {
"application/vnd.jupyter.widget-state+json": {
"state": {},
"version_major": 2,
"version_minor": 0
}
}
},
"nbformat": 4,
"nbformat_minor": 5
}