Japanese
言語
English
Japanese
Spanish
Table of Contents

注釈

このページは docs/tutorials/Error-Supression-and-Error-Mitigation.ipynb から生成されました。

Qiskit Runtimeによるエラー抑制とエラー緩和

Pedro Rivero
Quantum Developer @ IBM Quantum
pedro.rivero@ibm.com
Mariana Bernagozzi
Software Engineer @ IBM Quantum
mariana.bernagozzi@ibm.com
[1]:

import datetime
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

plt.rcParams.update({"text.usetex": True})
plt.rcParams["figure.figsize"] = (6, 4)
mpl.rcParams["figure.dpi"] = 200

from qiskit_ibm_runtime import Estimator, Session, QiskitRuntimeService, Options
from qiskit.quantum_info import SparsePauliOp
from qiskit import QuantumCircuit

service = QiskitRuntimeService()

はじめに

エラー抑制と緩和の必要性を説明するために、まず、エラー抑制やエラー緩和を行わない場合の結果をいくつか見てみます。まず、ノイズのないシミュレーターを使用して、理想的な結果がどのようなものであるかを把握することにします。次に、実機のバックエンドで、エラー抑制やエラー緩和を行わずに同じ実験を行います。

以下のコードセルは、実験に使用するTrotter回路のリストを定義しています。

トロッター回路の作成

[2]:

backend_simulator = "ibmq_qasm_simulator"
backend = "ibmq_montreal"

qubits = 4
trotter_layer = QuantumCircuit(qubits)
trotter_layer.rx(0.1, range(qubits))
trotter_layer.cx(0, 1)
trotter_layer.cx(2, 3)
trotter_layer.rz(-0.2, [1, 3])
trotter_layer.cx(0, 1)
trotter_layer.cx(2, 3)
trotter_layer.cx(1, 2)
trotter_layer.rz(-0.2, 2)
trotter_layer.cx(1, 2)

num_steps = 6
trotter_circuit_list = []
for i in range(1, num_steps):
    trotter_circuit = QuantumCircuit(qubits)
    for _ in range(i):
        trotter_circuit = trotter_circuit.compose(trotter_layer)
    trotter_circuit_list.append(trotter_circuit)
    print(f"Trotter circuit with {i} Trotter steps")
    display(trotter_circuit.draw(fold=-1))

obs = SparsePauliOp("Z" * qubits)
obs_list = [obs] * len(trotter_circuit_list)

Trotter circuit with 1 Trotter steps

     ┌─────────┐
q_0: ┤ Rx(0.1) ├──■────────────────■────────────────────────
     ├─────────┤┌─┴─┐┌──────────┐┌─┴─┐
q_1: ┤ Rx(0.1) ├┤ X ├┤ Rz(-0.2) ├┤ X ├──■────────────────■──
     ├─────────┤└───┘└──────────┘└───┘┌─┴─┐┌──────────┐┌─┴─┐
q_2: ┤ Rx(0.1) ├──■────────────────■──┤ X ├┤ Rz(-0.2) ├┤ X ├
     ├─────────┤┌─┴─┐┌──────────┐┌─┴─┐└───┘└──────────┘└───┘
q_3: ┤ Rx(0.1) ├┤ X ├┤ Rz(-0.2) ├┤ X ├──────────────────────
     └─────────┘└───┘└──────────┘└───┘                      
Trotter circuit with 2 Trotter steps

     ┌─────────┐                      ┌─────────┐
q_0: ┤ Rx(0.1) ├──■────────────────■──┤ Rx(0.1) ├──────────────────────────────■────────────────■────────────────────────
     ├─────────┤┌─┴─┐┌──────────┐┌─┴─┐└─────────┘                 ┌─────────┐┌─┴─┐┌──────────┐┌─┴─┐
q_1: ┤ Rx(0.1) ├┤ X ├┤ Rz(-0.2) ├┤ X ├─────■───────────────────■──┤ Rx(0.1) ├┤ X ├┤ Rz(-0.2) ├┤ X ├──■────────────────■──
     ├─────────┤└───┘└──────────┘└───┘   ┌─┴─┐   ┌──────────┐┌─┴─┐├─────────┤└───┘└──────────┘└───┘┌─┴─┐┌──────────┐┌─┴─┐
q_2: ┤ Rx(0.1) ├──■────────────────■─────┤ X ├───┤ Rz(-0.2) ├┤ X ├┤ Rx(0.1) ├──■────────────────■──┤ X ├┤ Rz(-0.2) ├┤ X ├
     ├─────────┤┌─┴─┐┌──────────┐┌─┴─┐┌──┴───┴──┐└──────────┘└───┘└─────────┘┌─┴─┐┌──────────┐┌─┴─┐└───┘└──────────┘└───┘
q_3: ┤ Rx(0.1) ├┤ X ├┤ Rz(-0.2) ├┤ X ├┤ Rx(0.1) ├────────────────────────────┤ X ├┤ Rz(-0.2) ├┤ X ├──────────────────────
     └─────────┘└───┘└──────────┘└───┘└─────────┘                            └───┘└──────────┘└───┘                      
Trotter circuit with 3 Trotter steps

     ┌─────────┐                      ┌─────────┐                                                  ┌─────────┐
q_0: ┤ Rx(0.1) ├──■────────────────■──┤ Rx(0.1) ├──────────────────────────────■────────────────■──┤ Rx(0.1) ├──────────────────────────────■────────────────■────────────────────────
     ├─────────┤┌─┴─┐┌──────────┐┌─┴─┐└─────────┘                 ┌─────────┐┌─┴─┐┌──────────┐┌─┴─┐└─────────┘                 ┌─────────┐┌─┴─┐┌──────────┐┌─┴─┐
q_1: ┤ Rx(0.1) ├┤ X ├┤ Rz(-0.2) ├┤ X ├─────■───────────────────■──┤ Rx(0.1) ├┤ X ├┤ Rz(-0.2) ├┤ X ├─────■───────────────────■──┤ Rx(0.1) ├┤ X ├┤ Rz(-0.2) ├┤ X ├──■────────────────■──
     ├─────────┤└───┘└──────────┘└───┘   ┌─┴─┐   ┌──────────┐┌─┴─┐├─────────┤└───┘└──────────┘└───┘   ┌─┴─┐   ┌──────────┐┌─┴─┐├─────────┤└───┘└──────────┘└───┘┌─┴─┐┌──────────┐┌─┴─┐
q_2: ┤ Rx(0.1) ├──■────────────────■─────┤ X ├───┤ Rz(-0.2) ├┤ X ├┤ Rx(0.1) ├──■────────────────■─────┤ X ├───┤ Rz(-0.2) ├┤ X ├┤ Rx(0.1) ├──■────────────────■──┤ X ├┤ Rz(-0.2) ├┤ X ├
     ├─────────┤┌─┴─┐┌──────────┐┌─┴─┐┌──┴───┴──┐└──────────┘└───┘└─────────┘┌─┴─┐┌──────────┐┌─┴─┐┌──┴───┴──┐└──────────┘└───┘└─────────┘┌─┴─┐┌──────────┐┌─┴─┐└───┘└──────────┘└───┘
q_3: ┤ Rx(0.1) ├┤ X ├┤ Rz(-0.2) ├┤ X ├┤ Rx(0.1) ├────────────────────────────┤ X ├┤ Rz(-0.2) ├┤ X ├┤ Rx(0.1) ├────────────────────────────┤ X ├┤ Rz(-0.2) ├┤ X ├──────────────────────
     └─────────┘└───┘└──────────┘└───┘└─────────┘                            └───┘└──────────┘└───┘└─────────┘                            └───┘└──────────┘└───┘                      
Trotter circuit with 4 Trotter steps

     ┌─────────┐                      ┌─────────┐                                                  ┌─────────┐                                                  ┌─────────┐
