Freigeben über

Verwalten von Sitzungen

  • Artikel

In diesem Artikel erfahren Sie, wie Sie mit Sitzungen arbeiten. Mit Sitzungen können Sie einen oder mehrere Aufträge anhand eines einzelnen targetAuftrags gruppieren, mit dem Sie Aufträge effektiv verwalten können. Weitere Informationen finden Sie unter Interactive Quantum Computing: Sessions.

Hinweis

Sitzungen werden mit Python verwaltet, auch wenn Inlinecode ausgeführt wird Q# . Weitere Informationen finden Sie im Abschnitt "Q# + Python" von "Erste Schritte mit Sitzungen".

Abrufen von Sitzungen, Listensitzungen und Listenaufträgen von Sitzungen

Die folgende Tabelle zeigt die Python-Befehle zum Abrufen der Liste aller Sitzungen und aller Aufträge für eine bestimmte Sitzung.

Befehl Beschreibung
workspace.list_sessions() oder session.list_sessions() Dient zum Abrufen einer Liste aller Sitzungen in einem Quantum Workspace.
workspace.get_session(sessionId) oder session.get_session(sessionId) Rufen Sie die Sitzung mit DER ID sessionIdab. Jede Sitzung verfügt über eine eindeutige ID.
workspace.list_session_jobs(sessionId) oder session.list_session_jobs(sessionId) Dient zum Abrufen einer Liste aller Aufträge in der Sitzung mit der ID sessionId. Jede Sitzung verfügt über eine eindeutige ID.

Der folgende Code definiert beispielsweise eine Funktion, die eine Sitzung mit einer Mindestanzahl von Aufträgen abruft. Anschließend werden für diese Sitzung alle Aufträge, die Gesamtzahl der Aufträge und die ersten 10 Aufträge aufgelistet.

def get_a_session_with_jobs(min_jobs):
    all_sessions = workspace.list_sessions() # list of all sessions
    for session in all_sessions:
        if len(workspace.list_session_jobs(session.id)) >= min_jobs:
            return session

session = get_a_session_with_jobs(min_jobs=3) # Get a Session with at least 3 jobs

session_jobs = workspace.list_session_jobs(session.id) # List of all jobs within Session ID

print(f"Job count: {len(session_jobs)} \n")
print(f"First 10 jobs for session {session.id}:")
for job in session_jobs[0:10]:
    print(f"Id: {job.id}, Name={job.details.name}")

Manuelle Methoden zum Öffnen/Schließen von Sitzungen

Es wird empfohlen, die Schritte in "Erste Schritte mit Sitzungen " auszuführen, um eine neue Sitzung zu erstellen. Sie können jedoch Sitzungen manuell erstellen.

  1. Erstellen Sie zunächst ein Session-Objekt.

    from azure.quantum.job.session import Session, SessionDetails, SessionJobFailurePolicy
import uuid

session = Session(
    workspace=workspace, # required
    id=f"{uuid.uuid1()}", # optional, if not passed will use uuid.uuid1()
    name="", # optional, will be blank if not passed
    provider_id="ionq", # optional, if not passed will try to parse from the target
    target="ionq.simulator", # required
    job_failure_policy=SessionJobFailurePolicy.ABORT # optional, defaults to abort
    )

print(f"Session status: {session.details.status}")

    Hinweis

    An diesem Punkt ist die Sitzung nur auf dem Client vorhanden, und Sie können sehen, dass der Status "Keine" lautet. Um den Status der Sitzung anzuzeigen, müssen Sie auch die Sitzung im Dienst erstellen.

  2. Um eine Sitzung im Dienst zu erstellen , können Sie diese verwenden workspace.open_session(session) oder session.open().

  3. Sie können den Status und die Sitzungsdetails mit session.refresh()oder durch Abrufen eines neuen Sitzungsobjekts aus einer Sitzungs-ID aktualisieren.

    same_session = workspace.get_session(session.id) 
print(f"Session: {session.details} \n")
print(f"Session: {same_session.details} \n")

  4. Sie können eine Sitzung mit session.close() oder workspace.close_session(session).

  5. Zum Anfügen der Sitzung an eine target, können Sie verwenden target.latest_session.

  6. Sie können warten , bis eine Sitzung abgeschlossen ist:

    session_jobs = session.list_jobs()
[session_job.id for session_job in session_jobs]

import time
while (session.details.status != "Succeeded" and session.details.status != "Failed" and session.details.status != "TimedOut"):
  session.refresh()
  time.sleep(5)

Übergeben von Argumenten in Q#

