Pelajari model noise sebuah Gate

Tutorial ini mendemonstrasikan cara mempelajari model noise untuk Gate uniter dengan protokol learning standar yang bisa diakses lewat fungsi protokol tingkat tinggi prepare_vanilla_program() dan process_vanilla_result().

1. Definisikan Gate-nya

2. Siapkan simulasi lokal

3. Siapkan program kuantum

4. Jalankan program kuantum

5. Baca hasilnya

Menjalankan di hardware sungguhan

Circuit di bawah ini disimulasikan secara lokal, jadi panduan ini tidak memerlukan kredensial IBM Quantum®. Untuk menjalankannya di perangkat sungguhan:

• Langkah 1: ganti FakeMarrakesh dengan Backend sungguhan.

• Langkah 2: berikan Backend tersebut sebagai mode executor, dan hapus opsi simulator.

1. Definisikan Gate-nya

Gate-nya adalah sebuah BoxOp yang memuat satu lapisan twirled berisi enam Gate CZ yang saling lepas.

from qiskit.circuit import QuantumCircuit
from qiskit_ibm_runtime.fake_provider import FakeMarrakesh
from samplomatic import InjectNoise, Tag, Twirl

backend = FakeMarrakesh()

cz_pairs = [(91, 92), (93, 94), (95, 99), (98, 111), (112, 113), (114, 115)]

circuit = QuantumCircuit(backend.num_qubits)
with circuit.box([Twirl(), Tag("cz_gate"), InjectNoise("cz_gate")]):
    for pair in cz_pairs:
        circuit.cz(*pair)

Menjalankan di hardware sungguhan

from qiskit_ibm_runtime import QiskitRuntimeService

backend = QiskitRuntimeService().backend("ibm_marrakesh")

2. Siapkan simulasi lokal

Indeks Pauli di dalam setiap map bersifat lokal terhadap gate, dalam urutan qubit fisik yang menaik:

cz_qubits = sorted({qubit for pair in cz_pairs for qubit in pair})
local = {qubit: index for index, qubit in enumerate(cz_qubits)}
local

{91: 0,
 92: 1,
 93: 2,
 94: 3,
 95: 4,
 98: 5,
 99: 6,
 111: 7,
 112: 8,
 113: 9,
 114: 10,
 115: 11}

Definisikan noise dengan suku ZZ yang berkorelasi dan suku XX yang lebih lemah pada setiap pasangan CZ, ditambah suku Z single-qubit di mana-mana; pengukuran mendapat suku bit-flip per qubit.

from qiskit.quantum_info import PauliLindbladMap

num_qubits = len(cz_qubits)

cz_noise = PauliLindbladMap.from_sparse_list(
    [("ZZ", [local[a], local[b]], 8e-4) for a, b in cz_pairs]
    + [("XX", [local[a], local[b]], 4e-4) for a, b in cz_pairs]
    + [("Z", [index], 3e-4) for index in range(num_qubits)],
    num_qubits=num_qubits,
)

readout_noise = PauliLindbladMap.from_sparse_list(
    [("X", [index], 5e-3) for index in range(num_qubits)], num_qubits=num_qubits
)

Buat sebuah box agar pengukuran bisa dipelajari.

measurement = QuantumCircuit(backend.num_qubits, num_qubits)
with measurement.box([Twirl(), Tag("readout"), InjectNoise("readout")]):
    for clbit, qubit in enumerate(cz_qubits):
        measurement.measure(qubit, clbit)

Setiap entri layer_noise_model memasangkan salah satu box tersebut dengan map yang diterapkan padanya. Gunakan metode simulasi stabilizer, lalu atur seed_simulator agar data hasil simulasi bisa direproduksi.

from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import Executor

executor = Executor(
    mode=AerSimulator(method="stabilizer"),
    options={
        "simulator": {
            "layer_noise_model": [
                (circuit[0], cz_noise),
                (measurement[0], readout_noise),
            ],
            "seed_simulator": 1234,
        }
    },
)

Menjalankan di hardware sungguhan

executor = Executor(mode=backend)

3. Siapkan program kuantum

Gunakan prepare_vanilla_program() untuk membangun program kuantum yang berisi eksperimen pembelajaran.

from qiskit_noise_learning.protocols import prepare_vanilla_program

program = prepare_vanilla_program(
    backend,
    [circuit[0], measurement[0]],
    fragment_depths=[2, 16, 64, 128],
    num_randomizations=50,
    shots_per_randomization=20,
)

print(f"Number of template circuits: {len(program.items)}")

Number of template circuits: 5

4. Jalankan program kuantum

Kirim program kuantumnya. Langkah ini sama saja, entah executor diarahkan ke simulator atau ke perangkat asli.

result = executor.run(program).result()

5. Baca hasilnya

Proses hasilnya dengan process_vanilla_result().

from qiskit_noise_learning.protocols import process_vanilla_result

noise_maps, gate_names, fit = process_vanilla_result(result)

Plot peluruhan fidelitas per pasangan qubit: data sekaligus fit eksponensialnya.

fit.plot_qubit_pair_decays(
    pairs=cz_pairs,
    observable_type="means",
    exponential_fit=True,
)