Hantera dina sessioner

Artikel
10/24/2024

I den här artikeln får du lära dig hur du hanterar dina sessioner. Med sessioner kan du gruppera ett eller flera jobb mot ett enda target, vilket gör att du kan hantera jobb effektivt. Mer information finns i Komma igång med sessioner.

Förutsättningar

Ett Azure-konto med en aktiv prenumeration. Om du inte har något Azure-konto registrerar du dig kostnadsfritt och registrerar dig för en betala per användning-prenumeration.
En Azure Quantum-arbetsyta. Mer information finns i Skapa en Azure Quantum-arbetsyta.
En Python-miljö med Python och Pip installerade.
Azure Quantum-paketet azure-quantum . Om du vill använda Qiskit eller Cirq måste du installera azure-quantum paketet med taggarna [qiskit] eller [cirq].
```
pip install --upgrade azure-quantum[qiskit] 
```

Kommentar

Sessioner hanteras med Python, även när infogad kod körs Q# .

Övervakningssessioner

Du kan använda bladet Jobbhantering på din Quantum-arbetsyta för att visa alla objekt på den översta nivån, inklusive sessioner och enskilda jobb som inte är associerade med någon session.

Välj bladet Jobbhantering på din Quantum-arbetsyta.
Identifiera jobb av typen Session. I den här vyn kan du se unikt ID för en session i kolumn-ID och övervaka dess status. Tillstånden för en session är:
- Väntar: Jobb i sessionen körs.
- Lyckades: Sessionen har avslutats.
- Tidsgräns: Om inget nytt jobb skickas inom sessionen i 10 minuter överskrids tidsgränsen för sessionen. Mer information finns i Tidsgränser för sessioner.
- Misslyckades: Om ett jobb inom en session misslyckas avslutas sessionen och rapporterar statusen Failed (Misslyckades). Mer information finns i Policy för jobbfel i sessioner.
Klicka på en sessions namn för mer information.
Du kan se listan över Alla jobb i sessionen och övervaka deras status.

Hämta och visa sessioner

I följande tabell visas Python-kommandon för att hämta listan över alla sessioner och alla jobb för en viss session.

Kommando	beskrivning
`workspace.list_sessions()` eller `session.list_sessions()`	Hämta en lista över alla sessioner på en Kvantarbetsyta.
`workspace.get_session(sessionId)` eller `session.get_session(sessionId)`	Hämta sessionen med ID `sessionId`. Varje session har ett unikt ID.
`workspace.list_session_jobs(sessionId)` eller `session.list_session_jobs(sessionId)`	Hämta en lista över alla jobb i sessionen med ID `sessionId`. Varje session har ett unikt ID.

Följande kod definierar till exempel en funktion som hämtar en session med ett minsta antal jobb. För den sessionen visas sedan alla jobb, det totala antalet jobb och de första 10 jobben.

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}")

Manuella metoder för att öppna/stänga sessioner

Vi rekommenderar att du följer stegen i Kom igång med sessioner för att skapa en ny session. Du kan också skapa sessioner manuellt.

Q# + Python
Qiskit

Skapa först ett sessionsobjekt.

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}")

Kommentar

I det här läget finns sessionen bara på klienten och du kan se att statusen är Ingen. Om du vill visa status för sessionen måste du också skapa sessionen i tjänsten.

Om du vill skapa en session i tjänsten kan du använda workspace.open_session(session) eller session.open().
Du kan uppdatera statusen och sessionsinformationen med session.refresh(), eller genom att hämta ett nytt sessionsobjekt från ett sessions-ID.
```
same_session = workspace.get_session(session.id) 
print(f"Session: {session.details} \n")
print(f"Session: {same_session.details} \n")
```
Du kan stänga en session med session.close() eller workspace.close_session(session).
Om du vill koppla sessionen till en targetkan du använda target.latest_session.

Du kan vänta tills en session har slutförts:

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)

Importera först autentiseringsuppgifterna för din Azure Quantum-arbetsyta.

import os
resource_id = os.environ.get("AZURE_QUANTUM_RESOURCE_ID")
location = os.environ.get("AZURE_QUANTUM_LOCATION")

Sedan skapar du ett providerobjekt.

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

workspace = Workspace (
    resource_id = resource_id,
    location = location
)

provider = AzureQuantumProvider(workspace)

Du skapar en kvantserverdel med hjälp av den target du vill använda. Följande kod skapar till exempel en kvantserverdel för IonQ-simulatorn. Mer information finns i Skapa en Azure Quantum-serverdel.
```
ionq_simulator_backend = provider.get_backend("ionq.simulator")
provider_backend = ionq_simulator_backend
backend_id = provider_backend.name()
```

Om du vill skapa ett sessionsobjekt kan du använda .open_session funktionen.

from azure.quantum.job.session import Session, SessionJobFailurePolicy
session = provider_backend.open_session(name="Azure Quantum Session",
job_failure_policy=SessionJobFailurePolicy.CONTINUE) # optional, defaults to abort
session.open()

print("Creating session")

Om du vill koppla sessionen som skapats manuellt till kvantserverdelen kan du använda session = provider_backend.latest_session.
Du kan hämta jobben i sessionen med hjälp av session.list(jobs).
Du kan stänga en session med session.close().

Du kan vänta tills en session har slutförts:

print("Waiting for jobs to complete")

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

Skicka argument i Q#

Om åtgärden Q# tar indataargument skickas dessa argument under jobböverföringen, vilket är Python-kod. Det innebär att du måste vara noga med att formatera argumenten som Q# objekt.

När argument skickas som parametrar till jobbet formateras de som Q# kod när de anropar qsharp.compile, så värdena från Python måste formateras till en sträng som giltig Q# syntax.

Överväg följande Q# program, som tar ett heltal, n, och en matris med vinklar, angle, som indata.

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

Du vill köra GenerateRandomBits åtgärden tre gånger med n=2 och olika vinklar. Du kan använda följande Python-kod för att skicka tre jobb med olika vinklar.

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]

I det här exemplet, eftersom matriser i Python redan skrivs ut som [item0, item1, ...], matchar indataargumenten Q# formateringen. För andra Python-datastrukturer kan du behöva mer hantering för att få strängvärdena infogade Q# på ett kompatibelt sätt. En tupplar måste till exempel Q# vara inom parenteser med kommaavgränsade värden.

Tidsgränser för sessioner

En session överskrider tidsgränsen om inget nytt jobb skickas inom sessionen i 10 minuter. Sessionen rapporterar statusen TimedOut. För att undvika den här situationen lägger du till ett with block med , backend.open_session(name="Name")så att sessionen close() anropas av tjänsten i slutet av kodblocket.

Kommentar

Om det finns fel eller buggar i programmet kan det ta mer än 10 minuter att skicka ett nytt jobb efter att alla tidigare jobb i sessionen har slutförts.

Följande kodfragment visar ett exempel på en tidsgräns för sessionen efter 10 minuter eftersom inga nya jobb skickas. För att undvika det visar nästa kodfragment hur du använder ett with block för att skapa en session.

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

Princip för jobbfel inom sessioner

Standardprincipen för en session när ett jobb misslyckas är att avsluta sessionen. Om du skickar ytterligare ett jobb inom samma session avvisar tjänsten det och sessionen rapporterar statusen Misslyckades. Alla pågående jobb avbryts.

Det här beteendet kan dock ändras genom att ange en princip job_failure_policy=SessionJobFailurePolicy.CONTINUEför jobbfel i stället för standardinställningen SessionJobFailurePolicy.ABORTnär sessionen skapas. När jobbfelsprincipen är CONTINUEfortsätter tjänsten att acceptera jobb. Sessionen rapporterar statusen Fel i det här fallet, som ändras till Misslyckades när sessionen har stängts.

Om sessionen aldrig stängs och tidsgränsen överskrids är statusen TimedOut även om jobben har misslyckats.

Följande program skapar till exempel en session med tre jobb. Det första jobbet misslyckas eftersom det anger "garbage" som indata. För att undvika slutet av sessionen vid den här tidpunkten visar programmet hur du lägger job_failure_policy=SessionJobFailurePolicy.CONTINUE till när du skapar sessionen.

#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")

Dela via

Hantera dina sessioner

Förutsättningar

Övervakningssessioner

Hämta och visa sessioner

Manuella metoder för att öppna/stänga sessioner

Skicka argument i Q#

Tidsgränser för sessioner

Princip för jobbfel inom sessioner

Feedback

Ytterligare resurser

Dela via

Hantera dina sessioner

Förutsättningar

Övervakningssessioner

Hämta och visa sessioner

Manuella metoder för att öppna/stänga sessioner

Skicka argument i Q#

Tidsgränser för sessioner

Princip för jobbfel inom sessioner

Relaterat innehåll

Feedback

Ytterligare resurser