scnc
/
qiskit-documentation
mirror of https://github.com/Qiskit/documentation.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
qiskit-documentation/translations/ja/verify/building_noise_models.ipynb

912 lines
117 KiB
Plaintext
Raw Blame History

{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Build noise models\n",
"\n",
"This page shows how to use the Qiskit Aer [`noise`](https://qiskit.org/ecosystem/aer/apidocs/aer_noise.html) module to build noise models for simulating quantum circuits in the presence of errors. This is useful for emulating noisy quantum processors and for studying the effects of noise on the execution of quantum algorithms."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"ExecuteTime": {
"end_time": "2019-08-19T17:00:43.403378Z",
"start_time": "2019-08-19T17:00:41.139269Z"
}
},
"outputs": [],
"source": [
"import numpy as np\n",
"from qiskit import QuantumCircuit\n",
"from qiskit.quantum_info import Kraus, SuperOp\n",
"from qiskit.tools.visualization import plot_histogram\n",
"from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n",
"from qiskit_aer import AerSimulator\n",
"\n",
"# Import from Qiskit Aer noise module\n",
"from qiskit_aer.noise import (\n",
" NoiseModel,\n",
" QuantumError,\n",
" ReadoutError,\n",
" depolarizing_error,\n",
" pauli_error,\n",
" thermal_relaxation_error,\n",
")"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Qiskit Aer `noise` module\n",
"\n",
"The Qiskit Aer `noise` module contains Python classes to build customized noise models for simulation. There are three key classes:\n",
"\n",
"1. The `NoiseModel` class which stores a noise model used for noisy simulation.\n",
"2. The `QuantumError` class which describes CPTP gate errors. These can be applied:\n",
" * After *gate* or *reset* instructions\n",
" * Before *measure* instructions.\n",
"\n",
"3. The `ReadoutError` class which describes classical readout errors."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Initializing a noise model from a backend\n",
"\n",
"You can initialize a noise model with parameters set from the latest calibration data for a physical backend:"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"from qiskit_ibm_runtime import QiskitRuntimeService\n",
"\n",
"service = QiskitRuntimeService()\n",
"backend = service.backend(\"ibm_brisbane\")\n",
"noise_model = NoiseModel.from_backend(backend)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This will yield a noise model that roughly approximates the errors one would encounter when using that backend. If you want to have more detailed control over the parameters of the noise model, then you'll need to create your own noise model, as described in the rest of this page."
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## Quantum Errors\n",
"\n",
"Rather than deal with the `QuantumError` object directly, many helper functions exist to automatically generate a specific type of parameterized quantum error. These are contained in the `noise` module and include functions for many common errors types used in quantum computing research. The function names and the type of error they return are:\n",
"\n",
"| Standard error function | Details |\n",
"| --- | --- |\n",
"| `kraus_error` | a general n-qubit CPTP error channel given as a list of Kraus matrices $[K_0, ...]$. |\n",
"| `mixed_unitary_error` | an n-qubit mixed unitary error given as a list of unitary matrices and probabilities $[(U_0, p_0),...]$. |\n",
"| `coherent_unitary_error` | an n-qubit coherent unitary error given as a single unitary matrix $U$. |\n",
"| `pauli_error` | an n-qubit Pauli error channel (mixed unitary) given as a list of Pauli's and probabilities $[(P_0, p_0),...]$ |\n",
"| `depolarizing_error` | an n-qubit depolarizing error channel parameterized by a depolarization probability $p$. |\n",
"| `reset_error` | a single-qubit reset error parameterized by a probabilities $p_0, p_1$ of resetting to the $|0\\rangle$, $|1\\rangle$ state.|\n",
"| `thermal_relaxation_error` | a single qubit thermal relaxation channel parameterized by relaxation time constants $T_1$, $T_2$, gate time $t$, and excited state thermal population $p_1$. |\n",
"| `phase_amplitude_damping_error` | A single-qubit generalized combined phase and amplitude damping error channel given by an amplitude damping parameter $\\lambda$, a phase damping parameter $\\gamma$, and an excited state thermal population $p_1$. |\n",
"| `amplitude_damping_error` | A single-qubit generalized amplitude damping error channel given by an amplitude damping parameter $\\lambda$, and an excited state thermal population $p_1$. |\n",
"| `phase_damping_error` | A single-qubit phase damping error channel given by a phase damping parameter $\\gamma$ |\n",
"\n",
"### Combining quantum errors\n",
"\n",
"`QuantumError` instances can be combined by using composition, tensor product, and tensor expansion (reversed order tensor product) to produce new `QuantumErrors` as:\n",
"\n",
" * Composition: $\\cal{E}(\\rho)=\\cal{E_2}(\\cal{E_1}(\\rho))$ as `error = error1.compose(error2)`\n",
" * Tensor product: $\\cal{E}(\\rho) =(\\cal{E_1}\\otimes\\cal{E_2})(\\rho)$ as `error error1.tensor(error2)`\n",
" * Expand product: $\\cal{E}(\\rho) =(\\cal{E_2}\\otimes\\cal{E_1})(\\rho)$ as `error error1.expand(error2)`"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"### Example\n",
"\n",
"For example to construct a 5% single-qubit Bit-flip error:"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"ExecuteTime": {
"end_time": "2019-08-19T17:00:43.420358Z",
"start_time": "2019-08-19T17:00:43.416062Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"QuantumError on 1 qubits. Noise circuits:\n",
" P(0) = 0.05, Circuit = \n",
" ┌───┐\n",
"q: ┤ X ├\n",
" └───┘\n",
" P(1) = 0.95, Circuit = \n",
" ┌───┐\n",
"q: ┤ I ├\n",
" └───┘\n",
"QuantumError on 1 qubits. Noise circuits:\n",
" P(0) = 0.05, Circuit = \n",
" ┌───┐\n",
"q: ┤ Z ├\n",
" └───┘\n",
" P(1) = 0.95, Circuit = \n",
" ┌───┐\n",
"q: ┤ I ├\n",
" └───┘\n"
]
}
],
"source": [
"# Construct a 1-qubit bit-flip and phase-flip errors\n",
"p_error = 0.05\n",
"bit_flip = pauli_error([('X', p_error), ('I', 1 - p_error)])\n",
"phase_flip = pauli_error([('Z', p_error), ('I', 1 - p_error)])\n",
"print(bit_flip)\n",
"print(phase_flip)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"ExecuteTime": {
"end_time": "2019-08-19T17:00:43.435843Z",
"start_time": "2019-08-19T17:00:43.432211Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"QuantumError on 1 qubits. Noise circuits:\n",
" P(0) = 0.0025000000000000005, Circuit = \n",
" ┌───┐┌───┐\n",
"q: ┤ X ├┤ Z ├\n",
" └───┘└───┘\n",
" P(1) = 0.0475, Circuit = \n",
" ┌───┐┌───┐\n",
"q: ┤ X ├┤ I ├\n",
" └───┘└───┘\n",
" P(2) = 0.0475, Circuit = \n",
" ┌───┐┌───┐\n",
"q: ┤ I ├┤ Z ├\n",
" └───┘└───┘\n",
" P(3) = 0.9025, Circuit = \n",
" ┌───┐┌───┐\n",
"q: ┤ I ├┤ I ├\n",
" └───┘└───┘\n"
]
}
],
"source": [
"# Compose two bit-flip and phase-flip errors\n",
"bitphase_flip = bit_flip.compose(phase_flip)\n",
"print(bitphase_flip)"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"ExecuteTime": {
"end_time": "2019-08-19T17:00:43.460191Z",
"start_time": "2019-08-19T17:00:43.456782Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"QuantumError on 2 qubits. Noise circuits:\n",
" P(0) = 0.0025000000000000005, Circuit = \n",
" ┌───┐\n",
"q_0: ┤ X ├\n",
" ├───┤\n",
"q_1: ┤ Z ├\n",
" └───┘\n",
" P(1) = 0.0475, Circuit = \n",
" ┌───┐\n",
"q_0: ┤ I ├\n",
" ├───┤\n",
"q_1: ┤ Z ├\n",
" └───┘\n",
" P(2) = 0.0475, Circuit = \n",
" ┌───┐\n",
"q_0: ┤ X ├\n",
" ├───┤\n",
"q_1: ┤ I ├\n",
" └───┘\n",
" P(3) = 0.9025, Circuit = \n",
" ┌───┐\n",
"q_0: ┤ I ├\n",
" ├───┤\n",
"q_1: ┤ I ├\n",
" └───┘\n"
]
}
],
"source": [
"# Tensor product two bit-flip and phase-flip errors with\n",
"# bit-flip on qubit-0, phase-flip on qubit-1\n",
"error2 = phase_flip.tensor(bit_flip)\n",
"print(error2)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"### Converting to and from QuantumChannel operators\n",
"\n",
"We can also convert back and forth between `QuantumError` objects in Qiskit Aer and `QuantumChannel` objects in Qiskit Terra."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"ExecuteTime": {
"end_time": "2019-08-19T17:00:43.482424Z",
"start_time": "2019-08-19T17:00:43.473779Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Kraus([[[ 9.74679434e-01+0.j, 0.00000000e+00+0.j],\n",
" [-1.20234617e-16+0.j, 9.74679434e-01+0.j]],\n",
"\n",
" [[ 2.62045272e-16+0.j, 2.23606798e-01+0.j],\n",
" [ 2.23606798e-01+0.j, -2.84112242e-16+0.j]]],\n",
" input_dims=(2,), output_dims=(2,))\n"
]
}
],
"source": [
"# Convert to Kraus operator\n",
"bit_flip_kraus = Kraus(bit_flip)\n",
"print(bit_flip_kraus)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"ExecuteTime": {
"end_time": "2019-08-19T17:00:43.509521Z",
"start_time": "2019-08-19T17:00:43.503976Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"SuperOp([[1. +0.j, 0. +0.j, 0. +0.j, 0. +0.j],\n",
" [0. +0.j, 0.9+0.j, 0. +0.j, 0. +0.j],\n",
" [0. +0.j, 0. +0.j, 0.9+0.j, 0. +0.j],\n",
" [0. +0.j, 0. +0.j, 0. +0.j, 1. +0.j]],\n",
" input_dims=(2,), output_dims=(2,))\n"
]
}
],
"source": [
"# Convert to Superoperator\n",
"phase_flip_sop = SuperOp(phase_flip)\n",
"print(phase_flip_sop)"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"ExecuteTime": {
"end_time": "2019-08-19T17:00:43.794037Z",
"start_time": "2019-08-19T17:00:43.778223Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"QuantumError on 1 qubits. Noise circuits:\n",
" P(0) = 1.0, Circuit = \n",
" ┌───────┐\n",
"q: ┤ kraus ├\n",
" └───────┘\n"
]
},
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Convert back to a quantum error\n",
"print(QuantumError(bit_flip_kraus))\n",
"\n",
"# Check conversion is equivalent to original error\n",
"QuantumError(bit_flip_kraus) == bit_flip"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"### Readout Error\n",
"\n",
"Classical readout errors are specified by a list of assignment probabilities vectors $P(A|B)$:\n",
"\n",
" * $A$ is the *recorded* classical bit value\n",
" * $B$ is the *true* bit value returned from the measurement\n",
"\n",
"E.g. for 1 qubits: $ P(A|B) = [P(A|0), P(A|1)]$."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"ExecuteTime": {
"end_time": "2019-08-19T17:00:44.659598Z",
"start_time": "2019-08-19T17:00:44.654818Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"ReadoutError([[0.95 0.05]\n",
" [0.1 0.9 ]])"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Measurement miss-assignement probabilities\n",
"p0given1 = 0.1\n",
"p1given0 = 0.05\n",
"\n",
"ReadoutError([[1 - p1given0, p1given0], [p0given1, 1 - p0given1]])"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Readout errors may also be combined using `compose`, `tensor` and `expand` like with quantum errors."
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## Adding errors to a Noise Model\n",
"\n",
"When adding a quantum error to a noise model we must specify the type of *instruction* that it acts on, and what qubits to apply it to. There are two cases for Quantum Errors:\n",
"\n",
" 1. All-qubit quantum error\n",
" 2. Specific qubit quantum error\n",
"\n",
"### 1. All-qubit quantum error\n",
"\n",
"This applies the same error to any occurrence of an instruction, regardless of which qubits it acts on.\n",
"\n",
"It is added as `noise_model.add_all_qubit_quantum_error(error, instructions)`:"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"ExecuteTime": {
"end_time": "2019-08-19T17:00:45.882254Z",
"start_time": "2019-08-19T17:00:45.877630Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"NoiseModel:\n",
" Basis gates: ['cx', 'id', 'rz', 'sx', 'u1', 'u2', 'u3']\n",
" Instructions with noise: ['u1', 'u3', 'u2']\n",
" All-qubits errors: ['u1', 'u2', 'u3']\n"
]
}
],
"source": [
"# Create an empty noise model\n",
"noise_model = NoiseModel()\n",
"\n",
"# Add depolarizing error to all single qubit u1, u2, u3 gates\n",
"error = depolarizing_error(0.05, 1)\n",
"noise_model.add_all_qubit_quantum_error(error, ['u1', 'u2', 'u3'])\n",
"\n",
"# Print noise model info\n",
"print(noise_model)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2. Specific qubit quantum error\n",
"\n",
"This applies the error to any occurrence of an instruction acting on a specified list of qubits. Note that the order of the qubit matters: For a 2-qubit gate an error applied to qubits [0, 1] is different to one applied to qubits [1, 0] for example.\n",
"\n",
"It is added as `noise_model.add_quantum_error(error, instructions, qubits)`:"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"ExecuteTime": {
"end_time": "2019-08-19T17:00:46.615959Z",
"start_time": "2019-08-19T17:00:46.612055Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"NoiseModel:\n",
" Basis gates: ['cx', 'id', 'rz', 'sx', 'u1', 'u2', 'u3']\n",
" Instructions with noise: ['u1', 'u3', 'u2']\n",
" Qubits with noise: [0]\n",
" Specific qubit errors: [('u1', (0,)), ('u2', (0,)), ('u3', (0,))]\n"
]
}
],
"source": [
"# Create an empty noise model\n",
"noise_model = NoiseModel()\n",
"\n",
"# Add depolarizing error to all single qubit u1, u2, u3 gates on qubit 0 only\n",
"error = depolarizing_error(0.05, 1)\n",
"noise_model.add_quantum_error(error, ['u1', 'u2', 'u3'], [0])\n",
"\n",
"# Print noise model info\n",
"print(noise_model)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"### Note on non-local qubit quantum error\n",
"\n",
"`NoiseModel` does not support addition of non-local qubit quantum errors. They should be handled outside of `NoiseModel`. That suggests you should [write your own transpiler pass](/transpile/custom-transpiler-pass) (`TransformationPass`) and run the pass just before running the simulator if you need to insert your quantum errors into your circuit under your own conditions."
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"### Executing a noisy simulation with a noise model\n",
"\n",
"The command `AerSimulator(noise_model=noise_model)` returns a simulator configured to the given noise model. In addition to setting the simulator's noise model, it also overrides the simulator's basis gates, according to the gates of the noise model."
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"## Noise Model Examples\n",
"\n",
"We will now give some examples of noise models. For our demonstrations we will use a simple test circuit generating a n-qubit GHZ state:"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"ExecuteTime": {
"end_time": "2019-08-19T17:00:48.817405Z",
"start_time": "2019-08-19T17:00:48.806966Z"
},
"slideshow": {
"slide_type": "fragment"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" ┌───┐ ░ ┌─┐ \n",
" q_0: ┤ H ├──■─────────────░─┤M├─────────\n",
" └───┘┌─┴─┐ ░ └╥┘┌─┐ \n",
" q_1: ─────┤ X ├──■────────░──╫─┤M├──────\n",
" └───┘┌─┴─┐ ░ ║ └╥┘┌─┐ \n",
" q_2: ──────────┤ X ├──■───░──╫──╫─┤M├───\n",
" └───┘┌─┴─┐ ░ ║ ║ └╥┘┌─┐\n",
" q_3: ───────────────┤ X ├─░──╫──╫──╫─┤M├\n",
" └───┘ ░ ║ ║ ║ └╥┘\n",
"meas: 4/════════════════════════╩══╩══╩══╩═\n",
" 0 1 2 3 \n"
]
}
],
"source": [
"# System Specification\n",
"n_qubits = 4\n",
"circ = QuantumCircuit(n_qubits)\n",
"\n",
"# Test Circuit\n",
"circ.h(0)\n",
"for qubit in range(n_qubits - 1):\n",
" circ.cx(qubit, qubit + 1)\n",
"circ.measure_all()\n",
"print(circ)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"### Ideal Simulation"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"ExecuteTime": {
"end_time": "2019-08-19T17:00:50.560988Z",
"start_time": "2019-08-19T17:00:50.415545Z"
}
},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 700x500 with 1 Axes>"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Ideal simulator and execution\n",
"sim_ideal = AerSimulator()\n",
"result_ideal = sim_ideal.run(circ).result()\n",
"plot_histogram(result_ideal.get_counts(0))"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "subslide"
}
},
"source": [
"## Noise Example 1: Basic bit-flip error noise model\n",
"\n",
"Lets consider a simple toy noise model example common in quantum information theory research:\n",
"\n",
"* When applying a single qubit gate, flip the state of the qubit with probability `p_gate1`.\n",
"* When applying a 2-qubit gate apply single-qubit errors to each qubit.\n",
"* When resetting a qubit reset to 1 instead of 0 with probability `p_reset`.\n",
"* When measuring a qubit, flip the state of the qubit with probability `p_meas`."
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"ExecuteTime": {
"end_time": "2019-08-19T17:00:51.543615Z",
"start_time": "2019-08-19T17:00:51.536564Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"NoiseModel:\n",
" Basis gates: ['cx', 'id', 'rz', 'sx', 'u1', 'u2', 'u3']\n",
" Instructions with noise: ['measure', 'u2', 'cx', 'u1', 'u3', 'reset']\n",
" All-qubits errors: ['reset', 'measure', 'u1', 'u2', 'u3', 'cx']\n"
]
}
],
"source": [
"# Example error probabilities\n",
"p_reset = 0.03\n",
"p_meas = 0.1\n",
"p_gate1 = 0.05\n",
"\n",
"# QuantumError objects\n",
"error_reset = pauli_error([('X', p_reset), ('I', 1 - p_reset)])\n",
"error_meas = pauli_error([('X',p_meas), ('I', 1 - p_meas)])\n",
"error_gate1 = pauli_error([('X',p_gate1), ('I', 1 - p_gate1)])\n",
"error_gate2 = error_gate1.tensor(error_gate1)\n",
"\n",
"# Add errors to noise model\n",
"noise_bit_flip = NoiseModel()\n",
"noise_bit_flip.add_all_qubit_quantum_error(error_reset, \"reset\")\n",
"noise_bit_flip.add_all_qubit_quantum_error(error_meas, \"measure\")\n",
"noise_bit_flip.add_all_qubit_quantum_error(error_gate1, [\"u1\", \"u2\", \"u3\"])\n",
"noise_bit_flip.add_all_qubit_quantum_error(error_gate2, [\"cx\"])\n",
"\n",
"print(noise_bit_flip)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"### Executing the noisy simulation"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"ExecuteTime": {
"end_time": "2019-08-19T17:00:52.951874Z",
"start_time": "2019-08-19T17:00:52.687440Z"
},
"slideshow": {
"slide_type": "-"
}
},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 700x500 with 1 Axes>"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Create noisy simulator backend\n",
"sim_noise = AerSimulator(noise_model=noise_bit_flip)\n",
"\n",
"# Transpile circuit for noisy basis gates\n",
"passmanager = generate_preset_pass_manager(optimization_level=3, backend=sim_noise)\n",
"circ_tnoise = passmanager.run(circ)\n",
"\n",
"# Run and get counts\n",
"result_bit_flip = sim_noise.run(circ_tnoise).result()\n",
"counts_bit_flip = result_bit_flip.get_counts(0)\n",
"\n",
"# Plot noisy output\n",
"plot_histogram(counts_bit_flip)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## Example 2: T1/T2 thermal relaxation\n",
"\n",
"Now consider a more realistic error model based on thermal relaxation with the qubit environment:\n",
"* Each qubit is parameterized by a thermal relaxation time constant $T_1$ and a dephasing time constant $T_2$.\n",
"* Note that we must have $T_2 \\le 2 T_1$.\n",
"* Error rates on instructions are determined by gate times and qubit $T_1$, $T_2$ values."
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"ExecuteTime": {
"end_time": "2019-08-19T17:00:54.577456Z",
"start_time": "2019-08-19T17:00:54.491018Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"NoiseModel:\n",
" Basis gates: ['cx', 'id', 'rz', 'sx', 'u2', 'u3']\n",
" Instructions with noise: ['measure', 'u2', 'cx', 'u3', 'reset']\n",
" Qubits with noise: [0, 1, 2, 3]\n",
" Specific qubit errors: [('reset', (0,)), ('reset', (1,)), ('reset', (2,)), ('reset', (3,)), ('measure', (0,)), ('measure', (1,)), ('measure', (2,)), ('measure', (3,)), ('u2', (0,)), ('u2', (1,)), ('u2', (2,)), ('u2', (3,)), ('u3', (0,)), ('u3', (1,)), ('u3', (2,)), ('u3', (3,)), ('cx', (0, 0)), ('cx', (0, 1)), ('cx', (0, 2)), ('cx', (0, 3)), ('cx', (1, 0)), ('cx', (1, 1)), ('cx', (1, 2)), ('cx', (1, 3)), ('cx', (2, 0)), ('cx', (2, 1)), ('cx', (2, 2)), ('cx', (2, 3)), ('cx', (3, 0)), ('cx', (3, 1)), ('cx', (3, 2)), ('cx', (3, 3))]\n"
]
}
],
"source": [
"# T1 and T2 values for qubits 0-3\n",
"T1s = np.random.normal(50e3, 10e3, 4) # Sampled from normal distribution mean 50 microsec\n",
"T2s = np.random.normal(70e3, 10e3, 4) # Sampled from normal distribution mean 50 microsec\n",
"\n",
"# Truncate random T2s <= T1s\n",
"T2s = np.array([min(T2s[j], 2 * T1s[j]) for j in range(4)])\n",
"\n",
"# Instruction times (in nanoseconds)\n",
"time_u1 = 0 # virtual gate\n",
"time_u2 = 50 # (single X90 pulse)\n",
"time_u3 = 100 # (two X90 pulses)\n",
"time_cx = 300\n",
"time_reset = 1000 # 1 microsecond\n",
"time_measure = 1000 # 1 microsecond\n",
"\n",
"# QuantumError objects\n",
"errors_reset = [thermal_relaxation_error(t1, t2, time_reset)\n",
" for t1, t2 in zip(T1s, T2s)]\n",
"errors_measure = [thermal_relaxation_error(t1, t2, time_measure)\n",
" for t1, t2 in zip(T1s, T2s)]\n",
"errors_u1 = [thermal_relaxation_error(t1, t2, time_u1)\n",
" for t1, t2 in zip(T1s, T2s)]\n",
"errors_u2 = [thermal_relaxation_error(t1, t2, time_u2)\n",
" for t1, t2 in zip(T1s, T2s)]\n",
"errors_u3 = [thermal_relaxation_error(t1, t2, time_u3)\n",
" for t1, t2 in zip(T1s, T2s)]\n",
"errors_cx = [[thermal_relaxation_error(t1a, t2a, time_cx).expand(\n",
" thermal_relaxation_error(t1b, t2b, time_cx))\n",
" for t1a, t2a in zip(T1s, T2s)]\n",
" for t1b, t2b in zip(T1s, T2s)]\n",
"\n",
"# Add errors to noise model\n",
"noise_thermal = NoiseModel()\n",
"for j in range(4):\n",
" noise_thermal.add_quantum_error(errors_reset[j], \"reset\", [j])\n",
" noise_thermal.add_quantum_error(errors_measure[j], \"measure\", [j])\n",
" noise_thermal.add_quantum_error(errors_u1[j], \"u1\", [j])\n",
" noise_thermal.add_quantum_error(errors_u2[j], \"u2\", [j])\n",
" noise_thermal.add_quantum_error(errors_u3[j], \"u3\", [j])\n",
" for k in range(4):\n",
" noise_thermal.add_quantum_error(errors_cx[j][k], \"cx\", [j, k])\n",
"\n",
"print(noise_thermal)"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"### Executing the noisy simulation"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"ExecuteTime": {
"end_time": "2019-08-19T17:00:55.689241Z",
"start_time": "2019-08-19T17:00:55.515394Z"
}
},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 700x500 with 1 Axes>"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Run the noisy simulation\n",
"sim_thermal = AerSimulator(noise_model=noise_thermal)\n",
"\n",
"# Transpile circuit for noisy basis gates\n",
"passmanager = generate_preset_pass_manager(optimization_level=3, backend=sim_thermal)\n",
"circ_tthermal = passmanager.run(circ)\n",
"\n",
"# Run and get counts\n",
"result_thermal = sim_thermal.run(circ_tthermal).result()\n",
"counts_thermal = result_thermal.get_counts(0)\n",
"\n",
"# Plot noisy output\n",
"plot_histogram(counts_thermal)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Next steps\n",
"\n",
"<Admonition type=\"tip\" title=\"Recommendations\">\n",
" - To simulate noisy circuits, see [Exact and noisy simulation with Qiskit Aer primitives](simulate-with-qiskit-primitives).\n",
" - Review the [Qiskit Aer noise module](https://qiskit.org/ecosystem/aer/apidocs/aer_noise.html) reference.\n",
"</Admonition>"
]
}
],
"metadata": {
"description": "Build custom noise models for noisy simulation with Qiskit Aer",
"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"
},
"title": "Building noise models"
},
"nbformat": 4,
"nbformat_minor": 4
}
Reference in New Issue View Git Blame Copy Permalink