Erste Schritte mit Sitzungen

Sitzungen sind ein wichtiges Feature von hybridem Quantencomputing, mit dem Sie mehrere Quantencomputingaufträge zusammen gruppieren können.

In diesem Artikel wird die Architektur von Sitzungen in Hybrid Quantum Computing und die Erstellung einer neuen Sitzung erläutert.

Voraussetzungen

Zum Erstellen einer Sitzung benötigen Sie die folgenden 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.

• Eine Python-Umgebung mit installiertem Python und Pip.

• Das Azure Quantum-Paket azure-quantum . Wenn Sie Qiskit oder Cirq verwenden möchten, müssen Sie das azure-quantum Paket mit den Tags [qiskit] oder [cirq] installieren.

  pip install --upgrade azure-quantum[qiskit] 
  

Was ist eine Sitzung?

Eine Sitzung ist eine logische Gruppierung einer oder mehrerer Aufträge, die an einen einzelnen targetgesendet werden. Jede Sitzung verfügt über eine eindeutige ID, die an jeden Auftrag in dieser Sitzung angefügt ist.

In Sitzungen kann die Client-Computeressource in die Cloud verschoben werden, was zu geringerer Latenz und der Möglichkeit führt, die Ausführung des Quantenkreises mit verschiedenen Parametern zu wiederholen. Aufträge können logisch in einer Sitzung gruppiert werden, und die Aufträge in dieser Sitzung können über Nichtsitzungsaufträge priorisiert werden. Obwohl die Qubit-Zustände nicht zwischen Aufträgen bestehen, ermöglicht eine Sitzung kürzere Warteschlangenzeiten für Aufträge und längere Ausführungsprobleme.

Sitzungen ermöglichen es Ihnen, mehrere Quantencomputingaufträge mit der Möglichkeit zu organisieren, klassischen Code zwischen Quantenaufträgen auszuführen. Sie können komplexe Algorithmen ausführen, um Ihre individuellen Quantencomputingaufträge besser zu organisieren und nachzuverfolgen.

Ein wichtiges Benutzerszenario, in dem Sie Aufträge in einer Sitzung kombinieren möchten, ist parametrisierte Quantenalgorithmen, bei denen die Ausgabe eines Quantencomputingauftrags die Parameter des nächsten Quantencomputingauftrags informiert. Die häufigsten Beispiele für diesen Algorithmustyp sind Variational Quantum Eigensolvers (VQE) und Quantum Approximate Optimization Algorithms (QAOA).

Unterstützte Hardware

Sitzungen werden für alle Quantencomputing-Hardwareanbieter unterstützt. In einigen Fällen werden aufträge, die innerhalb einer Sitzung übermittelt werden, in der Warteschlange dieses targetVorgangs priorisiert. Weitere Informationen finden Sie unter Target Verhalten.

So erstellen Sie eine Sitzung

Führen Sie die folgenden Schritte aus, um eine Sitzung zu erstellen:

Q# + Python

In diesem Beispiel wird gezeigt, wie Sie eine Sitzung mit Q# Inlinecode mithilfe eines Jupyter-Notizbuchs in Visual Studio Code erstellen. Sie können auch Sitzungen mit einem Python-Programm erstellen, das ein angrenzendes Q# Programm aufruft.

Hinweis

Sitzungen werden mit Python verwaltet, auch wenn Inlinecode ausgeführt wird Q# .

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 von Python und 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 .

3. Führen Sie in der ersten Zelle des Notizbuchs

   import azure.quantum
   
   workspace = azure.quantum.Workspace(
       resource_id = "", # add your resource ID
       location = "", # add your location, for example "westus"
   )
   

4. Klicken Sie auf +Code , um eine neue Zelle im Notizbuch hinzuzufügen und Python SDK zu importieren qsharp .

   import qsharp
   

5. Wählen Sie das Quantum target Ihrer Wahl aus. In diesem Beispiel verwenden Sie den IonQ-Simulator als target.

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

