Como gerenciar suas sessões

Em Azure Quantum, você pode agrupar vários trabalhos em um único destino para gerenciar efetivamente seus trabalhos. Isso é chamado de sessão. Para obter mais informações, consulte Introdução às sessões.

Neste artigo, você aprenderá a usar sessões para gerenciar manualmente seus trabalhos. Você também aprende sobre as políticas de falha de trabalho e como evitar tempos limite de sessão.

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 Azure Quantum espaço de trabalho. Para obter mais informações, consulte Como criar um Azure Quantum workspace.

• Um ambiente Python com Python e Pip instalado.

• A qdkPython biblioteca. Se você quiser usar Qiskit ou Cirq, então precisará instalar os extras azure e qiskit.

  pip install --upgrade "qdk[azure,qiskit]"
  

Monitore suas sessões

Você pode usar a folha Gerenciamento de trabalho no espaço de trabalho do 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. Escolha a folha Gerenciamento de trabalhos no workspace do Quantum.
2. Identificar os trabalhos do tipo Sessão. Nesse modo de exibição, você pode encontrar a ID Exclusiva de uma sessão na coluna Id e monitorar o Status da sessão. As sessões podem ter os seguintes status:
   • Aguardando: os trabalhos dentro da sessão estão em execução no momento.
   • Êxito: a sessão terminou com êxito.
   • Tempo Limite: se nenhum novo trabalho for enviado dentro da 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 terminará e relatará um status de Falha. Para mais informações, consulte Política de falhas de trabalho dentro das 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 seus status.

Recuperar e listar sessões

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

Por exemplo, o código a seguir define uma função que obtém uma sessão com um número mínimo de tarefas. Em seguida, para essa sessão, ela 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}")

Abrir ou fechar sessões manualmente

Para criar uma nova sessão, é uma prática recomendada seguir as etapas em Introdução às sessões. Caso queira criar sessões manualmente, escolha a guia do seu ambiente de desenvolvimento.

Passar argumentos em Q#

Se sua Q# operação usa argumentos de entrada, esses argumentos são passados durante o envio do trabalho, no qual o Python é o código. Isso significa que você precisa formatar seus argumentos como Q# objetos.

Quando você passa argumentos como parâmetros para o trabalho, os argumentos são formatados como código Q# quando qsharp.compile é chamado, portanto, os valores de Python precisam ser formatados em uma cadeia de caracteres como uma sintaxe Q# válida.

Considere o programa de Q# a seguir, que usa um inteiro, ne 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 a operação GenerateRandomBits três vezes com n=2 e ângulos diferentes. Você pode usar o código a seguir Python 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 os arrays em Python já estão impressos como [item0, item1, ...], os argumentos de entrada correspondem à formatação de Q#. Para outras Python estruturas de dados, talvez você precise de mais tratamento para inserir as strings no Q# de maneira compatível. Por exemplo, uma tupla Q# precisa estar entre parênteses com valores separados por vírgulas.

Tempos limite de sessão

Uma sessão atingirá o tempo limite se nenhum novo trabalho for enviado dentro da sessão por um período de 10 minutos. A sessão relata um status TimedOut. Para evitar essa situação, adicione um bloco de with usando backend.open_session(name="Name"), de modo que o close() de sessão seja invocado pelo serviço no final do bloco de código.

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 snippet de código mostra como usar um bloco with 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 falhas de trabalhos em sessões

A política padrão de uma sessão quando um trabalho falha é encerrar essa sessão. Se você enviar um trabalho adicional na mesma sessão, o serviço a rejeitará e a sessão reportará um status 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 job_failure_policy=SessionJobFailurePolicy.CONTINUE, em vez da SessionJobFailurePolicy.ABORTpadrão, ao criar a sessão. Quando a política de falha das tarefas é CONTINUE, o serviço continua a aceitar tarefas. A sessão relata um status de Falha(s) nesse caso, que será alterado para Falha assim que a sessão for encerrada.

Se a sessão nunca estiver 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 quando você cria 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

• Execução da computação quântica híbrida
• Introdução às sessões