Input dan output Executor

Versi pakej

Kod di halaman ini dibangunkan menggunakan keperluan berikut. Kami syorkan menggunakan versi ini atau yang lebih baru.

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

Primitif Executor adalah sebahagian daripada model pelaksanaan berarah, yang memberikan lebih fleksibiliti apabila menyesuaikan aliran kerja pengurangan ralat.

Input dan output primitif Executor sangat berbeza daripada primitif Sampler dan Estimator. Sebagai contoh, daripada mengambil senarai PUB sebagai input, Executor mengambil QuantumProgram, yang mengandungi senarai objek QuantumProgramItem. Kelas bekas ini memberi anda lebih fleksibiliti berbanding PUB, yang merupakan struktur data tupel mudah.

Output Executor adalah QuantumProgramResult, yang merupakan iterable dan mengandungi satu elemen untuk setiap QuantumProgramItem input.

Input: Program kuantum

Seperti yang dinyatakan sebelumnya, input kepada primitif Executor adalah QuantumProgram, yang merupakan iterable objek QuantumProgramItem. Objek-objek ini boleh terdiri daripada dua jenis:

• CircuitItem, yang biasanya menyimpan Circuit dan nilai parameternya (jika ada).
• SamplexItem, yang biasanya menyimpan yang berikut:
  • Circuit templat
  • Objek samplex, yang digunakan untuk menjana set parameter rawak pada masa jalan (misalnya untuk melakukan twirling atau menyuntik hingar)
  • Argumen untuk samplex, yang mungkin termasuk nilai parameter untuk Circuit asal

Setiap item ini mewakili tugas berbeza yang perlu dilaksanakan oleh Executor.

Sebelum anda mulakan

Sesetengah 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: Cipta QuantumProgram dengan dua tugas berbeza

Pertama mulakan program kuantum anda, kemudian tambahkan item program kepadanya menggunakan sama ada append_circuit_item atau append_samplex_item (jika samplex hadir), seperti yang ditunjukkan dalam contoh-contoh berikut.

Sel berikut memulakan QuantumProgram dan menentukan bahawa ia harus menjalankan 1024 tembakan untuk setiap konfigurasi setiap item dalam program.

nota

Tidak seperti dengan Sampler, QuantumProgram hanya mengambil satu nilai tembakan. Jika anda mahukan nilai tembakan yang berbeza, anda memerlukan QuantumProgram berasingan, yang akan menjadi kerja berasingan.

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

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

# Initialize and transpile a 3-qubit quantum circuit with 2 parameters.
circuit = QuantumCircuit(3)
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.rz(Parameter("theta"), 0)
circuit.rz(Parameter("phi"), 1)

# `measure_all` adds a 3-bit classical register named "meas"
circuit.measure_all()

# Choose the least busy backend
service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

# Generate a preset pass manager
# This will be used to convert the abstract circuit to an
# equivalent Instruction Set Architecture (ISA) circuit.
preset_pass_manager = generate_preset_pass_manager(
    backend=backend, optimization_level=0
)

# Transpile the circuit
isa_circuit = preset_pass_manager.run(circuit)

Tambah CircuitItem

Seterusnya, tambahkan Circuit sasaran, yang telah ditransail mengikut set seni bina arahan (ISA) Backend, ke QuantumProgram. Oleh kerana Circuit ini mempunyai dua parameter, kita juga perlu menyediakan nilai parameter (10 set dalam contoh ini). Menjalankan CircuitItem ini adalah tugas pertama yang akan dilakukan oleh program.

# Append the transpiled circuit and an array
# containing 10 sets of parameter values to the program
program.append_circuit_item(
    isa_circuit,
    circuit_arguments=np.random.rand(
        10, 2
    ),  # 10 sets of parameter values and 2 parameters
)

Tambah SamplexItem

Item Circuit dilaksanakan tanpa sebarang rawakan. Sebaliknya, item samplex membolehkan anda menentukan cara merawakkan kandungannya. Sel berikut menggunakan fungsi generate_boxing_pass_manager() untuk mengumpulkan gate dan ukuran Circuit ke dalam kotak dan menambahkan anotasi twirling ke setiap kotak. Ia kemudian menjana Circuit templat dan pasangan samplex menggunakan fungsi build().

Menjalankan SamplexItem ini adalah tugas kedua yang akan dilakukan oleh program.

Lihat dokumentasi API Samplomatic untuk butiran penuh tentang samplex dan argumennya. Lihat Panduan Transpiler Samplomatic untuk maklumat tentang penggunaan fungsi generate_boxing_pass_manager().

# Transpile the circuit, additionally grouping gates and measurements into annotated boxes
preset_pass_manager = generate_preset_pass_manager(
    backend=backend, optimization_level=0
)

# Use the boxing pass manager to group gates
# and measurements into boxes and add
# a`Twirl` annotation.
preset_pass_manager.post_scheduling = generate_boxing_pass_manager(
    # Add gate twirling
    enable_gates=True,
    # Add measurement twirling
    enable_measures=True,
)
boxed_circuit = preset_pass_manager.run(circuit)

# Build the template circuit and the samplex.  The template circuit has parametric gates
# without fixed values and the samplex randomly generates the parameter
# values on the server side at runtime to perform twirling.
template_circuit, samplex = build(boxed_circuit)

# Determine what arguments are required by the samplex.
# Input the arguments in samplex_arguments.
print(samplex.inputs())

TensorInterface(<
  - 'parameter_values' <float64[2]>: Input parameter values to use during sampling.
>)

# Append the template circuit and samplex as a samplex item
program.append_samplex_item(
    template_circuit,
    samplex=samplex,
    samplex_arguments={
        # the arguments required by the samplex.sample method
        "parameter_values": np.random.rand(10, 2),
    },
    shape=(28, 10),  # 28 randomizations and 10 sets of parameter values
)

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

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

# Retrieve the result
result = job.result()

Output

Output Executor adalah QuantumProgramResult, yang merupakan iterable. Ia mengandungi satu entri per QuantumProgramItem input dalam susunan yang sama seperti item input. Setiap item output ini adalah kamus di mana kuncinya adalah rentetan yang sepadan dengan nama daftar klasikal dalam Circuit input (antara lain), jadi anda tidak perlu lagi menghafal nama-nama ini seperti yang anda lakukan dengan output Sampler. Nilai kamus adalah dari jenis np.ndarray.

Keputusan untuk contoh sebelumnya mengandungi item-item ini:

Keputusan CircuitItem

Item pertama mengandungi keputusan menjalankan tugas pertama (sebuah CircuitItem) dalam program. Ia mengandungi satu kunci, meas, yang merupakan nama daftar klasikal dalam Circuit input. Nilai kunci ini dipetakan ke np.ndarray dengan bentuk (set parameter, tembakan, bit daftar), iaitu (10, 1024, 3) untuk contoh di atas.

Kod berikut menggambarkan cara mengakses maklumat ini:

# Access the results of the classical register of task #0, a CircuitItem
result_0 = result[0]["meas"]
print(f"Result shape: {result_0.shape}")

Result shape: (10, 1024, 3)

Keputusan SamplexItem

Item kedua mengandungi keputusan menjalankan tugas kedua (sebuah SamplexItem) dalam program. Item ini mengandungi beberapa kunci. Kunci meas, yang merupakan nama daftar klasikal Circuit input, dipetakan ke tatasusunan keputusan daftar tersebut. Tatasusunan ini mempunyai bentuk (rawakan, set parameter, tembakan, bit klasikal), atau (28, 10, 1024, 3) dalam contoh ini. Selain itu, output mengandungi kunci measurement_flips.meas, yang merupakan pembetulan balik-bit untuk membatalkan twirling ukuran bagi daftar meas. Bentuk output ini akan menjadi (28, 10, 1, 3) untuk contoh kita kerana hanya satu tembakan diperlukan untuk melakukan balik-bit.

# Access the results of the classical register of task #1
result_1 = result[1]["meas"]
print(f"Result shape: {result_1.shape}")

# Access the bit-flip corrections
flips_1 = result[1]["measurement_flips.meas"]
print(f"Bit-flip corrections shape: {flips_1.shape}")

# Undo the bit flips via classical XOR
unflipped_result_1 = result_1 ^ flips_1

Result shape: (28, 10, 1024, 3)
Bit-flip corrections shape: (28, 10, 1, 3)

Langkah seterusnya

Cadangan

• Terokai contoh yang menggunakan Executor.
• Ketahui tentang model pelaksanaan berarah.
• Fahami penyiaran Executor.