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 d’un notebook Azure Quantum, qui a un package intégré azure-quantumPython 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.

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.

   

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

IonQ

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 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.

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}

Quantinuum

Exécuter sur le vérificateur de syntaxe

Pour tester le programme avant de l’exécuter sur le matériel, exécutez-le d’abord sur le vérificateur de syntaxe Quantinuum. Utilisez la get_backend méthode pour créer un Backend objet pour vous connecter au serveur principal du vérificateur de syntaxe Quantinuum :

# Get Quantinuum's syntax checker backend:
syntax_backend = provider.get_backend("quantinuum.sim.h1-1sc")

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 huit coups :

# Submit the circuit to run on Azure Quantum
job = syntax_backend.run(circuit, shots=8)
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)

Result(backend_name='quantinuum.sim.h1-1sc', 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': 8}, memory=['000', '000', '000', '000', '000', '000', '000', '000'], probabilities={'000': 1.0}), 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)
{'000': 8, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 0}

Remarque

Bien que le vérificateur de syntaxe Quantinuum garantit que votre code s’exécutera correctement sur le matériel Quantinuum, il retourne également 0 pour chaque mesure quantique. Pour une véritable mesure quantique, vous devez exécuter votre circuit sur du matériel quantique.

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', '000', '000', '000', '000']

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.

Exécuter le travail sur un processeur quantique Quantinuum

Une fois l’exécution du validateur d’API terminée, vous pouvez exécuter votre travail sur l’un des processeurs matériels de Quantinuum (un processeur quantique).

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.

# Get Quantinuum's QPU backend:
qpu_backend = provider.get_backend("quantinuum.qpu.h1-1")

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

Result(backend_name='quantinuum.qpu.h1-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={'011': 16, '010': 5, '001': 1, '000': 500, '111': 471, '101': 6, '100': 17, '110': 8}, probabilities={'011': 0.015625, '010': 0.0048828125, '001': 0.0009765625, '000': 0.48828125, '111': 0.4599609375, '101': 0.005859375, '100': 0.0166015625, '110': 0.0078125}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit'))])
{'000': 500, '001': 1, '010': 5, '011': 16, '100': 17, '101': 6, '110': 8, '111': 471}

Rigetti

Remarque

Actuellement, Rigetti propose uniquement son simulateur quantique, rigetti.sim.qvmvia le service Azure Quantum.

Exécuter sur le simulateur QVM

Utilisez la provider.get_backend méthode pour créer un Backend objet pour vous connecter au serveur principal du simulateur QVM Rigetti :

# Get Rigetti's QVM simulator backend:
qvm_backend = provider.get_backend("rigetti.sim.qvm")

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 huit coups :

# Submit the circuit to run on Azure Quantum
job = qvm_backend.run(circuit, shots=8)
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)

Result(backend_name='rigetti.sim.qvm', 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', '111', '111', '000', '000', '000', '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)
{'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', '111', '111', '000', '000', '000', '111', '111']

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

IonQ

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 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.

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}

Quantinuum

Pour vérifier votre code avant de l’exécuter sur le matériel quantique réel, vous pouvez utiliser l’un des vérificateurs de syntaxe quantinuum. quantinuum.sim.h1-1sc

Ajoutez une nouvelle cellule et créez un objet pour représenter le vérificateur targetde syntaxe Quantinuum :

# Get Quantinuum's Syntax Checker target:
apival_backend = provider.get_backend("quantinuum.sim.h1-1sc")

Exécuter sur le vérificateur de syntaxe

Pour exécuter votre circuit sur le vérificateur de syntaxe, ajoutez le code suivant, qui 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 = apival_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)

Une fois le travail exécuté, récupérez les résultats du travail et affichez-les :

# Get the job results:
result = job.result()
print(result)

Result(backend_name='quantinuum.sim.h1-1sc', 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': 8}, memory=['000', '000', '000', '000', '000', '000', '000', '000'], probabilities={'000': 1.0}), 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)
{'000': 8, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 0}

É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': 8, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 0}

En examinant l’histogramme, vous remarquerez peut-être que le générateur de nombres aléatoires a retourné 0 chaque fois, ce qui n’est pas très aléatoire. Cela est dû au fait que, alors que le vérificateur de syntaxe garantit que votre code s’exécutera correctement sur le matériel Quantinuum, il 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.

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', '000', '000', '000', '000']

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 devez estimer la quantité d’exécution de ce travail.

Pour obtenir les informations de tarification les plus actuelles, consultez la tarification Azure Quantum ou affichez les options de tarification dans le panneau Fournisseurs de votre espace de travail. Pour voir l’état actuel de votre crédit et de votre utilisation, sélectionnez Crédits et quotas.

Exécuter le travail sur un processeur quantique Quantinuum

Après avoir exécuté votre circuit correctement sur le vérificateur de syntaxe et estimé le coût du QPU, il est temps de l’exécuter sur le matériel.

Remarque

Le temps nécessaire à l’exécution d’un circuit sur le processeur quantique peut varier 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 et les mêmes run opérations que celles que vous avez utilisées précédemment avec le vérificateur de syntaxe pour envoyer et surveiller 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 exécuté, récupérez les résultats du travail comme avant et affichez-les dans un histogramme :

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)

Vous pouvez voir que les résultats sont désormais à peu près répartis entre 0 et 1.

Result(backend_name='quantinuum.qpu.h1-1', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='48282d18-9c15-11ec-bfbd-00155d6373ba', success=True, results=[ExperimentResult(shots=100, success=True, meas_level=2, data=ExperimentResultData(counts={'111': 53, '101': 1, '000': 46}, probabilities={'111': 0.53, '101': 0.01, '000': 0.46}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit'))])
{'000': 46, '001': 0, '010': 0, '011': 0, '100': 0, '101': 1, '110': 0, '111': 53}

Rigetti

Remarque

Actuellement, Rigetti propose uniquement son simulateur quantique, rigetti.sim.qvmvia le service Azure Quantum.

Ajoutez une nouvelle cellule et créez un objet pour représenter le simulateur targetquantique Rigetti :

# Get Rigetti quantum simulator target:
simulator_backend = provider.get_backend("rigetti.sim.qvm")

Exécuter sur le simulateur Rigetti

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='rigetti.sim.qvm', 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', '111', '111', '000', '000', '000', '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)
{'000': 4, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 4}

É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', '111', '111', '000', '000', '000', '111', '111']

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

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 qsharpPython avec les balises et widget les qiskit balises.

  python 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.

Exécuter un circuit de base

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}

Étapes suivantes

• Démarrage rapide : Soumettre un circuit avec Cirq à Azure Quantum.
• Démarrage rapide : Envoyez un circuit avec un format spécifique au fournisseur à Azure Quantum.