Partager via

Comment gérer vos sessions

  • Article

Dans cet article, vous allez apprendre à gérer vos sessions. Avec des sessions, vous pouvez regrouper un ou plusieurs travaux sur un seul target, ce qui vous permet de gérer efficacement les travaux. Pour plus d’informations, consultez Prise en main des sessions.

Prérequis

  • Compte Azure avec un abonnement actif. Si vous n’avez pas de compte Azure, inscrivez-vous gratuitement et inscrivez-vous à un abonnement de paiement à l’utilisation.

  • Un espace de travail Azure Quantum. Pour plus d’informations, consultez Créer un espace de travail Azure Quantum.

  • Un environnement Python avec Python et Pip installés.

  • Package Azure Quantum azure-quantum . Si vous souhaitez utiliser Qiskit ou Cirq, vous devez installer le azure-quantum package avec les balises [qiskit] ou [cirq].

    pip install --upgrade azure-quantum[qiskit]

Remarque

Les sessions sont gérées avec Python, même lors de l’exécution Q# de code inline.

Sessions de supervision

Vous pouvez utiliser le panneau Gestion des travaux dans votre espace de travail Quantum pour afficher tous les éléments envoyés de niveau supérieur, y compris les sessions et les travaux individuels qui ne sont associés à aucune session.

  1. Sélectionnez le panneau Gestion des travaux dans votre espace de travail Quantum.
  2. Identifiez les travaux de type Session. Dans cette vue, vous pouvez voir l’ID unique d’une session dans l’ID de colonne et surveiller son état. Les états d’une session sont les suivants :
    • En attente : les travaux au sein de la session sont en cours d’exécution.
    • Réussite : la session s’est terminée avec succès.
    • Délai d’expiration : si aucun nouveau travail n’est envoyé dans la session pendant 10 minutes, cette session expire. Pour plus d’informations, consultez Délais d’expiration de session.
    • Échec : si un travail au sein d’une session échoue, cette session se termine et signale un état d’échec. Pour plus d’informations, consultez la stratégie d’échec du travail dans les sessions.
  3. Cliquez sur le nom d’une session pour plus d’informations.
  4. Vous pouvez voir la liste de tous les travaux au sein de la session et surveiller leur état.

Récupération et référencement des sessions

Le tableau suivant présente les commandes Python pour obtenir la liste de toutes les sessions et tous les travaux d’une session donnée.

Commande Description
workspace.list_sessions() ou session.list_sessions() Récupérez la liste de toutes les sessions d’un espace de travail Quantum.
workspace.get_session(sessionId) ou session.get_session(sessionId) Récupérez la session avec l’ID sessionId. Chaque session a un ID unique.
workspace.list_session_jobs(sessionId) ou session.list_session_jobs(sessionId) Récupérez une liste de tous les travaux de la session avec l’ID sessionId. Chaque session a un ID unique.

Par exemple, le code suivant définit une fonction qui obtient une session avec un nombre minimal de travaux. Ensuite, pour cette session, elle répertorie tous les travaux, le nombre total de travaux et les 10 premiers travaux.

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

Méthodes manuelles d’ouverture/fermeture de sessions

Nous vous recommandons de suivre les étapes de prise en main des sessions pour créer une session. Vous pouvez également créer manuellement des sessions.

  1. Tout d’abord, créez un objet Session.

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

    Remarque

    À ce stade, la session existe uniquement sur le client et vous pouvez voir que l’état est None. Pour afficher l’état de la session, vous devez également créer la session dans le service.

  2. Pour créer une session dans le service, vous pouvez utiliser workspace.open_session(session) ou session.open().

  3. Vous pouvez actualiser l’état et les détails de la session avec session.refresh(), ou en obtenant un nouvel objet de session à partir d’un ID de session.

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

  4. Vous pouvez fermer une session avec session.close() ou workspace.close_session(session).

  5. Pour attacher la session à un target, vous pouvez utiliser target.latest_session.

  6. Vous pouvez attendre la fin d’une session :

    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)

Passage d’arguments dans Q#

Si votre Q# opération prend des arguments d’entrée, ces arguments sont passés pendant l’envoi du travail, qui est du code Python. Cela signifie que vous devez être prudent pour mettre en forme vos arguments en tant qu’objets Q# .

Lors du passage d’arguments en tant que paramètres au travail, ils sont mis en forme en tant que Q# code lors de l’appel qsharp.compile. Par conséquent, les valeurs de Python doivent être mises en forme dans une chaîne comme syntaxe valide Q# .

Considérez le programme suivant Q# , qui prend un entier, net un tableau d’angles, anglecomme entrée.

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

Vous souhaitez exécuter l’opération GenerateRandomBits trois fois avec n=2 et différents angles. Vous pouvez utiliser le code Python suivant pour envoyer trois travaux avec des angles différents.

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]

Dans cet exemple, étant donné que les tableaux en Python sont déjà imprimés en tant que [item0, item1, ...], les arguments d’entrée correspondent à la Q# mise en forme. Pour d’autres structures de données Python, vous devrez peut-être gérer davantage pour obtenir les valeurs de chaîne insérées de manière Q# compatible. Par exemple, un Q# tuple doit être entre parenthèses avec des valeurs séparées par des virgules.

Délais d’expiration de session

Une session expire si aucun nouveau travail n’est envoyé dans la session pendant 10 minutes. La session signale un état de TimedOut. Pour éviter cette situation, ajoutez un with bloc à l’aide backend.open_session(name="Name"), de sorte que la session close() est appelée par le service à la fin du bloc de code.

Remarque

En cas d’erreurs ou de bogues dans votre programme, il peut prendre plus de 10 minutes pour envoyer un nouveau travail une fois les travaux précédents de la session terminés.

Les extraits de code suivants montrent un exemple de session expire après 10 minutes, car aucun nouveau travail n’est envoyé. Pour éviter cela, l’extrait de code suivant montre comment utiliser un with bloc pour créer une 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()

Stratégie d’échec de travail dans les sessions

La stratégie par défaut d’une session en cas d’échec d’un travail consiste à mettre fin à cette session. Si vous envoyez un travail supplémentaire au sein de la même session, le service le rejette et la session signale un état d’échec. Tous les travaux en cours sont annulés.

Toutefois, ce comportement peut être modifié en spécifiant une stratégie d’échec de travail , job_failure_policy=SessionJobFailurePolicy.CONTINUEau lieu de la stratégie par défaut SessionJobFailurePolicy.ABORT, lors de la création de la session. Lorsque la stratégie d’échec du travail est CONTINUE, le service continue d’accepter des travaux. La session signale l’état des échecs dans ce cas, ce qui passera à Échec une fois la session fermée.

Si la session n’est jamais fermée et expire, l’état est TimedOut même si les travaux ont échoué.

Par exemple, le programme suivant crée une session avec trois travaux. Le premier travail échoue, car il spécifie les "garbage" données d’entrée. Pour éviter la fin de la session à ce stade, le programme montre comment ajouter job_failure_policy=SessionJobFailurePolicy.CONTINUE lors de la création de la session.

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

Contenu connexe