Taken verzenden naar Azure Quantum met het QDKPython pakket

Gebruik het Microsoft Quantum Development-kit (QDK) Python-pakket om Q#, OpenQASM, Qiskit, Cirq en PennyLane-programma's in te dienen bij Azure Quantum.

Dit artikel bevat voorbeelden van het indienen van taken voor elke ondersteunde kwantumtaal of elk ondersteund framework. Zie Python voor een interactieve QDK- of VS Code-werkstroom waarvoor geen -code is vereist.

Prerequisites

• Een Azure-account met een actief abonnement.

• Een Azure Quantum werkruimte. Om er een te maken, raadpleegt u Een Azure Quantumwerkruimte maken.

• Python 3.10 of hoger.

• Als u een Jupyter-notebook gebruikt, is er een Jupyter-omgeving zoals de Jupyter-extensie voor VS Code en het ipykernel pakket.

• Installeer Azure CLI met de quantum extensie.

  az extension add --upgrade --name quantum
  

• Installeer de nieuwste versie van het qdkPython pakket met de azure en jupyter extra's.

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

  Als u een Qiskit- of Cirq-programma wilt indienen, installeert u de extra’s van cirq en qiskit.

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

Verbinding maken met uw Azure Quantum werkruimte

Voordat u een taak verzendt, moet u verbinding maken met een Azure Quantum werkruimte. De module qdk.azure stelt het object Workspace beschikbaar om verbinding te maken met Azure Quantum-werkruimtes. Volg deze stappen om verbinding te maken met uw werkruimte.

Aanmelden met Azure CLI

Als u dat nog niet hebt gedaan, meldt u zich aan bij Azure vanuit een terminal voordat u een Jupyter-notebook opent.

az login

Als u zich niet aanmeldt vanuit de terminal, moet u zich telkens verifiëren wanneer u verbinding maakt met een Quantum-werkruimte via Python. Als uw account toegang heeft tot meerdere abonnementen, stelt u het abonnement in dat uw Azure Quantum werkruimte bevat.

az account set --subscription <subscription-id>

Voer az login opnieuw uit wanneer de sessie verloopt of wanneer u een ander Azure-account wilt gebruiken.

De resource-id van uw werkruimte ophalen

1. Meld u aan bij het Azure-portaal.
2. Ga naar de Quantum-werkruimte waar u uw taak wilt verzenden.
3. Zoek en kopieer resource-id op de pagina Overzicht.

Verbinding maken met de werkruimte

1. Als u verbinding wilt maken met uw Quantum-werkruimte, maakt u een Workspace object met de resource-id die u hebt gekopieerd.

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

   Note

   Y

2. Controleer de verbinding en bekijk de targets beschikbare in de werkruimte.

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

Zie Verbinding maken met uw Azure Quantum werkruimte voor andere verbindings- en verificatieopties.

Note

In de volgende voorbeelden worden taken verzonden naar de simulator targets. Welke targets beschikbaar is in uw werkruimte, is afhankelijk van uw geconfigureerde providers.

Uw programma voorbereiden en verzenden

Kies het tabblad voor uw kwantumtaal of framework.

Q#

Gebruik de module qdk.qsharp om Q# code te definiëren of te laden, een toegangspunt naar QIR te compileren en de QIR in te dienen bij een Azure Quantumtarget.

Het programma definiëren en compileren Q#

1. Initialiseer Q# met een targetQIR-profiel dat door Azure Quantumtarget wordt ondersteund.

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

   Zie target voor meer informatie over QDKAzure Quantum-profielen.

2. Definieer een Q# bewerking. Gebruik bijvoorbeeld de volgende RandomBit bewerking.

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

3. Test de bewerking op de lokale simulator.

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

4. Compileer de bewerking naar QIR.

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

Q# De taak verzenden

1. Selecteer een compatibele target uit uw werkruimte.

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

2. Verzend het gecompileerde programma.

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

3. Wacht totdat de taak is voltooid en de resultaten ervan is opgehaald.

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

OpenQASM

Gebruik de module qdk.openqasm om OpenQASM 3-broncode te compileren naar QIR en dien vervolgens QIR in bij een Azure Quantumtarget.

Het programma definiëren en compileren OpenQASM

