Mabilisang pagsisimula sa Executor

Mga bersyon ng package

Ang code sa pahinang ito ay binuo gamit ang mga sumusunod na kinakailangan. Inirerekumenda naming gamitin ang mga bersyong ito o mas bago.

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 qiskit qiskit-ibm-runtime samplomatic

Katulad ng Sampler primitive, ang Executor ay nag-sa-sample ng mga output register mula sa mga quantum circuit execution, ngunit wala itong built-in na error suppression o mitigation. Sa halip, ito ay bahagi ng directed execution model na nagbibigay ng mga sangkap para makuha ang mga design intent sa client side, at inililipat ang mahal na paglikha ng mga variant ng circuit sa server side. Sinusunod ng Executor ang mga direktibo na ibinigay sa mga annotation at opsyon ng circuit, nag-ge-generate at nag-ba-bind ng mga halaga ng parameter, nagpapatupad ng mga bound circuit sa hardware, at ibinabalik ang mga resulta ng execution at metadata. Hindi ito gumagawa ng anumang implicit na desisyon para sa iyo at nagbibigay ng buong kontrol at transparency.

tala

Ang Qiskit package ay wala pang base class para sa Executor primitive.

Bago ka magsimula

Ang ilang halimbawa ng code sa pahinang ito ay gumagamit ng samplex, na bahagi ng Samplomatic package. Samakatuwid, bago patakbuhin ang mga code block na iyon, kailangan mong i-install ang Samplomatic, tulad ng ipinapakita sa sumusunod na code block. Para sa karagdagang impormasyon, tingnan ang dokumentasyon ng Samplomatic.

pip install samplomatic

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

Mga hakbang para gamitin ang Executor primitive

1. I-initialize ang account

Dahil ang Qiskit Runtime ay isang managed na serbisyo, kailangan mo munang i-initialize ang iyong account. Maaari kang pumili ng QPU na gusto mong gamitin para kalkulahin ang expectation value.

Sundin ang mga hakbang sa I-set up ang iyong IBM Cloud® account kung wala ka pang account.

from qiskit_ibm_runtime import QiskitRuntimeService, Executor
from qiskit_ibm_runtime.quantum_program import QuantumProgram
from qiskit.circuit import QuantumCircuit
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)

print(backend)

<IBMBackend('ibm_fez')>

2. Lumikha at mag-transpile ng circuit

Kailangan mo ng kahit isang circuit para gamitin ang Executor primitive. Maaari itong may mga opsyonal na parameter.

# Generate the circuit
circuit = QuantumCircuit(2)
circuit.h(0)
circuit.h(1)
circuit.cz(0, 1)
circuit.h(1)

# Using `measure_all` automatically creates the necessary
# classical registers.
circuit.measure_all()

Ang circuit ay kailangang i-transform para gumamit lamang ng mga tagubilin na sinusuportahan ng QPU (tinatawag na instruction set architecture (ISA) circuit). Gamitin ang transpiler para gawin ito.

# Transpile the circuit
preset_pass_manager = generate_preset_pass_manager(
    backend=backend, optimization_level=0
)
isa_circuit = preset_pass_manager.run(circuit)

3. I-initialize ang isang QuantumProgram

I-initialize ang isang QuantumProgram kasama ang iyong workload. Ang isang QuantumProgram ay binubuo ng mga QuantumProgramItem. Karaniwang, ang bawat item ay binubuo ng isang circuit, isang set ng mga halaga ng parameter, at posibleng isang samplex para gawing random ang nilalaman ng circuit. Para sa buong detalye, tingnan ang Mga input at output ng Executor.

Ang sumusunod na cell ay nag-i-initialize ng isang QuantumProgram at nagtatakda na magsagawa ng 25 shot. Susunod, ini-append nito ang transpiled na target na circuit.

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

# Append the circuit to the program
program.append_circuit_item(isa_circuit)

4. Opsyonal: Grupuhin ang mga gate at measurement sa mga annotated na box

Ang pag-grupo ng mga tagubilin sa mga box at pag-annotate sa mga ito ay ang pangunahing paraan para tukuyin ang iyong intent. Sa sumusunod na halimbawa, ginagamit namin ang generate_boxing_pass_manager at ang mga parameter ng twirling nito para grupuhin ang mga two-qubit gate at mga measurement sa mga box at mag-apply ng twirling annotation.

# Generate a boxing pass manager to group gates
# and measurements into boxes and add
# a`Twirl` annotation.
boxes_pm = generate_boxing_pass_manager(
    # Add gate twirling
    enable_gates=True,
    # Add measurement twirling
    enable_measures=True,
)

boxed_circuit = boxes_pm.run(isa_circuit)
boxed_circuit.draw("mpl", idle_wires=False)

5. Opsyonal: Bumuo ng template circuit at samplex, at idagdag ang mga ito sa program

Susunod, gamitin ang Samplomatic build method para makabuo ng pares ng template circuit at samplex. Ang template circuit ay structurally katumbas ng orihinal na circuit. Gayunpaman, ang mga single-qubit gate nito ay pinapalitan ng mga parameterized gate para ipatupad ang mga inireseta na annotation (gate at measurement twirling, sa halimbawang ito). Ine-encode ng samplex ang lahat ng impormasyong kinakailangan para makabuo ng mga randomized na parameter para sa template circuit.

Pagkatapos makabuo ng pares ng template circuit at samplex, gamitin ang method na append_samplex_item para idagdag ang pares sa program.

Tingnan ang dokumentasyon ng Samplomatic API para sa buong detalye tungkol sa samplomatic.samplex.Samplex at ang mga argumento nito.

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

# Append the template circuit and samplex as a `samplex_item`
program.append_samplex_item(
    template_circuit,
    samplex=samplex,
    shape=(num_randomizations := 20,),
)

6. I-invoke ang Executor at makuha ang mga resulta

Patakbuhin ang QuantumProgram sa isang IBM® backend sa pamamagitan ng paggamit ng Executor primitive na may mga default na opsyon. Tingnan ang Mga opsyon ng Executor para malaman ang tungkol sa mga available na opsyon.

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

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

<RuntimeJobV2('d8286580bvlc73d1vmsg', 'executor')>

# Retrieve the result
result = job.result()

Ang resulta ay may uri na QuantumProgramResult. Tingnan ang Mga input at output ng Executor para malaman ang tungkol sa result object.

Mga susunod na hakbang

Mga rekomendasyon

• Subukan ang ilang halimbawa ng Executor.
• Unawain ang Mga input at output ng Executor.
• Matuto tungkol sa Mga semantika ng Executor broadcasting.