Contoh Executor

Versi pakej

Kod di halaman ini dibangunkan menggunakan keperluan berikut. Kami mengesyorkan penggunaan versi ini atau yang lebih baharu.

qiskit[all]~=2.4.0
qiskit-ibm-runtime~=0.46.1
samplomatic~=0.18.0

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit qiskit-ibm-runtime samplomatic

Contoh-contoh dalam bahagian ini menggambarkan beberapa cara biasa untuk menggunakan primitif Executor. Sebelum menjalankan contoh-contoh ini, ikuti arahan dalam Pasang Qiskit dan Quickstart Executor.

Sebelum bermula

Beberapa contoh kod di halaman ini menggunakan samplex, yang merupakan sebahagian daripada pakej Samplomatic. Oleh itu, sebelum menjalankan blok kod tersebut, anda mesti memasang Samplomatic, seperti yang ditunjukkan dalam blok kod berikut. Untuk maklumat lanjut, lihat dokumentasi Samplomatic.

pip install samplomatic

# For visualization support, include the visualization dependencies.
# pip install samplomatic[vis]

Contoh: Litar berparameter

Contoh ini menggambarkan cara menambah item litar dengan parameter, serta cara menambah item samplex. Ia terdiri daripada langkah-langkah berikut:

1. Sediakan litar: Jana dan transpile litar sasaran.
2. Sediakan samplex: Kumpulkan gate dan pengukuran ke dalam kotak beranotasi dan jana pasangan templat litar dan samplex.
3. Laksanakan: Tambah item litar dan item samplex ke QuantumProgram dan laksanakan kedua-duanya dalam satu kerja.

Sediakan litar

Sediakan keadaan GHZ tiga qubit, putarkan qubit di sekitar paksi Pauli-Z, dan ukur qubit dalam asas pengkomputeran.

from qiskit.circuit import Parameter, QuantumCircuit
from qiskit_ibm_runtime import QiskitRuntimeService, Executor
from qiskit_ibm_runtime.quantum_program import QuantumProgram
from qiskit.transpiler import generate_preset_pass_manager
import numpy as np
from samplomatic import build
from samplomatic.transpiler import generate_boxing_pass_manager

# Generate the circuit
circuit = QuantumCircuit(3)
circuit.h(0)
circuit.h(1)
circuit.cz(0, 1)
circuit.h(1)
circuit.h(2)
circuit.cz(1, 2)
circuit.h(2)
circuit.rz(Parameter("theta"), 0)
circuit.rz(Parameter("phi"), 1)
circuit.rz(Parameter("lam"), 2)
circuit.measure_all()

Tentukan Backend dan transpile litar agar hanya menggunakan arahan yang disokong oleh QPU (dirujuk sebagai litar seni bina set arahan (ISA)).

# Initialize the service and choose a backend
service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

# Transpile the circuit to ISA
preset_pass_manager = generate_preset_pass_manager(
    backend=backend, optimization_level=3
)
isa_circuit = preset_pass_manager.run(circuit)

Sediakan samplex

Gunakan fungsi kemudahan generate_boxing_pass_manager dan parameter twirling-nya untuk mengumpulkan gate dua qubit dan pengukuran ke dalam kotak dan menerapkan anotasi twirling.

boxing_pm = generate_boxing_pass_manager(
    # Add gate twirling
    enable_gates=True,
    # Add measurement twirling
    enable_measures=True,
)

boxed_circuit = boxing_pm.run(isa_circuit)

Gunakan kaedah build untuk menjana templat litar dan samplex.

# Build the template circuit and the samplex
template_circuit, samplex = build(boxed_circuit)

Laksanakan litar

Executor menjalankan objek QuantumProgram. Setiap QuantumProgram boleh mengandungi beberapa item. Contoh ini menambah item litar dan item samplex untuk dilaksanakan. Untuk butiran lengkap, lihat Input dan output Executor.

Langkah pertama adalah memulakan program kosong, meminta 1024 shots untuk setiap konfigurasi setiap item.

