Comment envoyer un circuit avec Qiskit à Azure Quantum
Découvrez comment envoyer un circuit quantique Qiskit à l’aide du azure-quantum
Python package. Vous pouvez envoyer des circuits Qiskit à Azure Quantum à l’aide du notebook Azure Quantum, qui ont un package intégré azure-quantum
Python ou à partir de votre ordinateur local.
Pour plus d’informations, consultez la page Circuits quantiques.
Prérequis
Pour plus d’informations sur l’installation, consultez Installation du QDK sur VS Code.
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
Python avec la balise [qiskit].python -m pip install --upgrade azure-quantum[qiskit] qsharp ipykernel
Important
Vérifiez que vous disposez de la dernière version de Qiskit. Pour plus d’informations, consultez Mettre à jour le package azure-quantumPython.
Remarque
Si le noyau
ipykernel
Jupyter Python n’est pas détecté, VS Code vous invite à l’installer.
Créer un notebook Jupyter Notebook
- Dans VS Code, sélectionnez Affichage > Palette de commandes, puis sélectionnez Créer : Notebook Jupyter.
- En haut à droite, VS Code détecte et affiche la version de Python l’environnement virtuel Python sélectionné 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 import Workspace
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from azure.quantum.qiskit import AzureQuantumProvider
Se connecter au service Azure Quantum
Pour connecter au service Azure Quantum, vous avez besoin de l’ID de la 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 dans votre bloc-notes et utilisez les informations de votre compte pour créer Workspace
et AzureQuantumProvider
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")
)
provider = AzureQuantumProvider(workspace)
Liste de tous les serveurs principaux
Vous pouvez maintenant imprimer tous les serveurs principaux d’informatique quantique disponibles dans votre espace de travail :
print("This workspace's targets:")
for backend in provider.backends():
print("- " + backend.name())
This workspace's targets:
- ionq.qpu
- ionq.qpu.aria-1
- ionq.simulator
- microsoft.estimator
- quantinuum.hqs-lt-s1
- quantinuum.hqs-lt-s1-apival
- quantinuum.hqs-lt-s2
- quantinuum.hqs-lt-s2-apival
- quantinuum.hqs-lt-s1-sim
- quantinuum.hqs-lt-s2-sim
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm
Exécuter un circuit simple
Tout d’abord, créez un circuit Qiskit simple à exécuter.
# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(3, 3)
circuit.name = "Qiskit Sample - 3-qubit GHZ circuit"
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.measure([0,1,2], [0, 1, 2])
# Print out the circuit
circuit.draw()
┌───┐ ┌─┐
q_0: ┤ H ├──■───────┤M├──────
└───┘┌─┴─┐ └╥┘┌─┐
q_1: ─────┤ X ├──■───╫─┤M├───
└───┘┌─┴─┐ ║ └╥┘┌─┐
q_2: ──────────┤ X ├─╫──╫─┤M├
└───┘ ║ ║ └╥┘
c: 3/════════════════╩══╩══╩═
0 1 2
Sélectionnez une target option pour exécuter votre programme
Exécuter sur le simulateur IonQ
Avant d’exécuter sur du matériel réel, testons le circuit dans le simulateur. Permet get_backend
de créer un Backend
objet pour se connecter au serveur principal du simulateur IonQ :
simulator_backend = provider.get_backend("ionq.simulator")
Les back-ends IonQ prennent en charge les portes d’un ensemble de portes défini, qui sont compilées pour s’exécuter de façon optimale sur le matériel. Si votre circuit contient des portes qui ne figurent pas dans cette liste, vous devez transpiler dans la fonction prise en charge gateset
à l’aide de la transpile
fonction fournie par Qiskit :
from qiskit import transpile
circuit = transpile(circuit, simulator_backend)
La fonction transpile retourne un nouvel objet de circuit où les portes sont décomposées en portes prises en charge sur le back-end spécifié.
Vous pouvez maintenant exécuter le programme par le biais du service Azure Quantum et obtenir le résultat. La cellule suivante envoie un travail qui exécute le circuit avec 100 captures :
job = simulator_backend.run(circuit, shots=8)
job_id = job.id()
print("Job id", job_id)
Job id 00000000-0000-0000-0000-000000000000
Pour attendre la fin du travail et retourner les résultats, exécutez :
result = job.result()
print(result)
Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=8, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 4, '111': 4}, memory=['000', '000', '000', '000', '111', '111', '111', '111'], probabilities={'000': 0.5, '111': 0.5}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits=3, metadata={}), status=JobStatus.DONE, name='Qiskit Sample - 3-qubit GHZ circuit')], date=None, status=None, header=None, error_data=None)
Comme le résultat est un objet natif du package Qiskit, vous pouvez utiliser result.get_counts
et plot_histogram
de Qiskit pour visualiser les résultats. Pour vous assurer que toutes les étiquettes bitstring possibles sont représentées, ajoutez-les à counts
.
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)
{'000': 4, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 4}
Vous pouvez également utiliser la get_memory()
fonction pour afficher des données de capture individuelles à partir du travail
result.get_memory(circuit)
['000', '000', '000', '000', '111', '111', '111', '111']
Remarque
Sur IonQ targets, si vous envoyez un travail avec un nombre impair de tirs, les résultats seront arrondis au nombre pair suivant. Par exemple, si vous spécifiez 9 captures, les résultats affichent des données pour 8 captures.
Estimer le coût du travail
Avant d’exécuter un travail sur le QPU, vous pouvez estimer le coût d’exécution d’un travail. Pour estimer le coût d’exécution d’un travail sur le processeur quantique, vous pouvez utiliser la méthode estimate_cost
:
backend = provider.get_backend("ionq.qpu")
cost = backend.estimate_cost(circuit, shots=100)
print(f"Estimated cost: {cost.estimated_total}")
Cela imprime le coût estimé en dollars américains.
Pour obtenir les dernières informations tarifaires, consultez Tarifs IonQ, ou recherchez votre espace de travail et consultez les options tarifaires sous l’onglet « Fournisseur » de votre espace de travail via : aka.ms/aq/myworkspaces.
Exécuter sur la QPU IonQ
Pour vous connecter à du matériel réel (une unité de processeur quantique (QPU)), indiquez simplement le nom de target"ionq.qpu.aria-1"
la get_backend
méthode :
qpu_backend = provider.get_backend("ionq.qpu.aria-1")
Soumettez le circuit à exécuter sur Azure Quantum, obtenez les résultats et exécutez-le plot_histogram
pour tracer les résultats.
Remarque
Le temps nécessaire à l’exécution d’un circuit sur la QPU peut varier en fonction des durées de file d’attente actuelles.
# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)
# Get the job results (this method waits for the Job to complete):
result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)
Job id 00000000-0000-0000-0000-000000000000
Job Status: job has successfully run
Result(backend_name='ionq.qpu.aria-1', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'0': 505, '1': 6, '2': 1, '3': 1, '4': 1, '5': 10, '6': 11, '7': 488}, probabilities={'0': 0.4932, '1': 0.0059, '2': 0.001, '3': 0.001, '4': 0.001, '5': 0.0098, '6': 0.0117, '7': 0.4766}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])
{'000': 505, '001': 6, '010': 1, '011': 1, '100': 1, '101': 10, '110': 11, '111': 488}
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())
Prérequis
- Compte Azure avec un abonnement actif. Si vous n’avez pas de compte Azure, inscrivez-vous gratuitement et inscrivez-vous à un abonnement de paiement à l’utilisation.
- Un espace de travail Azure Quantum. Pour plus d’informations, consultez Créer un espace de travail Azure Quantum.
Créer un notebook dans votre espace de travail
- Connectez-vous au Portail Azure et sélectionnez l’espace de travail que vous avez créé à l’étape précédente.
- Dans le panneau de gauche, sélectionnez Notebooks.
- Cliquez sur Mes notebooks, puis sur Ajouter nouveau.
- Tapez un nom pour le fichier, par exemple Qiskit.ipynb, puis cliquez sur Créer le fichier.
Quand votre nouveau notebook s’ouvre, il crée automatiquement le code de la première cellule, en fonction de vos informations d’abonnement et d’espace de travail.
from azure.quantum import Workspace
workspace = Workspace (
resource_id = "", # Add your resource_id
location = "" # Add your workspace location (for example, "westus")
)
Remarque
Sauf indication contraire, vous devez exécuter chaque cellule dans l’ordre de création pour éviter les problèmes de compilation.
Cliquez sur l’icône triangulaire « lecture » à gauche de la cellule pour exécuter le code.
Charger les importations requises
Vous devez d’abord importer des modules supplémentaires.
Cliquez sur + Code pour ajouter une nouvelle cellule, puis ajoutez et exécutez le code suivant :
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from azure.quantum.qiskit import AzureQuantumProvider
Se connecter au service Azure Quantum
Ensuite, créez un AzureQuantumProvider
objet à l’aide de l’objet Workspace
de la cellule précédente pour vous connecter à votre espace de travail Azure Quantum. Ajoutez une nouvelle cellule avec le code suivant :
provider = AzureQuantumProvider(workspace)
Définir un circuit simple
Dans une nouvelle cellule, créez un objet circuit
. Cet exemple est un générateur de bits aléatoires quantique simple. Ajoutez le code suivant pour définir et afficher le circuit :
# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(3, 3)
circuit.name = "Qiskit Sample - 3-qubit GHZ circuit"
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.measure([0, 1, 2], [0, 1, 2])
# Print out the circuit
circuit.draw()
┌───┐ ┌─┐
q_0: ┤ H ├──■───────┤M├──────
└───┘┌─┴─┐ └╥┘┌─┐
q_1: ─────┤ X ├──■───╫─┤M├───
└───┘┌─┴─┐ ║ └╥┘┌─┐
q_2: ──────────┤ X ├─╫──╫─┤M├
└───┘ ║ ║ └╥┘
c: 3/════════════════╩══╩══╩═
0 1 2
Répertorier tout targets
Vous pouvez maintenant afficher tous les back-ends ou l’informatique targetsquantique qui sont disponibles dans votre espace de travail. Ajoutez une nouvelle cellule et exécutez la ligne suivante :
print("This workspace's targets:")
for backend in provider.backends():
print("- " + backend.name())
This workspace's targets:
- ionq.simulator
- ionq.qpu.aria-1
- microsoft.estimator
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm
Sélectionnez une target option pour exécuter votre programme
Pour vérifier votre code avant de l’exécuter sur du matériel quantique réel, vous pouvez utiliser le simulateur quantique IonQ, ionq.simulator
.
Ajoutez une nouvelle cellule et créez un objet pour représenter le simulateur targetquantique IonQ :
# Get IonQ quantum simulator target:
simulator_backend = provider.get_backend("ionq.simulator")
Exécuter sur le simulateur IonQ
Pour exécuter votre circuit sur le simulateur, ajoutez le code suivant. Cet exemple utilise la run
méthode de l’envoi target de votre travail, puis surveille l’état du travail.
# Submit the circuit to run on Azure Quantum
job = simulator_backend.run(circuit, shots=8)
job_id = job.id()
print("Job id", job_id)
Lorsque le travail s’exécute correctement, obtenez les résultats du travail et affichez-les :
# Get the job results:
result = job.result()
print(result)
Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=8, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 4, '111': 4}, memory=['000', '000', '000', '000', '111', '111', '111', '111'], probabilities={'000': 0.5, '111': 0.5}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits=3, metadata={}), status=JobStatus.DONE, name='Qiskit Sample - 3-qubit GHZ circuit')], date=None, status=None, header=None, error_data=None)
Étant donné que ce type result
est un objet natif du package Qiskit, vous pouvez utiliser result.get_counts
et plot_histogram
de Qiskit pour visualiser les résultats. Pour vous assurer que toutes les étiquettes bitstring possibles sont représentées, ajoutez-les à counts
.
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)
{'000': 4, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 4}
Vous pouvez également utiliser la get_memory()
fonction pour afficher des données de capture individuelles à partir du travail
result.get_memory(circuit)
['000', '000', '000', '000', '111', '111', '111', '111']
Remarque
Sur IonQ targets, si vous envoyez un travail avec un nombre impair de tirs, les résultats seront arrondis au nombre pair suivant. Par exemple, si vous spécifiez 9 captures, les résultats affichent des données pour 8 captures.
Estimer le coût du travail
Avant d’exécuter un travail sur un matériel quantique réel ou une unité de traitement quantique (QPU), vous pouvez estimer le coût d’exécution.
Tout d’abord, obtenez à nouveau la liste des fournisseurs disponibles :
print("This workspace's targets:")
for backend in provider.backends():
print("- " + backend.name())
This workspace's targets:
- ionq.simulator
- ionq.qpu.aria-1
- microsoft.estimator
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm
Ensuite, créez un objet pour représenter l’ordinateur quantique IonQ :
qpu_backend = provider.get_backend("ionq.qpu.aria-1")
Pour estimer le coût d’exécution d’un travail sur le QPU, ajoutez et exécutez une nouvelle cellule à l’aide targetde la estimate_cost
méthode suivante :
cost = qpu_backend.estimate_cost(circuit, shots=100)
print(f"Estimated cost: {cost.estimated_total}")
Cela affiche le coût estimé en dollars américains.
Pour obtenir les dernières informations tarifaires, consultez les tarifs d’IonQ ou consultez les options tarifaires du panneau Fournisseurs de votre espace de travail.
Exécuter sur la QPU IonQ
Une fois que vous avez exécuté votre travail avec succès sur le simulateur IonQ et que vous estimez le coût du QPU, il est temps d’exécuter votre circuit sur le matériel.
Remarque
Le temps nécessaire à l’exécution d’un circuit sur le processeur quantique varie en fonction des durées de file d’attente actuelles. Vous pouvez afficher le temps moyen de file d’attente pour un en target sélectionnant le panneau Fournisseurs de votre espace de travail.
Utilisez la même méthode run
et les mêmes opérations que celles que vous avez utilisées précédemment avec le validateur d’API pour envoyer et monitorer votre travail :
# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)
Une fois le travail terminé, obtenez les résultats du travail comme avant et affichez-les dans un graphique :
result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)
Job id 910b5ac8-98cd-11ec-b3ba-00155d5528cf
Job Status: job has successfully run
Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='Job id 54e8c740-98d9-11ec-b382-00155d957f5d', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'0': 505, '1': 6, '2': 1, '3': 1, '4': 1, '5': 10, '6': 11, '7': 488}, probabilities={'0': 0.4932, '1': 0.0059, '2': 0.001, '3': 0.001, '4': 0.001, '5': 0.0098, '6': 0.0117, '7': 0.4766}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])
{'000': 505, '001': 6, '010': 1, '011': 1, '100': 1, '101': 10, '110': 11, '111': 488}
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())