Sampler#

Samplerは、その名の通り、量子回路の出力からサンプリングして、擬似的な確率分布を推定します。出力からサンプリングすることで、量子回路の準確率分布全体を推定することができます。この機能は、回路設計の際に、回路全体の分布データを調べたり、作業する必要がある場合に、特に有効な機能です。つまり、ユーザーからの回路を入力とし、準確率のエラー軽減された読み出しを生成するプログラムです。このプログラムにより、ユーザーはエラー緩和を用いたショット結果をより適切に評価することができ、破壊的干渉の文脈で複数の関連するデータポイントの可能性をより効率的に評価することができるようになります。

これは要するに、回路を実行させたときに得られるおなじみの「counts」の出力と非常によく似ていますが、Samplerは、エラー緩和ルーチンの結果として準確率分布の出力を得ることができます。

簡単に言えば、より広い範囲の情報データを自由に使えるようになるのです。準確率分布の表現から得られる情報は，真の確率分布の尤度を調べたり，サンプリングのオーバーヘッドと引き換えに不偏の期待値ポイントを計算したりするのに，より関連性があると思われます。これらの分布はある意味で真の確率論と同じように振る舞いますが、異なるのは、元の理論の制約がいくつか緩和されていることです。その1つが、「負の」確率を表す負のデータポイントが存在する可能性です（ただし、集合的に和が1になることはあります）。また、このデータから、使用状況に基づいて真の確率分布を推定することもできます。例：グローバー探索、QSVMルーチン、スタビライザー計算、最適化ルーチンなど。

Smaplerは出力全体に対する完全な分布を与えますが、特定の結果に興味がある場合もあるでしょう。そこで、Estimator を見てみましょう！

Estimator#

Estimatorは、基本的に注目する演算子の期待値を計算し、受け取るものです。回路と観測値を取り込み、回路と観測値間を選択的にグルーピングして実行し、与えられたパラメータ入力に対する期待値と分散を効率的に評価するプログラム・インターフェースです。このPrimitiveにより、多くのアルゴリズムで必要とされる量子演算子の期待値の計算と解釈を効率的に行うことができます。

ある問題に対して最終的な解を求めることに興味があり、カウントの完全な分布を調べる必要がない人は、Estimator primitiveの方が便利だと感じるでしょう。このルーチンは、基本的にほとんどの近い将来の量子アルゴリズムに役立つもので、最も一般的な例は変分クラスのアルゴリズムです。Estimatorは回路だけでなく、量子観測量の期待値を計算するため、回路と観測量の入力が必要です。このような観測量には、分子の電子構造、最適化問題のコスト関数など、実に様々なものが含まれています。

Exercise1: ベルンシュタイン・ヴァジラニ アルゴリズム#

このアルゴリズムは、量子コンピューターを複雑な問題に適用した場合に優位性があることを示した特殊な量子アルゴリズムのうちの一つです。

入力と隠れたビット文字列$s$のビット積を返す関数があり，その長さは$n$です。

隠れたビット文字列を見つけるには、関数 $f$ を $n$ 回呼び出す必要があります。しかし、量子コンピューターを使用すると、関数を 1 回呼び出すだけ で100%の信頼度でこの問題を解くことができます。隠れたビット文字列を見つけるための量子ベルンシュタイン・ヴァジラニアルゴリズムは非常にシンプルです。

1. 入力量子ビットを状態 $|0{⟩}^{\otimes n}$ に初期化し、出力量子ビットを $|-⟩$ に初期化する。

2. アダマールゲートを入力レジスターに適用する。

3. オラクルに問い合わせる。

4. アダマールゲートを入力レジスターに適用する。

5. 測定する。

以下に、ベルンシュタイン・ヴァジラニ アルゴリズムが隠れたビット文字列 "001" を見つける例を示します。

hidden = "001"
print(len(hidden))

3

この隠れたビット文字列には、3つの入力量子ビットと1つの出力量子ビットが必要です。

# Make a quantum circuit
qc = QuantumCircuit(4, 3)
display(qc.draw(output="mpl"))

ステップ 1. 入力量子ビットを状態 $|0{⟩}^{\otimes n}$ に初期化し、出力量子ビットを $|-⟩$ に初期化します。

