Freigeben über

So übermitteln Sie einen Schaltkreis mit Qiskit an Azure Quantum

  • Artikel

Erfahren Sie, wie Sie mithilfe des azure-quantumPython Pakets eine Qiskit-Quantenschaltung übermitteln. Sie können Qiskit-Schaltkreise mithilfe des Azure Quantum-Notizbuchs azure-quantumPython , das über ein integriertes Paket oder von Ihrem lokalen Computer verfügt, an Azure Quantum übermitteln.

Weitere Informationen finden Sie unter Quantenschaltungen.

Voraussetzungen

Installationsdetails finden Sie unter Installieren des QDK unter VS Code.

Erstellen eines neuen Jupyter Notebooks

  1. Wählen Sie in VS Code die Optionen Ansicht > Befehlspalette und dann Erstellen aus: Verwenden von Jupyter Notebook.
  2. In der oberen rechten Ecke erkennt und zeigt VS Code die Version und Python die virtuelle Python Umgebung an, die für das Notizbuch ausgewählt wurde. 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 .

Laden der 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 qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from azure.quantum.qiskit import AzureQuantumProvider

Herstellen einer Verbindung mit dem Azure Quantum-Dienst

Um eine Verbindung mit dem Azure Quantum-Dienst herzustellen, benötigen Sie die Ressourcen-ID und den Standort Ihres Azure Quantum-Arbeitsbereichs.

  1. Melden Sie sich bei Ihrem Azure-Konto an, https://portal.azure.com

  2. Wählen Sie Ihren Azure Quantum-Arbeitsbereich aus, und navigieren Sie zu "Übersicht".

  3. Kopieren Sie die Parameter in den Feldern.

    Screenshot von Visual Studio Code, der zeigt, wie Sie den Übersichtsbereich Ihres Quantum Workspace erweitern.

Fügen Sie eine neue Zelle in Ihrem Notizbuch hinzu, und verwenden Sie Ihre Kontoinformationen, um eine Workspace Verbindung mit Ihrem Azure Quantum-Arbeitsbereich herzustellen.AzureQuantumProvider

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

provider = AzureQuantumProvider(workspace)

Auflisten aller Back-Ends

Sie können jetzt alle Quantencomputing-Back-Ends ausgeben, die in Ihrem Arbeitsbereich verfügbar sind:

print("This workspace's targets:")
for backend in provider.backends():
    print("- " + backend.name())

This workspace's targets:
- ionq.qpu
- ionq.qpu.aria-1
- ionq.simulator
- microsoft.estimator
- quantinuum.hqs-lt-s1
- quantinuum.hqs-lt-s1-apival
- quantinuum.hqs-lt-s2
- quantinuum.hqs-lt-s2-apival
- quantinuum.hqs-lt-s1-sim
- quantinuum.hqs-lt-s2-sim
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm
- rigetti.qpu.ankaa-2

Ausführen einer einfachen Schaltung

Erstellen Sie zunächst eine einfache Qiskit-Schaltung für die Ausführung.

# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(3, 3)
circuit.name = "Qiskit Sample - 3-qubit GHZ circuit"
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.measure([0,1,2], [0, 1, 2])

# Print out the circuit
circuit.draw()

     ┌───┐          ┌─┐      
q_0: ┤ H ├──■───────┤M├──────
     └───┘┌─┴─┐     └╥┘┌─┐   
q_1: ─────┤ X ├──■───╫─┤M├───
          └───┘┌─┴─┐ ║ └╥┘┌─┐
q_2: ──────────┤ X ├─╫──╫─┤M├
               └───┘ ║  ║ └╥┘
c: 3/════════════════╩══╩══╩═
                     0  1  2

Wählen Sie ein target , um Ihr Programm auszuführen.

Ausführen im IonQ-Simulator

Bevor wir auf echter Hardware laufen, testen wir den Schaltkreis im Simulator. Dient get_backend zum Erstellen eines Objekts zum Herstellen einer Backend Verbindung mit dem IonQ Simulator-Back-End:

simulator_backend = provider.get_backend("ionq.simulator")

IonQ-Back-Ends unterstützen Gates aus einem definierten Gateset, die für die optimale Ausführung auf der Hardware kompiliert werden. Wenn Ihr Schaltkreis Tore enthält, die nicht in dieser Liste enthalten sind, müssen Sie die unterstützte gateset Funktion mithilfe der transpile von Qiskit bereitgestellten Funktion transpilieren:

from qiskit import transpile
circuit = transpile(circuit, simulator_backend)

