Como gerir as suas sessões

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 de forma eficaz. Para obter mais informações, consulte Introdução às sessões.

Pré-requisitos

• Uma conta do Azure com uma subscrição ativa. Se não tiver uma conta do Azure, registe-se gratuitamente e inscreva-se numa subscrição pré-paga.

• Um espaço de trabalho do Azure Quantum. Para obter mais informações, consulte Criar um espaço de trabalho do Azure Quantum.

• Um ambiente Python com Python e Pip instalados.

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

  pip install --upgrade azure-quantum[qiskit] 
  

Sessões de monitorização

Você pode usar a folha Gerenciamento de tarefas em seu 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. Selecione a folha Gerenciamento de tarefas no espaço de trabalho do Quantum.
2. Identifique os trabalhos do tipo Sessão. Nesta vista, pode ver o ID Exclusivo de uma Sessão na coluna ID e monitorizar o seu Estado. Os estados de uma sessão são:
   • Aguardando: Os trabalhos dentro da sessão estão sendo executados.
   • Êxito: A sessão terminou com êxito.
   • Tempo limite: Se nenhum novo trabalho for enviado dentro da sessão por 10 minutos, esse tempo limite da sessão expira. Para obter mais informações, consulte Tempos limite de sessão.
   • Falha: Se um trabalho dentro de uma sessão falhar, essa sessão termina e relata 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 dentro da sessão e monitorar seu status.

Recuperando e listando sessões

A tabela a seguir mostra os comandos Python para obter a lista de todas as sessões e todos os trabalhos para 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 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.

Passando argumentos para dentro Q#

Se sua Q# operação usa argumentos de entrada, esses argumentos sã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 cadeia de caracteres como sintaxe válida Q# .

Considere o seguinte Q# programa, que usa 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 e ângulos diferentes. Você pode usar o seguinte código 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 matrizes em Python já são impressas como [item0, item1, ...], os argumentos de entrada correspondem à Q# formatação. Para outras estruturas de dados Python, você pode precisar de mais manipulação para obter os valores de cadeia de caracteres inseridos Q# no de forma compatível. Por exemplo, uma Q# tupla tem de 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 , para backend.open_session(name="Name")que a sessão close() seja invocada pelo serviço no final do bloco de código.

Os trechos de código a seguir mostram um exemplo de tempo limite de uma sessão 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 em 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 dentro da 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 job_failure_policy=SessionJobFailurePolicy.CONTINUE, em vez do padrã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 mudará 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údos relacionados

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