Start rapid cu Estimator

Primitiva Estimator calculează valorile așteptate (valorile medii) pentru una sau mai multe observabile față de stările pregătite de circuite cuantice. Circuitele pot fi parametrizate, cu condiția ca valorile parametrilor să fie furnizate de asemenea ca intrare primitivei.

Această primitivă are mai multe tehnici integrate de atenuare și suprimare a erorilor, inclusiv decuplare dinamică, Pauli-twirling, ZNE prin pliere de gate, PEA și PEC. Suportă, de asemenea, o opțiune resilience_level care îți permite să configurezi ușor compromisul cost-acuratețe. Pașii din acest subiect descriu cum să configurezi Estimator, să explorezi opțiunile pe care le poți folosi pentru a-l configura și să îl invoci într-un program.

Noua implementare Estimator

Noi implementări ale interfețelor Qiskit SamplerV2 și EstimatorV2 au fost introduse în qiskit-ibm-runtime v0.50.0. Aceste primitive client-side realizează majoritatea preprocesării și postprocesării pe partea de client și deleagă execuția primitivei Executor. Rularea pe partea de client oferă transparență mai mare, feedback de depanare mai rapid și control mai fin.

Deoarece implementează același API, aceste primitive client-side sunt în mare parte înlocuiri directe ale primitivelor server-side vechi, singura schimbare fiind instrucțiunea de import. Vezi Migrează de la Sampler și Estimator server-side la client-side pentru mai multe informații.

Versiuni de pachete

Codul de pe această pagină a fost dezvoltat folosind următoarele cerințe. Recomandăm utilizarea acestor versiuni sau a unor versiuni mai noi.

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

Pași pentru utilizarea primitivei Estimator

1. Inițializarea contului

Trebuie mai întâi să îți inițializezi contul. Poți selecta apoi QPU-ul pe care vrei să îl folosești pentru a calcula valoarea de așteptare.

Urmează pașii din Configurarea contului IBM Cloud dacă nu ai deja un cont.

Gate-uri fracționale

Pentru a utiliza gate-urile fracționale nou suportate, setează use_fractional_gates=True atunci când soliciți un backend dintr-o instanță QiskitRuntimeService. De exemplu:

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

Aceasta este o caracteristică experimentală și s-ar putea schimba în viitor.

# 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. Crearea unui circuit și a unui observabil

Ai nevoie de cel puțin un circuit și un observabil ca intrări pentru primitiva 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]

Circuitul și observabilul trebuie transformate pentru a utiliza doar instrucțiunile suportate de QPU (denumite circuite de arhitectură set de instrucțiuni (ISA)). Folosește transpilerul pentru aceasta.

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. Inițializarea IBM Quantum Estimator

Când inițializezi Estimator, folosești parametrul mode pentru a specifica modul în care vrei să ruleze. Valorile posibile sunt obiecte batch, session sau backend pentru modul de execuție batch, session și respectiv job. Pentru mai multe informații, consultă Introducere în modurile de execuție IBM Quantum Compute Service. Reține că utilizatorii planului Open nu pot trimite joburi de sesiune.

# 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. Invocarea Estimator și obținerea rezultatelor

Apoi, invocă metoda run() pentru a calcula valorile de așteptare pentru circuitele și observabilii de intrare. Circuitul, observabilul și seturile opționale de valori de parametri sunt introduse ca tupluri 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}

Pașii următori

Recomandări

• Află cum să testezi local înainte de a rula pe calculatoare cuantice.
• Consultă exemple detaliate.
• Exersează cu primitive parcurgând lecția despre funcțiile de cost din IBM Quantum Learning.
• Află cum să transpilezi local în secțiunea Transpilare.
• Încearcă ghidul Comparare setări transpiler.
• Află cum să utilizezi opțiunile primitivelor.
• Vizualizează API-ul pentru opțiunile Estimator.