Note

Cette page a été générée à partir de tutorials/simulators/3_building_noise_models.ipynb.

Exécuter en mode interactif dans le IBM Quantum lab.

Construction de modèles de bruit

Introduction

Ce bloc-notes explique comment utiliser le module Qiskit Aer noise pour construire des modèles de bruit personnalisés pour des simulations bruitées.

import numpy as np
from qiskit import QuantumCircuit, transpile
from qiskit.quantum_info import Kraus, SuperOp
from qiskit.providers.aer import AerSimulator
from qiskit.tools.visualization import plot_histogram

# Import from Qiskit Aer noise module
from qiskit.providers.aer.noise import NoiseModel
from qiskit.providers.aer.noise import QuantumError, ReadoutError
from qiskit.providers.aer.noise import pauli_error
from qiskit.providers.aer.noise import depolarizing_error
from qiskit.providers.aer.noise import thermal_relaxation_error

Module de bruit Aer Qiskit

Le module Qiskit Aer noise contient des classes Python permettant de construire des modèles de bruit personnalisés pour la simulation. Il existe trois classes principales:

1. La classe NoiseModel qui stocke un modèle de bruit utilisé pour la simulation bruitée.

2. La classe QuantumError qui décrit les erreurs CPTP des portes. Celles-ci peuvent être appliquées :

   • Après les instructions de gate ou reset

   • Avant les instructions de mesure.

3. La classe ReadoutError qui décrit les erreurs de lecture classiques.

Erreurs quantiques

Plutôt que d’utiliser directement l’objet QuantumError, de nombreuses fonctions d’aide existent pour générer automatiquement les paramètres spécifiques des erreurs quantiques. Elles sont contenues dans le module noise et comprennent des fonctions pour de nombreux types d’erreurs courantes utilisées dans la recherche informatique quantique. Les noms de fonction et le type d’erreur renvoyé sont les suivants:

Fonction d’erreur standard	Plus d’informations
kraus_error	un canal d’erreur CPTP général à n-qubit donné en tant que liste des matrices Kraus :math:` [ K_0, … ] `.
mixed_unitary_error	une erreur unitaire mixte n-qubit est sous la forme d’une liste de matrices unitaires et de probabilités :math:` [ (U_0, p_ 0), … ] `.
coherent_unitary_error	une erreur cohérente unitaire sur n-qubit est représentée par une seule matrice unitaire :math:` U `.
pauli_error	un canal d’erreur de Pauli sur n-qubit (unitaire mixte) est donné comme une liste de Pauli’s et de probabilités :math:` [ (P_0, p_ 0), … ] `
depolarizing_error	un canal d’erreur de dépolarisation n-qubit est paramétré par une probabilité de dépolarisation \(p\).
reset_error	a single-qubit reset error parameterized by a probabilities \(p_0, p_1\) of resetting to the \(|0\rangle\), \(|1\rangle\) state.
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\).
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\).
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\).
phase_damping_error	A single-qubit phase damping error channel given by a phase damping parameter \(\gamma\)

Combinaison d’erreurs quantiques

QuantumError instances can be combined by using composition, tensor product, and tensor expansion (reversed order tensor product) to produce new QuantumErrors as:

• Composition: \(\cal{E}(\rho)=\cal{E_2}(\cal{E_1}(\rho))\) as error = error1.compose(error2)

• Tensor product: \(\cal{E}(\rho) =(\cal{E_1}\otimes\cal{E_2})(\rho)\) as error error1.tensor(error2)

• Expand product: \(\cal{E}(\rho) =(\cal{E_2}\otimes\cal{E_1})(\rho)\) as error error1.expand(error2)

Exemple

For example to construct a 5% single-qubit Bit-flip error:

# Construct a 1-qubit bit-flip and phase-flip errors
p_error = 0.05
bit_flip = pauli_error([('X', p_error), ('I', 1 - p_error)])
phase_flip = pauli_error([('Z', p_error), ('I', 1 - p_error)])
print(bit_flip)
print(phase_flip)