q_0: ┤ Rx(0.1) ├──■────────────────■──┤ Rx(0.1) ├──────────────────────────────■────────────────■──┤ Rx(0.1) ├──────────────────────────────■────────────────■──┤ Rx(0.1) ├──────────────────────────────■────────────────■────────────────────────
     ├─────────┤┌─┴─┐┌──────────┐┌─┴─┐└─────────┘                 ┌─────────┐┌─┴─┐┌──────────┐┌─┴─┐└─────────┘                 ┌─────────┐┌─┴─┐┌──────────┐┌─┴─┐└─────────┘                 ┌─────────┐┌─┴─┐┌──────────┐┌─┴─┐
q_1: ┤ Rx(0.1) ├┤ X ├┤ Rz(-0.2) ├┤ X ├─────■───────────────────■──┤ Rx(0.1) ├┤ X ├┤ Rz(-0.2) ├┤ X ├─────■───────────────────■──┤ Rx(0.1) ├┤ X ├┤ Rz(-0.2) ├┤ X ├─────■───────────────────■──┤ Rx(0.1) ├┤ X ├┤ Rz(-0.2) ├┤ X ├──■────────────────■──
     ├─────────┤└───┘└──────────┘└───┘   ┌─┴─┐   ┌──────────┐┌─┴─┐├─────────┤└───┘└──────────┘└───┘   ┌─┴─┐   ┌──────────┐┌─┴─┐├─────────┤└───┘└──────────┘└───┘   ┌─┴─┐   ┌──────────┐┌─┴─┐├─────────┤└───┘└──────────┘└───┘┌─┴─┐┌──────────┐┌─┴─┐
q_2: ┤ Rx(0.1) ├──■────────────────■─────┤ X ├───┤ Rz(-0.2) ├┤ X ├┤ Rx(0.1) ├──■────────────────■─────┤ X ├───┤ Rz(-0.2) ├┤ X ├┤ Rx(0.1) ├──■────────────────■─────┤ X ├───┤ Rz(-0.2) ├┤ X ├┤ Rx(0.1) ├──■────────────────■──┤ X ├┤ Rz(-0.2) ├┤ X ├
     ├─────────┤┌─┴─┐┌──────────┐┌─┴─┐┌──┴───┴──┐└──────────┘└───┘└─────────┘┌─┴─┐┌──────────┐┌─┴─┐┌──┴───┴──┐└──────────┘└───┘└─────────┘┌─┴─┐┌──────────┐┌─┴─┐┌──┴───┴──┐└──────────┘└───┘└─────────┘┌─┴─┐┌──────────┐┌─┴─┐└───┘└──────────┘└───┘
q_3: ┤ Rx(0.1) ├┤ X ├┤ Rz(-0.2) ├┤ X ├┤ Rx(0.1) ├────────────────────────────┤ X ├┤ Rz(-0.2) ├┤ X ├┤ Rx(0.1) ├────────────────────────────┤ X ├┤ Rz(-0.2) ├┤ X ├┤ Rx(0.1) ├────────────────────────────┤ X ├┤ Rz(-0.2) ├┤ X ├──────────────────────
     └─────────┘└───┘└──────────┘└───┘└─────────┘                            └───┘└──────────┘└───┘└─────────┘                            └───┘└──────────┘└───┘└─────────┘                            └───┘└──────────┘└───┘                      
Trotter circuit with 5 Trotter steps

     ┌─────────┐                      ┌─────────┐                                                  ┌─────────┐                                                  ┌─────────┐                                                  ┌─────────┐
q_0: ┤ Rx(0.1) ├──■────────────────■──┤ Rx(0.1) ├──────────────────────────────■────────────────■──┤ Rx(0.1) ├──────────────────────────────■────────────────■──┤ Rx(0.1) ├──────────────────────────────■────────────────■──┤ Rx(0.1) ├──────────────────────────────■────────────────■────────────────────────
     ├─────────┤┌─┴─┐┌──────────┐┌─┴─┐└─────────┘                 ┌─────────┐┌─┴─┐┌──────────┐┌─┴─┐└─────────┘                 ┌─────────┐┌─┴─┐┌──────────┐┌─┴─┐└─────────┘                 ┌─────────┐┌─┴─┐┌──────────┐┌─┴─┐└─────────┘                 ┌─────────┐┌─┴─┐┌──────────┐┌─┴─┐
q_1: ┤ Rx(0.1) ├┤ X ├┤ Rz(-0.2) ├┤ X ├─────■───────────────────■──┤ Rx(0.1) ├┤ X ├┤ Rz(-0.2) ├┤ X ├─────■───────────────────■──┤ Rx(0.1) ├┤ X ├┤ Rz(-0.2) ├┤ X ├─────■───────────────────■──┤ Rx(0.1) ├┤ X ├┤ Rz(-0.2) ├┤ X ├─────■───────────────────■──┤ Rx(0.1) ├┤ X ├┤ Rz(-0.2) ├┤ X ├──■────────────────■──
     ├─────────┤└───┘└──────────┘└───┘   ┌─┴─┐   ┌──────────┐┌─┴─┐├─────────┤└───┘└──────────┘└───┘   ┌─┴─┐   ┌──────────┐┌─┴─┐├─────────┤└───┘└──────────┘└───┘   ┌─┴─┐   ┌──────────┐┌─┴─┐├─────────┤└───┘└──────────┘└───┘   ┌─┴─┐   ┌──────────┐┌─┴─┐├─────────┤└───┘└──────────┘└───┘┌─┴─┐┌──────────┐┌─┴─┐
q_2: ┤ Rx(0.1) ├──■────────────────■─────┤ X ├───┤ Rz(-0.2) ├┤ X ├┤ Rx(0.1) ├──■────────────────■─────┤ X ├───┤ Rz(-0.2) ├┤ X ├┤ Rx(0.1) ├──■────────────────■─────┤ X ├───┤ Rz(-0.2) ├┤ X ├┤ Rx(0.1) ├──■────────────────■─────┤ X ├───┤ Rz(-0.2) ├┤ X ├┤ Rx(0.1) ├──■────────────────■──┤ X ├┤ Rz(-0.2) ├┤ X ├
     ├─────────┤┌─┴─┐┌──────────┐┌─┴─┐┌──┴───┴──┐└──────────┘└───┘└─────────┘┌─┴─┐┌──────────┐┌─┴─┐┌──┴───┴──┐└──────────┘└───┘└─────────┘┌─┴─┐┌──────────┐┌─┴─┐┌──┴───┴──┐└──────────┘└───┘└─────────┘┌─┴─┐┌──────────┐┌─┴─┐┌──┴───┴──┐└──────────┘└───┘└─────────┘┌─┴─┐┌──────────┐┌─┴─┐└───┘└──────────┘└───┘
q_3: ┤ Rx(0.1) ├┤ X ├┤ Rz(-0.2) ├┤ X ├┤ Rx(0.1) ├────────────────────────────┤ X ├┤ Rz(-0.2) ├┤ X ├┤ Rx(0.1) ├────────────────────────────┤ X ├┤ Rz(-0.2) ├┤ X ├┤ Rx(0.1) ├────────────────────────────┤ X ├┤ Rz(-0.2) ├┤ X ├┤ Rx(0.1) ├────────────────────────────┤ X ├┤ Rz(-0.2) ├┤ X ├──────────────────────
     └─────────┘└───┘└──────────┘└───┘└─────────┘                            └───┘└──────────┘└───┘└─────────┘                            └───┘└──────────┘└───┘└─────────┘                            └───┘└──────────┘└───┘└─────────┘                            └───┘└──────────┘└───┘

シミュレーターの実行

[4]:

options = Options()
options.execution.shots = 1000
options.optimization_level = 0  # No optimization
options.resilience_level = 0  # No mitigation