# Generate a quantum program
program = QuantumProgram(shots=1024)

Tambah item litar ke QuantumProgram. Item litar ini terdiri daripada dua bahagian - litar ISA dan 10 set nilai parameternya.

# Append the circuit and the parameter values to the program
program.append_circuit_item(
    isa_circuit,
    circuit_arguments=np.random.rand(10, 3),  # 10 sets of parameter values
)

Tambah item samplex ke QuantumProgram dengan argumen-argumen ini:

• Templat litar dan samplex yang dijana oleh fungsi build
• Sepuluh set nilai parameter untuk litar asal
• Bilangan pengacakan yang akan dilakukan

# Append the template circuit and samplex as a samplex item
program.append_samplex_item(
    template_circuit,
    samplex=samplex,
    samplex_arguments={
        "parameter_values": np.random.rand(
            10, 3
        ),  # 10 sets of parameter values
    },
    shape=(2, 14, 10),
)

Jalankan kerja Executor

# initialize an Executor with default options
executor = Executor(mode=backend)

# Submit the job
job = executor.run(program)

# Retrieve the result
result = job.result()

Dapatkan semula keputusan untuk setiap tugas.

# Access the results of the classical register of task #0, the CircuitItem
result_0 = result[0]["meas"]

# Access the results of the classical register of task #1, the SamplexItem
result_1 = result[1]["meas"]

Contoh: Lakukan PEC

Contoh ini menunjukkan cara menggunakan item samplex untuk melakukan pembatalan ralat berkemungkinan (PEC) bagi mitigasi ralat.

Pertimbangkan versi litar bercermin dengan sepuluh qubit dan dua lapisan unik gate CX. Tugas-tugas utamanya adalah:

• Laksanakan litar dengan twirling.
• Laksanakan litar dengan mitigasi PEC, seperti dalam kertas kerja "Probabilistic error cancellation with sparse Pauli-Lindblad models on noisy quantum processors".

Saluran paip terdiri daripada langkah-langkah berikut:

1. Persediaan: Jana litar sasaran dan kumpulkan operasinya ke dalam kotak.
2. Pembelajaran: Pelajari hingar arahan yang ingin kita mitigasi dengan PEC.
3. Pelaksanaan: Jalankan litar pada Backend.
4. Analisis: Proses pasca dan analisis keputusan.

Untuk perbandingan, kita akan menjalankan litar bercermin ini dua kali. Sekali dengan hanya twirling Pauli yang diterapkan, dan sekali dengan mitigasi PEC yang diterapkan.

nota

Penggunaan untuk contoh ini adalah lebih kurang 10 minit pada pemproses Heron r2.

Sediakan litar

Pilih Backend dan sediakan litar 10-qubit.

from qiskit_ibm_runtime import QiskitRuntimeService, Executor
from qiskit_ibm_runtime.quantum_program import QuantumProgram
from qiskit.circuit import QuantumCircuit, Parameter
from qiskit.transpiler import generate_preset_pass_manager
from samplomatic.transpiler import generate_boxing_pass_manager
from samplomatic import build

# Initialize the service and choose a backend
service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

# Prepare a circuit

num_qubits = 10
num_layers = 10

qubits = list(range(num_qubits))
circuit = QuantumCircuit(num_qubits)

