Share via

Verwalten von Sitzungen

  • Artikel

In diesem Artikel erfahren Sie, wie Sie mit Sitzungen arbeiten. Mit Sitzungen können Sie einen oder mehrere Aufträge für eine einzelne gruppieren target, wodurch Sie Aufträge effektiv verwalten können. Weitere Informationen finden Sie unter Interaktives Quantencomputing: Sitzungen.

Hinweis

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

Abrufen von Sitzungen, Auflisten von Sitzungen und Auflisten von Aufträ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.

Get-Help BESCHREIBUNG
workspace.list_sessions() oder session.list_sessions() Ruft eine Liste aller Sitzungen in einem Quantum-Arbeitsbereich ab.
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) Rufen Sie eine Liste aller Aufträge in der Sitzung mit der ID sessionIdab. 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 unter Erste Schritte mit Sitzungen auszuführen, um eine neue Sitzung zu erstellen. Sie können Sitzungen jedoch 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 die status Keine ist. Um die status der Sitzung anzuzeigen, müssen Sie auch die Sitzung im Dienst erstellen.

  2. Zum Erstellen einer Sitzung im Dienst können Sie oder session.open()verwendenworkspace.open_session(session).

  3. Sie können die status und die Sitzungsdetails mit session.refresh()aktualisieren oder ein neues Sitzungsobjekt aus einer Sitzungs-ID abrufen.

    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)schließen.

  5. Um die Sitzung an einen targetanzufügen, 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 akzeptiert, 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.

Wenn Argumente als Parameter an den Auftrag übergeben werden, werden sie beim Aufrufen qsharp.compilevon als 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, angle, als 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 verschiedenen 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]

Da Arrays in Python in diesem Beispiel bereits als [item0, item1, ...] gedruckt werden, stimmen die Eingabeargumente mit der Q# Formatierung überein. Für andere Python-Datenstrukturen benötigen Sie möglicherweise mehr Behandlung, um die Zeichenfolgenwerte auf kompatible Weise in das Q# -Objekt einzufügen. Beispielsweise muss ein Q# Tupel in Klammern mit kommagetrennten Werten stehen.

Sitzungstimeouts

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

Hinweis

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

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 sie einen with -Block verwenden, um eine Sitzung zu erstellen.

#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 die status Fehler. Alle laufenden Aufträge werden abgebrochen.

Dieses Verhalten kann jedoch geändert werden, indem beim Erstellen der job_failure_policy=SessionJobFailurePolicy.CONTINUESitzung anstelle der Standardrichtlinie SessionJobFailurePolicy.ABORTfür Auftragsfehler angegeben wird. Wenn die Auftragsfehlerrichtlinie lautet CONTINUE, akzeptiert der Dienst weiterhin Aufträge. Die Sitzung meldet in diesem Fall eine status von Fehlern, die sich nach dem Schließen der Sitzung in Fehler ändert.

Wenn die Sitzung nie geschlossen wird und ein Timeout auftritt, ist die 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 an diesem Punkt zu vermeiden, zeigt das Programm, wie beim Erstellen der Sitzung hinzugefügt job_failure_policy=SessionJobFailurePolicy.CONTINUE wird.

#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 beacuse of CONTINUE policy
    target.submit(input_data=quil_program, name="Job 3")

Nächster Schritt

Integriertes Quantencomputing