with Session(service=service, backend=backend_simulator) as session:
    estimator_sim = Estimator(session=session, options=options)
    job_sim = estimator_sim.run(circuits=trotter_circuit_list, observables=obs_list)
    print("job id:", job_sim.job_id)
    print(job_sim.result())

expvals_ideal = job_sim.result().values
expvals_ideal_variance = [
    metadata["variance"] / metadata["shots"] for metadata in job_sim.result().metadata
]
std_error_ideal = np.sqrt(expvals_ideal_variance)

job id: cdkrpbpg1234sbmtrt3g
EstimatorResult(values=array([0.98 , 0.926, 0.872, 0.796, 0.68 ]), metadata=[{'variance': 0.03960000000000008, 'shots': 1000}, {'variance': 0.14252399999999987, 'shots': 1000}, {'variance': 0.23961600000000005, 'shots': 1000}, {'variance': 0.36638399999999993, 'shots': 1000}, {'variance': 0.5375999999999999, 'shots': 1000}])

緩和なし、実機のバックエンド

[5]:

options = Options()
options.execution.shots = 1000
options.optimization_level = 0  # No optimization
options.resilience_level = 0  # No error mitigation

with Session(service=service, backend=backend) as session:
    estimator = Estimator(session=session, options=options)
    job = estimator.run(circuits=trotter_circuit_list, observables=obs_list)
    print("job id:", job.job_id)
    print(job.result())

expvals_unmit = job.result().values
expvals_unmit_variance = [
    metadata["variance"] / metadata["shots"] for metadata in job.result().metadata
]
std_error_unmit = np.sqrt(expvals_unmit_variance)

job id: cdkrpeaan60ka16e8340
EstimatorResult(values=array([0.786, 0.74 , 0.636, 0.562, 0.446]), metadata=[{'variance': 0.382204, 'shots': 1000}, {'variance': 0.4524, 'shots': 1000}, {'variance': 0.595504, 'shots': 1000}, {'variance': 0.684156, 'shots': 1000}, {'variance': 0.801084, 'shots': 1000}])

理論と背景

IBM Quantum

2024 年から、 深さ 100 の 100量子ビット 回路の ノイズのない観測量 を 1 日 以内に推定できるツールを構築したいと考えています。

これは、量子的な優位性 そのもの を約束するものではありませんが、目標は、興味深い問題や関連する問題を、効率的な古典計算と比較して、より速く、より正確に、あるいはより安く、実用的な時間枠で解決できるようになることです。

シミュレーションの可能性のしきい値は、100量子ビット程度と思われます。しかし、これだけでは十分ではなく、古典的な計算で再現できないような十分に複雑な量子回路が必要です。例えば、深い、非クリフォード演算です。

75be7d4cdbb54c258f835f91a5779380

ゲートあたりの誤差が 1E-3 であることから、このような計算の最終的な忠実度は``1E-6`` 程度と推定され、全く意味のない結果を意味することになります。

フォールトトレラントな量子計算

どのようなコンピューターにもエラーはつきものです。量子コンピューターの場合、エラーはより複雑で、量子状態が正確に準備されていないときに発生します。例えば、目標値をオーバーシュートしたり、ドリフトしたりします。さらに、これらの問題を発生させる外からの乱れは、通常、避けられません。

これらのエラーを処理する方法はいくつかあります。この分野でも意見が分かれているため、用語が混乱することがありますが、ここでは、そのコアとなる3つの部分に分けて説明します。

  1. 抑制

  2. 緩和

  3. 訂正

まず、この分野で最初に正式に発見されたエラー訂正から始めましょう。

エラー訂正

古典コンピューターにおけるエラー訂正は、情報を冗長な方法で符号化し、不要なノイズに耐えられるようにすることで、発生したエラーを検出し訂正する標準的な手順です。

量子力学の計算では、量子力学系が環境と結合することで、時間的にも規模的にも限界があることは以前から知られていました。しかし、 量子エラー訂正 の理論的発見により、この問題は早くから解決されていました。

しきい値定理

量子コンピューターのエラーを一定 (有限) レベル以下に抑えることができれば、ノイズの多いハードウェアであっても、フォールト・トレラントな量子計算を任意の時間で実行できます。

参考: M.A. Nielsen, and I.L. Chuang, Quantum Computation and Quantum Information.

これが、 フォールト・トレラント な量子計算の究極の目標を達成する方法です。ただし、規定のしきい値を達成できるハードウェアを構築できたとしても、必要な量子ビット数といったような、完全なエラー訂正を実行するためのオーバーヘッドにより、短期的には実行不可能になります。そのため、複数の物理量子ビットをまたいで、単一量子ビットの論理値をエンコードしようとしています。

\[n/d = 100/100 \quad\]
\[p = \text{1E-3} \quad\]
\[p = \text{1E-4} \quad\]
\[p = \text{1E-5} \quad\]

Runtime [\(s\)]

2.3

1.2

0.8

物理量子ビット

140k

40k

16k

距離

21

11

7

これらの 表面的なコード リソース* は、2025 年のロードマップ計画をはるかに超えていますが、できるだけ早く実現できるようにこの分野で懸命に取り組んでいます。

* 前の表のデータは、特定の条件下におけるサーフェス・コードのシミュレーションに基づいています。コードの距離はT ゲートなし、あるいはランタイムの最後に100個の論理量子ビットで \(1\text{E}-2\) より大きな誤差を持たないように選択されています。T ゲートの数は \(n \times d\) で、各パリティ・チェック・サイクルには \(1 \mu s\) の時間がかかります。

参考文献: Daniel Litinski, A Game of Surface Codes: Large-Scale Quantum Computing with Lattice Surgery, arXiv:1808.02892

エラー抑止

エラー抑制は、エラー処理の最も基本的なレベルのものです。多くの場合、制御信号 (それは、Qiskit Pulse レベル) の変更など、ハードウェアの近くで実行される一連の手法を指します。簡単にするために、これらの手法を 従来のオーバーヘッド を導入するものとして定義します。これは通常、トランスパイル/コンパイル・プロセス内で行われます。

これらの技術は非常に古く、磁気共鳴画像装置などの最初の制御可能な量子系の一部と同時期に初めて開発されました。

動的デカップリング (Dynamical decoupling, DD)

量子コンピューターは、スピン・エコー (量子ビットの状態を再収束するのに役立つ一連のパルス) などの手法の一部を採用しています。実際、スピン・エコーは 動的デカップリング (Dynamical Decoupling, DD) として知られるクラスの手法として大きな役割を果たします。DDはアイドル状態の量子ビットにパルスを送信することで値を元の状態にリセットし、計算に使用されている付近の量子ビットの潜在的かつ有害な影響を元に戻します。

参考文献: Lorenza Viola, and Seth Lloyd , Dynamical suppression of decoherence in two-state quantum systems, arXiv:quant-ph/9803057

[6]:

options = Options()
options.execution.shots = 1000
options.optimization_level = 3  # Dynamical decoupling
options.resilience_level = 0  # No error mitigation

with Session(service=service, backend=backend) as session:
    estimator = Estimator(session=session, options=options)
    job_dd = estimator.run(circuits=trotter_circuit_list, observables=obs_list)
    print("job id:", job_dd.job_id)
    print(job_dd.result())

expvals_unmit_dd = job_dd.result().values
expvals_unmit_dd_variance = [
    metadata["variance"] / metadata["shots"] for metadata in job_dd.result().metadata
]
std_error_dd = np.sqrt(expvals_unmit_dd_variance)

job id: cdkrpk5f14jb6brgbmt0
EstimatorResult(values=array([0.87 , 0.752, 0.598, 0.484, 0.396]), metadata=[{'variance': 0.24309999999999998, 'shots': 1000}, {'variance': 0.434496, 'shots': 1000}, {'variance': 0.642396, 'shots': 1000}, {'variance': 0.765744, 'shots': 1000}, {'variance': 0.8431839999999999, 'shots': 1000}])

