Jalankan kerja dalam Session

Versi pakej

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

qiskit[all]~=2.5.2
qiskit-ibm-runtime~=0.47.0
scipy~=1.17.1

Nota

Pengguna Pelan Open tidak boleh menghantar kerja Session. Beban kerja mesti dijalankan dalam job mode atau batch mode.

Gunakan Session apabila anda memerlukan akses eksklusif dan khusus kepada QPU.

Persediaan untuk menggunakan Session

Sebelum memulakan Session, anda perlu menyediakan klien IBM Quantum Compute dan memulakannya sebagai perkhidmatan:

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"numpy": "numpy", "qiskit": "qiskit", "qiskit_ibm_runtime": "qiskit-ibm-runtime", "scipy": "scipy"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

from qiskit_ibm_runtime import QiskitRuntimeService, Session, Executor

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Sampler, Estimator

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler
from qiskit_ibm_runtime.executor_estimator import Estimator

service = QiskitRuntimeService()

Buka Session

Anda boleh membuka Session runtime dengan menggunakan pengurus konteks with Session(...) atau dengan memulakan kelas Session. Apabila anda memulakan Session, anda mesti menentukan QPU dengan menghantar objek backend. Session bermula apabila kerja pertamanya mula dilaksanakan.

nota

Jika anda membuka Session tetapi tidak menghantar sebarang kerja kepadanya selama 30 minit, Session akan ditutup secara automatik.

Kelas Session

awas

Blok kod berikut akan mengembalikan ralat untuk pengguna Pelan Open kerana ia menggunakan Session. Beban kerja pada Pelan Open hanya boleh berjalan dalam job mode atau batch mode.

backend = service.least_busy(operational=True, simulator=False)
session = Session(backend=backend)
estimator = Estimator(mode=session)
sampler = Sampler(mode=session)
executor = Executor(mode=session)
# Close the session because no context manager was used.
session.close()

Pengurus konteks

Pengurus konteks secara automatik membuka dan menutup Session.

awas

Blok kod berikut akan mengembalikan ralat untuk pengguna Pelan Open kerana ia menggunakan Session. Beban kerja pada Pelan Open hanya boleh berjalan dalam job mode atau batch mode.

from qiskit_ibm_runtime import Session, Executor

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Sampler, Estimator

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_sampler import Sampler
from qiskit_ibm_runtime.executor_estimator import Estimator

backend = service.least_busy(operational=True, simulator=False)
with Session(backend=backend):
    estimator = Estimator()
    sampler = Sampler()
    executor = Executor()

Tempoh Session

Masa hidup maksimum (TTL) Session menentukan berapa lama Session boleh berjalan. Anda boleh menetapkan nilai ini dengan parameter max_time. Ini hendaklah melebihi masa pelaksanaan kerja yang paling lama.

Pemasa ini bermula apabila Session dimulakan. Apabila nilai dicapai, Session ditutup. Mana-mana kerja yang sedang berjalan akan selesai, tetapi kerja yang masih dalam giliran akan digagalkan.

awas

Blok kod berikut akan mengembalikan ralat untuk pengguna Pelan Open kerana ia menggunakan Session. Beban kerja pada Pelan Open hanya boleh berjalan dalam job mode atau batch mode.

with Session(backend=backend, max_time="25m"):
  ...

Terdapat juga nilai masa hidup interaktif (interactive TTL) yang tidak boleh dikonfigurasi. Jika tiada kerja Session dalam giliran dalam tempoh tersebut, Session akan dinyahaktifkan sementara.

Nilai lalai:

Jenis instans (Pelan Open atau Premium)	Interactive TTL	TTL Maksimum
Pelan Premium	60 saat*	8 j*

* Sesetengah instans Pelan Premium mungkin dikonfigurasi dengan nilai yang berbeza.

Untuk menentukan max TTL atau interactive TTL Session, ikuti arahan dalam Tentukan butiran Session dan cari nilai max_time atau interactive_timeout.

Tamatkan Session

Session tamat dalam keadaan berikut:

• Nilai tamat masa maksimum (TTL) dicapai, menyebabkan pembatalan semua kerja dalam giliran.

• Session dibatalkan secara manual, menyebabkan pembatalan semua kerja dalam giliran.

• Session ditutup secara manual. Session berhenti menerima kerja baharu tetapi terus menjalankan kerja dalam giliran dengan keutamaan.

• Jika anda menggunakan Session sebagai pengurus konteks, iaitu with Session(), Session ditutup secara automatik apabila konteks berakhir (tingkah laku yang sama seperti menggunakan session.close()).

Tutup Session

Session ditutup secara automatik apabila ia keluar dari pengurus konteks. Apabila pengurus konteks Session ditamatkan, Session diletakkan dalam status "Sedang berjalan, tidak menerima kerja baharu". Ini bermakna Session menyelesaikan semua kerja yang sedang berjalan atau dalam giliran sehingga nilai tamat masa maksimum dicapai. Selepas semua kerja selesai, Session ditutup dengan segera. Ini membolehkan penjadual menjalankan kerja seterusnya tanpa menunggu tamat masa interaktif Session, dengan itu mengurangkan purata masa beratur kerja. Anda tidak boleh menghantar kerja ke Session yang telah ditutup.

awas

Blok kod berikut akan mengembalikan ralat untuk pengguna Pelan Open kerana ia menggunakan Session. Beban kerja pada Pelan Open hanya boleh berjalan dalam job mode atau batch mode.

from qiskit.quantum_info import SparsePauliOp
from qiskit.circuit import QuantumCircuit, Parameter
from qiskit.transpiler import generate_preset_pass_manager
import numpy as np

# This cell is hidden from users
service = QiskitRuntimeService()
backend = service.least_busy()

# Define two circuits, each with one parameter with two parameters.
circuit = QuantumCircuit(2)
circuit.h(0)
circuit.cx(0, 1)
circuit.ry(Parameter("a"), 0)
circuit.cx(0, 1)
circuit.h(0)
circuit.measure_all()

pm = generate_preset_pass_manager(optimization_level=1, backend=backend)
transpiled_circuit = pm.run(circuit)
transpiled_circuit_sampler = transpiled_circuit
transpiled_circuit_sampler.measure_all()

# Create parameters and mapped observables to submit
params = np.random.uniform(size=(2, 3)).T
observables = [
    SparsePauliOp(["XX", "IY"], [0.5, 0.5]),
    SparsePauliOp("XX"),
    SparsePauliOp("IY"),
]
mapped_observables = [
    [observable.apply_layout(transpiled_circuit.layout)]
    for observable in observables
]

sampler_pub = (transpiled_circuit_sampler, params)
estimator_pub = (transpiled_circuit_sampler, mapped_observables, params)

with Session(backend=backend) as session:
    estimator = Estimator()
    sampler = Sampler()
    job1 = estimator.run([estimator_pub])
    job2 = sampler.run([sampler_pub])

# The session is no longer accepting jobs but the submitted job will run to completion.
result = job1.result()
result2 = job2.result()

petua

Jika anda tidak menggunakan pengurus konteks, tutup Session secara manual untuk mengelakkan kos yang tidak diingini. Anda boleh menutup Session sebaik sahaja anda selesai menghantar kerja kepadanya. Apabila Session ditutup dengan session.close(), ia tidak lagi menerima kerja baharu, tetapi kerja yang telah dihantar akan tetap berjalan hingga selesai dan keputusannya boleh diambil semula.

awas

Blok kod berikut akan mengembalikan ralat untuk pengguna Pelan Open kerana ia menggunakan Session. Beban kerja pada Pelan Open hanya boleh berjalan dalam job mode atau batch mode.

session = Session(backend=backend)

# If using qiskit-ibm-runtime earlier than 0.24.0, change `mode=` to `session=`
estimator = Estimator(mode=session)
sampler = Sampler(mode=session)
job1 = estimator.run([estimator_pub])
job2 = sampler.run([sampler_pub])
print(f"Result1: {job1.result()}")
print(f"Result2: {job2.result()}")

# Manually close the session. Running and queued jobs will run to completion.
session.close()

Result1: PrimitiveResult([PubResult(data=DataBin(evs=np.ndarray(<shape=(3, 2), dtype=float64>), stds=np.ndarray(<shape=(3, 2), dtype=float64>), ensemble_standard_error=np.ndarray(<shape=(3, 2), dtype=float64>), shape=(3, 2)), metadata={'shots': 4096, 'target_precision': 0.015625, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32})], metadata={'dynamical_decoupling': {'enable': False, 'sequence_type': 'XX', 'extra_slack_distribution': 'middle', 'scheduling_method': 'alap'}, 'twirling': {'enable_gates': False, 'enable_measure': True, 'num_randomizations': 'auto', 'shots_per_randomization': 'auto', 'interleave_randomizations': True, 'strategy': 'active-accum'}, 'resilience': {'measure_mitigation': True, 'zne_mitigation': False, 'pec_mitigation': False}, 'version': 2})
Result2: PrimitiveResult([SamplerPubResult(data=DataBin(meas=BitArray(<shape=(3, 2), num_shots=4096, num_bits=2>), meas0=BitArray(<shape=(3, 2), num_shots=4096, num_bits=156>), shape=(3, 2)), metadata={'circuit_metadata': {}})], metadata={'execution': {'execution_spans': ExecutionSpans([DoubleSliceSpan(<start='2026-09-01 08:34:17', stop='2026-09-01 08:34:24', size=24576>)])}, 'version': 2})

Semak status Session

Anda boleh menyemak status Session untuk memahami keadaannya semasa dengan menggunakan session.status() atau dengan melihat halaman Beban Kerja.

Status Session boleh menjadi salah satu daripada berikut:

• Pending: Session belum bermula atau telah dinyahaktifkan. Kerja Session seterusnya perlu menunggu dalam giliran seperti kerja lain.

• In progress, accepting new jobs: Session aktif dan menerima kerja baharu.

• In progress, not accepting new jobs: Session aktif tetapi tidak menerima kerja baharu. Penghantaran kerja ke Session ditolak, tetapi kerja Session yang belum selesai akan berjalan hingga tamat. Session ditutup secara automatik setelah semua kerja selesai.

• Closed: Nilai tamat masa maksimum Session telah dicapai atau Session telah ditutup secara eksplisit.

Tentukan butiran Session

Untuk gambaran keseluruhan komprehensif konfigurasi dan status Session, gunakan session.details() method.

awas

Blok kod berikut akan mengembalikan ralat untuk pengguna Pelan Open kerana ia menggunakan Session. Beban kerja pada Pelan Open hanya boleh berjalan dalam job mode atau batch mode.

from qiskit_ibm_runtime import QiskitRuntimeService, Session

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Estimator

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_estimator import Estimator

service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

with Session(backend=backend) as session:
    print(session.details())

{'id': 'ff7977a5-ae7b-4509-9c84-bd1d7ff9f619', 'backend_name': 'ibm_marrakesh', 'interactive_timeout': 60, 'max_time': 28800, 'active_timeout': 28800, 'state': 'open', 'accepting_jobs': True, 'last_job_started': None, 'last_job_completed': None, 'started_at': None, 'closed_at': None, 'activated_at': None, 'mode': 'dedicated', 'usage_time': None}

Corak penggunaan

Session amat berguna untuk algoritma yang memerlukan komunikasi kerap antara sumber klasik dan kuantum.

Contoh: Jalankan beban kerja berulang yang menggunakan pengoptimum SciPy klasik untuk meminimumkan fungsi kos. Dalam model ini, SciPy menggunakan output fungsi kos untuk mengira input seterusnya.

awas

Blok kod berikut akan mengembalikan ralat untuk pengguna Pelan Open kerana ia menggunakan Session. Beban kerja pada Pelan Open hanya boleh berjalan dalam job mode atau batch mode.

from scipy.optimize import minimize
from qiskit.circuit.library import efficient_su2

def cost_func(params, ansatz, hamiltonian, estimator):
    # Return estimate of energy from estimator

    energy = sum(
        estimator.run([(ansatz, hamiltonian, params)]).result()[0].data.evs
    )
    return energy

hamiltonian = SparsePauliOp.from_list(
    [("YZ", 0.3980), ("ZI", -0.3980), ("ZZ", -0.0113), ("XX", 0.1810)]
)
su2_ansatz = efficient_su2(hamiltonian.num_qubits)
pm = generate_preset_pass_manager(backend=backend, optimization_level=3)
ansatz = pm.run(su2_ansatz)
mapped_hamiltonian = [
    operator.apply_layout(ansatz.layout) for operator in hamiltonian
]

num_params = ansatz.num_parameters
x0 = 2 * np.pi * np.random.random(num_params)

session = Session(backend=backend)

# If using qiskit-ibm-runtime earlier than 0.24.0, change `mode=` to `session=`
estimator = Estimator(mode=session, options={"default_shots": int(1e4)})
res = minimize(
    cost_func,
    x0,
    args=(ansatz, mapped_hamiltonian, estimator),
    method="cobyla",
    options={"maxiter": 25},
)

# Close the session because no context manager was used.
session.close()

Jalankan dua algoritma VQE dalam Session menggunakan threading

Anda boleh memaksimumkan penggunaan Session dengan menjalankan berbilang beban kerja serentak. Contoh berikut menunjukkan cara anda boleh menjalankan dua algoritma VQE, masing-masing menggunakan pengoptimum klasik yang berbeza, serentak dalam satu Session. Tag kerja juga digunakan untuk membezakan kerja dari setiap beban kerja.

awas

Blok kod berikut akan mengembalikan ralat untuk pengguna Pelan Open kerana ia menggunakan Session. Beban kerja pada Pelan Open hanya boleh berjalan dalam job mode atau batch mode.

from concurrent.futures import ThreadPoolExecutor

# Legacy server-side primitive before qiskit-ibm-runtime 0.50.0
# from qiskit_ibm_runtime import Estimator

# Client-side primitive introduced in qiskit-ibm-runtime 0.50.0
from qiskit_ibm_runtime.executor_estimator import Estimator

def minimize_thread(estimator, method):
    return minimize(
        cost_func,
        x0,
        args=(ansatz, mapped_hamiltonian, estimator),
        method=method,
        options={"maxiter": 25},
    )

with Session(backend=backend), ThreadPoolExecutor() as executor:
    estimator1 = Estimator()
    estimator2 = Estimator()

    # Use different tags to differentiate the jobs.
    estimator1.options.environment.job_tags = ["cobyla"]
    estimator2.options.environment.job_tags = ["nelder-mead"]

    # Submit the two workloads.
    cobyla_future = executor.submit(minimize_thread, estimator1, "cobyla")
    nelder_mead_future = executor.submit(
        minimize_thread, estimator2, "nelder-mead"
    )

    # Get workload results.
    cobyla_result = cobyla_future.result()
    nelder_mead_result = nelder_mead_future.result()

Langkah seterusnya

Cadangan

• Cuba contoh dalam tutorial Algoritma pengoptimuman anggaran kuantum (QAOA).
• Semak rujukan Session API.
• Fahami Had kerja apabila menghantar kerja ke QPU IBM®.
• Semak Soalan lazim mod pelaksanaan.