Partilhar via

Como gerir sessões

  • Artigo

Neste artigo, você aprenderá a trabalhar com 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 Computação quântica interativa: sessões.

Nota

As sessões são gerenciadas com Python, mesmo quando se executa Q# código embutido. Para obter mais informações, consulte a seção "Q# + Python" de Introdução às sessões.

Recuperar sessões, listar sessões e listar trabalhos de 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.

Comando Description
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. No entanto, você 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}")

    Nota

    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 o , ou obtendo um novo objeto de sessão a session.refresh()partir de uma 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_sessiono .

  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 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.

open Microsoft.Quantum.Measurement;
open Microsoft.Quantum.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.

Nota

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

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

Próximo passo

Computação quântica integrada