[7]:

plt.title("Trotter circuits expectation value")
plt.errorbar(
    range(1, num_steps),
    expvals_ideal,
    std_error_ideal,
    fmt="o",
    linestyle="--",
    capsize=4,
    c="red",
    label="Ideal",
)
plt.errorbar(
    range(1, num_steps),
    expvals_unmit,
    std_error_unmit,
    fmt="o",
    linestyle="-",
    capsize=4,
    c="green",
    label="No mitigation",
)
plt.errorbar(
    range(1, num_steps),
    expvals_unmit_dd,
    std_error_dd,
    fmt="o",
    linestyle="-",
    capsize=4,
    c="blue",
    label="Dynamical decoupling",
)

plt.ylabel(f"$\langle ZZZZ \\rangle$")
plt.xlabel("No. Trotter Steps")
plt.xticks([1, 2, 3, 4, 5])
plt.legend()
plt.show()
../_images/tutorials_Error-Suppression-and-Error-Mitigation_16_0.png

誤り軽減

エラー軽減では、計算に 量子オーバーヘッド が導入されます。

通常、誤り訂正では、ノイズの多い計算の複数のアンサンブルの出力を使用して、期待値などの量を推定する際のノイズを削減または除去します。通常は、従来の後処理を使用します。 この点で、エラーの軽減はエラーの修正とは異なります。 回路を実行するたびにエラーを修正する代わりに、エラーが発生することを許可し、これらのノイズの多い計算のいくつかからより良い結果を推測します。

量子エラー緩和が実用化される前に超えなければならないしきい値はないため、短期的に有用な量子コンピューターを実現するための鍵として、エラーの軽減が考えられます。

さまざまなエラー軽減手法のポートフォリオを開発しており、主に次の 3 つを探しています。

  • 小さなオーバーヘッド ( スピード )

  • 精度の向上 ( 品質 )

  • いくつかの仮定( スケール )

各方法には、関連する独自のオーバーヘッドが伴います。必要な量子計算の数 (時間) と結果の精度との間のトレードオフです。 達成できる精度のレベルも各方法に固有であり、通常は前述のオーバーヘッドに反比例します。 \(\lambda\) を計算のベース・ノイズとして定義します。

獲得方法

T-REx

ZNE

PEC

仮定

無し

ノイズを拡大する能力

ノイズに関する完全な知識

量子ビットのオーバーヘッド

\(1\)

\(1\)

\(1\)

サンプリング・オーバーヘッド

\(2\)

\(N_\text{noise-factors}\)

\(\mathcal{O}(e^{\lambda N_\text{layers}})\)

バイアス

\(0\)

\(\mathcal{O}(\lambda^{N_\text{noise-factors}})\)

\(0\)

より詳細な情報はこちら:

メソッドのポートフォリオを用意することで、ユーザーは、精度の要求と許容できるオーバーヘッドに基づいて、関心のある問題に最も適した手法を選択できます。 最良のシナリオでは、偏りのない (つまり、ノイズのない) 結果を達成できるため、私たちはこれに興奮しています。 そして、カーネルからアルゴリズムやモデルの開発者まで、スタック全体でこの機能にアクセスできるようにしたいと考えています。

エラー軽減はなぜ重要なのか？

スケール 、 品質 、 スピード の改善が必要です。

エラー軽減の約束は、量子ハードウェアの継続的な進歩を、量子計算と量子情報処理の継続的な改善に変換することです。 不完全さを完全に克服するには不十分ですが、すべての進歩は、実際に達成できるもののフロンティアを徐々に押し進めるべきであると期待しています。 フォールト・トレラントのしきい値を突然超えるまで、ほとんどまたはまったく進歩しないシナリオとは対照的です。

b9e072fac2814766bb18db21b2d995c9

100x100 回路を超えて、エラー修正とエラー軽減がハイブリッドな方法で機能する未来を想定しています。 その点で、このアプローチは実際に効果的であると同時に知的に挑戦的であることが証明されています。

コンセプト

このセクションでは、以下の用語を使用します。

用語

すべての新生分野と同様に、用語には一貫性がない場合があります。人々は同じ用語を使用して (わずかに) 異なるものを指します。

  • 推定値: 基本的に未知の特定の物理値を概算するための戦略です。

  • サンプリング: 1 つまたは複数のものについて複数の測定を行うプロセスです。

  • オーバーヘッド: 基本的な実装と比較して、新しい手法によって導入される追加のコストです。

  • バイアス: 測定された量の体系的なドリフトで、通常はエラーによって引き起こされます。

  • ショット/サンプル ノイズ: 無限の精度の欠如 (つまり、有限数のサンプル) による、得られた結果の不確実性です。

含意

エラー軽減手法を実装する場合、結果の バイアス は、以前の軽減されていないバイアスに対して減少することが期待されます。 場合によっては消えることさえあります。 ただし、これには代償が伴います。 推定量の偏りを減らすと、統計的変動性 (つまり、 分散) が増加します。これは、サンプリング・プロセスで回路あたりのショット数をさらに増やすことで説明できます。 これにより、バイアスを減らすために必要な以上のオーバーヘッドが発生するため、デフォルトでは行われません。 ユーザーは run_options で回路ごとの shots の量を調整することで、この動作を簡単にオプトインできます。

数学的に言えば、エラー軽減推定量は次のようになると予想されます。

\[\begin{split}0 \leq | \text{Bias}[{\langle}O{\rangle}_\text{em}] | \leq | \text{Bias}[{\langle}O{\rangle}_\text{noisy}] | \\ | \text{Var}[{\langle}O{\rangle}_\text{em}] | \geq | \text{Var}[{\langle}O{\rangle}_\text{noisy}] | > 0\end{split}\]

890e5b1b59534145b1432fbd8877cb13

トワイル読み出しエラー消去法

トワイル読み出しエラー消去法 (Twirled Readout Error eXtinction, T-REx) は、Pauli twirlingと呼ばれる技術を使用して、量子力学の測定過程で混入するノイズを低減します。この手法は、特定の形態のノイズを想定していないため、非常に汎用的で効果的です。

全体のワークフロー

  1. ランダム化されたビットフリップを使用してゼロ状態のデータを取得します (測定前のパウリ X)。

  2. ランダム化されたビットフリップを使用して目的の (ノイズの多い) 状態のデータを取得します (測定前のパウリ X)。

  3. 各データセットの特殊関数を計算し、除算します。

4c71e9f6808a4f7fa2c467917e38cfa4

参考文献: E. van den Berg, Z. Minev, and K. Temme, Model-free readout-error mitigation for quantum expectation values arXiv:2012.09738

[8]:

options = Options()
options.resilience_level = 1  # T-REx
options.optimization_level = 0  # No optimization
options.execution.shots = 1000

with Session(service=service, backend=backend) as session:
    estimator = Estimator(session=session, options=options)
    job_trex = estimator.run(circuits=trotter_circuit_list, observables=obs_list)
    print("job id:", job_trex.job_id)
    print(job_trex.result())

expvals_unmit_trex = job_trex.result().values
expvals_unmit_trex_variance = [
    metadata["variance"] / metadata["shots"] for metadata in job_trex.result().metadata
]
std_error_trex = np.sqrt(expvals_unmit_trex_variance)

