注釈

当ページは`tutorials/noise/4_randomized_benchmarking.ipynb`__から生成されました。

Run interactively in the IBM Quantum lab.

ランダマイズド・ベンチマーキング¶

はじめに¶

**ランダムマイズド・ベンチマーキング（RB）**は、量子ビットを初期状態に戻すランダムクリフォードゲートのシーケンスを実行して、平均ゲートパフォーマンスを測定するためのよく知られた手法です。Qiskit Ignis には、1および2量子ビットのクリフォードゲートシーケンスを同時に生成するツールがあります。

このノートブックでは、ignis.verification.randomized_benchmarking モジュールの使用方法を示します。ここでの例として、1量子ビットRBと同時に2量子ビットRBを実行する方法を示します。また、RBの忠実度を予測するためのコンパニオン関数の一部を使用する方法についての例も示します。

[1]:

#Import general libraries (needed for functions)
import numpy as np
import matplotlib.pyplot as plt
from IPython import display

#Import Qiskit classes
import qiskit
from qiskit.providers.aer.noise import NoiseModel
from qiskit.providers.aer.noise.errors.standard_errors import depolarizing_error, thermal_relaxation_error

#Import the RB Functions
import qiskit.ignis.verification.randomized_benchmarking as rb

1) RB実行におけるパラメータの選択¶

First, we need to choose the following parameters:

nseeds: The number of seeds. For each seed you will get a separate list of output circuits in rb_circs.
length_vector: The length vector of Clifford lengths. Must be in ascending order. RB sequences of increasing length grow on top of the previous sequences.
rb_pattern: A list of the form [[i,j],[k],…] which will make simultaneous RB sequences where Qi,Qj are a 2-qubit RB sequence and Qk is a 1-qubit sequence, etc. The number of qubits is the sum of the entries. For ‘regular’ RB the qubit_pattern is just [[0]],[[0,1]].
length_multiplier: If this is an array it scales each rb_sequence by the multiplier.
seed_offset: What to start the seeds at (e.g. if we want to add more seeds later).
align_cliffs: If true adds a barrier across all qubits in rb_pattern after each set of cliffords.

この例では、3つの量子ビットQ0、Q1、Q2があります。2Q RB（量子ビット Q0、Q2）と1Q RB（量子ビットQ1）を同時に実行しています。1Qクリフォードゲートの数は2倍です。

[2]:

#Number of qubits
nQ = 3
#There are 3 qubits: Q0,Q1,Q2.
#Number of seeds (random sequences)
nseeds = 5
#Number of Cliffords in the sequence (start, stop, steps)
nCliffs = np.arange(1,200,20)
#2Q RB on Q0,Q2 and 1Q RB on Q1
rb_pattern = [[0,2],[1]]
#Do three times as many 1Q Cliffords
length_multiplier = [1,3]

2) RBシーケンスを生成する¶

We generate RB sequences. We start with a small example (so it doesn’t take too long to run).

In order to generate the RB sequences rb_circs, which is a list of lists of quantum circuits, we run the function rb.randomized_benchmarking_seq.

この関数は次を返します:

rb_circs: A list of lists of circuits for the rb sequences (separate list for each seed).
xdata: クリフォードの長さ（該当する場合は乗数を含む）。

[3]:

rb_opts = {}
rb_opts['length_vector'] = nCliffs
rb_opts['nseeds'] = nseeds
rb_opts['rb_pattern'] = rb_pattern
rb_opts['length_multiplier'] = length_multiplier
rb_circs, xdata = rb.randomized_benchmarking_seq(**rb_opts)

例として、最初のRBシーケンスに対応する回路を出力します。

[4]:

print(rb_circs[0][0])

                        ┌───┐┌───┐┌───┐      ░  ┌───┐ ┌─────┐┌───┐            »
qr_0: |0>────────────■──┤ H ├┤ S ├┤ X ├──────░──┤ X ├─┤ Sdg ├┤ H ├────────────»
         ┌───┐┌───┐  │  ├───┤└─░─┘├───┤┌───┐ ░  ├───┤ └──░──┘├───┤┌─────┐┌───┐»
