Estimator-Schnellstart

Das Estimator-Primitive berechnet die Erwartungswerte für eine oder mehrere Observablen bezüglich der von Quantum Circuits präparierten Zustände. Die Circuits können parametrisiert sein, solange die Parameterwerte ebenfalls als Eingabe an das Primitive übergeben werden.

Dieses Primitive verfügt über mehrere eingebaute Fehlerminderungs- und -unterdrückungstechniken, darunter Dynamical Decoupling, Pauli-Twirling, Gate-Folding ZNE, PEA und PEC. Es unterstützt außerdem eine Option resilience_level, mit der du den Kompromiss zwischen Kosten und Genauigkeit einfach konfigurieren kannst. Dieser Leitfaden beschreibt Schritt für Schritt, wie du den Estimator einrichtest, die verfügbaren Konfigurationsoptionen erkundest und ihn in einem Programm aufrufst.

Neue Estimator-Implementierung

Neue Implementierungen der Qiskit SamplerV2- und EstimatorV2-Schnittstellen wurden in qiskit-ibm-runtime v0.50.0 eingeführt. Diese clientseitigen Primitives führen den Großteil der Vor- und Nachverarbeitung auf der Client-Seite aus und delegieren die Ausführung an das Executor-Primitive. Die Ausführung auf der Client-Seite bietet mehr Transparenz, schnelleres Debugging-Feedback und feinere Kontrolle.

Da sie dieselbe API implementieren, können diese clientseitigen Primitives die bisherigen serverseitigen Primitives größtenteils direkt ersetzen, wobei sich nur die Import-Anweisung ändert. Weitere Informationen findest du unter Migration von serverseitigen zu clientseitigen Sampler und Estimator.

Paketversionen

Der Code auf dieser Seite wurde mit den folgenden Anforderungen entwickelt. Wir empfehlen die Verwendung dieser oder neuerer Versionen.

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

Schritte zur Verwendung des Estimator-Primitives

1. Konto initialisieren

Du musst zunächst dein Konto initialisieren. Danach kannst du die QPU auswählen, die du zur Berechnung des Erwartungswerts verwenden möchtest.

Folge den Schritten unter IBM Cloud-Konto einrichten, falls du noch kein Konto hast.

Fractional Gates

Um die neu unterstützten Fractional Gates zu verwenden, setze use_fractional_gates=True, wenn du ein Backend von einer QiskitRuntimeService-Instanz anforderst. Zum Beispiel:

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

Dies ist eine experimentelle Funktion und kann sich in Zukunft ändern.

# 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. Circuit und Observable erstellen

Du benötigst mindestens einen Circuit und eine Observable als Eingaben für das 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]

Der Circuit und die Observable müssen so transformiert werden, dass sie nur Anweisungen verwenden, die von der QPU unterstützt werden (bezeichnet als Instruction Set Architecture (ISA)-Circuits). Verwende dafür den Transpiler.

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. Den IBM Quantum Estimator initialisieren

Wenn du den Estimator initialisierst, verwende den Parameter mode, um den gewünschten Ausführungsmodus festzulegen. Mögliche Werte sind batch-, session- oder backend-Objekte für den Batch-, Session- bzw. Job-Ausführungsmodus. Weitere Informationen findest du unter Einführung in die IBM Quantum Compute Service-Ausführungsmodi. Beachte, dass Nutzer des Open Plan keine Session-Jobs einreichen können.

# 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. Estimator aufrufen und Ergebnisse abrufen

Rufe als Nächstes die Methode run() auf, um Erwartungswerte für die Eingabe-Circuits und Observablen zu berechnen. Circuit, Observable und optionale Parameterwert-Sets werden als Primitive Unified Bloc (PUB)-Tupel übergeben.

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}

Nächste Schritte

Empfehlungen

• Lerne, wie du lokal testest, bevor du deine Programme auf Quantencomputern ausführst.
• Sieh dir detaillierte Beispiele an.
• Übe mit Primitives, indem du die Lektion zu Kostenfunktionen im IBM Quantum Learning durcharbeitest.
• Im Abschnitt Transpile lernst du, wie du lokal transpilierst.
• Probiere den Leitfaden Transpiler-Einstellungen vergleichen aus.
• Lerne, wie du die Primitive-Optionen verwendest.
• Sieh dir die API für Estimator-Optionen an.