Soumettre des tâches à Azure Quantum à l’aide du package QDKPython

Utilisez le Microsoft Quantum Development Kit package (QDK) Python pour envoyer Q#, OpenQASM, Qiskit, Cirq, et PennyLane les programmes à Azure Quantum.

Cet article fournit des exemples de soumission de travaux pour chaque langage ou infrastructure quantique pris en charge. Pour obtenir un flux de travail interactif Q# ou OpenQASM qui ne nécessite Python pas de code, consultez Envoyer des travaux avec l' QDK extension pour VS Code.

Prerequisites

• Un compte Azure avec un abonnement actif.

• Un Azure Quantum espace de travail. Pour en créer un, consultez Créer un Azure Quantum espace de travail.

• Python 3.10 ou version ultérieure.

• Si vous utilisez un notebook Jupyter, un environnement Jupyter comme l’extension Jupyter pour VS Code et le package ipykernel.

• Installez Azure CLI avec l’extensionquantum.

  az extension add --upgrade --name quantum
  

• Installez la dernière version du qdkPython package avec les azure et jupyter extras.

  pip install --upgrade "qdk[azure,jupyter]"
  

  Si vous souhaitez soumettre un programme Qiskit ou Cirq, installez les modules complémentaires cirq et qiskit.

  pip install --upgrade "qdk[qiskit,cirq]"
  

Se connecter à votre Azure Quantum espace de travail

Avant de soumettre un travail, vous devez vous connecter à un Azure Quantum espace de travail. Le qdk.azure module fournit l’objet Workspace pour se connecter aux Azure Quantum espaces de travail. Pour vous connecter à votre espace de travail, procédez comme suit.

Se connecter avec Azure CLI

Si vous ne l'avez pas déjà fait, connectez-vous à Azure à partir d'un terminal avant d'ouvrir un bloc-notes Jupyter.

az login

Si vous ne vous connectez pas à partir du terminal, vous devez vous authentifier chaque fois que vous vous connectez à un espace de travail Quantum via Python. Si votre compte a accès à plusieurs abonnements, définissez l’abonnement qui contient votre Azure Quantum espace de travail.

az account set --subscription <subscription-id>

Réexécutez az login lorsque la session expire ou lorsque vous souhaitez utiliser un autre compte Azure.

Obtenir l’ID de ressource de votre espace de travail

1. Connectez-vous au portail Azure.
2. Accédez à l’espace de travail Quantum dans lequel vous souhaitez envoyer votre travail.
3. Dans la page Vue d’ensemble , recherchez et copiez l’ID de ressource.

Se connecter à l’espace de travail

1. Pour vous connecter à votre espace de travail Quantum, créez un Workspace objet avec l’ID de ressource que vous avez copié.

   from qdk.azure import Workspace
   
   workspace = Workspace(resource_id="") # Add your resource ID
   

   Note

   Y

2. Vérifiez la connexion et consultez le targets disponible dans l’espace de travail.

   for target in workspace.get_targets():
       print(target.name)
   

Pour obtenir d’autres options de connexion et d’authentification, consultez Se connecter à votre Azure Quantum espace de travail.

Note

Les exemples suivants envoient des travaux au simulateur targets. Les targets disponibles dans votre espace de travail dépendent des fournisseurs que vous avez configurés.

Préparer et soumettre votre programme

Choisissez l’onglet de votre langage ou infrastructure quantique.

Q#

Utilisez le module qdk.qsharp pour définir ou charger du code QIR, compiler un point d’entrée en QIR et soumettre le Azure Quantum à un targetQ#.

Définir et compiler le Q# programme

1. Initialiser Q# avec un profil QIRtarget pris en charge par Azure Quantumtarget.

   from qdk import qsharp, TargetProfile
   
   qsharp.init(target_profile=TargetProfile.Base)
   

   Pour plus d’informations sur les QIRtarget profils, consultez Azure QuantumQIRtarget les profils dans le QDK.

