Compartilhar via

Como gerenciar suas sessões

  • Artigo

Neste artigo, você aprenderá a gerenciar suas sessões. Com as sessões, você pode agrupar um ou mais trabalhos em um único target, o que permite gerenciar trabalhos com eficiência. Para obter mais informações, consulte Introdução às sessões.

Pré-requisitos

  • Uma conta do Azure com uma assinatura ativa. Se você não tiver uma conta do Azure, registre-se gratuitamente e inscreva-se para uma assinatura paga conforme o uso.

  • Um workspace do Azure Quantum. Para obter mais informações, confira Criar um workspace do Azure Quantum.

  • Um ambiente Python com Python e Pip instalados.

  • O pacote do Azure Quantum azure-quantum . Se você quiser usar o Qiskit ou o Cirq, você precisa instalar o azure-quantum pacote com as tags [qiskit] ou [cirq].

    pip install --upgrade azure-quantum[qiskit]

Observação

As sessões são gerenciadas com Python, mesmo ao executar Q# código embutido.

Sessões de monitoramento

Você pode usar a folha Gerenciamento de trabalhos em seu workspace Quantum para exibir todos os itens enviados de nível superior, incluindo sessões e trabalhos individuais que não estão associados a nenhuma sessão.

  1. Selecione a folha Gerenciamento de trabalhos em seu workspace do Quantum.
  2. Identifique os trabalhos do tipo Sessão. Nessa visualização, você pode ver o ID exclusivo de uma sessão na coluna ID e monitorar seu status. Os estados de uma sessão são:
    • Aguardando: Os trabalhos dentro da sessão estão sendo executados.
    • Êxito: A sessão foi encerrada com êxito.
    • Tempo limite: se nenhum novo trabalho for enviado na sessão por 10 minutos, essa sessão atingirá o tempo limite. Para obter mais informações, consulte Tempos limite de sessão.
    • Falha: se um trabalho em uma sessão falhar, essa sessão será encerrada e relatará um status de Falha. Para obter mais informações, consulte Política de falha de trabalho em sessões.
  3. Clique no nome de uma sessão para obter mais detalhes.
  4. Você pode ver a lista de Todos os trabalhos na sessão e monitorar seu status.

Sessões de recuperação e listagem

A tabela a seguir mostra os comandos do Python para obter a lista de todas as sessões e todos os trabalhos de uma determinada sessão.

Comando Descrição
workspace.list_sessions() ou session.list_sessions() Recupere uma lista de todas as sessões em um Quantum Workspace.
workspace.get_session(sessionId) ou session.get_session(sessionId) Recupere a sessão com ID sessionId. Cada sessão tem um ID exclusivo.
workspace.list_session_jobs(sessionId) ou session.list_session_jobs(sessionId) Recupere uma lista de todos os trabalhos na sessão com ID sessionId. Cada sessão tem um ID exclusivo.

Por exemplo, o código a seguir define uma função que obtém uma sessão com um número mínimo de trabalhos. Em seguida, para essa sessão, ele lista todos os trabalhos, o número total de trabalhos e os primeiros 10 trabalhos.

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étodos manuais de abertura/encerramento de sessões

Recomendamos seguir as etapas em Introdução às sessões para criar uma nova sessão. Você também pode criar sessões manualmente.

  1. Primeiro, crie um objeto 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}")

    Observação

    Neste ponto, a sessão só existe no cliente e você pode ver que o status é Nenhum. Para exibir o status da sessão, você também precisa criar a sessão no serviço.

  2. Para criar uma sessão no serviço, você pode usar workspace.open_session(session) ou session.open().

  3. Você pode atualizar o status e os detalhes da sessão com session.refresh()ou obtendo um novo objeto de sessão de um ID de sessão.

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

  4. Você pode fechar uma sessão com session.close() ou workspace.close_session(session).

  5. Para anexar a sessão a um target, você pode usar target.latest_session.

  6. Você pode aguardar a conclusão de uma sessão:

    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)

Passando argumentos em Q#

Se sua Q# operação usar argumentos de entrada, esses argumentos serão passados durante o envio do trabalho, que é o código Python. Isso significa que você precisa ter cuidado para formatar seus argumentos como Q# objetos.

Ao passar argumentos como parâmetros para o trabalho, eles são formatados como Q# código ao chamar qsharp.compile, portanto, os valores do Python precisam ser formatados em uma string como sintaxe válida Q# .

Considere o programa a seguir Q# , que recebe um inteiro, n, e uma matriz de ângulos, angle, como entrada.

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

Você deseja executar GenerateRandomBits a operação três vezes com n=2 ângulos diferentes. Você pode usar o código Python a seguir para enviar três trabalhos com ângulos diferentes.

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]

Neste exemplo, como as matrizes em Python já estão impressas como [item0, item1, ...], os argumentos de entrada correspondem à Q# formatação. Para outras estruturas de dados do Python, Q# você pode precisar de mais tratamento para inserir os valores de string no de maneira compatível. Por exemplo, uma Q# tupla deve estar entre parênteses com valores separados por vírgula.

Tempos limite da sessão

Uma sessão expira se nenhum novo trabalho for enviado dentro da sessão por 10 minutos. A sessão relata um status de TimedOut. Para evitar essa situação, adicione um with bloco usando backend.open_session(name="Name"), para que a sessão close() seja invocada pelo serviço no final do bloco de código.

Observação

Se houver erros ou bugs em seu programa, pode levar mais de 10 minutos para enviar um novo trabalho depois que todos os trabalhos anteriores na sessão forem concluídos.

Os snippets de código a seguir mostram um exemplo de uma sessão que atinge o tempo limite após 10 minutos porque nenhum novo trabalho é enviado. Para evitar isso, o próximo trecho de código mostra como usar um with bloco para criar uma sessão.

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

Política de falha de trabalho nas sessões

A política padrão para uma sessão quando um trabalho falha é encerrar essa sessão. Se você enviar um trabalho adicional na mesma sessão, o serviço o rejeitará e a sessão relatará um status de Falha. Todos os trabalhos em andamento são cancelados.

No entanto, esse comportamento pode ser alterado especificando uma política de falha de trabalho de , em vez do job_failure_policy=SessionJobFailurePolicy.CONTINUEpadrão SessionJobFailurePolicy.ABORT, ao criar a sessão. Quando a política de falha de trabalho é CONTINUE, o serviço continua a aceitar trabalhos. A sessão relata um status de Falha(s) nesse caso, que será alterado para Falha quando a sessão for fechada.

Se a sessão nunca for fechada e atingir o tempo limite, o status será TimedOut, mesmo que os trabalhos tenham falhado.

Por exemplo, o programa a seguir cria uma sessão com três trabalhos. O primeiro trabalho falha porque especifica "garbage" como dados de entrada. Para evitar o fim da sessão neste ponto, o programa mostra como adicionar job_failure_policy=SessionJobFailurePolicy.CONTINUE ao criar a sessão.

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

Conteúdo relacionado