注釈

当ページは tutorials/noise/1_hamiltonian_and_gate_characterization.ipynb から生成されました。

IBM Quantum lab でインタラクティブに実行します。

ハミルトニアンとゲートの特性評価¶

このノートブックでは、Qiskit Ignisの characterization.hamiltonian および characterization.gates モジュールの使用方法を示す例を提供します。理論の背景については、Ignis Community Notebooks を参照してください。

[1]:

import numpy as np
import matplotlib.pyplot as plt

import qiskit
from qiskit.providers.aer.noise.errors.standard_errors import coherent_unitary_error
from qiskit.providers.aer.noise import NoiseModel

from qiskit.ignis.characterization.hamiltonian import ZZFitter, zz_circuits

from qiskit.ignis.characterization.gates import (AmpCalFitter, ampcal_1Q_circuits,
                                                 AngleCalFitter, anglecal_1Q_circuits,
                                                 AmpCalCXFitter, ampcal_cx_circuits,
                                                 AngleCalCXFitter, anglecal_cx_circuits)

ZZ測定¶

characterization.hamiltonian.zz_circuits モジュールは、2量子ビット間のZZ測定を実験する回路を構築します。ここで、ZZは \(|11\rangle\) 状態でのエネルギー・シフトとして定義されます:

\[H=\omega_0 (1-\sigma_{Z,0})/2 +\omega_1 (1-\sigma_{Z,1})/2 + \xi |11\rangle\langle 11|\]

\(\xi\) を測定する実験は、Q0 (H-t-H)上でRamsey実験をし、励起状態のQ1でRamsey実験を繰り返すことです。これらの実験の振動数の違いは、その比が:math:`xi`です。

[2]:

# ZZ rates are typically ~ 100kHz so we want Ramsey oscillations around 1MHz
# 12 numbers ranging from 10 to 1000, logarithmically spaced
# extra point at 1500
num_of_gates = np.arange(0,150,5)
gate_time = 0.1

# Select the qubits whose ZZ will be measured
qubits = [0]
spectators = [1]

# Generate experiments
circs, xdata, osc_freq = zz_circuits(num_of_gates, gate_time, qubits, spectators, nosc=2)

フィッターの特徴の一つは、回路を複数のジョブに分割してから、結果をリストとしてフィッターに渡すことです。これを以下に示します。

[3]:

# Set the simulator with ZZ
zz_unitary = np.eye(4,dtype=complex)
zz_unitary[3,3] = np.exp(1j*2*np.pi*0.02*gate_time)
error = coherent_unitary_error(zz_unitary)
noise_model = NoiseModel()
noise_model.add_nonlocal_quantum_error(error, 'id', [0], [0,1])

# Run the simulator
backend = qiskit.Aer.get_backend('qasm_simulator')
shots = 500
# For demonstration purposes split the execution into two jobs
print("Running the first 20 circuits")
backend_result1 = qiskit.execute(circs[0:20], backend,
                                shots=shots, noise_model=noise_model).result()
print("Running the rest of the circuits")
backend_result2 = qiskit.execute(circs[20:], backend,
                                shots=shots, noise_model=noise_model).result()

Running the first 20 circuits
Running the rest of the circuits

[4]:

%matplotlib inline
# Fit the data to an oscillation

plt.figure(figsize=(10, 6))
initial_a = 1
initial_c = 0
initial_f = osc_freq
initial_phi = -np.pi/20

# Instantiate the fitter
# pass the 2 results in as a list of results
fit = ZZFitter([backend_result1, backend_result2], xdata, qubits, spectators,
                   fit_p0=[initial_a, initial_f, initial_phi, initial_c],
                   fit_bounds=([-0.5, 0, -np.pi, -0.5],
                               [1.5, 2*osc_freq, np.pi, 1.5]))

fit.plot_ZZ(0, ax=plt.gca())

print("ZZ Rate: %f kHz"%(fit.ZZ_rate()[0]*1e3))
plt.show()

ZZ Rate: 20.602746 kHz

