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 d’un notebook Azure Quantum, qui a un package intégré azure-quantum
Python ou à partir de votre ordinateur local. Vous pouvez également tester vos circuits à l’aide du simulateur partiellement alloué local.
Pour plus d’informations, consultez la page Circuits quantiques.
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].Invite de commandes Windowspython -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.
Notes
Si le noyau
ipykernel
Jupyter Python n’est pas détecté, VS Code vous invite à l’installer.
- 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.
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
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)
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
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
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']
Notes
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.
Avant d’exécuter un travail sur le QPU, vous devez estimer le coût d’exécution d’un travail.
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.
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.
Notes
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())
- 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.
- 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")
)
Notes
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.
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
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)
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
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
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")
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']
Notes
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.
Avant d’exécuter un travail sur le matériel quantique réel ou une unité de traitement quantique (QPU), vous devez estimer le coût d’exécution.
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.
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.
Notes
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())
Pour plus d’informations sur l’installation, consultez Installation du Kit de développement Quantum sur VS Code.
Un Python environnement avec Python et Pip installé.
VS Code avec le Kit de développement Azure Quantum et Python les extensions installées.
Package Azure Quantum
qsharp
Python avec les balises etwidget
lesqiskit
balises.Invite de commandes Windowspython pip install "qsharp[qiskit,widgets]>=1.9"
Important
Vérifiez que vous disposez de la dernière version de Qiskit. Pour plus d’informations, consultez Mettre à jour le package azure-quantumPython.
Dans VS Code, ouvrez un nouveau Python fichier pour définir et exécuter un circuit de base à l’aide du simulateur partiellement alloué intégré dans le package Qsharp.
# load the required imports
from qiskit.circuit.random import random_circuit
from qsharp.interop.qiskit import QSharpBackend
# define and display the circuit
circuit = random_circuit(2, 2, measure=True)
print(circuit)
# run the circuit using the built-in sparse simulator
backend = QSharpBackend()
job = backend.run(circuit)
counts = job.result().get_counts()
print(counts)
Pour exécuter le programme, sélectionnez l’icône Exécuter en haut à droite, puis sélectionnez Exécuter Python le fichier. La sortie s’affiche dans une nouvelle fenêtre de terminal.
┌─────────────────────────┐┌─┐
q_0: ─■───────────┤0 ├┤M├───
│P(0.79983) │ (XX-YY)(1.9337,1.7385) │└╥┘┌─┐
q_1: ─■───────────┤1 ├─╫─┤M├
└─────────────────────────┘ ║ └╥┘
c: 2/═════════════════════════════════════════╩══╩═
0 1
{'11': 680, '00': 344}