QuantumError on 1 qubits. Noise circuits:
  P(0) = 0.05, QasmQobjInstructions = [[{'name': 'x', 'qubits': [0]}]
  P(1) = 0.95, QasmQobjInstructions = [[{'name': 'id', 'qubits': [0]}]
QuantumError on 1 qubits. Noise circuits:
  P(0) = 0.05, QasmQobjInstructions = [[{'name': 'z', 'qubits': [0]}]
  P(1) = 0.95, QasmQobjInstructions = [[{'name': 'id', 'qubits': [0]}]

# Compose two bit-flip and phase-flip errors
bitphase_flip = bit_flip.compose(phase_flip)
print(bitphase_flip)

QuantumError on 1 qubits. Noise circuits:
  P(0) = 0.0025000000000000005, QasmQobjInstructions = [[{'name': 'x', 'qubits': [0]}, {'name': 'z', 'qubits': [0]}]
  P(1) = 0.0475, QasmQobjInstructions = [[{'name': 'x', 'qubits': [0]}]
  P(2) = 0.0475, QasmQobjInstructions = [[{'name': 'z', 'qubits': [0]}]
  P(3) = 0.9025, QasmQobjInstructions = [[{'name': 'id', 'qubits': [0]}]

# Tensor product two bit-flip and phase-flip errors with
# bit-flip on qubit-0, phase-flip on qubit-1
error2 = phase_flip.tensor(bit_flip)
print(error2)

QuantumError on 2 qubits. Noise circuits:
  P(0) = 0.0025000000000000005, QasmQobjInstructions = [[{'name': 'x', 'qubits': [0]}, {'name': 'z', 'qubits': [1]}]
  P(1) = 0.0475, QasmQobjInstructions = [[{'name': 'z', 'qubits': [1]}]
  P(2) = 0.0475, QasmQobjInstructions = [[{'name': 'x', 'qubits': [0]}]
  P(3) = 0.9025, QasmQobjInstructions = [[{'name': 'id', 'qubits': [1]}]

Converting to and from QuantumChannel operators

We can also convert back and forth between QuantumError objects in Qiskit Aer and QuantumChannel objects in Qiskit Terra.

# Convert to Kraus operator
bit_flip_kraus = Kraus(bit_flip)
print(bit_flip_kraus)

Kraus([[[ 9.74679434e-01+0.j,  0.00000000e+00+0.j],
        [ 0.00000000e+00+0.j,  9.74679434e-01+0.j]],

       [[ 0.00000000e+00+0.j,  2.23606798e-01+0.j],
        [ 2.23606798e-01+0.j, -4.96506831e-17+0.j]]],
      input_dims=(2,), output_dims=(2,))

# Convert to Superoperator
phase_flip_sop = SuperOp(phase_flip)
print(phase_flip_sop)

SuperOp([[1. +0.j, 0. +0.j, 0. +0.j, 0. +0.j],
         [0. +0.j, 0.9+0.j, 0. +0.j, 0. +0.j],
         [0. +0.j, 0. +0.j, 0.9+0.j, 0. +0.j],
         [0. +0.j, 0. +0.j, 0. +0.j, 1. +0.j]],
        input_dims=(2,), output_dims=(2,))

# Convert back to a quantum error
print(QuantumError(bit_flip_kraus))

# Check conversion is equivalent to original error
QuantumError(bit_flip_kraus) == bit_flip

QuantumError on 1 qubits. Noise circuits:
  P(0) = 0.04999999999999995, QasmQobjInstructions = [[{'name': 'x', 'qubits': [0]}]
  P(1) = 0.9500000000000002, QasmQobjInstructions = [[{'name': 'id', 'qubits': [0]}]

True

Erreur de lecture (readout)

Classical readout errors are specified by a list of assignment probabilities vectors \(P(A|B)\):

• \(A\) est la valeur de bit classique enregistrée

• :math:` B ` est la valeur du bit réellement renvoyée par la mesure

E.g. for 1 qubits: $ P(A|B) = [P(A|0), P(A|1)]$.

# Measurement miss-assignement probabilities
p0given1 = 0.1
p1given0 = 0.05

ReadoutError([[1 - p1given0, p1given0], [p0given1, 1 - p0given1]])

ReadoutError([[0.95 0.05]
 [0.1  0.9 ]])

Les erreurs de lecture peuvent également être combinées en utilisant compose, tensor et expand comme avec des erreurs quantiques.

Ajouter des erreurs à un modèle de bruit

Lors de l’ajout d’une erreur quantique à un modèle de bruit, nous devons spécifier le type d”instruction sur lequel il agit, et à quels qubits l’appliquer. Il y a trois cas pour les erreurs quantiques:

1. Erreur quantique tout-qubit

2. Erreur quantique spécifique par qubit

3. Erreur quantique non locale

Erreur quantique tout-qubit

Cela applique la même erreur à toute occurrence d’une instruction, indépendamment du qubits sur lequel elle agit.

Il est ajouté sous la forme ``noise_model.add_all_qubit_quantum_error(erreo, instructions) ``:

# Create an empty noise model
noise_model = NoiseModel()

# Add depolarizing error to all single qubit u1, u2, u3 gates
error = depolarizing_error(0.05, 1)
noise_model.add_all_qubit_quantum_error(error, ['u1', 'u2', 'u3'])

# Print noise model info
print(noise_model)

NoiseModel:
  Basis gates: ['cx', 'id', 'u1', 'u2', 'u3']
  Instructions with noise: ['u3', 'u2', 'u1']
  All-qubits errors: ['u1', 'u2', 'u3']

Erreur quantique spécifique par qubit

Ceci applique l’erreur à toute occurrence d’une instruction agissant sur une liste de qubits spécifiée. Notez que l’ordre des qubits a une importance : pour une grille 2-qubits, une erreur appliquée aux qubits [0, 1] est différente de celle appliquée aux qubits [1, 0] par exemple.

Il est ajouté sous la forme noise_model.add_quantum_error (error, instructions, qubits):

# Create an empty noise model
noise_model = NoiseModel()

# Add depolarizing error to all single qubit u1, u2, u3 gates on qubit 0 only
error = depolarizing_error(0.05, 1)
noise_model.add_quantum_error(error, ['u1', 'u2', 'u3'], [0])

# Print noise model info
print(noise_model)

NoiseModel:
  Basis gates: ['cx', 'id', 'u1', 'u2', 'u3']
  Instructions with noise: ['u3', 'u2', 'u1']
  Qubits with noise: [0]
  Specific qubit errors: [('u1', [0]), ('u2', [0]), ('u3', [0])]

Erreur quantique non locale sur des qubits

This applies an error to a specific set of noise qubits after any occurrence of an instruction acting on a specific of gate qubits.

It is added as noise_model.add_nonlocal_quantum_error(error, instructions, instr_qubits, error_qubits):

# Create an empty noise model
noise_model = NoiseModel()

# Add depolarizing error on qubit 2 forall single qubit u1, u2, u3 gates on qubit 0
error = depolarizing_error(0.05, 1)
noise_model.add_nonlocal_quantum_error(error, ['u1', 'u2', 'u3'], [0], [2])

# Print noise model info
print(noise_model)

NoiseModel:
  Basis gates: ['cx', 'id', 'u1', 'u2', 'u3']
  Instructions with noise: ['u3', 'u2', 'u1']
  Qubits with noise: [0, 2]
  Non-local specific qubit errors: [('u1', [0], [2]), ('u2', [0], [2]), ('u3', [0], [2])]

Executing a noisy simulation with a noise model

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.

Noise Model Examples

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:

# System Specification
n_qubits = 4
circ = QuantumCircuit(n_qubits)

# Test Circuit
circ.h(0)
for qubit in range(n_qubits - 1):
    circ.cx(qubit, qubit + 1)
circ.measure_all()
print(circ)

        ┌───┐                ░ ┌─┐
   q_0: ┤ H ├──■─────────────░─┤M├─────────
        └───┘┌─┴─┐           ░ └╥┘┌─┐
   q_1: ─────┤ X ├──■────────░──╫─┤M├──────
             └───┘┌─┴─┐      ░  ║ └╥┘┌─┐
   q_2: ──────────┤ X ├──■───░──╫──╫─┤M├───
                  └───┘┌─┴─┐ ░  ║  ║ └╥┘┌─┐
   q_3: ───────────────┤ X ├─░──╫──╫──╫─┤M├
                       └───┘ ░  ║  ║  ║ └╥┘
meas: 4/════════════════════════╩══╩══╩══╩═
                                0  1  2  3

Simulation idéale

# Ideal simulator and execution
sim_ideal = AerSimulator()
result_ideal = sim_ideal.run(circ).result()
plot_histogram(result_ideal.get_counts(0))

Exemple de bruit 1 : modèle basique de bruit pour des erreurs de type bit-flip

Lets consider a simple toy noise model example common in quantum information theory research:

• When applying a single qubit gate, flip the state of the qubit with probability p_gate1.

• When applying a 2-qubit gate apply single-qubit errors to each qubit.

• When resetting a qubit reset to 1 instead of 0 with probability p_reset.

• When measuring a qubit, flip the state of the qubit with probability p_meas.

# Example error probabilities
p_reset = 0.03
p_meas = 0.1
p_gate1 = 0.05

# QuantumError objects
error_reset = pauli_error([('X', p_reset), ('I', 1 - p_reset)])
error_meas = pauli_error([('X',p_meas), ('I', 1 - p_meas)])
error_gate1 = pauli_error([('X',p_gate1), ('I', 1 - p_gate1)])
error_gate2 = error_gate1.tensor(error_gate1)

# Add errors to noise model
noise_bit_flip = NoiseModel()
noise_bit_flip.add_all_qubit_quantum_error(error_reset, "reset")
noise_bit_flip.add_all_qubit_quantum_error(error_meas, "measure")
noise_bit_flip.add_all_qubit_quantum_error(error_gate1, ["u1", "u2", "u3"])
noise_bit_flip.add_all_qubit_quantum_error(error_gate2, ["cx"])

print(noise_bit_flip)

NoiseModel:
  Basis gates: ['cx', 'id', 'u1', 'u2', 'u3']
  Instructions with noise: ['reset', 'u3', 'cx', 'u2', 'u1', 'measure']
  All-qubits errors: ['reset', 'measure', 'u1', 'u2', 'u3', 'cx']

Exécution de la simulation bruitée

# Create noisy simulator backend
sim_noise = AerSimulator(noise_model=noise_bit_flip)

# Transpile circuit for noisy basis gates
circ_tnoise = transpile(circ, sim_noise)

# Run and get counts
result_bit_flip = sim_noise.run(circ_tnoise).result()
counts_bit_flip = result_bit_flip.get_counts(0)

# Plot noisy output
plot_histogram(counts_bit_flip)

Exemple 2 : relaxation thermique T1/T2

Now consider a more realistic error model based on thermal relaxation with the qubit environment: * Each qubit is parameterized by a thermal relaxation time constant \(T_1\) and a dephasing time constant \(T_2\). * Note that we must have \(T_2 \le 2 T_1\). * Error rates on instructions are determined by gate times and qubit \(T_1\), \(T_2\) values.

# T1 and T2 values for qubits 0-3
T1s = np.random.normal(50e3, 10e3, 4) # Sampled from normal distribution mean 50 microsec
T2s = np.random.normal(70e3, 10e3, 4)  # Sampled from normal distribution mean 50 microsec

# Truncate random T2s <= T1s
T2s = np.array([min(T2s[j], 2 * T1s[j]) for j in range(4)])

# Instruction times (in nanoseconds)
time_u1 = 0   # virtual gate
time_u2 = 50  # (single X90 pulse)
time_u3 = 100 # (two X90 pulses)
time_cx = 300
time_reset = 1000  # 1 microsecond
time_measure = 1000 # 1 microsecond

# QuantumError objects
errors_reset = [thermal_relaxation_error(t1, t2, time_reset)
                for t1, t2 in zip(T1s, T2s)]
errors_measure = [thermal_relaxation_error(t1, t2, time_measure)
                  for t1, t2 in zip(T1s, T2s)]
errors_u1  = [thermal_relaxation_error(t1, t2, time_u1)
              for t1, t2 in zip(T1s, T2s)]
errors_u2  = [thermal_relaxation_error(t1, t2, time_u2)
              for t1, t2 in zip(T1s, T2s)]
errors_u3  = [thermal_relaxation_error(t1, t2, time_u3)
              for t1, t2 in zip(T1s, T2s)]
errors_cx = [[thermal_relaxation_error(t1a, t2a, time_cx).expand(
             thermal_relaxation_error(t1b, t2b, time_cx))
              for t1a, t2a in zip(T1s, T2s)]
               for t1b, t2b in zip(T1s, T2s)]

# Add errors to noise model
noise_thermal = NoiseModel()
for j in range(4):
    noise_thermal.add_quantum_error(errors_reset[j], "reset", [j])
    noise_thermal.add_quantum_error(errors_measure[j], "measure", [j])
    noise_thermal.add_quantum_error(errors_u1[j], "u1", [j])
    noise_thermal.add_quantum_error(errors_u2[j], "u2", [j])
    noise_thermal.add_quantum_error(errors_u3[j], "u3", [j])
    for k in range(4):
        noise_thermal.add_quantum_error(errors_cx[j][k], "cx", [j, k])

print(noise_thermal)

NoiseModel:
  Basis gates: ['cx', 'id', 'u2', 'u3']
  Instructions with noise: ['reset', 'cx', 'u3', 'u2', 'measure']
  Qubits with noise: [0, 1, 2, 3]
  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])]

Exécution de la simulation bruitée

# Run the noisy simulation
sim_thermal = AerSimulator(noise_model=noise_thermal)

# Transpile circuit for noisy basis gates
circ_tthermal = transpile(circ, sim_thermal)

# Run and get counts
result_thermal = sim_thermal.run(circ_tthermal).result()
counts_thermal = result_thermal.get_counts(0)

# Plot noisy output
plot_histogram(counts_thermal)

import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
Qiskit	0.25.0
Terra	0.17.0
Aer	0.8.0
Ignis	0.6.0
Aqua	0.9.0
IBM Q Provider	0.12.2
System information
Python	3.7.7 (default, May 6 2020, 04:59:01) [Clang 4.0.1 (tags/RELEASE_401/final)]
OS	Darwin
CPUs	6
Memory (Gb)	32.0
Fri Apr 02 12:05:34 2021 EDT

This code is a part of Qiskit

© Copyright IBM 2017, 2021.

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.