Die Transpile-Funktion gibt ein neues Schaltkreisobjekt zurück, bei dem Gates in Tore zerlegt werden, die im angegebenen Back-End unterstützt werden.

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:

job = simulator_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)

Job id 00000000-0000-0000-0000-000000000000

Führen Sie Folgendes aus, um zu warten, bis der Auftrag abgeschlossen ist, und die Ergebnisse zurückzugeben:

result = job.result()
print(result)

Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=100, success=True, meas_level=2, data=ExperimentResultData(counts={'000': 50, '111': 50}, probabilities={'000': 0.5, '111': 0.5}), header=QobjExperimentHeader(meas_map='[0, 1, 2]', name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])

Da es sich beim Ergebnis um ein für das Qiskit-Paket natives Objekt handelt, können Sie result.get_counts und plot_histogram von Quiskit verwenden, um die Ergebnisse zu visualisieren. Damit sichergestellt ist, dass alle möglichen Bitzeichenfolgen-Bezeichnungen dargestellt werden, fügen Sie sie zu counts hinzu.

counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

{'000': 50, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 50}

Ergebnis der Qiskit-Schaltung im IonQ-Simulator

Schätzen der Auftragskosten

Bevor Sie einen Auftrag auf der QPU ausführen, können Sie abschätzen, wie viel es kostet. Um die Kosten für die Ausführung eines Auftrags auf der QPU zu schätzen, können Sie die Methode estimate_cost verwenden:

backend = provider.get_backend("ionq.qpu")
cost = backend.estimate_cost(circuit, shots=1024)

print(f"Estimated cost: {cost.estimated_total}")

Dadurch werden die geschätzten Kosten in US-Dollar gedruckt.

Die aktuellen Preisdetails finden Sie unter Preise. Suchen Sie alternativ nach Ihrem Arbeitsbereich, und zeigen Sie die Preisoptionen auf der Registerkarte „Anbieter“ Ihres Arbeitsbereichs über aka.ms/aq/myworkspaces an.

Ausführen auf der IonQ-QPU

Um eine Verbindung mit echter Hardware herzustellen (eine Quantum Processor Unit (QPU)), geben Sie einfach den Namen der target"ionq.qpu" Methode get_backend an:

qpu_backend = provider.get_backend("ionq.qpu")

Übermitteln Sie den Schaltkreis für die Ausführung auf Azure Quantum, rufen Sie die Ergebnisse ab und führen Sie plot_histogram aus, um die Ergebnisse zu zeichnen.

Hinweis

Die zum Ausführen einer Schaltung auf der QPU erforderliche Zeit kann je nach aktueller Warteschlangenzeit variieren.

# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=1024)
job_id = job.id()
print("Job id", job_id)

# Get the job results (this method waits for the Job to complete):
result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

Job id 00000000-0000-0000-0000-000000000000
Job Status: job has successfully run
Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='00000000-0000-0000-0000-000000000000', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'0': 505, '1': 6, '2': 1, '3': 1, '4': 1, '5': 10, '6': 11, '7': 488}, probabilities={'0': 0.4932, '1': 0.0059, '2': 0.001, '3': 0.001, '4': 0.001, '5': 0.0098, '6': 0.0117, '7': 0.4766}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])
{'000': 505, '001': 6, '010': 1, '011': 1, '100': 1, '101': 10, '110': 11, '111': 488}

Ergebnis der Qiskit-Schaltung auf der IonQ-QPU

Wichtig

Das Übermitteln mehrerer Schaltungen in einem einzelnen Auftrag wird derzeit nicht unterstützt. Sie können allerdings die Methode backend.run 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())

Voraussetzungen

  • Ein Azure-Konto mit einem aktiven Abonnement. Wenn Sie nicht über ein Azure-Konto verfügen, registrieren Sie sich kostenlos, und registrieren Sie sich für ein Kostenpflichtiges Abonnement.
  • Azure Quantum-Arbeitsbereich Weitere Informationen finden Sie unter Erstellen eines Azure Quantum-Arbeitsbereichs.

Erstellen eines neuen Notebooks in Ihrem Arbeitsbereich

  1. Melden Sie sich beim Azure-Portal an, und wählen Sie den Arbeitsbereich aus, den Sie im vorherigen Schritt erstellt haben.
  2. Wählen Sie auf dem linken Blatt Notebooks aus.
  3. Klicken Sie auf Meine Notebooks und dann auf Neu hinzufügen.
  4. Geben Sie einen Namen für die Datei ein, z. B. Qiskit.ipynb, und klicken Sie auf Datei erstellen.