qr_1: |0>┤ H ├┤ H ├──┼──┤ S ├──░──┤ H ├┤ S ├────┤ X ├────░───┤ H ├┤ Sdg ├┤ H ├»
         ├───┤├───┤┌─┴─┐├───┤┌───┐└───┘└───┘ ░ ┌┴───┴┐ ┌───┐ └───┘└─────┘└───┘»
qr_2: |0>┤ H ├┤ S ├┤ X ├┤ H ├┤ S ├───────────░─┤ Sdg ├─┤ H ├──────────────────»
         └───┘└───┘└───┘└───┘└───┘           ░ └─────┘ └───┘                  »
 cr_0: 0 ═════════════════════════════════════════════════════════════════════»
                                                                              »
 cr_1: 0 ═════════════════════════════════════════════════════════════════════»
                                                                              »
 cr_2: 0 ═════════════════════════════════════════════════════════════════════»
                                                                              »
«                  ┌─┐
«qr_0: ──■─────────┤M├───────────
«        │     ░   └╥┘     ┌─┐
«qr_1: ──┼─────░────╫──────┤M├───
«      ┌─┴─┐┌─────┐ ║ ┌───┐└╥┘┌─┐
«qr_2: ┤ X ├┤ Sdg ├─╫─┤ H ├─╫─┤M├
«      └───┘└─────┘ ║ └───┘ ║ └╥┘
«cr_0: ═════════════╩═══════╬══╬═
«                           ║  ║
«cr_1: ═════════════════════╬══╩═
«                           ║
«cr_2: ═════════════════════╩════
«

1回路のユニタリーを見る¶

計算された反転ゲートを含むランダムなクリフォード要素をかけているため、各RB回路を表すユニタリー行列は（グローバル位相で）恒等変換である必要があります。Aerユニタリーシミュレータを使用してこれをシミュレートします。

[5]:

#Create a new circuit without the measurement
qc = qiskit.QuantumCircuit(*rb_circs[0][-1].qregs,*rb_circs[0][-1].cregs)
for i in rb_circs[0][-1][0:-nQ]:
    qc.data.append(i)

[6]:

#The Unitary is an identity (with a global phase)
backend = qiskit.Aer.get_backend('unitary_simulator')
basis_gates = ['u1', 'u2', 'u3', 'cx'] # use U,CX for now
job = qiskit.execute(qc, backend=backend, basis_gates=basis_gates)
print(np.around(job.result().get_unitary(), 3))

[[ 0.+1.j -0.+0.j  0.-0.j  0.-0.j -0.-0.j  0.+0.j -0.+0.j  0.-0.j]
 [-0.-0.j  0.+1.j -0.+0.j  0.-0.j  0.-0.j  0.+0.j -0.-0.j -0.+0.j]
 [ 0.+0.j -0.+0.j  0.+1.j -0.+0.j -0.-0.j  0.+0.j -0.-0.j  0.+0.j]
 [-0.+0.j  0.+0.j -0.-0.j  0.+1.j  0.-0.j -0.-0.j  0.-0.j  0.+0.j]
 [ 0.+0.j  0.-0.j  0.+0.j -0.-0.j  0.+1.j -0.+0.j  0.-0.j -0.+0.j]
 [ 0.-0.j -0.+0.j -0.+0.j -0.+0.j  0.+0.j  0.+1.j  0.-0.j  0.-0.j]
 [ 0.+0.j  0.-0.j -0.+0.j  0.-0.j  0.+0.j  0.-0.j  0.+1.j  0.-0.j]
 [-0.-0.j  0.+0.j  0.-0.j -0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+1.j]]

ノイズモデルを定義する¶

シミュレータのノイズモデルを定義します。減衰をシミュレートするために、CNOTおよびUゲートに脱分極誤差確率を追加します。

[7]:

noise_model = NoiseModel()
p1Q = 0.002
p2Q = 0.01
noise_model.add_all_qubit_quantum_error(depolarizing_error(p1Q, 1), 'u2')
noise_model.add_all_qubit_quantum_error(depolarizing_error(2*p1Q, 1), 'u3')
noise_model.add_all_qubit_quantum_error(depolarizing_error(p2Q, 2), 'cx')