1. Definieer een OpenQASM circuit als een Python tekenreeks.

   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. Compileer het programma naar QIR.

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

OpenQASM De taak verzenden

1. Selecteer een target programma dat het gecompileerde programma accepteert.

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

2. Verzend het gecompileerde programma.

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

3. Wacht totdat de taak is voltooid en de resultaten ervan is opgehaald.

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

Voor geparameteriseerde OpenQASM programma's verbindt u de invoerwaarden voordat u een taak verzendt. Zie QDK voor meer informatie over OpenQASM in de QDK.

Qiskit

Gebruik AzureQuantumProvider vanuit de qdk.azure module om taken naar een Azure Quantum provider te verzendenQiskit. Het providerobject geeft een overzicht van compatibele Azure Quantumtargets en retourneert Qiskit taken en resultaten.

Qiskit Een circuit maken

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

Qiskit De taak verzenden

1. Maak een Azure Quantum providerobject vanuit de werkruimte.

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

2. Geef de backends weer die Qiskit-circuits accepteren.

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

3. Selecteer een back-end en verzend het 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. Wacht totdat de taak is voltooid en haal de Qiskit resultaten op.

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

De Qiskit adapter verwerkt de Azure Quantum invoerindeling en converteert de providerreactie naar een Qiskit resultaat.

Qiskit taakresultaten voor programma's met qubitverlies

Sommige kwantumhardware kunnen qubitverlies ondervinden wanneer een programma wordt uitgevoerd. Als qubitverlies op enig moment optreedt tijdens een opname voor een Qiskit programma, wordt die opname verwijderd uit de resultaten van de Azure Quantum taak. Als bijvoorbeeld qubitverlies optreedt in 10 van de 200 runs, bevatten de taakresultaten in totaal 190 meettellingen.

De onbewerkte resultaten voor alle shots, inclusief shots waar qubitverlies is opgetreden, zijn nog steeds beschikbaar in het results object. Met de volgende code worden beide sets resultaten opgehaald.

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

Voor taken of targets die geen verlies van qubits hebben, zijn de standaardresultaten en onbewerkte resultaten identiek.

Note

Het memory kenmerk voor Qiskit taakresultaten is een lijst met het meetresultaat voor elke opname.

Cirq

Gebruik AzureQuantumService vanuit de qdk.azure module om taken naar een Azure Quantum provider te verzendenCirq. Het serviceobject bevat compatibele Azure Quantumtargets en retourneert Cirq-systeemeigen of providereigen resultaten.

Cirq Een circuit maken

import cirq

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

Cirq De taak verzenden

1. Maak het Azure Quantum serviceobject.

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

2. Vermeld de targets die Cirq-circuits accepteren.

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

3. Een asynchrone taak maken.

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

4. Wacht totdat de taak is voltooid en de resultaten ervan is opgehaald.

   result = job.results()
   print(result)
   

De indeling van de resultaten is afhankelijk van de provider en target. Sommige providerresultaatobjecten kunnen worden geconverteerd naar een cirq.Result object.

PennyLane

Converteer een PennyLane kwantumknooppunt naar OpenQASM, compileer het OpenQASM naar QIRen verzend de QIR naar een Azure Quantumtarget.

PennyLane Een circuit maken

Het volgende circuit is een geparameteriseerd circuit. Het effect van de RY poort hangt af van de hoek 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))

Het circuit converteren naar QIR

1. Zet het geparameteriseerde circuit om naar OpenQASM voor een specifieke parameterwaarde.

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

2. Compileer het OpenQASM naar QIR met een compatibel target profiel.

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

PennyLane De taak verzenden

1. Kies een compatibele target en dien het QIR in.

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

2. Wacht totdat de taak is voltooid en de resultaten ervan is opgehaald.

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

De indeling van de resultaten is afhankelijk van de provider en target. Azure Quantum retourneert PennyLane geen kwantumknooppuntresultaten van de ingediende QIR.

Verwante onderwerpen

• Jobs indienen bij Azure Quantum
• Jobs indienen met de QDK-extensie voor VS Code
• Taken indienen naar Azure Quantum met Azure CLI
• Werken met Azure Quantum banen
• Ondersteuning voor kwantumprogrammeertalen in de QDK
• Azure Quantum aanbieder van computerdiensten targets