6. Wählen Sie die Konfigurationen des target Profils, entweder Base, , Adaptive_RIoder Unrestricted.

   qsharp.init(target_profile=qsharp.TargetProfile.Base) # or qsharp.TargetProfile.Adaptive_RI, qsharp.TargetProfile.Unrestricted
   

   Hinweis

   Adaptive_RItarget Profilaufträge werden derzeit auf Quantinuum targetsunterstützt. Weitere Informationen finden Sie unter Integrated Hybrid Quantum Computing.

7. Schreiben Sie Ihr Q# Programm. Beispielsweise generiert das folgende Q# Programm ein zufälliges Bit. Um die Verwendung von Eingabeargumenten zu veranschaulichen, verwendet dieses Programm eine ganze Zahl nund ein Array von Winkeln angleals Eingabe.

   %%qsharp
   import Std.Measurement.*;
   import Std.Arrays.*;
   
   operation GenerateRandomBits(n: Int, angle: Double[]) : Result[] {
      use qubits = Qubit[n]; // n parameter as the size of the qubit array
      for q in qubits {
          H(q);
      }
      R(PauliZ, angle[0], qubits[0]); // arrays as entry-points parameters
      R(PauliZ, angle[1], qubits[1]);
      let results = MeasureEachZ(qubits);
      ResetAll(qubits);
      return results;
   }
   

8. Als Nächstes erstellen Sie eine Sitzung. Angenommen, Sie möchten den Vorgang dreimal ausführen GenerateRandomBit , sodass Sie target.submit den Vorgang mit den Q# target Daten übermitteln und den Code dreimal wiederholen – in einem realen Szenario möchten Sie möglicherweise verschiedene Programme anstelle desselben Codes übermitteln.

   angle = [0.0, 0.0]
   with target.open_session(name="Q# session of three jobs") as session:
       target.submit(input_data=qsharp.compile(f"GenerateRandomBits(2, {angle})"), name="Job 1", shots=100) # First job submission
       angle[0] += 1
       target.submit(input_data=qsharp.compile(f"GenerateRandomBits(2, {angle})"), name="Job 2", shots=100) # Second job submission
       angle[1] += 1
       target.submit(input_data=qsharp.compile(f"GenerateRandomBits(2, {angle})"), name="Job 3", shots=100) # Third job submission
   
   session_jobs = session.list_jobs()
   [session_job.details.name for session_job in session_jobs]
   

   Wichtig

   Beim Übergeben von Argumenten als Parameter an den Auftrag werden sie beim Aufrufen qsharp.compilein den Q# Ausdruck formatiert. Dies bedeutet, dass Sie darauf achten müssen, ihre Argumente als Q# Objekte zu formatieren. In diesem Beispiel, da Arrays in Python bereits als [Element0, Element1, ...] gedruckt werden, stimmen die Eingabeargumente mit der Q# Formatierung überein. Für andere Python-Datenstrukturen benötigen Sie möglicherweise mehr Handhabung, um die Zeichenfolgenwerte auf Q# kompatible Weise abzurufen.

9. Nachdem Sie eine Sitzung erstellt haben, können workspace.list_session_jobs Sie eine Liste aller Aufträge in der Sitzung abrufen. Weitere Informationen finden Sie unter Verwalten von Sitzungen.

Qiskit

1. Zunächst müssen Sie zusätzliche Module aus azure-quantum und qiskitimportieren. Erstellen Sie als Nächstes ein provider Objekt mit Ihren Quantum-Arbeitsbereichsinformationen.

   from qiskit import QuantumCircuit
   from azure.quantum import Workspace
   from azure.quantum.qiskit import AzureQuantumProvider
   
   workspace = Workspace(
               resource_id = "", # add your resource ID
               location = "") # add your location
   
   provider = AzureQuantumProvider(workspace)
   

2. Schreiben Sie Ihren Quantenkreis. Beispielsweise generiert der folgende Schaltkreis ein zufälliges Bit.

   circuit = QuantumCircuit(2, 2)
   circuit.name = "GenerateRandomBit"
   circuit.h(0)
   circuit.cx(0,1)
   circuit.measure([0,1], [0,1])
   circuit.draw()
   

3. Erstellen Sie als Nächstes eine Back-End-Instanz mit dem Quantum target Ihrer Wahl. Legen Sie in diesem Beispiel den IonQ-Simulator als den target.

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

4. Erstellen Sie als Nächstes eine Sitzung. Angenommen, Sie möchten Ihre Quantenschaltung dreimal ausführen, damit Sie backend.run den Qiskit-Schaltkreis übermitteln und den Code dreimal wiederholen – in einem realen Szenario können Sie verschiedene Programme anstelle desselben Codes übermitteln. Sie können workspace.list_session_jobs eine Liste aller Aufträge in der Sitzung abrufen. Weitere Informationen finden Sie unter Verwalten von Sitzungen.

   with backend.open_session(name="Qiskit Session") as session:
       job1 = backend.run(circuit=circuit, shots=100, job_name="Job 1") # First job submission
       job1.wait_for_final_state()
       job2 = backend.run(circuit=circuit, shots=100, job_name="Job 2") # Second job submission
       job2.wait_for_final_state()
       job3 = backend.run(circuit=circuit, shots=100, job_name="Job 3") # Third job submission
       job3.wait_for_final_state()
   
   session_jobs = session.list_jobs()
   [session_job.details.name for session_job in session_jobs]
   

Cirq

1. Schreiben Sie zuerst Ihren Quantenkreis. Beispielsweise generiert der folgende Schaltkreis ein zufälliges Bit.

   import cirq
   
   q0 = cirq.LineQubit(0)
   q1 = cirq.LineQubit(1)
   circuit = cirq.Circuit(
       cirq.H(q0),  # H gate
       cirq.CNOT(q0, q1),
       cirq.measure(q0, key='q0'),
       cirq.measure(q1, key='q1')
   )
   print(circuit)
   

2. Erstellen Sie dann ein service Objekt mit Ihren Quantum-Arbeitsbereichsinformationen.

   from azure.quantum.cirq import AzureQuantumService
   
   service = AzureQuantumService(
               resource_id = "", # add your resource ID
               location = "") # add your location
   

3. Wählen Sie das Quantum target Ihrer Wahl aus. In diesem Beispiel verwenden Sie den IonQ-Simulator als target.

   Hinweis

   Zirq-Schaltkreise können nur IonQ oder Quantinuum targetsverwenden.

   target = service.get_target("ionq.simulator")
   

4. Als Nächstes erstellen Sie eine Sitzung. Angenommen, Sie möchten Ihre Quantenschaltung dreimal ausführen, damit Sie target.submit den Cirq-Schaltkreis übermitteln und den Code dreimal wiederholen – in einem realen Szenario möchten Sie möglicherweise verschiedene Programme anstelle desselben Codes übermitteln. Sie können workspace.list_session_jobs eine Liste aller Aufträge in der Sitzung abrufen. Weitere Informationen finden Sie unter Verwalten von Sitzungen.

   with target.open_session(name="Cirq Session") as session:
       target.submit(program=circuit, name="Job 1", repetitions=100) # First job submission
       target.submit(program=circuit, name="Job 2", repetitions=100) # Second job submission
       target.submit(program=circuit, name="Job 3", repetitions=100) # Third job submission
   
   session_jobs = session.list_jobs()
   [session_job.details.name for session_job in session_jobs]
   

Verhalten von Target

Jeder Quantenhardwareanbieter definiert ihre eigenen Heuristiken, um die Priorisierung von Aufträgen innerhalb einer Sitzung optimal zu verwalten.

Quantinuum

Wenn Sie sich entscheiden, Aufträge innerhalb einer Sitzung an einen Quantinuum targetzu übermitteln, hat Ihre Sitzung exklusiven Zugriff auf die Hardware, solange Sie Aufträge innerhalb einer Minute voneinander in die Warteschlange stellen. Danach werden Ihre Aufträge mit der Standard-Warteschlangen- und Priorisierungslogik akzeptiert und verarbeitet.

Zugehöriger Inhalt

• So verwalten Sie Ihre Sitzungen
• Ausführen von Hybrid-Quantencomputing