job id: cdkrpq7tlcfkm5f0demg
EstimatorResult(values=array([0.95941791, 0.81652588, 0.68894371, 0.55625825, 0.45674416]), metadata=[{'variance': 0.733385959939609, 'shots': 1008, 'readout_mitigation_num_twirled_circuits': 16, 'readout_mitigation_shots_calibration': 8192}, {'variance': 0.9871541699414397, 'shots': 1008, 'readout_mitigation_num_twirled_circuits': 16, 'readout_mitigation_shots_calibration': 8192}, {'variance': 1.1792252443219302, 'shots': 1008, 'readout_mitigation_num_twirled_circuits': 16, 'readout_mitigation_shots_calibration': 8192}, {'variance': 1.3444454335924159, 'shots': 1008, 'readout_mitigation_num_twirled_circuits': 16, 'readout_mitigation_shots_calibration': 8192}, {'variance': 1.4452534486647257, 'shots': 1008, 'readout_mitigation_num_twirled_circuits': 16, 'readout_mitigation_shots_calibration': 8192}])

[9]:

plt.title("Trotter circuits expectation value")
plt.errorbar(
    range(1, num_steps),
    expvals_ideal,
    std_error_ideal,
    fmt="o",
    linestyle="--",
    capsize=4,
    c="red",
    label="Ideal",
)
plt.errorbar(
    range(1, num_steps),
    expvals_unmit,
    std_error_unmit,
    fmt="o",
    linestyle="-",
    capsize=4,
    c="green",
    label="No mitigation",
)
plt.errorbar(
    range(1, num_steps),
    expvals_unmit_trex,
    std_error_trex,
    fmt="o",
    linestyle="-",
    capsize=4,
    c="violet",
    label="T-REx",
)

plt.ylabel(f"$\langle ZZZZ \\rangle$")
plt.xlabel("No. Trotter Steps")
plt.xticks([1, 2, 3, 4, 5])
plt.legend()
plt.show()
../_images/tutorials_Error-Suppression-and-Error-Mitigation_26_0.png

ゼロ・ノイズ外挿

ゼロ・ノイズ外挿 (ZNE) は、最初に目的の量子状態を準備している回路内のノイズを増幅し、いくつかの異なるレベルのノイズの測定値を取得し、それらの測定値を使用してノイズのない結果を推測することによって機能します。

全体のワークフロー

  1. いくつかのノイズ要因に対して回路ノイズを増幅する

  2. すべてのノイズ増幅回路を実行する

  3. ゼロ・ノイズ限界に外挿する

c379477e6ef84096bd6995d945dab6bb

[10]:

options = Options()
options.execution.shots = 1000
options.optimization_level = 0  # No optimization
options.resilience_level = 2  # ZNE

with Session(service=service, backend=backend) as session:
    estimator = Estimator(session=session, options=options)
    job_zne = estimator.run(circuits=trotter_circuit_list, observables=obs_list)
    print("job id:", job_zne.job_id)
    print(job_zne.result())

expvals_unmit_zne = job_zne.result().values
# Standard error: coming soon!

job id: cdkrq4i2h6kvivdb2an0
EstimatorResult(values=array([0.896     , 0.86833333, 0.82716667, 0.63116667, 0.58366667]), metadata=[{'zne': {'noise_amplification': {'noise_amplifier': "<TwoQubitAmplifier:{'noise_factor_relative_tolerance': 0.01, 'random_seed': None, 'sub_folding_option': 'from_first'}>", 'noise_factors': [1, 3, 5], 'values': [0.84, 0.788, 0.664], 'variance': [0.2944000000000001, 0.37905599999999995, 0.5591039999999999], 'shots': [1000, 1000, 1000]}, 'extrapolation': {'extrapolator': 'LinearExtrapolator'}}}, {'zne': {'noise_amplification': {'noise_amplifier': "<TwoQubitAmplifier:{'noise_factor_relative_tolerance': 0.01, 'random_seed': None, 'sub_folding_option': 'from_first'}>", 'noise_factors': [1, 3, 5], 'values': [0.778, 0.614, 0.43], 'variance': [0.39471599999999996, 0.623004, 0.8151], 'shots': [1000, 1000, 1000]}, 'extrapolation': {'extrapolator': 'LinearExtrapolator'}}}, {'zne': {'noise_amplification': {'noise_amplifier': "<TwoQubitAmplifier:{'noise_factor_relative_tolerance': 0.01, 'random_seed': None, 'sub_folding_option': 'from_first'}>", 'noise_factors': [1, 3, 5], 'values': [0.718, 0.498, 0.28], 'variance': [0.484476, 0.751996, 0.9216], 'shots': [1000, 1000, 1000]}, 'extrapolation': {'extrapolator': 'LinearExtrapolator'}}}, {'zne': {'noise_amplification': {'noise_amplifier': "<TwoQubitAmplifier:{'noise_factor_relative_tolerance': 0.01, 'random_seed': None, 'sub_folding_option': 'from_first'}>", 'noise_factors': [1, 3, 5], 'values': [0.54, 0.376, 0.19], 'variance': [0.7083999999999999, 0.858624, 0.9639], 'shots': [1000, 1000, 1000]}, 'extrapolation': {'extrapolator': 'LinearExtrapolator'}}}, {'zne': {'noise_amplification': {'noise_amplifier': "<TwoQubitAmplifier:{'noise_factor_relative_tolerance': 0.01, 'random_seed': None, 'sub_folding_option': 'from_first'}>", 'noise_factors': [1, 3, 5], 'values': [0.498, 0.31, 0.142], 'variance': [0.751996, 0.9039, 0.979836], 'shots': [1000, 1000, 1000]}, 'extrapolation': {'extrapolator': 'LinearExtrapolator'}}}])

[11]:

plt.title("Trotter circuits expectation value")
plt.errorbar(
    range(1, num_steps),
    expvals_ideal,
    std_error_ideal,
    fmt="o",
    linestyle="--",
    capsize=4,
    c="red",
    label="Ideal",
)
plt.errorbar(
    range(1, num_steps),
    expvals_unmit,
    std_error_unmit,
    fmt="o",
    linestyle="-",
    capsize=4,
    c="green",
    label="No mitigation",
)
plt.errorbar(
    range(1, num_steps),
    expvals_unmit_zne,
    [0] * (num_steps - 1),
    fmt="o",
    linestyle="-",
    capsize=4,
    c="cyan",
    label="ZNE",
)

plt.xlabel("No. Trotter Steps")
plt.ylabel(f"$\langle ZZZZ \\rangle$")
plt.xticks([1, 2, 3, 4, 5])
plt.legend()
plt.show()
../_images/tutorials_Error-Suppression-and-Error-Mitigation_29_0.png

確率的エラー・キャンセル

回路のコレクションの確率的エラー・キャンセル (PEC) サンプルは、平均してノイズ反転チャネルを模倣して、目的の計算のノイズをキャンセルします。 このプロセスは、ノイズ・キャンセリング・ヘッドフォンの動作に少し似ており、優れた結果をもたらしますが、他の方法ほど一般的ではなく、サンプリング・オーバーヘッドは指数関数的です。

参考文献: E. van den Berg, Z. Minev, A. Kandala, and K. Temme, Probabilistic error cancellation with sparse Pauli-Lindblad models on noisy quantum processors arXiv:2201.09866

全体のワークフロー

af3ecb14724b4f6babe76085a1fb59fb

ステップ 1: Pauliトワイル

975bc03ae0234d98b21deb122dc6c856

ステップ2：レイヤーを繰り返したノイズの学習

8f27d5337f454c11b56bb6b049872b53

ステップ 3: 忠実度の導出 (各ノイズ・チャネルの誤差)

70ebc3a63c7a490297aa59b5437944d9

[ ]:

def interim_results_callback(job_id, result):
    now = datetime.datetime.now()
    print(now, "*** Callback ***", result, "\n")


options = Options()
options.optimization_level = 0  # No optimization
options.execution.shots = 100
options.resilience_level = 3  # PEC
options.environment.callback = interim_results_callback

with Session(service=service, backend=backend) as session:
    estimator_pec = Estimator(session=session, options=options)
    job_pec = estimator_pec.run(circuits=trotter_circuit_list, observables=obs_list)
    print("job id:", job_pec.job_id)