../../_images/tutorials_noise_1_hamiltonian_and_gate_characterization_7_1.png

単一量子ビット・ゲートの振幅エラー特性¶

単一量子ビット・ゲートにおける振幅エラーを測定します。ここでは、:math:`pi/2’パルスのエラーを測定します。複数の振幅調整を並行して実行できることに注意してください。ここでは、量子ビット2と4を測定します。

[5]:

qubits = [4,2]
circs, xdata = ampcal_1Q_circuits(10, qubits)

これは、較正のシーケンスを示しており、Y90 (U2[0,0])を繰り返したアプリケーションとなります。測定値は量子ビットリストの順序では、最小数のクラシックレジスターにマッピングされることに注意してください。

[6]:

print(circs[2])

                                                                               »
q1_0: |0>──────────────────────────────────────────────────────────────────────»
                                                                               »
q1_1: |0>──────────────────────────────────────────────────────────────────────»
         ┌─────────┐ ░ ┌─────────┐ ░ ┌─────────┐ ░ ┌─────────┐ ░ ┌─────────┐   »
q1_2: |0>┤ U2(0,0) ├─░─┤ U2(0,0) ├─░─┤ U2(0,0) ├─░─┤ U2(0,0) ├─░─┤ U2(0,0) ├───»
         └─────────┘ ░ └─────────┘ ░ └─────────┘ ░ └─────────┘ ░ └─────────┘   »
q1_3: |0>──────────────────────────────────────────────────────────────────────»
         ┌─────────┐ ░ ┌─────────┐ ░ ┌─────────┐ ░ ┌─────────┐ ░ ┌─────────┐┌─┐»
q1_4: |0>┤ U2(0,0) ├─░─┤ U2(0,0) ├─░─┤ U2(0,0) ├─░─┤ U2(0,0) ├─░─┤ U2(0,0) ├┤M├»
         └─────────┘ ░ └─────────┘ ░ └─────────┘ ░ └─────────┘ ░ └─────────┘└╥┘»
 c1_0: 0 ════════════════════════════════════════════════════════════════════╩═»
                                                                               »
 c1_1: 0 ══════════════════════════════════════════════════════════════════════»
                                                                               »
«
«q1_0: ───
«
«q1_1: ───
«      ┌─┐
«q1_2: ┤M├
«      └╥┘
«q1_3: ─╫─
«       ║
«q1_4: ─╫─
«       ║
«c1_0: ═╬═
«       ║
«c1_1: ═╩═
«

[7]:

# Set the simulator
# Add a rotation error
err_unitary = np.zeros([2,2],dtype=complex)
angle_err = 0.1
for i in range(2):
    err_unitary[i,i] = np.cos(angle_err)
    err_unitary[i,(i+1) % 2] = np.sin(angle_err)
err_unitary[0,1] *= -1.0

error = coherent_unitary_error(err_unitary)
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error, 'u2')

# Run the simulator
backend = qiskit.Aer.get_backend('qasm_simulator')
shots = 500
backend_result1 = qiskit.execute(circs, backend,
                                shots=shots, noise_model=noise_model).result()

[8]:

%matplotlib inline
# Fit the data to an oscillation

plt.figure(figsize=(10, 6))
initial_theta = 0.02
initial_c = 0.5
initial_phi = 0.1


fit = AmpCalFitter(backend_result1, xdata, qubits,
                   fit_p0=[initial_theta, initial_c],
                   fit_bounds=([-np.pi, -1],
                               [np.pi, 1]))

# plot the result for the number 1 indexed qubit.
# In this case that refers to Q2 since we passed in as [4, 2])
fit.plot(1, ax=plt.gca())

print("Rotation Error on U2: %f rads"%(fit.angle_err()[0]))
plt.show()

Rotation Error on U2: 0.100412 rads

../../_images/tutorials_noise_1_hamiltonian_and_gate_characterization_14_1.png

単一量子ビット・ゲートにおける角度エラーの特性評価¶

X ゲートと Y ゲートの間の角度を測定します。:

[9]:

qubits = [0,1]
circs, xdata = anglecal_1Q_circuits(10, qubits, angleerr=0.1)

角度エラーを測定するためのゲートシーケンス:

[10]:

#The U1 gates are added errors to test the procedure
print(circs[2])

         ┌─────────┐┌──────────┐ ░ ┌────────────────┐ ░ ┌────────────────┐»
q2_0: |0>┤ U2(0,0) ├┤ U1(-0.2) ├─░─┤ U2(-pi/2,pi/2) ├─░─┤ U2(-pi/2,pi/2) ├»
         ├─────────┤├──────────┤ ░ ├────────────────┤ ░ ├────────────────┤»
q2_1: |0>┤ U2(0,0) ├┤ U1(-0.2) ├─░─┤ U2(-pi/2,pi/2) ├─░─┤ U2(-pi/2,pi/2) ├»
         └─────────┘└──────────┘ ░ └────────────────┘ ░ └────────────────┘»
 c2_0: 0 ═════════════════════════════════════════════════════════════════»
                                                                          »
 c2_1: 0 ═════════════════════════════════════════════════════════════════»
                                                                          »
«      ┌─────────┐ ░ ┌─────────┐ ░ ┌─────────┐┌──────────┐ ░ ┌────────────────┐»
«q2_0: ┤ U1(0.2) ├─░─┤ U2(0,0) ├─░─┤ U2(0,0) ├┤ U1(-0.2) ├─░─┤ U2(-pi/2,pi/2) ├»
«      ├─────────┤ ░ ├─────────┤ ░ ├─────────┤├──────────┤ ░ ├────────────────┤»
«q2_1: ┤ U1(0.2) ├─░─┤ U2(0,0) ├─░─┤ U2(0,0) ├┤ U1(-0.2) ├─░─┤ U2(-pi/2,pi/2) ├»
«      └─────────┘ ░ └─────────┘ ░ └─────────┘└──────────┘ ░ └────────────────┘»
«c2_0: ════════════════════════════════════════════════════════════════════════»
«                                                                              »
«c2_1: ════════════════════════════════════════════════════════════════════════»
«                                                                              »
«       ░ ┌────────────────┐┌─────────┐ ░ ┌─────────┐ ░ ┌─────────┐┌──────────┐»
«q2_0: ─░─┤ U2(-pi/2,pi/2) ├┤ U1(0.2) ├─░─┤ U2(0,0) ├─░─┤ U2(0,0) ├┤ U1(-0.1) ├»
«       ░ ├────────────────┤├─────────┤ ░ ├─────────┤ ░ ├─────────┤├──────────┤»
«q2_1: ─░─┤ U2(-pi/2,pi/2) ├┤ U1(0.2) ├─░─┤ U2(0,0) ├─░─┤ U2(0,0) ├┤ U1(-0.1) ├»
«       ░ └────────────────┘└─────────┘ ░ └─────────┘ ░ └─────────┘└──────────┘»
«c2_0: ════════════════════════════════════════════════════════════════════════»
«                                                                              »
«c2_1: ════════════════════════════════════════════════════════════════════════»
«                                                                              »
«      ┌────────────────┐┌─┐
«q2_0: ┤ U2(-pi/2,pi/2) ├┤M├───
«      ├────────────────┤└╥┘┌─┐
«q2_1: ┤ U2(-pi/2,pi/2) ├─╫─┤M├
«      └────────────────┘ ║ └╥┘
«c2_0: ═══════════════════╩══╬═
«                            ║
«c2_1: ══════════════════════╩═
«

[11]:

# Set the simulator
# Run the simulator
backend = qiskit.Aer.get_backend('qasm_simulator')
shots = 1000
backend_result1 = qiskit.execute(circs, backend,
                                shots=shots).result()

[12]:

%matplotlib inline
# Fit the data to an oscillation

plt.figure(figsize=(10, 6))
initial_theta = 0.02
initial_c = 0.5
initial_phi = 0.01


fit = AngleCalFitter(backend_result1, xdata, qubits,
                   fit_p0=[initial_theta, initial_c],
                   fit_bounds=([-np.pi, -1],
                               [np.pi, 1]))

fit.plot(0, ax=plt.gca())

print("Angle error between X and Y: %f rads"%(fit.angle_err()[0]))
plt.show()

Angle error between X and Y: 0.096159 rads

../../_images/tutorials_noise_1_hamiltonian_and_gate_characterization_21_1.png

CX ゲートにおける振幅エラーの特性評価¶

これにより、CXゲートの回転エラーが検出されます。ゲートが実際に \(CR_x(\pi/2+\delta)\) の場合、\(\delta\) を測定します。これは、制御量子ビット (状態:math:|1rangle`に設定されています) を指定しなければならないことと、回転が :math:pi` であることを除いて、単一量子ビットの振幅エラーの較正と非常に似ています。

[13]:

# We can specify more than one CX gate to calibrate in parallel
# but these lists must be the same length and not contain
# any duplicate elements
qubits = [0,2]
controls = [1,3]
circs, xdata = ampcal_cx_circuits(15, qubits, controls)

Q0-Q1 および Q2-Q3 上の CX ゲートの振幅を並列に較正するゲート・シーケンス :

[14]:

print(circs[2])

         ┌────────────────┐ ░ ┌───┐ ░ ┌───┐┌─┐
q3_0: |0>┤ U2(-pi/2,pi/2) ├─░─┤ X ├─░─┤ X ├┤M├───
         └─────┬───┬──────┘ ░ └─┬─┘ ░ └─┬─┘└╥┘
q3_1: |0>──────┤ X ├────────░───■───░───■───╫────
         ┌─────┴───┴──────┐ ░ ┌───┐ ░ ┌───┐ ║ ┌─┐
q3_2: |0>┤ U2(-pi/2,pi/2) ├─░─┤ X ├─░─┤ X ├─╫─┤M├
         └─────┬───┬──────┘ ░ └─┬─┘ ░ └─┬─┘ ║ └╥┘
q3_3: |0>──────┤ X ├────────░───■───░───■───╫──╫─
               └───┘        ░       ░       ║  ║
 c3_0: 0 ═══════════════════════════════════╩══╬═
                                               ║
 c3_1: 0 ══════════════════════════════════════╩═

[15]:

# Set the simulator
# Add a rotation error on CX
# only if the control is in the excited state
err_unitary = np.eye(4,dtype=complex)
angle_err = 0.15
for i in range(2):
    err_unitary[2+i,2+i] = np.cos(angle_err)
    err_unitary[2+i,2+(i+1) % 2] = -1j*np.sin(angle_err)

error = coherent_unitary_error(err_unitary)
noise_model = NoiseModel()
noise_model.add_nonlocal_quantum_error(error, 'cx', [1,0], [0,1])

# Run the simulator
backend = qiskit.Aer.get_backend('qasm_simulator')
shots = 1500
backend_result1 = qiskit.execute(circs, backend,
                                shots=shots, noise_model=noise_model).result()

[16]:

%matplotlib inline
# Fit the data to an oscillation

plt.figure(figsize=(10, 6))
initial_theta = 0.02
initial_c = 0.5
initial_phi = 0.01


fit = AmpCalCXFitter(backend_result1, xdata, qubits,
                   fit_p0=[initial_theta, initial_c],
                   fit_bounds=([-np.pi, -1],
                               [np.pi, 1]))

fit.plot(0, ax=plt.gca())

print("Rotation Error on CX: %f rads"%(fit.angle_err()[0]))
plt.show()

Rotation Error on CX: 0.149493 rads

../../_images/tutorials_noise_1_hamiltonian_and_gate_characterization_28_1.png

CXゲートにおける角度エラーの特性評価¶

Measure the angle error \(\theta\) in the CX gate, i.e. \(CR_{\cos(\theta)X+\sin(\theta)Y}(\pi/2)\) with respect to the angle of the single qubit gates.

[17]:

qubits = [0,2]
controls = [1,3]
circs, xdata = anglecal_cx_circuits(15, qubits, controls, angleerr=0.1)

Q0-Q1 および Q3-Q4 の CX 角度を並行して調整するゲート・シーケンス:

[18]:

print(circs[2])

         ┌─────────┐┌──────────┐ ░ ┌───┐┌─────────┐┌───┐┌──────────┐ ░ ┌───┐»
q4_0: |0>┤ U2(0,0) ├┤ U1(-0.1) ├─░─┤ X ├┤ U1(0.1) ├┤ Y ├┤ U1(-0.1) ├─░─┤ X ├»
         └──┬───┬──┘└──────────┘ ░ └─┬─┘└─────────┘└───┘└──────────┘ ░ └─┬─┘»
q4_1: |0>───┤ X ├────────────────░───■───────────────────────────────░───■──»
         ┌──┴───┴──┐┌──────────┐ ░ ┌───┐┌─────────┐┌───┐┌──────────┐ ░ ┌───┐»
q4_2: |0>┤ U2(0,0) ├┤ U1(-0.1) ├─░─┤ X ├┤ U1(0.1) ├┤ Y ├┤ U1(-0.1) ├─░─┤ X ├»
         └──┬───┬──┘└──────────┘ ░ └─┬─┘└─────────┘└───┘└──────────┘ ░ └─┬─┘»
q4_3: |0>───┤ X ├────────────────░───■───────────────────────────────░───■──»
            └───┘                ░                                   ░      »
 c4_0: 0 ═══════════════════════════════════════════════════════════════════»
                                                                            »
 c4_1: 0 ═══════════════════════════════════════════════════════════════════»
                                                                            »
«      ┌─────────┐┌───┐┌────────────────┐┌─┐
«q4_0: ┤ U1(0.1) ├┤ Y ├┤ U2(-pi/2,pi/2) ├┤M├───
«      └─────────┘└───┘└────────────────┘└╥┘
«q4_1: ───────────────────────────────────╫────
«      ┌─────────┐┌───┐┌────────────────┐ ║ ┌─┐
«q4_2: ┤ U1(0.1) ├┤ Y ├┤ U2(-pi/2,pi/2) ├─╫─┤M├
«      └─────────┘└───┘└────────────────┘ ║ └╥┘
«q4_3: ───────────────────────────────────╫──╫─
«                                         ║  ║
«c4_0: ═══════════════════════════════════╩══╬═
«                                            ║
«c4_1: ══════════════════════════════════════╩═
«

[19]:

# Set the simulator
# Run the simulator
backend = qiskit.Aer.get_backend('qasm_simulator')
shots = 1000
backend_result1 = qiskit.execute(circs, backend,
                                shots=shots).result()

[20]:

%matplotlib inline
# Fit the data to an oscillation

plt.figure(figsize=(10, 6))
initial_theta = 0.02
initial_c = 0.5
initial_phi = 0.01


fit = AngleCalCXFitter(backend_result1, xdata, qubits,
                   fit_p0=[initial_theta, initial_c],
                   fit_bounds=([-np.pi, -1],
                               [np.pi, 1]))

fit.plot(0, ax=plt.gca())

print("Rotation Error on CX: %f rads"%(fit.angle_err()[0]))
plt.show()

Rotation Error on CX: 0.099402 rads

../../_images/tutorials_noise_1_hamiltonian_and_gate_characterization_35_1.png

[2]:

import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
Qiskit	None
Terra	0.9.0
Aer	0.3.0
Ignis	0.2.0
Aqua	0.5.3
IBM Q Provider	0.3.2rc1
System information
Python	3.7.4 (default, Aug 13 2019, 15:17:50) [Clang 4.0.1 (tags/RELEASE_401/final)]
OS	Darwin
CPUs	4
Memory (Gb)	16.0
Wed Aug 21 21:30:24 2019 EDT

This code is a part of Qiskit

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.

[ ]: