Comment envoyer un circuit Cirq à Azure Quantum

Découvrez comment soumettre un circuit quantique Cirq à l’aide du qdk.azure.cirqPython sous-module. Vous pouvez envoyer des circuits Cirq à Azure Quantum à l’aide du Kit de développement Microsoft Quantum (QDK) et jupyter Notebook dans Visual Studio Code (VS Code) à partir de votre ordinateur local.

Pour plus d’informations, consultez circuits Quantum.

Prérequis

Pour plus d’informations sur l’installation, consultez Configurer l’extension QDK.

Un espace de travail Azure Quantum dans votre abonnement Azure. Pour créer un espace de travail, consultez Créer un espace de travail Azure Quantum.
Un Python environnement avec Python et Pip installé.
VS Code avec les extensions QDK et Python Jupyter installées.
La bibliothèque qdkPython avec les extras azurecirq et le paquet ipykernel.
```
python -m pip install --upgrade "qdk[azure,cirq]" ipykernel 
```
Remarque

Si le noyau Python Jupyter ipykernel n’est pas détecté, VS Code vous invite à l’installer.

Créer un notebook Jupyter

Dans VS Code, ouvrez le menu Affichage et choisissez Palette de commandes.
Entrez et sélectionnez Créer : Nouveau bloc-notes Jupyter.
VS Code détecte et affiche la version de Python et l’environnement virtuel Python sélectionnés pour le notebook. Si vous avez plusieurs Python environnements, vous devrez peut-être sélectionner un noyau à l’aide du sélecteur de noyau en haut à droite. Si aucun environnement n’a été détecté, consultez Jupyter Notebooks dans VS Code pour obtenir des informations de configuration.

Charger les importations requises

Dans la première cellule de votre notebook, exécutez le code suivant pour charger les importations requises :

from qdk.azure import Workspace
from qdk.azure.cirq import AzureQuantumService

Se connecter au service Azure Quantum

Pour vous connecter au service Azure Quantum, votre programme a besoin de l’ID de ressource de votre espace de travail Azure Quantum.

Connectez-vous à votre compte Azure, https://portal.azure.com
Sélectionnez votre espace de travail Azure Quantum, puis accédez à Vue d’ensemble.
Copiez la valeur dans le champ ID de ressource .

Ajoutez une nouvelle cellule et utilisez les informations de votre compte pour créer Workspace et AzureQuantumService objets pour vous connecter à votre espace de travail Azure Quantum.

workspace = Workspace(resource_id="") # Add the resource ID of your workspace

service = AzureQuantumService(workspace)

Afficher tous targets

Utilisez la targets()méthode pour répertorier tous les targets éléments de votre espace de travail qui peuvent exécuter votre circuit, y compris l’heure et la disponibilité de la file d’attente actuelle.

Remarque

Il se peut que tous les targets de votre espace de travail ne soient pas répertoriés - seuls les targets qui acceptent un circuit Cirq ou OpenQASM seront répertoriés ici.

print(service.targets())

[<Target name="quantinuum.qpu.h2-1", avg. queue time=0 s, Degraded>,
<Target name="quantinuum.sim.h2-1sc", avg. queue time=1 s, Available>,
<Target name="quantinuum.sim.h2-1e", avg. queue time=40 s, Available>,
<Target name="ionq.simulator", avg. queue time=3 s, Available>,
<Target name="ionq.qpu.aria-1", avg. queue time=1136774 s, Available>]

Créer un circuit simple

Ensuite, créez un circuit Cirq simple à exécuter. Ce circuit utilise la porte "racine carrée de X", qui est native du système matériel IonQ.

import cirq

q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
    cirq.X(q0)**0.5,             # Square root of X
    cirq.CX(q0, q1),              # CNOT
    cirq.measure(q0, q1, key='b') # Measure both qubits
)
print(circuit)

0: ───X^0.5───@───M────────
              │   │
1: ───────────X───M────────

Sélectionnez une target option pour exécuter votre programme

IonQ
Quantinuum

Exécuter sur le simulateur IonQ

Vous pouvez maintenant exécuter le programme par le biais du service Azure Quantum et obtenir le résultat. La cellule suivante soumet un travail (au simulateur IonQ par défaut) qui exécute le circuit avec 100 captures, attend que le travail soit terminé, puis renvoie les résultats.

result = service.run(program=circuit, repetitions=100, target="ionq.simulator")

Cela retourne un objet cirq.Result.

print(result)

    b=1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010, 1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010

Estimer le coût du travail

Avant d’exécuter un travail sur le QPU, vous devez estimer le coût d’exécution d’un travail.

Pour obtenir les informations de tarification les plus actuelles, consultez tarification IonQ, ou recherchez votre espace de travail et affichez les options de tarification sous l’onglet « Fournisseur » de votre espace de travail via : aka.ms/aq/myworkspaces.

