So übermitteln Sie einen Schaltkreis mit Cirq an Azure Quantum

Erfahren Sie, wie Sie einen Cirq-Quantenkreis mithilfe des azure-quantumPython Pakets übermitteln. Sie können Cirq-Schaltkreise über das Azure Quantum Development Kit (QDK) und das Jupyter-Notizbuch in Visual Studio Code (VS Code) von Ihrem lokalen Computer an Azure Quantum übermitteln.

Weitere Informationen finden Sie unter Quantenschaltungen.

Voraussetzungen

Details zur Installation finden Sie unter Einrichten der QDK-Erweiterung.

Ein Azure Quantum-Arbeitsbereich in Ihrem Azure-Abonnement. Zur Erstellung eines Arbeitsbereichs, siehe bitte Erstellen eines Azure Quantum Arbeitsbereichs.
Eine Python-Umgebung mit installiertem Python und Pip.
VS Code mit installierten Azure Quantum Development Kit- Pythonund Jupyter-Erweiterungen .
Das Azure Quantum-Paket azure-quantum mit dem zusätzlichen cirq-Extra sowie den qdk- und ipykernel-Paketen.
```
python -m pip install --upgrade "azure-quantum[cirq]" qdk ipykernel 
```
Hinweis

Wenn der Jupyter-Kernel Pythonipykernel nicht erkannt wird, werden Sie von VS Code aufgefordert, ihn zu installieren.

Erstellen eines neuen Jupyter Notebooks

Öffnen Sie im VS Code das Menü "Ansicht" , und wählen Sie "Befehlspalette" aus.
Geben Sie ein und wählen Sie Erstellen: Neues Jupyter-Notizbuch aus.
VS Code erkennt und zeigt die Version von Python und die virtuelle Python Umgebung, die für das Notizbuch ausgewählt wurden, an. Wenn Sie über mehrere Python Umgebungen verfügen, müssen Sie möglicherweise einen Kernel mit der Kernelauswahl oben rechts auswählen. Wenn keine Umgebung erkannt wurde, finden Sie Informationen zum Einrichten unter Jupyter-Notizbücher in VS Code .

Lade die erforderlichen Importe

Führen Sie in der ersten Zelle Ihres Notizbuchs den folgenden Code aus, um die erforderlichen Importe zu laden:

import azure.quantum
from azure.quantum.cirq import AzureQuantumService

Herstellen einer Verbindung mit dem Azure Quantum-Dienst

Zum Herstellen einer Verbindung mit dem Azure Quantum-Dienst benötigt Ihr Programm die Ressourcen-ID und den Speicherort Ihres Azure Quantum Arbeitsbereichs.

Melden Sie sich bei Ihrem Azure-Konto an, https://portal.azure.com
Wählen Sie Ihren Azure Quantum-Arbeitsbereich aus, und navigieren Sie zu "Übersicht".
Kopieren Sie die Parameter in den Feldern.

Fügen Sie eine neue Zelle hinzu, und verwenden Sie Ihre Kontoinformationen, um die Objekte Workspace und AzureQuantumService zu erstellen, die mit Ihrem Azure Quantum-Arbeitsbereich verbunden sind.

workspace = Workspace(  
    resource_id = "", # Add the resourceID of your workspace
    location = "" # Add the location of your workspace (for example "westus")
    )

service = AzureQuantumService(workspace)

Auflisten aller targets

Verwenden Sie die targets()-Methode, um alle targets in Ihrem Arbeitsbereich aufzulisten, die Ihre Schaltung ausführen können, einschließlich der aktuellen Warteschlangenzeit und Verfügbarkeit.

Hinweis

Möglicherweise sind nicht alle targets in Ihrem Arbeitsbereich aufgeführt. Hier werden nur die targets aufgelistet, die eine Cirq- oder OpenQASM-Schaltung akzeptieren können.

print(service.targets())

