Erste Schritte mit Sitzungen

Sitzungen sind ein wichtiges Feature von hybridem Quantencomputing, mit dem Sie mehrere Quantencomputingaufträge zusammen gruppieren können. 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. Sitzungen sind nützlich, wenn Sie mehrere Quantencomputing-Aufträge in Sequenz ausführen möchten, mit der Fähigkeit, klassischen Code zwischen Quantenaufträgen auszuführen.

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.
Ein Azure Quantum Arbeitsbereich. Weitere Informationen finden Sie unter Erstellen eines Azure Quantum Arbeitsbereichs.
Eine Python-Umgebung mit installiertem Python und Pip.
Die qdkPython Bibliothek. Wenn Sie Qiskit oder Cirq verwenden möchten, müssen Sie die Extras azure und qiskit installieren.
```
pip install --upgrade qdk
```
oder
```
pip install --upgrade "qdk[azure,qiskit]" 
```

Was ist eine Sitzung?

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 von allen Anbietern von Quantencomputing-Hardware 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 Zielverhalten.

So erstellen Sie eine Sitzung

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

In diesem Beispiel wird gezeigt, wie Sie eine Sitzung mit Q# Inlinecode mithilfe eines Jupyter Notebook in Visual Studio Code (VS 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 Q# Inlinecode ausgeführt wird.

VS CodeÖffnen Sie im Menü "Ansicht" das Menü "Ansicht", und wählen Sie "Befehlspalette" aus.
Geben Sie die Eingabetaste ein, und wählen Sie "Erstellen: Neu" Jupyter Notebookaus.
Oben rechts erkennt und zeigt VS Code die Version von Python und der virtuellen Python Umgebung an, die für das Notebook 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, sehen Sie in Jupyter Notebooks VS Code nach, um Informationen zur Einrichtung zu erhalten.

Führen Sie in der ersten Zelle des Notizbuchs den folgenden Code aus:

from qdk.azure import Workspace

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

Fügen Sie eine neue Zelle im Notizbuch hinzu, und importieren Sie das qsharpPython Paket:
```
from qdk import qsharp
```
Wählen Sie Ihr Quantum targetaus. In diesem Beispiel ist der target der IonQ-Simulator.
```
target = workspace.get_targets("ionq.simulator")
```
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_RI target Profilaufträge werden derzeit auf Quantinuum targetsunterstützt. Weitere Informationen finden Sie unter Integrated Hybrid Quantum Computing.

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

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

Wenn Sie Argumente als Parameter an den Auftrag übergeben, werden die Argumente in den Q# Ausdruck formatiert, wenn qsharp.compile aufgerufen wird. Dies bedeutet, dass Sie Ihre Argumente als Q# Objekte formatieren müssen. In diesem Beispiel werden die Arrays in Python bereits als [item0, item1, ...] gedruckt, daher stimmen die Eingabeargumente mit der Q#-Formatierung überein. Bei anderen Python Datenstrukturen benötigen Sie möglicherweise mehr Aufwand, um die Zeichenfolgenwerte auf eine mit Q# kompatible Weise einzufügen.
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.

Importieren sie zusätzliche Module aus azure-quantum und qiskit.

from qdk.qiskit import QuantumCircuit
from qdk.azure import Workspace
from azure.quantum.qiskit import AzureQuantumProvider

Erstellen Sie ein provider Objekt mit Ihren Quantum-Arbeitsbereichsinformationen.

workspace = Workspace(
            resource_id = "", # add your resource ID
            location = "") # add your location

provider = AzureQuantumProvider(workspace)

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

Erstellen Sie eine Back-End-Instanz mit dem Quantum target Ihrer Wahl. Legen Sie in diesem Beispiel Ihr target auf den IonQ-Simulator fest.
```
backend = provider.get_backend("ionq.simulator")
```

Erstellen Sie eine neue Sitzung. Angenommen, Sie möchten Ihren Quanten-Schaltkreis dreimal ausführen, damit Sie backend.run den Qiskit 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 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]

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

Erstellen Sie 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

Wählen Sie Ihr Quantum targetaus. In diesem Beispiel ist der target der IonQ-Simulator.

Hinweis

Cirq Schaltungen können nur IonQ oder Quantinuum targetsverwenden.
```
target = service.get_target("ionq.simulator")
```
Erstellen Sie eine neue Sitzung. Angenommen, Sie möchten Ihren Quanten-Schaltkreis 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]
```

Zielverhalten

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

Quantinuum

Wenn Sie sich entscheiden, innerhalb einer Sitzung Aufträge an ein Quantinuum target zu senden, hat Ihre Sitzung exklusiven Zugriff auf die Hardware, solange Sie innerhalb einer Minute nacheinander Aufträge in die Warteschlange stellen. Danach werden Ihre Aufträge mit der Standard-Warteschlangen- und Priorisierungslogik akzeptiert und behandelt.

Feedback

War diese Seite hilfreich?

Last updated on 2025-11-12