Démarrage rapide avec Executor

Versions des packages

Le code de cette page a été développé avec les versions suivantes. Nous recommandons d'utiliser ces versions ou des versions plus récentes.

qiskit[all]~=2.6.1
qiskit-ibm-runtime~=0.50.0
samplomatic~=0.21.0

Comme la primitive Sampler, Executor échantillonne les registres de sortie des exécutions de circuits quantiques, mais il n'a pas de suppression ou d'atténuation d'erreurs intégrée. Au lieu de cela, il fait partie du modèle d'exécution dirigée qui fournit les ingrédients pour capturer les intentions de conception côté client, et déplace la génération coûteuse de variantes de circuits côté serveur. Executor suit les directives fournies dans les annotations et les options de circuit, génère et lie les valeurs de paramètres, exécute les circuits liés sur le matériel, et renvoie les résultats d'exécution et les métadonnées. Il ne prend aucune décision implicite pour toi et te donne un contrôle et une transparence totaux.

remarque

Le package Qiskit n'a pas encore de classe de base pour la primitive Executor.

Avant de commencer

Certains des exemples de code sur cette page utilisent samplex, qui fait partie du package Samplomatic. Par conséquent, avant d'exécuter ces blocs de code, tu dois installer Samplomatic, comme indiqué dans le bloc de code suivant. Pour plus d'informations, consulte la documentation Samplomatic.

pip install samplomatic

# For visualization support, include the visualization dependencies.
# pip install samplomatic[vis]

Étapes pour utiliser la primitive Executor

1. Initialiser le compte

Comme IBM Quantum Compute Service est un service géré, tu dois d'abord initialiser ton compte. Tu peux ensuite sélectionner la QPU que tu veux utiliser pour calculer la valeur d'espérance.

Suis les étapes dans Configurer ton compte IBM Cloud® si tu n'as pas encore de compte.

# 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", "samplomatic": "samplomatic"}
_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, Executor
from qiskit_ibm_runtime.quantum_program import QuantumProgram
from qiskit.circuit import QuantumCircuit
from qiskit.transpiler import generate_preset_pass_manager
from samplomatic.transpiler import generate_boxing_pass_manager
from samplomatic import build

# Initialize the service and choose a backend
service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

print(backend)

<IBMBackend('ibm_marrakesh')>

2. Créer et transpiler un circuit

Tu as besoin d'au moins un circuit pour utiliser la primitive Executor. Il peut optionnellement avoir des paramètres.

# Generate the circuit
circuit = QuantumCircuit(2)
circuit.h(0)
circuit.h(1)
circuit.cz(0, 1)
circuit.h(1)

# Using `measure_all` automatically creates the necessary
# classical registers.
circuit.measure_all()

Le circuit doit être transformé pour n'utiliser que des instructions prises en charge par la QPU (appelées circuits d'architecture d'ensemble d'instructions (ISA)). Utilise le Transpiler pour ce faire.

# Transpile the circuit
preset_pass_manager = generate_preset_pass_manager(
    backend=backend, optimization_level=0
)
isa_circuit = preset_pass_manager.run(circuit)

3. Initialiser un QuantumProgram

Initialise un QuantumProgram avec ta charge de travail. Un QuantumProgram est composé d'éléments QuantumProgramItems. En général, chaque élément consiste en un circuit, un ensemble de valeurs de paramètres et éventuellement un samplex pour randomiser le contenu du circuit. Pour tous les détails, voir Entrées et sorties Executor.

La cellule suivante initialise un QuantumProgram et spécifie d'effectuer 25 shots. Ensuite, elle ajoute le circuit cible transpilé.

# Initialize an empty program
program = QuantumProgram(shots=25)

# Append the circuit to the program
program.append_circuit_item(isa_circuit)

4. Facultatif : Regrouper les portes et les mesures dans des boîtes annotées

Regrouper les instructions dans des boîtes et les annoter est le principal moyen de spécifier ton intention. Dans l'exemple suivant, nous utilisons generate_boxing_pass_manager et ses paramètres de twirling pour regrouper les portes à deux qubits et les mesures dans des boîtes et appliquer l'annotation de twirling.

# Generate a boxing pass manager to group gates
# and measurements into boxes and add
# a`Twirl` annotation.
boxes_pm = generate_boxing_pass_manager(
    # Add gate twirling
    enable_gates=True,
    # Add measurement twirling
    enable_measures=True,
)

boxed_circuit = boxes_pm.run(isa_circuit)
boxed_circuit.draw("mpl", idle_wires=False)

5. Facultatif : Construire un circuit modèle et un samplex, et les ajouter au programme

Ensuite, utilise la méthode Samplomatic build pour générer la paire circuit modèle et samplex. Le circuit modèle est structurellement équivalent au circuit original. Cependant, ses portes à un qubit sont remplacées par des portes paramétrées afin d'implémenter les annotations prescrites (twirling de portes et de mesures, dans cet exemple). Le samplex encode toutes les informations requises pour générer des paramètres randomisés pour le circuit modèle.

Après avoir généré la paire circuit modèle et samplex, utilise la méthode append_samplex_item pour ajouter la paire au programme.

Consulte la documentation de l'API Samplomatic pour tous les détails sur samplomatic.samplex.Samplex et ses arguments.

# Build the template circuit and the samplex
template_circuit, samplex = build(boxed_circuit)

# Append the template circuit and samplex as a `samplex_item`
program.append_samplex_item(
    template_circuit,
    samplex=samplex,
    shape=(num_randomizations := 20,),
)

6. Invoquer Executor et obtenir les résultats

Exécute le QuantumProgram sur un Backend IBM® en utilisant la primitive Executor avec les options par défaut. Consulte Options Executor pour en savoir plus sur les options disponibles.

# Initialize an Executor with the default options
executor = Executor(mode=backend)

# Submit the job
job = executor.run(program)
job

<RuntimeJobV2('dbjeahhkdqps7390ervg', 'executor')>

# Retrieve the result
result = job.result()

Le résultat est de type QuantumProgramResult. Consulte Entrée et sortie Executor pour en savoir plus sur l'objet résultat.

Étapes suivantes

Recommandations

• Essaie quelques exemples Executor.
• Comprends les entrées et sorties Executor.
• Découvre la sémantique de diffusion Executor.