[<Target name="quantinuum.qpu.h2-1", avg. queue time=0 s, Degraded>,
<Target name="quantinuum.sim.h2-1sc", avg. queue time=1 s, Available>,
<Target name="quantinuum.sim.h2-1e", avg. queue time=40 s, Available>,
<Target name="ionq.simulator", avg. queue time=3 s, Available>,
<Target name="ionq.qpu.aria-1", avg. queue time=1136774 s, Available>]

Erstellen eines einfachen Schaltkreises

Erstellen Sie als Nächstes eine einfache Cirq-Schaltung für die Ausführung. Diese Schaltung verwendet die Quadratwurzel des X-Gatters, was nativ für das IonQ-Hardwaresystem ist.

import cirq

q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
    cirq.X(q0)**0.5,             # Square root of X
    cirq.CX(q0, q1),              # CNOT
    cirq.measure(q0, q1, key='b') # Measure both qubits
)
print(circuit)

0: ───X^0.5───@───M────────
              │   │
1: ───────────X───M────────

Auswählen eines target zum Ausführen des Programms

IonQ
Quantinuum

Auf IonQ-Simulator ausführen

Sie können das Programm jetzt über den Azure Quantum-Dienst ausführen und das Ergebnis abrufen. Die folgende Zelle übermittelt einen Auftrag (an den als Standard festgelegten IonQ-Simulator), der die Schaltung mit 100 Ausführungen abläuft, wartet, bis der Auftrag abgeschlossen ist, und die Ergebnisse zurückgibt.

result = service.run(program=circuit, repetitions=100, target="ionq.simulator")

Hierbei wird ein cirq.Result-Objekt zurückgegeben.

print(result)

    b=1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010, 1001100101100001000011011101000011010100010111100011001000100100010000001110010010101110110000011010

Schätzen der Auftragskosten

Bevor Sie einen Auftrag auf der QPU ausführen, sollten Sie schätzen, wie viel die Ausführung kostet.

Für die aktuellsten Preisdetails sehen Sie bitte unter IonQ Pricing nach, oder finden Sie Ihren Arbeitsbereich und rufen Sie die Preisoptionen auf der Registerkarte „Anbieter“ Ihres Arbeitsbereichs unter aka.ms/aq/myworkspaces auf.

Ausführen auf der IonQ-QPU

Der vorherige Auftrag wurde im Standardsimulator "ionq.simulator" ausgeführt. Sie können ihn jedoch ebenfalls auf dem Hardwareprozessor von IonQ ausführen (einer Quantenprozessoreinheit (QPU)). Geben Sie zur Ausführung auf der IonQ-QPU "ionq.qpu.aria-1" als target-Argument an:

result = service.run(
    program=circuit,
    repetitions=100,
    target="ionq.qpu.aria-1",
    timeout_seconds=500 # Set timeout to accommodate queue time on QPU
)

Hierbei wird wiederum ein cirq.Result-Objekt zurückgegeben.

print(result)

b=0101011011011111100001011101101011011110100010000000011110111000100100110110101100110001001111101111, 0101011011011111100001011101101011011110100010000000011110111000100100110110101100110001001111101111

Asynchrones Modell mit Jobs

Bei Schaltungen mit langer Ausführungsdauer kann es sinnvoll sein, sie asynchron auszuführen. Die service.create_job-Methode gibt ein Job-Objekt zurück, das Sie verwenden können, um die Ergebnisse nach der erfolgreichen Ausführung des Auftrags abzurufen.

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

Verwenden Sie job.status(), um den Auftragsstatus zu überprüfen:

print(job.status())

'completed'

Wenn Sie auf den Abschluss des Auftrags warten und dann die Ergebnisse abrufen möchten, verwenden Sie den blockierenden Aufruf job.results():

result = job.results()
print(result)

00: 0.5
11: 0.5

Beachten Sie, dass hierbei kein cirq.Result-Objekt zurückgegeben wird. Stattdessen wird ein Ergebnisobjekt zurückgegeben, das für den IonQ-Simulator spezifisch ist und Zustandswahrscheinlichkeiten anstelle von Ausführungsdaten verwendet.

type(result)

cirq_ionq.results.SimulatorResult

Verwenden Sie cirq.Result, um dies in ein result.to_cirq_result()-Objekt zu konvertieren:

print(result.to_cirq_result())

b=1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100, 1110101111111110111000011101011111001100010000001011011101001111001111001101100111010000001100011100

Auf dem Quantinuum-Simulator ausführen

Sie können das Programm jetzt über den Azure Quantum-Dienst ausführen und das Ergebnis abrufen. Die folgende Zelle übermittelt einen Auftrag, der die Schaltung mit 100 Ausführungen durchläuft, wartet, bis der Auftrag abgeschlossen ist, und die Ergebnisse zurückgibt.

result = service.run(program=circuit, repetitions=100, target="quantinuum.sim.h2-1sc")

Hierbei wird ein cirq.Result-Objekt zurückgegeben.

print(result)

    b=0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Sie können die Ergebnisse in einem Histogramm zeichnen:

import pylab as pl

pl.hist(result.data)
pl.ylabel("Counts")
pl.xlabel("Result")

Im Histogramm sehen Sie, dass der Zufallszahlengenerator jedes Mal 0 zurückgegeben hat, was nicht gerade unserer Vorstellung von Zufälligkeit entspricht. Das liegt daran, dass die API-Validierung zwar sicherstellt, dass Ihr Code erfolgreich auf Quantinuum-Hardware ausgeführt wird, aber auch 0 für jede Quantenmessung zurückgegeben wird. Für einen echten Zufallszahlengenerator müssen Sie Ihre Schaltung auf Quantenhardware ausführen.

Schätzen der Auftragskosten

Bevor Sie einen Auftrag auf der QPU ausführen, sollten Sie schätzen, wie viel die Ausführung kostet.

Die aktuellsten Preisdetails finden Sie unter Azure Quantum-Preise, oder suchen Sie Ihren Arbeitsbereich und zeigen Sie Preisoptionen auf der Registerkarte "Anbieter" Ihres Arbeitsbereichs über: aka.ms/aq/myworkspaces an.

Asynchroner Workflow mit Aufträgen

job = service.create_job(
    program=circuit,
    repetitions=100,
    target="quantinuum.sim.h2-1sc"
)

Verwenden Sie job.status(), um den Auftragsstatus zu überprüfen:

print(job.status())

'Waiting'

Wenn Sie auf den Abschluss des Auftrags warten und dann die Ergebnisse abrufen möchten, verwenden Sie den blockierenden Aufruf job.results():

result = job.results()
print(result)

    {'m_b': ['00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00', '00']}

Beachten Sie, dass hierbei kein cirq.Result-Objekt zurückgegeben wird. Stattdessen wird ein Wörterbuch mit Bitzeichenfolgen-Messungsergebnissen zurückgegeben, die mit dem Messschlüssel indiziert wurden.

Wichtig

Das Übermitteln mehrerer Schaltungen in einem einzelnen Auftrag wird derzeit nicht unterstützt. Sie können allerdings die backend.run-Methode aufrufen, um die einzelnen Schaltungen asynchron zu übermitteln, und anschließend die Ergebnisse jedes Auftrags abrufen. Zum Beispiel:

jobs = []
for circuit in circuits:
    jobs.append(backend.run(circuit, shots=N))

results = []
for job in jobs:
    results.append(job.result())

Feedback

War diese Seite hilfreich?

Last updated on 2025-10-17

Freigeben über

So übermitteln Sie einen Schaltkreis mit Cirq an Azure Quantum

Voraussetzungen

Erstellen eines neuen Jupyter Notebooks

Lade die erforderlichen Importe

Herstellen einer Verbindung mit dem Azure Quantum-Dienst

Auflisten aller targets

Erstellen eines einfachen Schaltkreises

Auswählen eines target zum Ausführen des Programms

Auf IonQ-Simulator ausführen

Schätzen der Auftragskosten

Ausführen auf der IonQ-QPU

Asynchrones Modell mit Jobs

Feedback

Zusätzliche Ressourcen