for layer_idx in range(num_layers):
    circuit.rx(Parameter(f"theta_{layer_idx}"), qubits)
    for i in range(num_qubits // 2):
        circuit.cz(qubits[2 * i], qubits[2 * i + 1])

    circuit.rx(Parameter(f"phi_{layer_idx}"), qubits)
    for i in range(num_qubits // 2 - 1):
        circuit.cz(qubits[2 * i] + 1, qubits[2 * i + 1] + 1)

circuit.draw("mpl", scale=0.35, fold=100)

Gabungkan litar dengan inversnya untuk mencipta litar bercermin.

mirror_circuit = circuit.compose(circuit.inverse())
mirror_circuit.measure_all()

mirror_circuit.draw("mpl", scale=0.35, fold=100)

Tetapkan beberapa nilai parameter:

import numpy as np

parameter_values = np.random.rand(mirror_circuit.num_parameters)

Gunakan pengurus pas untuk mentranspile litar agar menjadi litar ISA.

preset_pass_manager = generate_preset_pass_manager(
    backend=backend,
    optimization_level=3,
)

isa_circuit = preset_pass_manager.run(mirror_circuit)

Seterusnya, kumpulkan gate dan pengukuran ke dalam kotak beranotasi. Anda boleh melakukan ini secara manual atau menggunakan fungsi generate_boxing_pass_manager daripada Samplomatic untuk kemudahan. Litar pertama hanya akan diterapkan twirling dan oleh itu hanya memerlukan anotasi Twirl. Litar kedua akan dijalankan dengan mitigasi PEC penuh dan memerlukan kedua-dua anotasi Twirl dan InjectNoise.

# Pass manager used to create twirled-annotated boxes.
boxing_pm = generate_boxing_pass_manager(
    enable_gates=True,
    enable_measures=True,
)

mirror_circuit_twirl = boxing_pm.run(isa_circuit)

# Pass manager used to create a new boxed circuit with
# both Twirl and InjectNoise annotations.
boxing_pm = generate_boxing_pass_manager(
    enable_gates=True,
    enable_measures=True,
    inject_noise_targets="gates",  # no measurement mitigation
    inject_noise_strategy="uniform_modification",
)

mirror_circuit_pec = boxing_pm.run(isa_circuit)

Pelajari hingar

Untuk meminimumkan bilangan eksperimen pembelajaran hingar, kenal pasti arahan unik dalam litar kedua (yang mempunyai kotak beranotasi dengan InjectNoise). Dalam menentukan keunikan, dua arahan kotak adalah sama jika kedua-dua perkara berikut adalah benar:

• Kandungannya adalah sama, sehingga gate satu qubit.
• Anotasi Twirl-nya adalah sama (setiap anotasi lain diabaikan).

Ini menghasilkan tiga arahan unik, iaitu kotak gate ganjil dan genap, serta kotak pengukuran akhir.

from samplomatic.utils import find_unique_box_instructions

unique_box_instructions = find_unique_box_instructions(
    mirror_circuit_pec.data
)
assert len(unique_box_instructions) == 3

Inisialisasikan NoiseLearnerV3, pilih parameter pembelajaran dengan menetapkan pilihan-pilihannya, dan jalankan kerja pembelajaran hingar.

from qiskit_ibm_runtime.noise_learner_v3 import NoiseLearnerV3

learner = NoiseLearnerV3(backend)

learner.options.shots_per_randomization = 128
learner.options.num_randomizations = 32
learner.options.layer_pair_depths = [0, 1, 2, 4, 16, 32]

learner_job = learner.run(unique_box_instructions)

learner_job.job_id()
learner_result = learner_job.result()

Tukar result kepada objek yang diperlukan oleh samplex menggunakan kaedah result.to_dict.

noise_maps = learner_result.to_dict(
    instructions=unique_box_instructions, require_refs=False
)

Laksanakan litar-litar

Executor menjalankan objek QuantumProgram. Setiap QuantumProgram boleh mengandungi beberapa item, yang ditambahkan ke program. Setiap item adalah satu tugas untuk program dilaksanakan.

Inisialisasikan program kosong, meminta 1000 shots untuk setiap konfigurasi setiap item.

from qiskit_ibm_runtime.quantum_program import QuantumProgram

# Initialize an empty QuantumProgram
program = QuantumProgram(shots=1000)

Seterusnya, bina templat litar dan samplex untuk mirror_circuit_twirl dan tambahkannya ke program. Juga minta 900 pengacakan daripada samplex. Ini bermakna samplex akan menjana 900 set parameter, dan setiap set akan dilaksanakan sebanyak 1000 kali (bilangan shots) dalam QPU.

Ini adalah tugas pertama program (keputusan 0).

template_twirl, samplex_twirl = build(mirror_circuit_twirl)

program.append_samplex_item(
    template_twirl,
    samplex=samplex_twirl,
    samplex_arguments={"parameter_values": parameter_values},
    shape=(900,),
)

Begitu juga, tambahkan templat litar dan samplex yang dibina untuk mirror_circuit_pec, meminta 900 pengacakan. Ini adalah tugas kedua program (keputusan 1).

template_pec, samplex_pec = build(mirror_circuit_pec)

program.append_samplex_item(
    template_pec,
    samplex=samplex_pec,
    samplex_arguments={
        "parameter_values": parameter_values,
        "pauli_lindblad_maps": noise_maps,
        "noise_scales": {
            ref: -1.0 for ref in noise_maps
        },  # Set the scales to -1 for PEC
    },
    shape=(900,),
)

Import Executor dan hantar kerja.

from qiskit_ibm_runtime.executor import Executor

executor = Executor(backend)
executor_job = executor.run(program)

executor_job.job_id()

executor_results = executor_job.result()
executor_results

twirl_result = executor_results[0]

print(f"Twirl result keys:\n {list(twirl_result.keys())}\n")
print(f"Shape of results: {twirl_result['meas'].shape}")

pec_result = executor_results[1]

print(f"PEC result keys:\n {list(pec_result.keys())}\n")
print(f"Shape of results: {pec_result['meas'].shape}")

Twirl result keys:
 ['meas', 'measurement_flips.meas']

Shape of results: (900, 1000, 10)
PEC result keys:
 ['meas', 'measurement_flips.meas', 'pauli_signs']

Shape of results: (900, 1000, 10)

Analisis keputusan

Akhirnya, proses pasca keputusan untuk menganggarkan nilai jangkaan operator Pauli-Z satu qubit yang bertindak pada setiap sepuluh qubit aktif (nilai jangkaan: 1.0).

# Undo measurement twirling
twirl_result_unflipped = (
    twirl_result["meas"] ^ twirl_result["measurement_flips.meas"]
)

# Calculate the expectation values of single-qubit Z operators
exp_vals = 1 - 2 * twirl_result_unflipped.mean(axis=1).mean(axis=0)

for qubit, val in enumerate(exp_vals):
    print(f"Qubit {qubit} -> {np.round(val, 2)}")

Qubit 0 -> 0.77
Qubit 1 -> 0.76
Qubit 2 -> 0.66
Qubit 3 -> 0.71
Qubit 4 -> 0.69
Qubit 5 -> 0.67
Qubit 6 -> 0.62
Qubit 7 -> 0.59
Qubit 8 -> 0.62
Qubit 9 -> 0.68

# Undo measurement twirling
pec_result_unflipped = (
    pec_result["meas"] ^ pec_result["measurement_flips.meas"]
)

# Calculate the signs for PEC mitigation
signs = np.prod((-1) ** pec_result["pauli_signs"], axis=-1)
signs = signs.reshape((signs.shape[0], 1))

# Calculate the expectation values of single-qubit Z operators as required by
# PEC mitigation
exp_vals = 1 - (2 * pec_result_unflipped.mean(axis=1) * signs).mean(axis=0)

for qubit, val in enumerate(exp_vals):
    print(f"Qubit {qubit} -> {np.round(val, 2)}")

Qubit 0 -> 0.98
Qubit 1 -> 0.99
Qubit 2 -> 0.96
Qubit 3 -> 0.98
Qubit 4 -> 0.98
Qubit 5 -> 0.98
Qubit 6 -> 0.98
Qubit 7 -> 0.95
Qubit 8 -> 0.95
Qubit 9 -> 0.94

Langkah seterusnya

Cadangan

• Semak gambaran keseluruhan broadcasting.
• Ketahui cara menggunakan pilihan Executor.
• Fahami model pelaksanaan terarah.
• Semak dokumentasi Samplomatic.
• Ketahui cara menggabungkan teknik mitigasi ralat yang berbeza apabila menggunakan model pelaksanaan terarah dalam tutorial Probabilistic error cancellation with shaded lightcones.