Schnellstart für den Kostenvoranschlagsrechner

Die Estimator-Primitive berechnet die Erwartungswerte für eine oder mehrere Observablen in Bezug auf Zustände, die von Quantenschaltungen erzeugt wurden. Die Schaltungen können parametrisiert werden, sofern die Parameterwerte ebenfalls als Eingabe für die Primitive bereitgestellt werden.

Diese Primitive verfügt über mehrere integrierte Techniken zur Fehlerminderung und -unterdrückung, darunter dynamische Entkopplung, Pauli-Twirling, Gate-Folding-ZNE, PEA und PEC. Außerdem unterstützt es eine Option resilience_level , mit der Sie den Kompromiss zwischen Kosten und Genauigkeit ganz einfach konfigurieren können.

In den Schritten dieses Abschnitts wird beschrieben, wie Sie Estimator einrichten, die verfügbaren Konfigurationsoptionen erkunden und das Programm aufrufen.

• Paketversionen

  Der Code auf dieser Seite wurde unter Berücksichtigung der folgenden Anforderungen entwickelt. Wir empfehlen, diese Versionen oder neuere zu verwenden.

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

Schritte zur Verwendung der Estimator-Primitive

1. Konto einrichten

Zunächst müssen Sie Ihr Konto einrichten. Anschließend können Sie die QPU auswählen, die Sie zur Berechnung des Erwartungswerts verwenden möchten.

Befolgen Sie die Schritte unter „ IBM Cloud -Konto einrichten “, falls Sie noch kein Konto haben.

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

from qiskit_ibm_runtime import QiskitRuntimeService

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

print(backend.name)

Output:

ibm_fez

2. Erstelle einen Schaltkreis und eine Beobachtungsgröße

Als Eingaben für die Estimator-Primitive benötigst du mindestens einen Schaltkreis und eine Beobachtungsgröße.

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]

Die Schaltung und die Observable müssen so umgewandelt werden, dass sie ausschließlich Befehle verwenden, die von der QPU unterstützt werden (sogenannte ISA -Schaltungen). Verwenden Sie dazu 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()}")

Output:

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

3. Initialisieren Sie den „ IBM Quantum “-Schätzer

Wenn Sie Estimator initialisieren, legen Sie mithilfe des Parameters mode fest, in welchem Modus das Programm ausgeführt werden soll. Mögliche Werte sind batch, session, oder Objekte backend für den Batch-, Sitzungs- bzw. Job-Ausführungsmodus. Weitere Informationen finden Sie unter „Einführung in die Ausführungsmodi des Dienstes ‚ IBM Quantum Compute ‘ “. Bitte beachten Sie, dass Open-Plan-Benutzer keine Sitzungsaufträge 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. Den Schätzer aufrufen und Ergebnisse abrufen

Rufen Sie anschließend die run() Methode auf, um die Erwartungswerte für die Eingangsschaltungen und Observablen zu berechnen. Die Schaltkreis-, Beobachtungs- und optionalen Parameterwertsätze werden als Tupel aus primitiven vereinheitlichten Blöcken ( PUB ) eingegeben.

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

Output:

>>> 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}")

Output:

>>> 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