Korean
언어
English
Japanese
German
Korean
Portuguese, Brazilian
French
Table of Contents
  • Docs >
  • 해밀토니안과 게이트 정의
Shortcuts

참고

이 페이지는 “tutorials/noise/1_hamian_and_gate_glnb” __ 에서 생성되었다.

Run interactively in the IBM Quantum lab.

해밀토니안과 게이트 정의

이 노트북은 Qiskit Ignis의 characterization.hamiltonian``와 ``characterization.gates 모듈을 사용하는 방법을 알려주는 예로 구성되어 있다. 이론적인 배경지식을 위해서는 `Ignis Community Notebooks <https://github.com/Qiskit/qiskit-community-tutorials/tree/master/ignis>`__를 참조하라.

[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 모듈은 쌍을 이룬 큐비트 사이에서 ZZ를 측정하는 실험을 수행하기 위해 회로를 만든다. 여기서 \(|11\rangle\) state: 상태에서의 에너지 이동으로 정의된다.

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

\(\xi\)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)

적합자(fitter)의 특징 중 하나는 회로를 여러 개의 작업으로 나누고 그 결과를 적합자에게 목록으로 제공할 수 있다는 것이다. 이는 아래에서 설명된다.

[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 게이트의 진폭 에러 특성

This looks for a rotation error in the CX gate, i.e. if the gate is actually \(CR_x(\pi/2+\delta)\) measure \(\delta\). This is very similar to the single qubit amplitude error calibration except we need to specify a control qubit (which is set to be in state \(|1\rangle\)) and the rotation is \(\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 SoftwareVersion
QiskitNone
Terra0.9.0
Aer0.3.0
Ignis0.2.0
Aqua0.5.3
IBM Q Provider0.3.2rc1
System information
Python3.7.4 (default, Aug 13 2019, 15:17:50) [Clang 4.0.1 (tags/RELEASE_401/final)]
OSDarwin
CPUs4
Memory (Gb)16.0
Wed Aug 21 21:30:24 2019 EDT

This code is a part of Qiskit

© Copyright IBM 2017, 2019.

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.

[ ]:

© Copyright 2021, Qiskit Development Team. 최종 업데이트: 2021/06/04

Built with Sphinx using a theme provided by Read the Docs.