Exécuter sur la QPU IonQ

Le travail précédent a été exécuté sur le simulateur par défaut, "ionq.simulator". Toutefois, vous pouvez également l’exécuter sur le processeur matériel d’IonQ (une unité de processeur quantique (QPU)). Pour exécuter la QPU IonQ, fournissez "ionq.qpu.aria-1" comme argument target :

result = service.run(
    program=circuit,
    repetitions=100,
    target="ionq.qpu.aria-1",
    timeout_seconds=500 # Set timeout to accommodate queue time on QPU
)

À nouveau, cela retourne un objet cirq.Result.

print(result)

b=0101011011011111100001011101101011011110100010000000011110111000100100110110101100110001001111101111, 0101011011011111100001011101101011011110100010000000011110111000100100110110101100110001001111101111

Modèle asynchrone utilisant des tâches

Pour des circuits longs, il peut être utile de les exécuter de manière asynchrone. La méthode service.create_job renvoie un objet Job que vous pouvez utiliser pour obtenir les résultats une fois l’exécution du travail aboutie.

job = service.create_job(
    program=circuit,
    repetitions=100,
    target="ionq.simulator"
)

Pour vérifier l’état du travail, utilisez la méthode job.status() :

print(job.status())

'completed'

Pour attendre que le travail soit terminé puis obtenir les résultats, utilisez l’appel bloquant job.results() :

result = job.results()
print(result)

00: 0.5
11: 0.5

Notez que cela ne renvoie aucun objet cirq.Result. À la place, cela renvoie un objet de résultat spécifique au simulateur IonQ, utilisant des probabilités d'état plutôt que des données de tir.

type(result)

cirq_ionq.results.SimulatorResult

Pour convertir ceci en objet cirq.Result, utilisez result.to_cirq_result() :

print(result.to_cirq_result())

b=1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100, 1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100

Exécuter sur le simulateur Quantinuum

Vous pouvez maintenant exécuter le programme par le biais du service Azure Quantum et obtenir le résultat. La cellule suivante soumet une tâche qui exécute le circuit avec 100 exécutions, attend que la tâche soit terminée, puis renvoie les résultats.

result = service.run(program=circuit, repetitions=100, target="quantinuum.sim.h2-1sc")

Cela retourne un objet cirq.Result.

print(result)

    b=0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Vous pouvez tracer les résultats dans un histogramme :

import pylab as pl

pl.hist(result.data)
pl.ylabel("Counts")
pl.xlabel("Result")

En examinant l’histogramme, vous pouvez remarquer que le générateur de nombres aléatoires a retourné 0 chaque fois, ce qui n’est pas très aléatoire. En effet, le validateur d’API garantit que votre code s’exécute correctement sur le matériel Quantinuum, mais retourne également 0 pour chaque mesure quantique. Pour un générateur de vrais nombres aléatoires, vous devez exécuter votre circuit sur du matériel quantique.

Estimer le coût du travail

Avant d’exécuter un travail sur le QPU, vous devez estimer le coût d’exécution d’un travail.

Pour obtenir les informations de tarification les plus actuelles, consultez la tarification Azure Quantum, ou recherchez votre espace de travail et affichez les options de tarification sous l’onglet « Fournisseur » de votre espace de travail via : aka.ms/aq/myworkspaces.

Flux de travail asynchrone utilisant des tâches

job = service.create_job(
    program=circuit,
    repetitions=100,
    target="quantinuum.sim.h2-1sc"
)

Pour vérifier l’état du travail, utilisez la méthode job.status() :

print(job.status())

'Waiting'

Pour attendre que le travail soit terminé puis obtenir les résultats, utilisez l’appel bloquant job.results() :

result = job.results()
print(result)

    {'m_b': ['00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00']}

Notez que cela ne renvoie aucun objet cirq.Result. Au lieu de cela, il retourne un dictionnaire de résultats de mesure de chaîne de bits indexés par clé de mesure.

Important

L’envoi de plusieurs circuits sur un seul travail n’est pas actuellement pris en charge. Une solution de contournement consiste à appeler la méthode backend.run pour envoyer chaque circuit de manière asynchrone, puis à extraire les résultats de chaque travail. Par exemple :

jobs = []
for circuit in circuits:
    jobs.append(backend.run(circuit, shots=N))

results = []
for job in jobs:
    results.append(job.result())

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-02-25

Comment envoyer un circuit Cirq à Azure Quantum

Prérequis

Créer un notebook Jupyter

Charger les importations requises

Se connecter au service Azure Quantum

Afficher tous targets

Créer un circuit simple

Sélectionnez une target option pour exécuter votre programme

Exécuter sur le simulateur IonQ

Estimer le coût du travail

Exécuter sur la QPU IonQ

Modèle asynchrone utilisant des tâches

Commentaires

Ressources supplémentaires