2. Définissez une Q# opération. Par exemple, utilisez l’opération suivante RandomBit .

   qsharp.eval("""
       operation RandomBit() : Result {
           use q = Qubit();
           H(q);
           return MResetZ(q);
       }
   """)
   

3. Testez l’opération sur le simulateur local.

   print(qsharp.run("RandomBit()", shots=10))
   

4. Compilez l’opération sur QIR.

   from qdk.qsharp import compile
   
   program = compile("RandomBit()")
   

Soumettre la Q# tâche

1. Sélectionnez un(e) target compatible dans votre espace de travail.

   target = workspace.get_targets("rigetti.sim.qvm")
   

2. Soumettez le programme compilé.

   job = target.submit(program, "qsharp-job", shots=100)
   print("Job ID:", job.id)
   

3. Attendez que la tâche soit terminée et récupérez ses résultats.

   job.wait_until_completed()
   print("Status:", job.details.status)
   
   results = job.get_results()
   print(results)
   

OpenQASM

Utilisez le module qdk.openqasm pour compiler le code source OpenQASM 3 en QIR, puis soumettez le QIR à un Azure Quantumtarget.

Définir et compiler le OpenQASM programme

1. Définissez un OpenQASM circuit sous forme de Python chaîne de caractères.

   qasm_source = """
   OPENQASM 3.0;
   include "stdgates.inc";
   
   bit[2] c;
   qubit[2] q;
   
   h q[0];
   cx q[0], q[1];
   c = measure q;
   """
   

2. Compilez le programme sur QIR.

   from qdk.openqasm import compile
   
   program = compile(qasm_source)
   

Soumettre la OpenQASM tâche

1. Sélectionnez un target qui accepte le programme compilé.

   target = workspace.get_targets("ionq.simulator")
   

2. Soumettez le programme compilé.

   job = target.submit(program, "openqasm-job", shots=100)
   print("Job ID:", job.id)
   

3. Attendez que la tâche se termine et récupérez ses résultats.

   job.wait_until_completed()
   print("Status:", job.details.status)
   
   results = job.get_results()
   print(results)
   

Pour les programmes paramétrables OpenQASM , liez les valeurs d’entrée avant d’envoyer un travail. Pour plus d’informations sur OpenQASM dans le QDK, consultez Développer des programmes OpenQASM dans le QDK.

Qiskit

Utilisez AzureQuantumProvider du module qdk.azure pour soumettre des tâches Qiskit à un fournisseur Azure Quantum. L’objet fournisseur répertorie les tâches et les résultats compatibles Azure Quantumtargets et retourne Qiskit les résultats.

Créer un Qiskit circuit

from qiskit import QuantumCircuit

circuit = QuantumCircuit(3, 3)
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.measure([0, 1, 2], [0, 1, 2])

Soumettre la Qiskit tâche

1. Créez un Azure Quantum objet fournisseur à partir de l’espace de travail.

   from qdk.azure.qiskit import AzureQuantumProvider
   
   provider = AzureQuantumProvider(workspace)
   

2. Répertoriez les backends qui acceptent les circuits Qiskit.

   for backend in provider.backends():
       print(backend.name)
   

3. Sélectionnez un backend et soumettez le circuit.

   backend = provider.get_backend("rigetti.sim.qvm")
   job = backend.run(circuit, shots=100)
   
   print("Job ID:", job.job_id())
   print("Status:", job.status())
   

4. Attendez que la tâche soit terminée et récupérez les résultats Qiskit.

   result = job.result()
   counts = result.get_counts(circuit)
   print(counts)
   

L’adaptateur Qiskit gère le format d’entrée Azure Quantum et convertit la réponse du fournisseur en résultat Qiskit .

Qiskit résultats des tâches pour les programmes avec perte de qubits

Certains matériels quantiques peuvent subir une perte de qubit lorsqu’un programme est en cours d’exécution. Si une perte de qubit se produit à n’importe quel moment au cours d’un shot pour un programme Qiskit, alors ce shot est supprimé des résultats du travail Azure Quantum. Par exemple, si une perte de qubit se produit dans 10 essais sur 200, les résultats de la tâche comportent un total de 190 mesures.