3）AerシミュレータでRBシーケンスを実行する¶

Qiskit Aer シミュレーター（ノイズモデル版）またはIBMQプロバイダーを使用してRBシーケンスを実行し、結果のリスト``result_list``を取得できます。

[8]:

backend = qiskit.Aer.get_backend('qasm_simulator')
basis_gates = ['u1','u2','u3','cx'] # use U,CX for now
shots = 200
result_list = []
transpile_list = []
import time
for rb_seed,rb_circ_seed in enumerate(rb_circs):
    print('Compiling seed %d'%rb_seed)
    rb_circ_transpile = qiskit.transpile(rb_circ_seed, basis_gates=basis_gates)
    print('Simulating seed %d'%rb_seed)
    job = qiskit.execute(rb_circ_transpile, noise_model=noise_model, shots=shots, backend=backend, backend_options={'max_parallel_experiments': 0})
    result_list.append(job.result())
    transpile_list.append(rb_circ_transpile)
print("Finished Simulating")

Compiling seed 0
Simulating seed 0
Compiling seed 1
Simulating seed 1
Compiling seed 2
Simulating seed 2
Compiling seed 3
Simulating seed 3
Compiling seed 4
Simulating seed 4
Finished Simulating

4）RB結果を当てはめ、ゲート忠実度を計算する¶

生存確率に関する統計を取得する¶

The results in result_list should fit to an exponentially decaying function \(A \cdot \alpha ^ m + B\), where \(m\) is the Clifford length.

:math:`alpha`から、クリフォードあたりの誤差（Error per Clifford、EPC） が計算できます。:

\[EPC = \frac{2^n-1}{2^n} (1-\alpha)\]

(where \(n=nQ\) is the number of qubits).

[9]:

#Create an RBFitter object with 1 seed of data
rbfit = rb.fitters.RBFitter(result_list[0], xdata, rb_opts['rb_pattern'])

1シードのプロット¶

[10]:

plt.figure(figsize=(15, 6))

for i in range(2):
    ax = plt.subplot(1, 2, i+1)
    pattern_ind = i

    # Plot the essence by calling plot_rb_data
    rbfit.plot_rb_data(pattern_ind, ax=ax, add_label=True, show_plt=False)

    # Add title and label
    ax.set_title('%d Qubit RB'%(len(rb_opts['rb_pattern'][i])), fontsize=18)

plt.show()

../../_images/tutorials_noise_4_randomized_benchmarking_20_0.png

残りのシードのプロット¶

プロットは各シードの後に更新されます。

[11]:

rbfit = rb.fitters.RBFitter(result_list[0], xdata, rb_opts['rb_pattern'])

for seed_num, data in enumerate(result_list):#range(1,len(result_list)):
    plt.figure(figsize=(15, 6))
    axis = [plt.subplot(1, 2, 1), plt.subplot(1, 2, 2)]

    # Add another seed to the data
    rbfit.add_data([data])

    for i in range(2):
        pattern_ind = i

        # Plot the essence by calling plot_rb_data
        rbfit.plot_rb_data(pattern_ind, ax=axis[i], add_label=True, show_plt=False)

        # Add title and label
        axis[i].set_title('%d Qubit RB - after seed %d'%(len(rb_opts['rb_pattern'][i]), seed_num), fontsize=18)

    # Display
    display.display(plt.gcf())

    # Clear display after each seed and close
    display.clear_output(wait=True)
    time.sleep(1.0)
    plt.close()

../../_images/tutorials_noise_4_randomized_benchmarking_22_0.png

データにショットを追加する¶

[12]:

shots = 200
result_list = []
transpile_list = []
for rb_seed,rb_circ_seed in enumerate(rb_circs):
    print('Compiling seed %d'%rb_seed)
    rb_circ_transpile = qiskit.transpile(rb_circ_seed, basis_gates=basis_gates)
    print('Simulating seed %d'%rb_seed)
    job = qiskit.execute(rb_circ_transpile, noise_model=noise_model, shots=shots, backend=backend, backend_options={'max_parallel_experiments': 0})
    result_list.append(job.result())
    transpile_list.append(rb_circ_transpile)