Wenn Ihr neues Notebook geöffnet wird, wird der Code für die erste Zelle automatisch auf der Grundlage Ihrer Abonnement- und Arbeitsbereichsinformationen erstellt.

from azure.quantum import Workspace
workspace = Workspace ( 
    resource_id = "", # Add your resource_id 
    location = ""  # Add your workspace location (for example, "westus") 
)

Hinweis

Sofern nicht anders angegeben, müssen Sie die einzelnen Zellen in der Reihenfolge ihrer Erstellung ausführen, um Kompilierungsprobleme zu vermeiden.

Klicken Sie links neben der Zelle auf das dreieckige Wiedergabesymbol, um den Code auszuführen.

Laden der erforderlichen Importe

Zunächst müssen Sie einige zusätzliche Module importieren.

Klicken Sie auf + Code, um eine neue Zelle hinzuzufügen, fügen Sie dann den folgenden Code hinzu, und führen Sie ihn aus:

from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from azure.quantum.qiskit import AzureQuantumProvider

Herstellen einer Verbindung mit dem Azure Quantum-Dienst

Erstellen Sie als Nächstes ein AzureQuantumProvider Objekt mithilfe des Workspace Objekts aus der vorherigen Zelle, um eine Verbindung mit Ihrem Azure Quantum-Arbeitsbereich herzustellen. Fügen Sie eine neue Zelle mit dem folgenden Code hinzu:

provider = AzureQuantumProvider(workspace)

Definieren einer einfachen Schaltung

Erstellen Sie in einer neuen Zelle ein circuit-Objekt. Dieses Beispiel ist ein einfacher Quanten-Zufallsbitgenerator. Fügen Sie den folgenden Code hinzu, um die Schaltung zu definieren und anzuzeigen:

# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(3, 3)
circuit.name = "Qiskit Sample - 3-qubit GHZ circuit"
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.measure([0, 1, 2], [0, 1, 2])

# Print out the circuit
circuit.draw()

     ┌───┐          ┌─┐      
q_0: ┤ H ├──■───────┤M├──────
     └───┘┌─┴─┐     └╥┘┌─┐   
q_1: ─────┤ X ├──■───╫─┤M├───
          └───┘┌─┴─┐ ║ └╥┘┌─┐
q_2: ──────────┤ X ├─╫──╫─┤M├
               └───┘ ║  ║ └╥┘
c: 3/════════════════╩══╩══╩═
                     0  1  2

Alle auflisten targets

Sie können jetzt alle Quantencomputing targets- oder Back-End-Dateien anzeigen, die in Ihrem Arbeitsbereich verfügbar sind. Fügen Sie eine neue Zelle hinzu, und führen Sie die folgende Zeile aus:

print("This workspace's targets:")
for backend in provider.backends():
    print("- " + backend.name())

This workspace's targets:
- ionq.qpu
- ionq.simulator
- ionq.qpu.aria-1
- microsoft.estimator
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm
- rigetti.qpu.ankaa-2

Wählen Sie ein target , um Ihr Programm auszuführen.

Um Ihren Code zu überprüfen, bevor Sie ihn auf der tatsächlichen Quantenhardware ausführen, können Sie den IonQ-Quantensimulator ionq.simulator verwenden.

Fügen Sie eine neue Zelle hinzu, und erstellen Sie ein Objekt, um den IonQ-Quantensimulator targetdarzustellen:

# Get IonQ quantum simulator target:
simulator_backend = provider.get_backend("ionq.simulator")

Ausführen im IonQ-Simulator

Um den Schaltkreis auf dem Simulator auszuführen, fügen Sie den folgenden Code hinzu. In diesem Beispiel wird die run Methode verwendet target , um Ihren Auftrag zu übermitteln, und anschließend wird der Auftragsstatus überwacht.

# Submit the circuit to run on Azure Quantum
job = simulator_backend.run(circuit, shots=100)
job_id = job.id()
print("Job id", job_id)

Wenn der Auftrag erfolgreich ausgeführt wird, rufen Sie die Auftragsergebnisse ab, und zeigen Sie sie an:

