Guide de démarrage rapide d'Estimator

La primitive Estimator calcule les valeurs attendues d'une ou plusieurs observables par rapport à des états préparés par des circuits quantiques. Les circuits peuvent être paramétrés, à condition que les valeurs des paramètres soient également fournies en entrée à la primitive.

Cette primitive intègre plusieurs techniques de limitation et de suppression des erreurs, notamment le découplage dynamique, le Pauli-twirling, le ZNE par repliement de grille, le PEA et le PEC. Il prend également en charge une resilience_level option qui vous permet de régler facilement le compromis entre coût et précision.

Les étapes décrites dans cette rubrique expliquent comment installer Estimator, découvrir les options disponibles pour le configurer et l'appeler dans un programme.

• Versions de package

  Le code présenté sur cette page a été développé en tenant compte des exigences suivantes. Nous vous recommandons d'utiliser ces versions ou des versions plus récentes.

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

Étapes pour utiliser la primitive « Estimator »

1. Créer le compte

Vous devez d'abord configurer votre compte. Vous pouvez ensuite sélectionner le QPU que vous souhaitez utiliser pour calculer la valeur attendue.

Si vous n'avez pas encore de compte, suivez les étapes décrites dans la section « Créer votre compte IBM Cloud ».

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. Créer un circuit et une grandeur observable

Vous devez fournir au moins un circuit et une grandeur observable en entrée à la primitive 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]

Le circuit et l'observable doivent être transformés afin de n'utiliser que des instructions prises en charge par le QPU (ce que l'on appelle des circuits d'architecture de jeu d'instructions (ISA) ). Pour ce faire, utilisez le transcompilateur.

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. Initialiser l'estimateur « IBM Quantum »

Lorsque vous initialisez Estimator, utilisez le paramètre mode pour spécifier le mode dans lequel vous souhaitez qu'il s'exécute. Les valeurs possibles sont batch, session, ou pour backend les modes d'exécution par lots, par session et par tâche, respectivement. Pour plus d'informations, consultez la section « Introduction aux modes d'exécution du service de calcul d' IBM Quantum ». Veuillez noter que les utilisateurs d'Open Plan ne peuvent pas soumettre de tâches de session.

from qiskit_ibm_runtime import EstimatorV2 as Estimator

estimator = Estimator(mode=backend)

4. Lancer l'estimateur et obtenir les résultats

Ensuite, appelez la run() méthode pour calculer les valeurs attendues des circuits d'entrée et des observables. Les ensembles de paramètres de circuit, observables et optionnels sont fournis sous forme de tuples de blocs unifiés primitifs ( PUB ).

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: d9mq9tnurbec73e67aj0
>>> 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: 29.745702323497138
  > Metadata: {'shots': 4096, 'target_precision': 0.015625, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32}

Etapes suivantes