print("Finished Simulating")

Compiling seed 0
Simulating seed 0
Compiling seed 1
Simulating seed 1
Compiling seed 2
Simulating seed 2
Compiling seed 3
Simulating seed 3
Compiling seed 4
Simulating seed 4
Finished Simulating

[13]:

#Add this data to the previous fit
rbfit.add_data(result_list)

#Replot
plt.figure(figsize=(15, 6))

for i in range(2):
    ax = plt.subplot(1, 2, i+1)
    pattern_ind = i

    # Plot the essence by calling plot_rb_data
    rbfit.plot_rb_data(pattern_ind, ax=ax, add_label=True, show_plt=False)

    # Add title and label
    ax.set_title('%d Qubit RB'%(len(rb_opts['rb_pattern'][i])), fontsize=18)

plt.show()

../../_images/tutorials_noise_4_randomized_benchmarking_25_0.png

ゲート忠実度の予測¶

シミュレーションにおける既知の脱分極誤差から、**忠実度**を予測できます。まず、**クリフォードあたりのゲート数**を数える必要があります。

The function gates_per_clifford takes a list of transpiled RB circuits and outputs the number of basis gates in each circuit.

[22]:

#Count the number of single and 2Q gates in the 2Q Cliffords
gates_per_cliff = rb.rb_utils.gates_per_clifford(transpile_list,xdata[0],basis_gates,rb_opts['rb_pattern'][0])
for basis_gate in basis_gates:
    print("Number of %s gates per Clifford: %f "%(basis_gate ,
                                                  np.mean([gates_per_cliff[0][basis_gate],
                                                           gates_per_cliff[2][basis_gate]])))

Number of u1 gates per Clifford: 0.271522
Number of u2 gates per Clifford: 0.923587
Number of u3 gates per Clifford: 0.490109
Number of cx gates per Clifford: 1.526739

The function calculate_2q_epc gives measured errors in the basis gates that were used to construct the Clifford. It assumes that the error in the underlying gates is depolarizing. It outputs the error per a 2-qubit Clifford.

The input to this function is: - gate_per_cliff: dictionary of gate per Clifford. - epg_2q: EPG estimated by error model. - qubit_pair: index of two qubits to calculate EPC. - list_epgs_1q: list of single qubit EPGs of qubit listed in qubit_pair. - two_qubit_name: name of two qubit gate in basis gates (default is cx).

[15]:

# Error per gate from noise model
epgs_1q = {'u1': 0, 'u2': p1Q/2, 'u3': 2*p1Q/2}
epg_2q = p2Q*3/4
pred_epc = rb.rb_utils.calculate_2q_epc(
    gate_per_cliff=gates_per_cliff,
    epg_2q=epg_2q,
    qubit_pair=[0, 2],
    list_epgs_1q=[epgs_1q, epgs_1q])

# Calculate the predicted epc
print("Predicted 2Q Error per Clifford: %e"%pred_epc)

Predicted 2Q Error per Clifford: 1.591172e-02

T1、T2エラーのあるRBシーケンスを実行する¶

次に、2量子ビットのクリフォードのみを含むRBシーケンスを選択します。

以前のようにこれらのシーケンスを実行しますが、T1/T2熱緩和エラーで拡張されたノイズモデルを使用して、指数関数的に減衰する曲線を近似します。

[16]:

rb_opts2 = rb_opts.copy()
rb_opts2['rb_pattern'] = [[0,1]]
rb_opts2['length_multiplier'] = 1
rb_circs2, xdata2 = rb.randomized_benchmarking_seq(**rb_opts2)

noise_model2 = NoiseModel()

#Add T1/T2 noise to the simulation
t1 = 100.
t2 = 80.
gate1Q = 0.1
gate2Q = 0.5
noise_model2.add_all_qubit_quantum_error(thermal_relaxation_error(t1,t2,gate1Q), 'u2')
noise_model2.add_all_qubit_quantum_error(thermal_relaxation_error(t1,t2,2*gate1Q), 'u3')
noise_model2.add_all_qubit_quantum_error(
    thermal_relaxation_error(t1,t2,gate2Q).tensor(thermal_relaxation_error(t1,t2,gate2Q)), 'cx')

