Quickstart Estimator

Primitif Estimator menghitung nilai ekspektasi untuk satu atau lebih observabel terhadap state yang disiapkan oleh Circuit kuantum. Circuit bisa terparameterisasi, selama nilai parameter juga disertakan sebagai input ke primitif.

Primitif ini memiliki beberapa teknik mitigasi dan penekanan error bawaan, termasuk dynamical decoupling, Pauli-twirling, gate-folding ZNE, PEA, dan PEC. Primitif ini juga mendukung opsi resilience_level yang memungkinkanmu mengonfigurasi trade-off biaya dan akurasi dengan mudah. Langkah-langkah dalam topik ini menjelaskan cara menyiapkan Estimator, menjelajahi opsi yang bisa kamu gunakan untuk mengonfigurasinya, dan memanggilnya dalam sebuah program.

Implementasi Estimator baru

Implementasi baru dari interface Qiskit SamplerV2 dan EstimatorV2 diperkenalkan di qiskit-ibm-runtime v0.50.0. Primitif sisi klien ini melakukan sebagian besar pra-pemrosesan dan pasca-pemrosesan di sisi klien dan mendelegasikan eksekusi ke primitif Executor. Menjalankan di sisi klien memberikan transparansi yang lebih besar, umpan balik debugging yang lebih cepat, dan kontrol yang lebih terperinci.

Karena mengimplementasikan API yang sama, primitif sisi klien ini sebagian besar merupakan pengganti langsung (drop-in) dari primitif sisi server versi lama, karena yang perlu diubah hanyalah pernyataan import. Lihat Migrasi dari Sampler dan Estimator sisi server ke sisi klien untuk informasi lebih lanjut.

Versi paket

Kode di halaman ini dikembangkan menggunakan persyaratan berikut. Kami menyarankan menggunakan versi ini atau yang lebih baru.

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

Langkah-langkah menggunakan primitif Estimator

1. Inisialisasi akun

Kamu perlu menginisialisasi akunmu terlebih dahulu. Kemudian kamu bisa memilih QPU yang ingin kamu gunakan untuk menghitung nilai ekspektasi.

Ikuti langkah-langkah di Atur akun IBM Cloud kamu jika kamu belum memiliki akun.

Fractional gates

Untuk menggunakan fractional gates yang baru didukung, atur use_fractional_gates=True saat meminta backend dari instance QiskitRuntimeService. Contoh:

service = QiskitRuntimeService()
fractional_gate_backend = service.least_busy(use_fractional_gates=True)

Ini adalah fitur eksperimental dan mungkin berubah di masa mendatang.

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

_needed = {"qiskit": "qiskit", "qiskit_ibm_runtime": "qiskit-ibm-runtime"}
_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

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

print(backend.name)

ibm_fez

2. Buat Circuit dan observabel

Kamu membutuhkan setidaknya satu Circuit dan satu observabel sebagai input ke primitif Estimator.

from qiskit.circuit.library import qaoa_ansatz
from qiskit.quantum_info import SparsePauliOp

entanglement = [tuple(edge) for edge in backend.coupling_map.get_edges()]
observable = SparsePauliOp.from_sparse_list(
    [("ZZ", [i, j], 0.5) for i, j in entanglement],
    num_qubits=backend.num_qubits,
)
circuit = qaoa_ansatz(observable, reps=2)
# The circuit is parametrized, so we will define the parameter values for execution
param_values = [0.1, 0.2, 0.3, 0.4]

Circuit dan observabel perlu ditransformasi untuk hanya menggunakan instruksi yang didukung oleh QPU (disebut sebagai Circuit instruction set architecture (ISA)). Gunakan Transpiler untuk melakukan ini.

from qiskit.transpiler import generate_preset_pass_manager

pm = generate_preset_pass_manager(optimization_level=1, backend=backend)
isa_circuit = pm.run(circuit)
isa_observable = observable.apply_layout(isa_circuit.layout)
print(f">>> Circuit ops (ISA): {isa_circuit.count_ops()}")

>>> Circuit ops (ISA): OrderedDict([('rz', 4472), ('sx', 1884), ('cz', 1120)])

3. Inisialisasi IBM Quantum Estimator

Saat kamu menginisialisasi Estimator, gunakan parameter mode untuk menentukan mode yang ingin dijalankan. Nilai yang mungkin adalah objek batch, session, atau backend untuk mode eksekusi batch, session, dan job, masing-masing. Untuk info lebih lanjut, lihat Pengantar mode eksekusi IBM Quantum Compute Service. Perlu diperhatikan bahwa pengguna Open Plan tidak bisa mengirimkan job 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

estimator = Estimator(mode=backend)

4. Panggil Estimator dan dapatkan hasilnya

Selanjutnya, panggil metode run() untuk menghitung nilai ekspektasi untuk Circuit dan observabel input. Circuit, observabel, dan set nilai parameter opsional dimasukkan sebagai tuple primitive unified bloc (PUB).

job = estimator.run([(isa_circuit, isa_observable, param_values)])
print(f">>> Job ID: {job.job_id()}")
print(f">>> Job Status: {job.status()}")

>>> Job ID: dab7lfurrl7c7386gjn0

>>> Job Status: QUEUED

result = job.result()
print(f">>> {result}")
print(f"  > Expectation value: {result[0].data.evs}")
print(f"  > Metadata: {result[0].metadata}")

>>> PrimitiveResult([PubResult(data=DataBin(evs=np.ndarray(<shape=(), dtype=float64>), stds=np.ndarray(<shape=(), dtype=float64>), ensemble_standard_error=np.ndarray(<shape=(), dtype=float64>)), 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})
  > Expectation value: 28.60306448415693
  > Metadata: {'shots': 4096, 'target_precision': 0.015625, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32}

Langkah selanjutnya

Rekomendasi

• Pelajari cara menguji secara lokal sebelum menjalankan di komputer kuantum.
• Tinjau contoh detail.
• Berlatih dengan primitif melalui pelajaran fungsi biaya di IBM Quantum Learning.
• Pelajari cara transpile secara lokal di bagian Transpile.
• Coba panduan Bandingkan pengaturan transpiler.
• Pelajari cara menggunakan opsi primitif.
• Lihat API untuk opsi Estimator.