Microsoft Quantum Development Kit Använd paketet (QDK) Python för att skicka Q#, OpenQASM, Qiskit, Cirqoch PennyLane program till Azure Quantum.
Den här artikeln innehåller exempel på jobbinskickning för varje kvantspråk eller ramverk som stöds. För ett interaktivt Q#- eller OpenQASM-arbetsflöde som inte kräver Python-kod, se Skicka jobb med tillägget QDK för VS Code.
Förutsättningar
Ett Azure-konto med en aktiv prenumeration.
En Azure Quantum arbetsyta. Information om hur du skapar en finns i Skapa en Azure Quantum arbetsyta.
Python 3.10 eller senare.
Om du använder en Jupyter-anteckningsbok, en Jupyter-miljö som tillägget Jupyter för VS Code och paketet ipykernel.
Installera Azure CLI med quantum tillägget.
az extension add --upgrade --name quantum
Installera den senaste versionen av qdkPython paketet med azure och jupyter extrafunktionerna.
pip install --upgrade "qdk[azure,jupyter]"
Om du vill skicka in ett Qiskit- eller Cirq-program, installera tilläggen cirq och qiskit.
pip install --upgrade "qdk[qiskit,cirq]"
Ansluta till din Azure Quantum arbetsyta
Innan du skickar ett jobb måste du ansluta till en Azure Quantum arbetsyta. Modulen qdk.azure innehåller objektet Workspace för att ansluta till Azure Quantum arbetsytor. Följ dessa steg för att ansluta till din arbetsyta.
Logga in med Azure CLI
Om du inte redan har gjort det loggar du in på Azure från en terminal innan du öppnar en Jupyter-anteckningsbok.
az login
Om du inte loggar in från terminalen måste du autentisera varje gång du ansluter till en Quantum-arbetsyta via Python. Om ditt konto har åtkomst till flera prenumerationer anger du den prenumeration som innehåller din Azure Quantum arbetsyta.
az account set --subscription <subscription-id>
Kör az login igen när sessionen upphör att gälla eller när du vill använda ett annat Azure konto.
Hämta resurs-ID för din arbetsyta
- Logga in på Azure-portalen.
- Gå till Quantum-arbetsytan där du vill skicka in jobbet.
- På sidan Översikt letar du upp och kopierar resurs-ID.
Anslut till arbetsytan
Om du vill ansluta till din Quantum-arbetsyta skapar du ett Workspace objekt med det resurs-ID som du kopierade.
from qdk.azure import Workspace
workspace = Workspace(resource_id="") # Add your resource ID
Kontrollera anslutningen och visa de targets som är tillgängliga på arbetsytan.
for target in workspace.get_targets():
print(target.name)
Andra alternativ för anslutning och autentisering finns i Ansluta till din Azure Quantum arbetsyta.
Note
I följande exempel skickas jobb till simulatorn targets. Vilka targets som är tillgängliga på din arbetsyta beror på dina konfigurerade leverantörer.
Förbereda och skicka in ditt program
Välj fliken för ditt kvantspråk eller ramverk.
Använd modulen qdk.qsharp för att definiera eller läsa in Q# kod, kompilera en startpunkt till QIRoch skicka QIR till en Azure Quantumtarget.
Definiera och kompilera Q# programmet
Initiera Q# med en QIRtarget-profil som Azure Quantumtarget stöder.
from qdk import qsharp, TargetProfile
qsharp.init(target_profile=TargetProfile.Base)
Mer information om QIRtarget-profiler finns i Azure QuantumQIRtarget profiler i QDK.
Definiera en Q# åtgärd. Använd till exempel följande RandomBit åtgärd.
qsharp.eval("""
operation RandomBit() : Result {
use q = Qubit();
H(q);
return MResetZ(q);
}
""")
Testa åtgärden på den lokala simulatorn.
print(qsharp.run("RandomBit()", shots=10))
Kompilera åtgärden till QIR.
from qdk.qsharp import compile
program = compile("RandomBit()")
Skicka jobbet Q#
Välj en kompatibel target från din arbetsyta.
target = workspace.get_targets("rigetti.sim.qvm")
Skicka det kompilerade programmet.
job = target.submit(program, "qsharp-job", shots=100)
print("Job ID:", job.id)
Vänta tills jobbet har slutförts och hämta dess resultat.
job.wait_until_completed()
print("Status:", job.details.status)
results = job.get_results()
print(results)
Använd modulen qdk.openqasm för att kompilera OpenQASM 3 källkod till QIRoch skicka QIR sedan till en Azure Quantumtarget.
Definiera och kompilera OpenQASM programmet
Definiera en OpenQASM krets som en Python sträng.
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;
"""
Kompilera programmet till QIR.
from qdk.openqasm import compile
program = compile(qasm_source)
Skicka jobbet OpenQASM
Välj en target som accepterar det kompilerade programmet.
target = workspace.get_targets("ionq.simulator")
Skicka det kompilerade programmet.
job = target.submit(program, "openqasm-job", shots=100)
print("Job ID:", job.id)
Vänta tills jobbet har slutförts och hämta dess resultat.
job.wait_until_completed()
print("Status:", job.details.status)
results = job.get_results()
print(results)
För parametriserade OpenQASM program binder du indatavärdena innan du skickar ett jobb. Mer information om OpenQASM i QDK finns i Utveckla OpenQASM-program i QDK.
Använd AzureQuantumProvider från modulen qdk.azure för att skicka Qiskit jobb till en Azure Quantum provider. Providerobjektet listar kompatibla Azure Quantumtargets och returnerar Qiskit jobb och resultat.
Skapa en Qiskit krets
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])
Skicka jobbet Qiskit
Skapa ett Azure Quantum providerobjekt från arbetsytan.
from qdk.azure.qiskit import AzureQuantumProvider
provider = AzureQuantumProvider(workspace)
Visa en lista över de serverdelar som accepterar Qiskit kretsar.
for backend in provider.backends():
print(backend.name)
Välj en backend och skicka in kretsen.
backend = provider.get_backend("rigetti.sim.qvm")
job = backend.run(circuit, shots=100)
print("Job ID:", job.job_id())
print("Status:", job.status())
Vänta tills jobbet har slutförts och hämta resultatet Qiskit .
result = job.result()
counts = result.get_counts(circuit)
print(counts)
Adaptern Qiskit hanterar Azure Quantum indataformatet och konverterar providersvaret till ett Qiskit resultat.
Qiskit jobbresultat för program med qubitförlust
En del kvantmaskinvara kan uppleva kvantbitsförlust när ett program körs. Om qubitförlust uppstår vid någon tidpunkt under ett skott för ett Qiskit-program tas detta skott bort från jobbresultaten för Azure Quantum. Om qubitförlust till exempel inträffar i 10 av 200 skott har jobbresultatet 190 totala måttantal.
De råa resultaten för alla skott, inklusive skott där qubitförlust inträffade, är fortfarande tillgängliga i results objektet. Följande kod hämtar båda uppsättningarna med resultat.
# 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)
För jobb eller targets som inte har qubitförlust är standardresultaten och råresultaten identiska.
Note
Attributet memory för Qiskit jobbresultaten är en lista över mätresultaten för varje skott.
Använd AzureQuantumService från modulen qdk.azure för att skicka Cirq jobb till en Azure Quantum provider. Serviceobjektet listar kompatibla Azure Quantumtargets och returnerar Cirq-baserade eller leverantörsbaserade resultat.
Skapa en Cirq krets
import cirq
q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
cirq.H(q0),
cirq.CX(q0, q1),
cirq.measure(q0, q1, key="result"),
)
Skicka jobbet Cirq
Azure Quantum Skapa tjänstobjektet.
from qdk.azure.cirq import AzureQuantumService
service = AzureQuantumService(workspace)
Visa en lista över vilka targets som accepterar Cirq kretsar.
for target in service.targets():
print(target.name)
Skapa ett asynkront jobb.
job = service.create_job(
program=circuit,
repetitions=100,
target="ionq.simulator",
)
print("Status:", job.status())
Vänta tills jobbet har slutförts och hämta dess resultat.
result = job.results()
print(result)
Resultatets format beror på providern och target. Vissa providerresultatobjekt kan konverteras till ett cirq.Result objekt.
Konvertera en PennyLane kvantnod till OpenQASM, kompilera OpenQASM till QIRoch skicka QIR till en Azure Quantumtarget.
Skapa en PennyLane krets
Följande krets är en parametriserad krets. Effekten av grinden RY beror på vinkeln 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))
Konvertera kretsen till QIR
Konvertera den parametriserade kretsen till OpenQASM för ett specifikt parametervärde.
theta = 0.3
qasm_source = qml.to_openqasm(circuit)(theta)
Kompilera OpenQASM till QIR med en kompatibel target profil.
from qdk import TargetProfile
from qdk.openqasm import compile
program = compile(qasm_source, TargetProfile.Base)
Skicka jobbet PennyLane
Välj en kompatibel target och skicka QIR.
target = workspace.get_targets("rigetti.sim.qvm")
job = target.submit(program, "pennylane-job", shots=100)
print("Job ID:", job.id)
Vänta tills jobbet har slutförts och hämta dess resultat.
job.wait_until_completed()
print("Status:", job.details.status)
results = job.get_results()
print(results)
Resultatets format beror på providern och target.
Azure Quantum returnerar inte PennyLane resultat från kvantnoder från den skickade QIR.
Relaterat innehåll