[17]:

backend = qiskit.Aer.get_backend('qasm_simulator')
basis_gates = ['u1','u2','u3','cx'] # use U,CX for now
shots = 500
result_list2 = []
transpile_list2 = []
for rb_seed,rb_circ_seed in enumerate(rb_circs2):
    print('Compiling seed %d'%rb_seed)
    rb_circ_transpile = qiskit.transpile(rb_circ_seed, basis_gates=basis_gates)
    print('Simulating seed %d'%rb_seed)
    job = qiskit.execute(rb_circ_transpile, noise_model=noise_model, shots=shots, backend=backend, backend_options={'max_parallel_experiments': 0})
    result_list2.append(job.result())
    transpile_list2.append(rb_circ_transpile)
print("Finished Simulating")

Compiling seed 0
Simulating seed 0
Compiling seed 1
Simulating seed 1
Compiling seed 2
Simulating seed 2
Compiling seed 3
Simulating seed 3
Compiling seed 4
Simulating seed 4
Finished Simulating

[18]:

#Create an RBFitter object
rbfit = rb.RBFitter(result_list2, xdata2, rb_opts2['rb_pattern'])

plt.figure(figsize=(10, 6))
ax = plt.gca()

# Plot the essence by calling plot_rb_data
rbfit.plot_rb_data(0, ax=ax, add_label=True, show_plt=False)

# Add title and label
ax.set_title('2 Qubit RB with T1/T2 noise', fontsize=18)

plt.show()

../../_images/tutorials_noise_4_randomized_benchmarking_34_0.png

以前と同様に、**クリフォードあたりのゲート数**を再度カウントし、コヒーレンス限界から予測されるプリミティブゲートエラーを使用して、**2量子ビットのクリフォードゲートエラー**を計算します。

[23]:

#Count the number of single and 2Q gates in the 2Q Cliffords
gates_per_cliff = rb.rb_utils.gates_per_clifford(transpile_list2,xdata[0],basis_gates,rb_opts2['rb_pattern'][0])
for basis_gate in basis_gates:
    print("Number of %s gates per Clifford: %f "%(basis_gate ,
                                                  np.mean([gates_per_cliff[0][basis_gate],
                                                           gates_per_cliff[1][basis_gate]])))

Number of u1 gates per Clifford: 0.250761
Number of u2 gates per Clifford: 0.969565
Number of u3 gates per Clifford: 0.489130
Number of cx gates per Clifford: 1.503696

[20]:

# Predicted primitive gate errors from the coherence limit
u2_error = rb.rb_utils.coherence_limit(1,[t1],[t2],gate1Q)
u3_error = rb.rb_utils.coherence_limit(1,[t1],[t2],2*gate1Q)
epg_2q = rb.rb_utils.coherence_limit(2,[t1,t1],[t2,t2],gate2Q)
epgs_1q = {'u1': 0, 'u2': u2_error, 'u3': u3_error}
pred_epc = rb.rb_utils.calculate_2q_epc(
    gate_per_cliff=gates_per_cliff,
    epg_2q=epg_2q,
    qubit_pair=[0, 1],
    list_epgs_1q=[epgs_1q, epgs_1q])

# Calculate the predicted epc
print("Predicted 2Q Error per Clifford: %e"%pred_epc)

Predicted 2Q Error per Clifford: 1.313111e-02

[21]:

import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
Qiskit	0.16.1
Terra	0.13.0.dev0+98fd14e
Aer	0.4.1
Ignis	0.3.0.dev0+dd2c926
Aqua	0.6.4
IBM Q Provider	0.5.0
System information
Python	3.7.6 (default, Jan 8 2020, 19:59:22) [GCC 7.3.0]
OS	Linux
CPUs	8
Memory (Gb)	62.920127868652344
Fri Mar 27 15:44:43 2020 IST

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.

[ ]: