Senden Sie Jobs an Azure Quantum mit dem QDKPython-Paket

Verwenden Sie das Microsoft Quantum Development Kit (QDK) Python-Paket, um Q#, OpenQASM, Qiskit, Cirq und PennyLane-Programme bei Azure Quantum einzureichen.

Dieser Artikel bietet Beispiele für die Übermittlung von Aufträgen für jede unterstützte Quantensprache und jedes unterstützte Framework. Einen interaktiven Q#- oder OpenQASM-Workflow, der keinen Python-Code erfordert, finden Sie unter Übermitteln von Jobs mit der Erweiterung QDK für VS Code.

Voraussetzungen

Ein Azure-Konto mit einem aktiven Abonnement.
Ein Azure Quantum Arbeitsbereich. Informationen zum Erstellen eines Arbeitsbereichs finden Sie unter "Erstellen eines Azure Quantum Arbeitsbereichs".
Python 3.10 oder neuer.
Wenn Sie ein Jupyter-Notebook verwenden, benötigen Sie eine Jupyter-Umgebung wie die Jupyter-Erweiterung für VS Code und das Paket ipykernel.
Installieren Sie Azure CLI mit der quantum Erweiterung.
```
az extension add --upgrade --name quantum
```
Installieren Sie die neueste Version des qdkPython Pakets mit den azure Und jupyter Extras.
```
pip install --upgrade "qdk[azure,jupyter]"
```
Wenn Sie ein Qiskit oder Cirq Programm einreichen möchten, installieren Sie die cirq und qiskit Extras.
```
pip install --upgrade "qdk[qiskit,cirq]"
```

Verbinden Sie sich mit Ihrem Azure Quantum Arbeitsbereich

Bevor Sie einen Auftrag absenden, müssen Sie sich mit einem Azure Quantum Arbeitsbereich verbinden. Das qdk.azure Modul stellt das Workspace Objekt zum Herstellen einer Verbindung mit Azure Quantum Arbeitsbereichen bereit. Führen Sie die folgenden Schritte aus, um eine Verbindung mit Ihrem Arbeitsbereich herzustellen.

Falls noch nicht geschehen, melden Sie sich von einem Terminal aus bei Azure an, bevor Sie ein Jupyter-Notizbuch öffnen.

az login

Wenn Sie sich nicht über das Terminal anmelden, müssen Sie sich jedes Mal erneut authentifizieren, wenn Sie über Python eine Verbindung zu einem Quantum-Arbeitsbereich herstellen. Wenn Ihr Konto Zugriff auf mehrere Abonnements hat, legen Sie das Abonnement fest, das Ihren Azure Quantum Arbeitsbereich enthält.

az account set --subscription <subscription-id>

Führen Sie den Vorgang az login erneut aus, wenn die Sitzung abläuft oder wenn Sie ein anderes Azure Konto verwenden möchten.

Rufen Sie die Ressourcen-ID Ihres Arbeitsbereichs ab

Melden Sie sich im Azure-Portal an.
Wechseln Sie zum Quantum-Arbeitsbereich, in dem Sie Ihre Arbeit einreichen möchten.
Suchen und kopieren Sie auf der Seite "Übersicht " die Ressourcen-ID.

Verbindung mit dem Arbeitsbereich herstellen

Um eine Verbindung mit Ihrem Quantum-Arbeitsbereich herzustellen, erstellen Sie ein Workspace Objekt mit der Ressourcen-ID, die Sie kopiert haben.
```
from qdk.azure import Workspace

workspace = Workspace(resource_id="") # Add your resource ID
```
Note

Y
Überprüfen Sie die Verbindung und zeigen Sie die im Arbeitsbereich verfügbare targets an.
```
for target in workspace.get_targets():
    print(target.name)
```

Weitere Verbindungs- und Authentifizierungsoptionen finden Sie unter Herstellen einer Verbindung mit Ihrem Azure Quantum Arbeitsbereich.

Note

In den folgenden Beispielen werden Aufträge an den Simulator targetsübermittelt. Die in Ihrem Arbeitsbereich verfügbaren targets hängen von Ihren konfigurierten Anbietern ab.

Vorbereiten und Übermitteln Ihres Programms

Wählen Sie die Registerkarte für Ihre Quantensprache oder Ihr Framework aus.

Verwenden Sie das qdk.qsharp-Modul, um Q#-Code zu definieren oder zu laden, einen Einstiegspunkt nach QIR zu kompilieren und QIR an ein Azure Quantumtarget zu übermitteln.

Definieren und Kompilieren des Q# Programms

Initialisieren Sie Q# mit einem QIRtarget-Profil, das Azure Quantumtarget unterstützt.
```
from qdk import qsharp, TargetProfile

qsharp.init(target_profile=TargetProfile.Base)
```
Weitere Informationen zu QIRtarget-Profilen finden Sie unter Azure QuantumQIRtarget Profilen in QDK.

Definieren Sie einen Q# Vorgang. Verwenden Sie beispielsweise den folgenden RandomBit Vorgang.

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

Testen Sie den Vorgang im lokalen Simulator.

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

Kompilieren Sie den Vorgang in QIR.

from qdk.qsharp import compile

program = compile("RandomBit()")

Absenden des Q# Auftrags

Wählen Sie aus Ihrem Arbeitsbereich einen kompatiblen target aus.
```
target = workspace.get_targets("rigetti.sim.qvm")
```

Übermitteln Sie das kompilierte Programm.

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

Warten Sie, bis der Auftrag abgeschlossen ist, und rufen Sie dessen Ergebnisse ab.

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

results = job.get_results()
print(results)

Verwenden Sie das qdk.openqasm-Modul, um QIR3-Quellcode zu OpenQASM zu kompilieren, und übermitteln Sie dann das QIR an eine Azure Quantumtarget.

Definieren und Kompilieren des OpenQASM Programms