最初に、すべての量子ビットは $|0⟩$ として初期化されるため、入力量子ビットにゲートを適用する必要はありません。 ただし、出力量子ビットの状態は $|-⟩$ として変更する必要があります。 そのために、X-gate を適用してから H-gate (アダマールゲート) を適用します。

qc.x(3)
qc.h(3)
display(qc.draw(output="mpl"))

ステップ 2. アダマールゲートを入力レジスターに適用します。

各入力量子ビットにアダマールゲートを適用します。

qc.h(0)
qc.h(1)
qc.h(2)
display(qc.draw(output="mpl"))

ステップ 3. オラクルに問い合わせます。

CNOTゲートを使用してオラクルにクエリーを実行します。隠し回路が"001"であるため、CNOTゲートを量子ビット0と出力ゲートに適用します。

qc.cx(0,3)
display(qc.draw(output="mpl"))

ステップ 4. アダマールゲートを入力レジスターに適用します。

各入力量子ビットにアダマールゲートを再度適用します。

qc.h(0)
qc.h(1)
qc.h(2)
display(qc.draw(output="mpl"))

ステップ 5. 測定します。

measure メソッドですべての入力量子ビットを測定します。

qc.measure(range(3), range(3))
display(qc.draw(output="mpl"))

回路はシミュレーターで実行できます。下のセルを実行すると、結果を確認できます。

# Use local simulator
aer_sim = AerSimulator()
results = aer_sim.run(qc).result()
answer = results.get_counts()

print(answer)

{'001': 1024}

結果には、最初に設定した隠れたビット文字列"001"が表示されています。

def bernstein_vazirani(string):
    
    ##### Save the length of string
    string_length = len(string)
    
    ##### Make a quantum circuit
    qc = QuantumCircuit(string_length+1, string_length)
    
    ##### Initialize each input qubit to apply a Hadamard gate and output qubit to |->
    
    ###### build your code here #####
    
    ###### Apply an oracle for the given string
    ###### Note: In Qiskit, numbers are assigned to the bits in a string from right to left
    

    ###### build your code here #####

    
    ###### Apply Hadamard gates after querying the oracle
    

    ###### build your code here ######
    
    ###### Measurement
    qc.measure(range(string_length), range(string_length))
    
    return qc

def bernstein_vazirani(string):

    # Save the length of string
    string_length = len(string)

    # Make a quantum circuit
    qc = QuantumCircuit(string_length+1, string_length)

    # 1. Initialize each input qubit to apply a Hadamard gate and output qubit to |->
    qc.x(string_length)
    qc.h(range(string_length+1))
    qc.barrier()

    # 2. Apply an oracle for the given string
    # Note: In Qiskit, numbers are assigned to the bits in a string from right to left 
    string = string[::-1] # Reverse password to fit qiskit's qubit ordering
    for q in range(string_length):
        if string[q] == '1':
            qc.cx(q, string_length)
    qc.barrier()

    # 3. Apply Hadamard gates after querying the oracle
    qc.h(range(string_length))

    # Measurement
    qc.measure(range(string_length), range(string_length))

    return qc

ここで、上記の関数を呼び出して、定義されているベルンシュタイン・ヴァジラニ回路を構築します。

qc1 = bernstein_vazirani('111')
display(qc1.draw(output="mpl"))

この回路を実行する前に、先ほど述べたように、1つのSamplerセッションに対して複数の回路呼び出しと実行が可能です。そのことを示すために、もう1つベルンシュタイン・ヴァジラニ回路を作ることにします。

qc2 = bernstein_vazirani('000')
display(qc2.draw(output="mpl"))

回路実行のためにRuntimeを使う#

Qiskit Runtimeで量子回路を実行する前に、3つのステップがあることを忘れないでください。

1. 使用するBackendを設定する

2. Sessionを設定する

3. sessionの中でPrimitivesの Sampler または Estimator をインスタンス化

まず、使用するバックエンドを設定しましょう。 ここでは、クラウド上のibmq_qasm_simulator上でルーチンを実行することにします。ローカル上のAerSimulator上でルーチンを実行することにします。

backend = AerSimulator()

from qiskit_ibm_runtime import Options
options = Options(simulator={"seed_simulator": 42}) # Do not change values in simulator

with Session(service=service, backend=backend):
    sampler = Sampler(options=options)
    job = sampler.run(circuits=[qc1,qc2])

result.quasi_dists # => [{7: 1.0}, {0: 1.0}]

from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

pm = generate_preset_pass_manager(target=backend.target, optimization_level=1)
isa_qc1 = pm.run(qc1)
isa_qc2 = pm.run(qc2)

from qiskit_ibm_runtime import SamplerV2 as Sampler, EstimatorV2 as Estimator

sampler = Sampler(backend=backend)
pub_results = sampler.run([isa_qc1, isa_qc2]).result()

[pub_result.data.c.get_int_counts() for pub_result in pub_results]

[{7: 1024}, {0: 1024}]

この結果、各回路から2つの結果が得られます。最初の回路qc1の隠れ文字列は111であり、最初の結果は7（7は2進数で111）です。この確率は1.0であり、この回路は100%確実に7を返すということです。同様に、2番目の結果は0（0は2進数で000）であり、その確率も1.0です。

このように、回路を作るときに渡したビット列と同じ結果になります。どうしてこんなことが可能なのか、不思議に思われるかもしれません。下の画像を見てください：

4つのHゲートの間にCNOTゲートがあり、これは反転したCNOTゲートと同じす。これはキックバック（または位相キックバック）の例で、ゲートによってある量子ビットに加えられた固有値が、制御演算によって別の量子ビットにキックバックされるのです。これにより、ベルンシュタイン・ヴァジラニ回路は、隠されたビット列を明らかにすることができます。

Exercise2: パラメーター化された回路#

Primitivesのメリットの1つは、パラメーター化された回路に複数のパラメーターをバインドするのが簡単になることです。回路にパラメーターをバインドする方法の例については、 Qiskit Document をご覧ください。

ここでは制御Pゲート（制御位相ゲート）を使ったキックバックの別の例を紹介しましょう。Pゲート を回転パラメーターthetaでパラメター化します。

theta = Parameter('theta')

qc = QuantumCircuit(2,1)
qc.x(1)
qc.h(0)
qc.cp(theta,0,1)
qc.h(0)
qc.measure(0,0)

qc.draw("mpl")

上記の回路はパラメーター化されており、固有値は測定のために量子ビット 0 に戻されます。 キックバックの度合いは、パラメーター theta によって決まります。 下のセルで、上記の回路のパラメーターをリストとして定義します。ここでのパラメーターは、$0$ から $2\pi$ までを50等間隔のポイントで分割したものになります。

位相制御ゲートについて、異なる位相で回路を評価してみましょう：

phases = np.linspace(0, 2*np.pi, 50) # Specify the range of parameters to look within 0 to 2pi with 50 different phases

# Phases need to be expressed as list of lists in order to work
individual_phases = [[ph] for ph in phases]

上記の回路に適用する前に、ブロッホ球を使ってどのように見えるかをイメージしてみましょう。

# help understanding of how its phase is moving
from qiskit.visualization import plot_bloch_multivector

states = []

for i in range(0, 50, 10):
    
    temp = QuantumCircuit(2,1)
    temp.x(1)
    temp.h(0)
    temp.cp(individual_phases[i][0],0,1)
    temp.h(0)
    
    state = Statevector(temp)
    states.append(state)

plot_bloch_multivector(states[0])

plot_bloch_multivector(states[1])

plot_bloch_multivector(states[2])

plot_bloch_multivector(states[3])

plot_bloch_multivector(states[4])

それぞれの位相で状態が変化し、Y-Z軸に沿って回転しているのがわかると思います。さて、このパラメーターリストを回路 qc に適用して、次の演習を行ってみましょう。

with Session(service=service, backend=backend):    
    sampler = # build your code here
    job = # build your code here
    result = # build your code here

pm = generate_preset_pass_manager(target=backend.target, optimization_level=1)
isa_qc = pm.run(qc)

sampler = Sampler(backend=backend)
pubs = [(isa_qc, parameter_values) for parameter_values in individual_phases]
pubs_result = sampler.run(pubs).result()

上のコードセルは、パラメーター化された回路を受け取り、Runtimeサービスを使ってバックエンドで実行します。このルーチンは各パラメーターを定義された回路に結びつけ、その結果得られたすべての回路を実行し、集合的な結果を得ることができます。

それでは、得られた結果と理論的に推測される結果をプロットしてみましょう。これらの回路について、1つの状態となる確率の準分布を求めます。各回路は位相パラメーターとして異なるtheta値を持つことになります。

