Mabilisang pagsisimula sa Estimator

Kinakalkula ng Estimator primitive ang mga expectation value ng isa o higit pang observable kaugnay ng mga state na inihanda ng mga quantum circuit. Ang mga circuit ay maaaring i-parametrize, basta't ang mga halaga ng parameter ay ibinibigay rin bilang input sa primitive.

May ilang built-in na teknik ng error mitigation at suppression ang primitive na ito, kabilang ang dynamical decoupling, Pauli-twirling, gate-folding ZNE, PEA, at PEC. Sinusuportahan din nito ang isang opsyon na resilience_level na nagpapahintulot sa iyo na madaling i-configure ang trade-off ng gastos at katumpakan. Inilalarawan ng mga hakbang sa paksang ito kung paano i-set up ang Estimator, i-explore ang mga opsyon na maaari mong gamitin para i-configure ito, at i-invoke ito sa isang programa.

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.5.2
qiskit-ibm-runtime~=0.47.0

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

Mga hakbang para gamitin ang Estimator primitive

1. I-initialize ang account

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.

Mga fractional gate

Para gamitin ang bagong sinusuportahang mga fractional gate, itakda ang use_fractional_gates=True kapag humihiling ng backend mula sa isang QiskitRuntimeService instance. Halimbawa:

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

Ito ay isang experimental na feature at maaaring magbago sa hinaharap.

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. Lumikha ng circuit at isang observable

Kailangan mo ng kahit isang circuit at isang observable bilang mga input sa Estimator primitive.

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]

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

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. I-initialize ang IBM Quantum Estimator

Kapag ini-initialize mo ang Estimator, gamitin ang parameter na mode para tukuyin ang mode na gusto mong patakbuhin nito. Ang mga posibleng halaga ay mga object na batch, session, o backend para sa batch, session, at job execution mode, ayon sa pagkakasunod. Para sa karagdagang impormasyon, tingnan ang Panimula sa IBM Quantum Compute Service execution modes. Tandaan na ang mga gumagamit ng Open Plan ay hindi makakapagsumite ng mga session job.

from qiskit_ibm_runtime import EstimatorV2 as Estimator

estimator = Estimator(mode=backend)

4. I-invoke ang Estimator at makuha ang mga resulta

Susunod, i-invoke ang method na run() para kalkulahin ang mga expectation value para sa mga input na circuit at observable. Ang circuit, observable, at mga opsyonal na set ng halaga ng parameter ay inilalagay bilang mga tuple ng 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}

Mga susunod na hakbang

Mga rekomendasyon

• Alamin kung paano subukan nang lokal bago patakbuhin sa mga quantum computer.
• Suriin ang mga detalyadong halimbawa.
• Magsanay sa mga primitive sa pamamagitan ng paggawa ng Cost function lesson sa IBM Quantum Learning.
• Alamin kung paano mag-transpile nang lokal sa seksyon ng Transpile.
• Subukan ang gabay na Ihambing ang mga setting ng transpiler.
• Alamin kung paano gamitin ang mga opsyon ng primitive.
• Tingnan ang API para sa mga opsyon ng Estimator.