# Get the job results:
result = job.result()
print(result)

Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='7d909574-98d4-11ec-b382-00155d957f5d', success=True, results=[ExperimentResult(shots=100, success=True, meas_level=2, data=ExperimentResultData(counts=defaultdict(<class 'int'>, {'000': 50, '111': 50}), probabilities=defaultdict(<class 'int'>, {'000': 0.5, '111': 0.5})), header=QobjExperimentHeader(meas_map='[0, 1, 2]', name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])

Da es sich bei diesem result-Typ um ein für das Qiskit-Paket natives Objekt handelt, können Sie result.get_counts und plot_histogram von Quiskit verwenden, um die Ergebnisse zu visualisieren. Damit sichergestellt ist, dass alle möglichen Bitzeichenfolgen-Bezeichnungen dargestellt werden, fügen Sie sie zu counts hinzu.

counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

{'000': 50, '001': 0, '010': 0, '011': 0, '100': 0, '101': 0, '110': 0, '111': 50}

Ergebnis der Qiskit-Schaltung im IonQ-Simulator

Schätzen der Auftragskosten

Bevor Sie einen Auftrag auf der tatsächlichen Quantenhardware oder einer Quantenverarbeitungseinheit (Quantum Processing Unit , QPU) ausführen, können Sie abschätzen, wie viel es kostet.

Rufen Sie zunächst erneut die Liste der verfügbaren Anbieter ab:

print("This workspace's targets:")
for backend in provider.backends():
    print("- " + backend.name())

This workspace's targets:
- ionq.qpu
- ionq.simulator
- ionq.qpu.aria-1
- microsoft.estimator
- quantinuum.qpu.h1-1
- quantinuum.sim.h1-1sc
- quantinuum.sim.h1-1e
- rigetti.sim.qvm
- rigetti.qpu.ankaa-2

Erstellen Sie als Nächstes ein Objekt, das den IonQ-Quantencomputer darstellt:

qpu_backend = provider.get_backend("ionq.qpu")

Um die Kosten für die Ausführung eines Auftrags auf der QPU zu schätzen, fügen Sie eine neue Zelle hinzu, und führen Sie sie mithilfe der estimate_cost Methode der Folgenden targetaus:

cost = qpu_backend.estimate_cost(circuit, shots=100)

print(f"Estimated cost: {cost.estimated_total}")

Dadurch werden die geschätzten Kosten in US-Dollar angezeigt.

Die aktuellen Preisdetails finden Sie unter Preise. Suchen Sie alternativ nach Ihrem Arbeitsbereich, und zeigen Sie die Preisoptionen auf dem Blatt Anbieter Ihres Arbeitsbereichs an.

Ausführen auf der IonQ-QPU

Nachdem Sie Ihren Auftrag erfolgreich auf dem IonQ-Simulator ausgeführt und die QPU-Kosten geschätzt haben, ist es an der Zeit, Ihren Schaltkreis auf der Hardware auszuführen.

Hinweis

Die zum Ausführen einer Schaltung auf der QPU erforderliche Zeit variiert je nach aktueller Warteschlangenzeit. Sie können die durchschnittliche Warteschlangenzeit für ein Objekt target anzeigen, indem Sie das Blatt "Anbieter " Ihres Arbeitsbereichs auswählen.

Verwenden Sie die gleiche run-Methode und die gleichen Vorgänge, die Sie zuvor mit der API-Validierung verwendet haben, um Ihren Auftrag zu übermitteln und zu überwachen:

# Submit the circuit to run on Azure Quantum
job = qpu_backend.run(circuit, shots=1024)
job_id = job.id()
print("Job id", job_id)

Wenn der Auftrag abgeschlossen ist, rufen Sie die Auftragsergebnisse wie zuvor ab, und zeigen Sie sie in einem Diagramm an:

result = job.result()
print(result)
counts = {format(n, "03b"): 0 for n in range(8)}
counts.update(result.get_counts(circuit))
print(counts)
plot_histogram(counts)

Job id 910b5ac8-98cd-11ec-b3ba-00155d5528cf
Job Status: job has successfully run
Result(backend_name='ionq.simulator', backend_version='1', qobj_id='Qiskit Sample - 3-qubit GHZ circuit', job_id='Job id 54e8c740-98d9-11ec-b382-00155d957f5d', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'0': 505, '1': 6, '2': 1, '3': 1, '4': 1, '5': 10, '6': 11, '7': 488}, probabilities={'0': 0.4932, '1': 0.0059, '2': 0.001, '3': 0.001, '4': 0.001, '5': 0.0098, '6': 0.0117, '7': 0.4766}), header=QobjExperimentHeader(name='Qiskit Sample - 3-qubit GHZ circuit', num_qubits='3', qiskit='True'))])
{'000': 505, '001': 6, '010': 1, '011': 1, '100': 1, '101': 10, '110': 11, '111': 488}

Ergebnis der Qiskit-Schaltung auf der IonQ-QPU

Wichtig

Das Übermitteln mehrerer Schaltungen in einem einzelnen Auftrag wird derzeit nicht unterstützt. Sie können allerdings die Methode backend.run 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())

Nächste Schritte