Guide de démarrage rapide d'Executor

• Versions de package

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

  qiskit[all]~=2.4.0
  qiskit-ibm-runtime~=0.46.1
  samplomatic~=0.18.0
  

Tout comme la primitive Sampler, Executor échantillonne les registres de sortie issus de l'exécution de circuits quantiques, mais il ne dispose d'aucun mécanisme intégré de suppression ou d'atténuation des erreurs. Au contraire, cela s'inscrit dans le cadre du modèle d'exécution dirigée, qui fournit les éléments nécessaires pour saisir les intentions de conception côté client et transfère la génération coûteuse des variantes de circuits vers le côté serveur. L'exécuteur suit les directives fournies dans les annotations et les options des circuits, génère et associe les valeurs des paramètres, exécute les circuits associés sur le matériel, puis renvoie les résultats d'exécution et les métadonnées. Il ne prend aucune décision à votre place et vous offre un contrôle total ainsi qu'une transparence totale.

Avant de commencer

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

pip install samplomatic

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

Étapes pour utiliser la primitive Executor

1. Créer le compte

IBM Quantum Compute Service étant un service géré, vous devez d'abord initialiser 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® ».

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)

Output:

<IBMBackend('ibm_fez')>

2. Créer et compiler un circuit

Il faut au moins un circuit pour pouvoir utiliser la primitive Executor. Elle peut éventuellement comporter 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 modifié afin de n'utiliser que les instructions prises en charge par le QPU (ce que l'on appelle les circuits d'architecture de jeu d'instructions, ou ISA ). Pour ce faire, utilisez le transcompilateur.

# 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 objet de type QuantumProgram

Initialisez un QuantumProgram avec votre charge de travail. A QuantumProgram est constitué de QuantumProgramItems. En général, chaque élément se compose d'un circuit, d'un ensemble de valeurs de paramètres et, éventuellement, d'un mécanisme samplex permettant de randomiser le contenu du circuit. Pour plus de détails, consultez la section « Entrées et sorties de l'exécuteur ».

La cellule suivante initialise un QuantumProgram et spécifie d'effectuer 25 tirs. Ensuite, il 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 : regroupez les portes et les mesures dans des encadrés annotés

Le regroupement des instructions dans des blocs et leur annotation constituent le principal moyen d'exprimer votre intention. Dans l'exemple suivant, nous utilisons generate_boxing_pass_manager et ses paramètres de rotation pour regrouper des portes à deux qubits et des mesures dans des cases, puis nous appliquons une annotation de rotation.

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

Output:

5. Facultatif : Créez un circuit type et un exemple, puis ajoutez-les au programme

Ensuite, utilisez la méthode de construction Samplomatic pour générer le circuit modèle et la paire de samplex. Le circuit modèle est structurellement équivalent au circuit d'origine. Cependant, ses portes à un qubit sont remplacées par des portes paramétrées afin de mettre en œuvre les annotations prescrites (rotation des portes et des mesures, dans cet exemple). Le samplex contient toutes les informations nécessaires pour générer des paramètres aléatoires pour le circuit modèle.

Une fois le circuit modèle et la paire de samplex générés, utilisez la append_samplex_item méthode pour ajouter la paire au programme.

Consultez la documentation de l'API Samplomatic pour obtenir tous les détails concernant 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. Lancer Executor et obtenir les résultats

Exécutez le QuantumProgram sur un backend IBM® en utilisant la Executor primitive avec les options par défaut. Consultez la section « Options de l'exécuteur » 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

Output:

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

# Retrieve the result
result = job.result()

Le résultat est de type QuantumProgramResult. Consultez la section « Entrées et sorties de l'exécuteur » pour en savoir plus sur l'objet résultat.

Etapes suivantes