expvals_pec = job_pec.result().values
std_error_pec = [metadata["standard_error"] for metadata in job_pec.result().metadata]

job id: cdkqv522h6kvivdat0vg
2022-11-07 20:23:43.013816 *** Callback *** {'unique_layers_detected': 2, 'total_layers': 60}

2022-11-07 20:30:41.251325 *** Callback *** {'msg': 'Sampling overhead for layer 1/2: 1.0263820029324646'}

2022-11-07 20:37:38.920151 *** Callback *** {'msg': 'Sampling overhead for layer 2/2: 1.0692954781746'}

2022-11-07 20:37:39.334815 *** Callback *** {'sampling_overhead_by_layer': [1.0692954781746, 1.0263820029324646], 'unique_layers': 2, 'total_sampling_overhead': 1.4508651011392564}

2022-11-07 20:37:39.336883 *** Callback *** {'sampling_overhead_by_layer': [1.0692954781746, 1.0263820029324646], 'unique_layers': 2, 'total_sampling_overhead': 1.2045186180127132}

2022-11-07 20:37:39.336983 *** Callback *** {'sampling_overhead_by_layer': [1.0692954781746, 1.0263820029324646], 'unique_layers': 2, 'total_sampling_overhead': 1.7475940265471324}

2022-11-07 20:37:39.337099 *** Callback *** {'sampling_overhead_by_layer': [1.0692954781746, 1.0263820029324646], 'unique_layers': 2, 'total_sampling_overhead': 2.105009541703825}

2022-11-07 20:37:39.338120 *** Callback *** {'sampling_overhead_by_layer': [1.0692954781746, 1.0263820029324646], 'unique_layers': 2, 'total_sampling_overhead': 2.5355231840766654}

2022-11-07 20:44:17.157534 *** Callback *** {'values': array([0.96681631, 0.96346463, 0.81458917, 0.83279075, 0.71165489]), 'metadata': [{'standard_error': 0.04741526161355738, 'confidence_interval': [0.6946850904749993, 1.2389475260753755], 'confidence_level': 0.95, 'shots': 15360, 'samples': 120, 'sampling_overhead': 1.2045186180127132, 'total_mitigated_layers': 4}, {'standard_error': 0.06003453067758544, 'confidence_interval': [0.6917633123010369, 1.235165948939192], 'confidence_level': 0.95, 'shots': 18560, 'samples': 145, 'sampling_overhead': 1.4508651011392564, 'total_mitigated_layers': 8}, {'standard_error': 0.07893102265063534, 'confidence_interval': [0.5423767896024972, 1.086801560321982], 'confidence_level': 0.95, 'shots': 22272, 'samples': 174, 'sampling_overhead': 1.7475940265471324, 'total_mitigated_layers': 12}, {'standard_error': 0.08198342212333354, 'confidence_interval': [0.5608466609152284, 1.104734830411759], 'confidence_level': 0.95, 'shots': 26880, 'samples': 210, 'sampling_overhead': 2.105009541703825, 'total_mitigated_layers': 16}, {'standard_error': 0.08955468433998504, 'confidence_interval': [0.43973826826406204, 0.9835715192472465], 'confidence_level': 0.95, 'shots': 32384, 'samples': 253, 'sampling_overhead': 2.5355231840766654, 'total_mitigated_layers': 20}]}


[ ]:

plt.title("Trotter circuits expectation value")
plt.errorbar(
    range(1, num_steps),
    expvals_ideal,
    std_error_ideal,
    fmt="o",
    linestyle="--",
    capsize=4,
    c="red",
    label="Ideal",
)
plt.errorbar(
    range(1, num_steps),
    expvals_unmit,
    std_error_unmit,
    fmt="o",
    linestyle="-",
    capsize=4,
    c="green",
    label="No mitigation",
)
plt.errorbar(
    range(1, num_steps),
    expvals_pec,
    std_error_pec,
    fmt="d",
    linestyle="-",
    capsize=4,
    c="orange",
    label="PEC",
)

plt.ylabel(f"$\langle ZZZZ \\rangle$")
plt.xlabel("No. Trotter Steps")
plt.xticks([1, 2, 3, 4, 5])
plt.legend()
plt.show()
../_images/tutorials_Error-Suppression-and-Error-Mitigation_35_0.png

PEC コールバック・メッセージの説明

検出されたレイヤー:

2022-11-07 20:23:43.013816 *** Callback *** {'unique_layers_detected': 2, 'total_layers': 60}

Estimator に渡された回路のリストでは、合計で 60 のレイヤーが検出され、そのうちの 2 は一意でした。 Qiskit Runtime は、2 つの固有のレイヤーのノイズ・モデルを学習します。

レイヤーのサンプリング・オーバーヘッド:

2022-11-07 20:30:41.251325 *** Callback *** {'msg': 'Sampling overhead for layer 1/2: 1.0263820029324646'}

2022-11-07 20:37:38.920151 *** Callback *** {'msg': 'Sampling overhead for layer 2/2: 1.0692954781746'}

これらのメッセージは、一意のレイヤーごとのサンプリング・オーバーヘッドを示します。 各レイヤーのノイズ・モデルを学習するのに約 7 分かかったことに注意してください。

PEC コールバック・メッセージの説明

検出されたレイヤー:

2022-11-07 20:23:43.013816 *** Callback *** {'unique_layers_detected': '2, total_layers: 60'}

Estimator に渡された回路のリストでは、合計で 60 のレイヤーが検出され、そのうちの 2 は一意でした。 Qiskit Runtime は、2 つの固有のレイヤーのノイズ・モデルを学習します。

レイヤーのサンプリング・オーバーヘッド:

2022-11-07 20:30:41.251325 *** Callback *** {'msg': 'Sampling overhead for layer 1/2: 1.0263820029324646'} 2022-11-07 20:37:38.920151 *** Callback *** {'msg': 'Sampling overhead for layer 2/2: 1.0692954781746'}

これらのメッセージは、一意のレイヤーごとのサンプリング・オーバーヘッドを示します。 各レイヤーのノイズ・モデルを学習するのに約 7 分かかったことに注意してください。

回路の合計サンプリング・オーバーヘッド

  • 回路 1 の合計サンプリング・オーバーヘッド: 1.2045186180127132

    2022-11-07 20:37:39.336883 *** Callback *** {sampling_overhead_by_layer: [1.0692954781746, 1.0263820029324646], unique_layers: 2, total_sampling_overhead: 1.2045186180127132}

  • サーキット 2 の合計サンプリング・オーバーヘッド: 1.4508651011392564

    2022-11-07 20:37:39.334815 *** Callback *** {sampling_overhead_by_layer: [1.0692954781746, 1.0263820029324646], unique_layers: 2, total_sampling_overhead: 1.4508651011392564}

  • 回路 3 の合計サンプリング・オーバーヘッド: 1.7475940265471324

    2022-11-07 20:37:39.336983 *** Callback *** {sampling_overhead_by_layer: [1.0692954781746, 1.0263820029324646], unique_layers: 2, total_sampling_overhead: 1.7475940265471324}

  • 回路 4 の合計サンプリング・オーバーヘッド: 2.105009541703825

    2022-11-07 20:37:39.337099 *** Callback *** {sampling_overhead_by_layer: [1.0692954781746, 1.0263820029324646], unique_layers: 2, total_sampling_overhead: 2.105009541703825}

  • 回路 5 の合計サンプリング・オーバーヘッド: 2.5355231840766654

    2022-11-07 20:37:39.338120 *** Callback *** {sampling_overhead_by_layer: [1.0692954781746, 1.0263820029324646], unique_layers: 2, total_sampling_overhead: 2.5355231840766654}

軽減するレイヤーが増えると、サンプリングのオーバーヘッドが増加します。

[ ]:

print(job_pec.result())

EstimatorResult(values=array([0.96681631, 0.96346463, 0.81458917, 0.83279075, 0.71165489]), metadata=[{'standard_error': 0.04741526161355738, 'confidence_interval': [0.6946850904749993, 1.2389475260753755], 'confidence_level': 0.95, 'shots': 15360, 'samples': 120, 'sampling_overhead': 1.2045186180127132, 'total_mitigated_layers': 4}, {'standard_error': 0.06003453067758544, 'confidence_interval': [0.6917633123010369, 1.235165948939192], 'confidence_level': 0.95, 'shots': 18560, 'samples': 145, 'sampling_overhead': 1.4508651011392564, 'total_mitigated_layers': 8}, {'standard_error': 0.07893102265063534, 'confidence_interval': [0.5423767896024972, 1.086801560321982], 'confidence_level': 0.95, 'shots': 22272, 'samples': 174, 'sampling_overhead': 1.7475940265471324, 'total_mitigated_layers': 12}, {'standard_error': 0.08198342212333354, 'confidence_interval': [0.5608466609152284, 1.104734830411759], 'confidence_level': 0.95, 'shots': 26880, 'samples': 210, 'sampling_overhead': 2.105009541703825, 'total_mitigated_layers': 16}, {'standard_error': 0.08955468433998504, 'confidence_interval': [0.43973826826406204, 0.9835715192472465], 'confidence_level': 0.95, 'shots': 32384, 'samples': 253, 'sampling_overhead': 2.5355231840766654, 'total_mitigated_layers': 20}])

PEC メタデータ

  • 回路 1:

{
  "standard_error": 0.04741526161355738,
  "confidence_interval": [
    0.6946850904749993,
    1.2389475260753755
  ],
  "confidence_level": 0.95,
  "shots": 15360,
  "samples": 120,
  "sampling_overhead": 1.2045186180127132,
  "total_mitigated_layers": 4
}

  • 回路 2:

{
  "standard_error": 0.06003453067758544,
  "confidence_interval": [
    0.6917633123010369,
    1.235165948939192
  ],
  "confidence_level": 0.95,
  "shots": 18560,
  "samples": 145,
  "sampling_overhead": 1.4508651011392564,
  "total_mitigated_layers": 8
}

  • 回路 3:

{
  "standard_error": 0.07893102265063534,
  "confidence_interval": [
    0.5423767896024972,
    1.086801560321982
  ],
  "confidence_level": 0.95,
  "shots": 22272,
  "samples": 174,
  "sampling_overhead": 1.7475940265471324,
  "total_mitigated_layers": 12
}

  • 回路 4:

{
  "standard_error": 0.08198342212333354,
  "confidence_interval": [
    0.5608466609152284,
    1.104734830411759
  ],
  "confidence_level": 0.95,
  "shots": 26880,
  "samples": 210,
  "sampling_overhead": 2.105009541703825,
  "total_mitigated_layers": 16
}

  • 回路5

{
  "standard_error": 0.08955468433998504,
  "confidence_interval": [
    0.43973826826406204,
    0.9835715192472465
  ],
  "confidence_level": 0.95,
  "shots": 32384,
  "samples": 253,
  "sampling_overhead": 2.5355231840766654,
  "total_mitigated_layers": 20
}

[ ]:

pec_metadata = job_pec.result().metadata
fig, ax = plt.subplots()
fig.subplots_adjust(right=0.75)

twin1 = ax.twinx()
twin2 = ax.twinx()
twin3 = ax.twinx()

twin2.spines.right.set_position(("axes", 1.2))
twin3.spines.right.set_position(("axes", 1.4))

(p1,) = ax.plot(
    range(1, num_steps),
    [m["total_mitigated_layers"] for m in pec_metadata],
    "b-",
    label="Total mitigated layers",
)
(p2,) = twin1.plot(
    range(1, num_steps),
    [m["sampling_overhead"] for m in pec_metadata],
    "r-",
    label="Sampling overhead",
)
(p3,) = twin2.plot(
    range(1, num_steps), [m["samples"] for m in pec_metadata], "g-", label="Samples"
)
(p4,) = twin3.plot(
    range(1, num_steps), [m["shots"] for m in pec_metadata], "c-", label="Shots"
)

ax.set_ylim(0, 20)
twin1.set_ylim(0, 2.8)
twin2.set_ylim(0, 300)
twin3.set_ylim(0, 35000)

ax.set_xlabel("No. Trotter Steps")
ax.set_ylabel("Total mitigated layers")
twin1.set_ylabel("Sampling overhead")
twin2.set_ylabel("Samples")
twin3.set_ylabel("Shots")

ax.yaxis.label.set_color(p1.get_color())
twin1.yaxis.label.set_color(p2.get_color())
twin2.yaxis.label.set_color(p3.get_color())
twin3.yaxis.label.set_color(p4.get_color())

tkw = dict(size=4, width=1.5)
ax.tick_params(axis="y", colors=p1.get_color(), **tkw)
twin1.tick_params(axis="y", colors=p2.get_color(), **tkw)
twin2.tick_params(axis="y", colors=p3.get_color(), **tkw)
twin3.tick_params(axis="y", colors=p4.get_color(), **tkw)
plt.xticks([1, 2, 3, 4, 5])

ax.legend(handles=[p1, p2, p3, p4])

plt.title("PEC metadata")
plt.show()
../_images/tutorials_Error-Suppression-and-Error-Mitigation_41_0.png

結合されたプロット

[ ]:

from matplotlib.pyplot import figure

plt.errorbar(
    range(1, num_steps),
    expvals_ideal,
    std_error_ideal,
    fmt="o",
    linestyle="--",
    capsize=4,
    c="red",
    label="Ideal",
)
plt.errorbar(
    range(1, num_steps),
    expvals_unmit,
    std_error_unmit,
    fmt="o",
    linestyle="-",
    capsize=4,
    c="green",
    label="No mitigation",
)
plt.errorbar(
    range(1, num_steps),
    expvals_unmit_trex,
    std_error_trex,
    fmt="o",
    linestyle="-",
    capsize=4,
    c="violet",
    label="T-REx",
)
plt.errorbar(
    range(1, num_steps),
    expvals_unmit_zne,
    [0] * (num_steps - 1),
    fmt="o",
    linestyle="-",
    capsize=4,
    c="cyan",
    label="ZNE",
)
plt.errorbar(
    range(1, num_steps),
    expvals_pec,
    std_error_pec,
    fmt="d",
    linestyle="-",
    capsize=4,
    c="orange",
    label="PEC",
)

plt.title("Trotter circuits expectation value")
plt.ylabel(f"$\langle ZZZZ \\rangle$")
plt.xlabel("No. Trotter Steps")
plt.xticks([1, 2, 3, 4, 5])
plt.legend()
plt.show()
../_images/tutorials_Error-Suppression-and-Error-Mitigation_43_0.png

高度なZNEオプション

ノイズ増幅

最初のアプローチとして、 ユニタリ・フォールディング として知られるノイズ増幅技術を提供します。

参考文献: Tudor Giurgica-Tiron, Yousef Hindy, Ryan LaRose, Andrea Mari, and William J. Zeng, Digital zero noise extrapolation for quantum error mitigation arXiv:2005.10921.

デジタル vs アナログ

49f71e676e304a30bb81b179460707df

ローカル対グローバル

092b9e00a57d4cbeb9efb921f20ff715

外挿

便利なノイズ・プロファイル

537d9698b063454ba2269bd9a4d8320d

役に立たないノイズ・プロファイル

741361b9ee434fb688cc69619b33cb7c

[ ]:

options = Options()
options.execution.shots = 1000
options.optimization_level = 0  # no optimization
options.resilience_level = 2  # ZNE
options.resilience.noise_factors = [1, 2, 3, 4]
options.resilience.noise_amplifier = "LocalFoldingAmplifier"
options.resilience.extrapolator = "QuadraticExtrapolator"

with Session(service=service, backend="ibmq_montreal") as session:
    estimator = Estimator(session=session, options=options)
    job_zne_options = estimator.run(circuits=trotter_circuit_list, observables=obs_list)
    print("job id:", job_zne_options.job_id)
    print(job_zne_options.result())

job id: cdkrqbdf14jb6brgbrl0
EstimatorResult(values=array([0.9285, 0.8165, 0.835 , 0.6815, 0.4945]), metadata=[{'zne': {'noise_amplification': {'noise_amplifier': "<LocalFoldingAmplifier:{'gates_to_fold': None, 'noise_factor_relative_tolerance': 0.01, 'random_seed': None, 'sub_folding_option': 'from_first'}>", 'noise_factors': [1, 2, 3, 4], 'values': [0.838, 0.798, 0.738, 0.752], 'variance': [0.297756, 0.36319599999999996, 0.455356, 0.434496], 'shots': [1000, 1000, 1000, 1000]}, 'extrapolation': {'extrapolator': 'QuadraticExtrapolator'}}}, {'zne': {'noise_amplification': {'noise_amplifier': "<LocalFoldingAmplifier:{'gates_to_fold': None, 'noise_factor_relative_tolerance': 0.01, 'random_seed': None, 'sub_folding_option': 'from_first'}>", 'noise_factors': [1, 2, 3, 4], 'values': [0.732, 0.676, 0.572, 0.522], 'variance': [0.46417600000000003, 0.543024, 0.6728160000000001, 0.727516], 'shots': [1000, 1000, 1000, 1000]}, 'extrapolation': {'extrapolator': 'QuadraticExtrapolator'}}}, {'zne': {'noise_amplification': {'noise_amplifier': "<LocalFoldingAmplifier:{'gates_to_fold': None, 'noise_factor_relative_tolerance': 0.01, 'random_seed': None, 'sub_folding_option': 'from_first'}>", 'noise_factors': [1, 2, 3, 4], 'values': [0.674, 0.51, 0.436, 0.328], 'variance': [0.5457239999999999, 0.7399, 0.809904, 0.892416], 'shots': [1000, 1000, 1000, 1000]}, 'extrapolation': {'extrapolator': 'QuadraticExtrapolator'}}}, {'zne': {'noise_amplification': {'noise_amplifier': "<LocalFoldingAmplifier:{'gates_to_fold': None, 'noise_factor_relative_tolerance': 0.01, 'random_seed': None, 'sub_folding_option': 'from_first'}>", 'noise_factors': [1, 2, 3, 4], 'values': [0.512, 0.372, 0.266, 0.188], 'variance': [0.7378560000000001, 0.8616159999999999, 0.929244, 0.964656], 'shots': [1000, 1000, 1000, 1000]}, 'extrapolation': {'extrapolator': 'QuadraticExtrapolator'}}}, {'zne': {'noise_amplification': {'noise_amplifier': "<LocalFoldingAmplifier:{'gates_to_fold': None, 'noise_factor_relative_tolerance': 0.01, 'random_seed': None, 'sub_folding_option': 'from_first'}>", 'noise_factors': [1, 2, 3, 4], 'values': [0.442, 0.35, 0.268, 0.13], 'variance': [0.804636, 0.8775000000000001, 0.928176, 0.9831], 'shots': [1000, 1000, 1000, 1000]}, 'extrapolation': {'extrapolator': 'QuadraticExtrapolator'}}}])

{
  "values": [
    0.928499999999999,
    0.8165,
    0.835,
    0.6815000000000001,
    0.49449999999999983
  ],
  "metadata": [
    {
      "zne": {
        "noise_amplification": {
          "noise_amplifier": "<LocalFoldingAmplifier:{'gates_to_fold': None, 'noise_factor_relative_tolerance': 0.01, 'random_seed': None, 'sub_folding_option': 'from_first'}>",
          "noise_factors": [
            1,
            2,
            3,
            4
          ],
          "values": [
            0.838,
            0.798,
            0.738,
            0.752
          ],
          "variance": [
            0.297756,
            0.36319599999999996,
            0.455356,
            0.434496
          ],
          "shots": [
            1000,
            1000,
            1000,
            1000
          ]
        },
        "extrapolation": {
          "extrapolator": "QuadraticExtrapolator"
        }
      }
    },
    {
      "zne": {
        "noise_amplification": {
          "noise_amplifier": "<LocalFoldingAmplifier:{'gates_to_fold': None, 'noise_factor_relative_tolerance': 0.01, 'random_seed': None, 'sub_folding_option': 'from_first'}>",
          "noise_factors": [
            1,
            2,
            3,
            4
          ],
          "values": [
            0.732,
            0.676,
            0.572,
            0.522
          ],
          "variance": [
            0.46417600000000003,
            0.543024,
            0.6728160000000001,
            0.727516
          ],
          "shots": [
            1000,
            1000,
            1000,
            1000
          ]
        },
        "extrapolation": {
          "extrapolator": "QuadraticExtrapolator"
        }
      }
    },
    {
      "zne": {
        "noise_amplification": {
          "noise_amplifier": "<LocalFoldingAmplifier:{'gates_to_fold': None, 'noise_factor_relative_tolerance': 0.01, 'random_seed': None, 'sub_folding_option': 'from_first'}>",
          "noise_factors": [
            1,
            2,
            3,
            4
          ],
          "values": [
            0.674,
            0.51,
            0.436,
            0.328
          ],
          "variance": [
            0.5457239999999999,
            0.7399,
            0.809904,
            0.892416
          ],
          "shots": [
            1000,
            1000,
            1000,
            1000
          ]
        },
        "extrapolation": {
          "extrapolator": "QuadraticExtrapolator"
        }
      }
    },
    {
      "zne": {
        "noise_amplification": {
          "noise_amplifier": "<LocalFoldingAmplifier:{'gates_to_fold': None, 'noise_factor_relative_tolerance': 0.01, 'random_seed': None, 'sub_folding_option': 'from_first'}>",
          "noise_factors": [
            1,
            2,
            3,
            4
          ],
          "values": [
            0.512,
            0.372,
            0.266,
            0.188
          ],
          "variance": [
            0.7378560000000001,
            0.8616159999999999,
            0.929244,
            0.964656
          ],
          "shots": [
            1000,
            1000,
            1000,
            1000
          ]
        },
        "extrapolation": {
          "extrapolator": "QuadraticExtrapolator"
        }
      }
    },
    {
      "zne": {
        "noise_amplification": {
          "noise_amplifier": "<LocalFoldingAmplifier:{'gates_to_fold': None, 'noise_factor_relative_tolerance': 0.01, 'random_seed': None, 'sub_folding_option': 'from_first'}>",
          "noise_factors": [
            1,
            2,
            3,
            4
          ],
          "values": [
            0.442,
            0.35,
            0.268,
            0.13
          ],
          "variance": [
            0.804636,
            0.8775000000000001,
            0.928176,
            0.9831
          ],
          "shots": [
            1000,
            1000,
            1000,
            1000
          ]
        },
        "extrapolation": {
          "extrapolator": "QuadraticExtrapolator"
        }
      }
    }
  ]
}

[ ]:

from qiskit.tools import jupyter

%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit SoftwareVersion
qiskit-terra0.22.2
qiskit-aer0.11.0
qiskit-ibmq-provider0.19.2
System information
Python version3.10.4
Python compilerClang 12.0.0
Python buildmain, Mar 31 2022 03:38:35
OSDarwin
CPUs4
Memory (Gb)16.0
Tue Nov 08 12:15:46 2022 EST

This code is a part of Qiskit

© Copyright IBM 2017, 2022.

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.