Wenn Ihr Q# Vorgang Eingabeargumente verwendet, werden diese Argumente während der Auftragsübermittlung übergeben, was Python-Code ist. Dies bedeutet, dass Sie darauf achten müssen, ihre Argumente als Q# Objekte zu formatieren.

Beim Übergeben von Argumenten als Parameter an den Auftrag werden sie beim Aufrufen qsharp.compileals Q# Code formatiert, sodass die Werte aus Python als gültige Q# Syntax in eine Zeichenfolge formatiert werden müssen.

Betrachten Sie das folgende Q# Programm, das eine ganze Zahl nund ein Array von Winkeln angleals Eingabe akzeptiert.

open Microsoft.Quantum.Measurement;
open Microsoft.Quantum.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;
}

Sie möchten den Vorgang dreimal mit n=2 und unterschiedlichen Winkeln ausführenGenerateRandomBits. Sie können den folgenden Python-Code verwenden, um drei Aufträge mit unterschiedlichen Winkeln zu ü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]

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. Ein Tupel muss z. B Q# . in Klammern mit kommagetrennten Werten enthalten sein.

Sitzungstimeouts

Ein Sitzungstimeout, wenn innerhalb der Sitzung 10 Minuten kein neuer Auftrag übermittelt wird. Die Sitzung meldet einen Status von TimedOut. Um diese Situation zu vermeiden, fügen Sie einen with Block hinzu backend.open_session(name="Name"), sodass die Sitzung close() vom Dienst am Ende des Codeblocks aufgerufen wird.

Hinweis

Wenn in Ihrem Programm Fehler oder Fehler auftreten, kann es mehr als 10 Minuten dauern, bis ein neuer Auftrag übermittelt wird, nachdem die vorherigen Aufträge in der Sitzung abgeschlossen wurden.

Die folgenden Codeausschnitte zeigen ein Beispiel für ein Sitzungstimeout nach 10 Minuten, da keine neuen Aufträge übermittelt werden. Um dies zu vermeiden, zeigt der nächste Codeausschnitt, wie ein with Block zum Erstellen einer Sitzung verwendet wird.

#Example of a session that times out 

session = backend.open_session(name="Qiskit circuit session") # Session times out because only contains one job
backend.run(circuit=circuit, shots=100, job_name="Job 1")

#Example of a session that includes a with block to avoid timeout

with backend.open_session(name="Qiskit circuit session") as session:  # Use a with block to submit multiple jobs within a 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()

Richtlinie für Auftragsfehler innerhalb von Sitzungen

Die Standardrichtlinie für eine Sitzung, wenn ein Auftrag fehlschlägt, besteht darin, diese Sitzung zu beenden. Wenn Sie einen zusätzlichen Auftrag innerhalb derselben Sitzung übermitteln, lehnt der Dienst ihn ab, und die Sitzung meldet den Status " Fehlgeschlagen". Alle laufenden Aufträge werden abgebrochen.

Dieses Verhalten kann jedoch geändert werden, indem beim Erstellen der Sitzung eine Auftragsfehlerrichtlinie angegeben job_failure_policy=SessionJobFailurePolicy.CONTINUEwird, anstelle der Standardeinstellung SessionJobFailurePolicy.ABORT. Wenn die Auftragsfehlerrichtlinie lautet CONTINUE, akzeptiert der Dienst weiterhin Aufträge. In diesem Fall meldet die Sitzung den Status "Fehler", der nach dem Schließen der Sitzung in "Fehlgeschlagen" geändert wird.

Wenn die Sitzung nie geschlossen wird und timeout ist, ist der Status "TimedOut ", auch wenn Aufträge fehlgeschlagen sind.

Das folgende Programm erstellt beispielsweise eine Sitzung mit drei Aufträgen. Der erste Auftrag schlägt fehl, da er als Eingabedaten angibt "garbage" . Um das Ende der Sitzung zu diesem Zeitpunkt zu vermeiden, zeigt das Programm, wie sie beim Erstellen der Sitzung hinzugefügt job_failure_policy=SessionJobFailurePolicy.CONTINUE werden.

#Example of a session that does not close but reports Failure(s) when a jobs fails

with target.open_session(name="JobFailurePolicy Continue", job_failure_policy=SessionJobFailurePolicy.CONTINUE) as session:
    target.submit(input_data="garbage", name="Job 1") #Input data is missing, this job fails
    target.submit(input_data=quil_program, name="Job 2") #Subsequent jobs are accepted because of CONTINUE policy
    target.submit(input_data=quil_program, name="Job 3")

Nächster Schritt

Integrierte Quantencomputing