Definieren Sie einen OpenQASM Schaltkreis als Python Zeichenfolge.

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;
"""

Kompilieren Sie das Programm in QIR.

from qdk.openqasm import compile

program = compile(qasm_source)

OpenQASM Auftrag übermitteln

Wählen Sie ein target , das das kompilierte Programm akzeptiert.
```
target = workspace.get_targets("ionq.simulator")
```

Übermitteln Sie das kompilierte Programm.

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

Warten Sie, bis der Auftrag abgeschlossen ist, und rufen Sie dessen Ergebnisse ab.

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

results = job.get_results()
print(results)

Binden Sie bei parametrisierten OpenQASM Programmen die Eingabewerte, bevor Sie einen Auftrag übermitteln. Weitere Informationen zu OpenQASM finden Sie in QDK unter Entwickeln von OpenQASM Programmen in der QDK.

Verwenden Sie AzureQuantumProvider aus dem qdk.azure-Modul, um Azure Quantum-Jobs an einen Qiskit-Anbieter zu übermitteln. Das Provider-Objekt führt kompatible Azure Quantumtargets auf und gibt Qiskit Jobs und Ergebnisse zurück.

Erstellen einer Qiskit Schaltung

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 Auftrag absenden

Erstellen Sie ein Azure Quantum Providerobjekt aus dem Workspace.

from qdk.azure.qiskit import AzureQuantumProvider

provider = AzureQuantumProvider(workspace)

Liste die Backends auf, die Qiskit-Schaltkreise akzeptieren.

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

Wählen Sie ein Back-End aus, und übermitteln Sie den Schaltkreis.

backend = provider.get_backend("rigetti.sim.qvm")
job = backend.run(circuit, shots=100)

print("Job ID:", job.job_id())
print("Status:", job.status())

Warten Sie, bis der Auftrag abgeschlossen ist, und rufen Sie die Qiskit Ergebnisse ab.
```
result = job.result()
counts = result.get_counts(circuit)
print(counts)
```

Der Qiskit Adapter verarbeitet das Azure Quantum Eingabeformat und konvertiert die Anbieterantwort in ein Qiskit Ergebnis.

Qiskit Auftragsergebnisse für Programme mit Qubit-Verlust

Bei einigen Quantenhardware kann qubit-Verlust auftreten, wenn ein Programm ausgeführt wird. Wenn bei einem Qiskit-Programm zu irgendeinem Zeitpunkt während eines Schusses ein Qubit-Verlust auftritt, wird dieser Schuss aus den Azure Quantum-Jobergebnissen entfernt. Wenn z. B. der Qubit-Verlust in 10 von 200 Ausführungen auftritt, dann haben die Jobergebnisse insgesamt 190 Messzählwerte.

Die rohen Ergebnisse für alle Aufnahmen, einschließlich Aufnahmen, bei denen qubit-Verlust aufgetreten ist, sind weiterhin im results Objekt verfügbar. Der folgende Code ruft beide Ergebnisgruppen ab.

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

Bei Aufträgen oder targets ohne Qubitverlust sind das Standardergebnis und die Rohdaten identisch.

Note

Das memory Attribut für Qiskit Auftragsergebnisse ist eine Liste des Messergebnisses für jeden Schuss.

Verwenden Sie AzureQuantumService aus dem qdk.azure-Modul, um Azure Quantum-Jobs bei einem Cirq-Anbieter einzureichen. Das Dienstobjekt führt kompatible Azure Quantumtargets auf und gibt Cirq-native oder provider-native Ergebnisse zurück.

Erstellen einer Cirq Schaltung

import cirq

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

Den Cirq Auftrag absenden

Erstellen Sie das Azure Quantum Dienstobjekt.

from qdk.azure.cirq import AzureQuantumService

service = AzureQuantumService(workspace)

Listen Sie die targets auf, die Cirq Schaltkreise akzeptieren.
```
for target in service.targets():
    print(target.name)
```

Erstellen Sie eine asynchrone Aufgabe.

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

print("Status:", job.status())

Warten Sie, bis der Auftrag abgeschlossen ist, und rufen Sie dessen Ergebnisse ab.
```
result = job.results()
print(result)
```

Das Format der Ergebnisse hängt vom Anbieter und target ab. Einige Anbieterergebnisobjekte können in ein cirq.Result Objekt konvertiert werden.

Konvertieren Sie einen OpenQASM Quantenknoten in OpenQASM, kompilieren Sie das QIR zu QIR, und übermitteln Sie das Azure Quantum an ein targetPennyLane.

Erstellen einer PennyLane Schaltung

Der folgende Schaltkreis ist ein parametrisierter Schaltkreis. Die Wirkung des RY Gates hängt vom Winkel thetaab.

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

Konvertieren des Schaltkreises in QIR

Wandeln Sie den parametrisierten Schaltkreis für einen bestimmten Parameterwert in OpenQASM um.
```
theta = 0.3
qasm_source = qml.to_openqasm(circuit)(theta)
```

Kompilieren Sie OpenQASM zu QIR mit einem kompatiblen target-Profil.

from qdk import TargetProfile
from qdk.openqasm import compile

program = compile(qasm_source, TargetProfile.Base)

PennyLane Auftrag absenden

Wählen Sie eine kompatible target Option aus, und übermitteln Sie die QIRDatei .

target = workspace.get_targets("rigetti.sim.qvm")
job = target.submit(program, "pennylane-job", shots=100)

print("Job ID:", job.id)

Warten Sie, bis der Auftrag abgeschlossen ist, und rufen Sie dessen Ergebnisse ab.

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

results = job.get_results()
print(results)

Das Format der Ergebnisse hängt vom Anbieter und target ab. Azure Quantumgibt keine Ergebnisse des Quantenknotens aus dem übermittelten PennyLane zurück.

Feedback

War diese Seite hilfreich?

Last updated on 2026-08-29

Senden Sie Jobs an Azure Quantum mit dem QDKPython-Paket

Voraussetzungen

Verbinden Sie sich mit Ihrem Azure Quantum Arbeitsbereich

Anmelden mit Azure CLI

Rufen Sie die Ressourcen-ID Ihres Arbeitsbereichs ab

Verbindung mit dem Arbeitsbereich herstellen

Vorbereiten und Übermitteln Ihres Programms

Definieren und Kompilieren des Q# Programms

Absenden des Q# Auftrags

Verwandte Inhalte

Feedback

Zusätzliche Ressourcen