Les résultats bruts de toutes les captures, y compris les plans où la perte de qubit s’est produite, sont toujours disponibles dans l’objet results . Le code suivant obtient les deux ensembles de résultats.

# Get results only for shots without qubit loss
print('Counts:', result.results[0].data.counts)
print('Probabilities:', result.results[0].data.probabilities)
print('Memory:', result.results[0].data.memory)

# Get the raw total shot results
print('Raw counts:', result.results[0].data.raw_counts)
print('Raw probabilities:', result.results[0].data.raw_probabilities)
print('Raw memory:', result.results[0].data.raw_memory)

Pour les travaux ou targets qui n’ont pas de perte de qubit, les résultats par défaut et les résultats bruts sont identiques.

Note

L’attribut memory des résultats de tâche Qiskit est une liste du résultat de mesure pour chaque prise de vue.

Cirq

Utilisez AzureQuantumService du module qdk.azure pour soumettre des tâches Cirq à un fournisseur Azure Quantum. L’objet de service répertorie les Azure Quantumtargets compatibles et renvoie des résultats natifs à Cirq ou natifs au fournisseur.

Créer un Cirq circuit

import cirq

q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
    cirq.H(q0),
    cirq.CX(q0, q1),
    cirq.measure(q0, q1, key="result"),
)

Soumettre la Cirq tâche

1. Créez l’objet Azure Quantum de service.

   from qdk.azure.cirq import AzureQuantumService
   
   service = AzureQuantumService(workspace)
   

2. Répertoriez les targets qui acceptent des circuits Cirq.

   for target in service.targets():
       print(target.name)
   

3. Créez un travail asynchrone.

   job = service.create_job(
       program=circuit,
       repetitions=100,
       target="ionq.simulator",
   )
   
   print("Status:", job.status())
   

4. Attendez que la tâche soit terminée et récupérez ses résultats.

   result = job.results()
   print(result)
   

Le format des résultats dépend du fournisseur et target. Certains objets de résultat du fournisseur peuvent être convertis en objet cirq.Result .

PennyLane

Convertissez un nœud quantique PennyLane en OpenQASM, compilez le QIR en QIR et soumettez le Azure Quantum à un targetOpenQASM.

Créer un PennyLane circuit

Le circuit suivant est un circuit paramétrable. L’effet de la RY porte dépend de l’angle theta.

import pennylane as qml

device = qml.device("default.qubit", wires=2)

@qml.qnode(device)
def circuit(theta):
    qml.Hadamard(wires=0)
    qml.CNOT(wires=[0, 1])
    qml.RY(theta, wires=1)
    return qml.expval(qml.PauliZ(1))

Convertir le circuit en QIR

1. Convertissez le circuit paramétré en OpenQASM pour une valeur spécifique du paramètre.

   theta = 0.3
   qasm_source = qml.to_openqasm(circuit)(theta)
   

2. Compilez de OpenQASM à QIR avec un profil target compatible.

   from qdk import TargetProfile
   from qdk.openqasm import compile
   
   program = compile(qasm_source, TargetProfile.Base)
   

Soumettre la PennyLane tâche

1. Sélectionnez un target compatible et soumettez le QIR.

   target = workspace.get_targets("rigetti.sim.qvm")
   job = target.submit(program, "pennylane-job", shots=100)
   
   print("Job ID:", job.id)
   

2. Attendez que la tâche soit terminée et récupérez ses résultats.

   job.wait_until_completed()
   print("Status:", job.details.status)
   
   results = job.get_results()
   print(results)
   

Le format des résultats dépend du fournisseur et target. Azure Quantum ne retourne PennyLane pas les résultats du nœud quantique de la requête QIR soumise.

Contenu connexe

• Comment envoyer des travaux à Azure Quantum
• Envoyer des travaux avec l’extension QDK pour VS Code
• Soumettre des travaux à Azure Quantum avec Azure CLI
• Travailler avec des Azure Quantum jobs
• Prise en charge du langage de programmation quantique dans QDK
• Azure Quantum fournisseur de calcul targets