Partage via


Comment envoyer un circuit avec Qiskit à Azure Quantum

Découvrez comment envoyer un circuit quantique Qiskit à l’aide du azure-quantumPython package. Vous pouvez envoyer des circuits Qiskit à Azure Quantum à l’aide du notebook Azure Quantum, qui ont un package intégré azure-quantumPython 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-quantumPython 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

  1. Dans VS Code, sélectionnez Affichage > Palette de commandes, puis sélectionnez Créer : Notebook Jupyter.
  2. 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.

  1. Connectez-vous à votre compte Azure, https://portal.azure.com

  2. Sélectionnez votre espace de travail Azure Quantum, puis accédez à Vue d’ensemble.

  3. Copiez les paramètres dans les champs.

    Capture d’écran de Visual Studio Code montrant comment développer le volet vue d’ensemble de votre espace de travail Quantum.

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}

Résultat du circuit Qiskit sur le Simulateur IonQ

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}

Résultat du circuit Qiskit sur la QPU IonQ

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

  1. Connectez-vous au Portail Azure et sélectionnez l’espace de travail que vous avez créé à l’étape précédente.
  2. Dans le panneau de gauche, sélectionnez Notebooks.
  3. Cliquez sur Mes notebooks, puis sur Ajouter nouveau.
  4. 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}

Résultat du circuit Qiskit sur le Simulateur IonQ

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}

Résultat du circuit Qiskit sur la QPU IonQ

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

Étapes suivantes