Comment envoyer un circuit avec Cirq à Azure Quantum

Découvrez comment envoyer un circuit quantique Cirq à l’aide du azure-quantumPython package. Vous pouvez envoyer des circuits Cirq à Azure Quantum à l’aide du Kit de développement Azure 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 le Kit de développement Azure Quantum et Pythonles extensions Jupyter installées.
Package Azure Quantum azure-quantum avec l’extra cirq, ainsi que les packages qdk et ipykernel.
```
python -m pip install --upgrade "azure-quantum[cirq]" qdk ipykernel 
```
Remarque

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

Créer un notebook Jupyter Notebook

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 :

import azure.quantum
from azure.quantum.cirq import AzureQuantumService

Se connecter au service Azure Quantum

Pour se connecter au service Azure Quantum, votre programme aura besoin de l’ID de ressource et de l’emplacement 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 les paramètres dans les champs.

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 resourceID of your workspace
    location = "" # Add the location of your workspace (for example "westus")
    )

service = AzureQuantumService(workspace)

Répertorier tout 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

Tous les targets espaces de travail peuvent ne pas être répertoriés. Seuls les targets circuits Cirq ou OpenQASM peuvent être 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, 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 travaux

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 accompli, 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 résultat spécifique au simulateur IonQ, et utilisant des probabilités d’état plutôt que des données de capture.

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 un travail 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="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 travaux

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 accompli, 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 2025-10-17

Partager via

Comment envoyer un circuit avec Cirq à Azure Quantum

Prérequis

Créer un notebook Jupyter Notebook

Charger les importations requises

Se connecter au service Azure Quantum

Répertorier tout 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 travaux

Commentaires

Ressources supplémentaires