# The probablity of being in the 1 state for each of these values
num_shots = pubs_result[0].data.c.num_shots
pubs_result_counts_list = [pub_result.data.c.get_int_counts() for pub_result in pubs_result]
prob_values = [dist.get(1, 0) / num_shots for dist in pubs_result_counts_list]

plt.plot(phases, prob_values, 'o', label='simulator')
plt.plot(phases, np.sin(phases/2,)**2, label='theory')
plt.xlabel('Phase')
plt.ylabel('Probability')
plt.legend()

<matplotlib.legend.Legend at 0x7f4c3330f7d0>

黄色い線が理論値で、青い点はバックエンドで実行したときの値です。ほぼ理論と一致していますが、シミュレータ固有のランダム性により、結果の分布のカーブには若干のずれが生じています。

ここまでは擬確率分布を見てきましたが、期待値の評価という観点からも見てみましょう。

ハミルトニアンについて#

Estimatorの面白い使い方の一つは、特にオブザーバブルに関するハミルトニアンを計算するのに使えることです。

ハミルトニアンは量子力学的な演算子であり、運動エネルギーと位置エネルギーを含む系内の全エネルギー情報を持っています。
そのためハミルトニアンの計算が必要であり、そのエネルギー値を計算できれば、自然界におけるエネルギーや、機械学習におけるコストを計算することができます。
基底状態や励起状態を見つけることができるので量子物理学、量子化学、量子機械学習と密接に関係しています。

ハミルトニアンを計算するためには、パラメーター化された回路が必要です。RealAmplitudes を使えば、ランダムなパラメーター化された回路を簡単に作ることができます。以下にコード例を示します。

ansatz = RealAmplitudes(3, reps=2)  # create the circuit on 3 qubits
ansatz.decompose().draw("mpl")

このansatzは3量子ビットの回路で、reps は2です。この場合、パラメータの総数は$3\times (2+1)=9$となります。

Exercise 3: 期待値計算の推定ルーチンを構築#

##### Make three random circuits using RealAmplitudes

psi1 = # build your code here
psi2 = # build your code here
psi3 = # build your code here

##### Make hamiltonians using SparsePauliOp

H1 = # build your code here
H2 = # build your code here
H3 = # build your code here

##### Make a list of evenly spaced values for theta between 0 and 1

theta1 = # build your code here
theta2 = # build your code here
theta3 = # build your code here

##### Use the Estimator to calculate each expectation value

estimator = # build your code here

# calculate [ <psi1(theta1)|H1|psi1(theta1)>,
#             <psi2(theta2)|H2|psi2(theta2)>,
#             <psi3(theta3)|H3|psi3(theta3)> ]
# Note: Please keep the order
job = # build your code here    

pubs_result = # build your code here

psi1 = RealAmplitudes(num_qubits=5, reps=2)
psi2 = RealAmplitudes(num_qubits=5, reps=3)
psi3 = RealAmplitudes(num_qubits=5, reps=4)

pm = generate_preset_pass_manager(target=backend.target, optimization_level=1)
isa_psi1 = pm.run(psi1)
isa_psi2 = pm.run(psi2)
isa_psi3 = pm.run(psi3)

H1 = SparsePauliOp.from_list([("IIZXI", 1), ("YIIIY", 3)])
H2 = SparsePauliOp.from_list([("IXIII", 2)])
H3 = SparsePauliOp.from_list([("IIYII", 3), ("IXIZI", 5)])

isa_H1 = H1.apply_layout(isa_psi1.layout)
isa_H2 = H2.apply_layout(isa_psi2.layout)
isa_H3 = H3.apply_layout(isa_psi3.layout)

("YIIIY", 3)

theta1 = np.linspace(0, 1, 15)
theta2 = np.linspace(0, 1, 20)
theta3 = np.linspace(0, 1, 25)

RealAmplitudes(num_qubits=5, reps=2, insert_barriers=True)

estimator = Estimator(backend=backend)

# calculate [ <psi1(theta1)|H1|psi1(theta1)>,
#             <psi2(theta2)|H2|psi2(theta2)>,
#             <psi3(theta3)|H3|psi3(theta3)> ]
# Note: Please keep the order
pubs = [
    (isa_psi1, isa_H1, theta1),
    (isa_psi2, isa_H2, theta2),
    (isa_psi3, isa_H3, theta3)
]
job = estimator.run(pubs)
pubs_result = job.result()