Administración de las sesiones

En Azure Quantum, puede agrupar varios trabajos en un único destino para administrar eficazmente sus trabajos. Esto se denomina sesión. Para obtener más información, consulte Introducción a las sesiones.

En este artículo, aprenderá a usar sesiones para gestionar los trabajos de forma manual. También obtendrá información sobre las políticas de errores del trabajo y cómo evitar los tiempos de espera en las sesiones.

Prerrequisitos

• Una cuenta de Azure con una suscripción activa. Si no tiene una cuenta de Azure, regístrese gratuitamente y regístrese para obtener una suscripción de pago por uso.

• Un área de Azure Quantum trabajo. Para obtener más información, consulte Creación de un Azure Quantum área de trabajo.

• Un entorno Python con Python y Pip instalado.

• La qdkPython biblioteca. Si desea usar Qiskit o Cirq, debe instalar los azure extras y qiskit .

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

Supervisión de las sesiones

Puede usar la hoja Administración de trabajos en el área de trabajo de Quantum para ver todos los elementos enviados de nivel superior, incluidas las sesiones y los trabajos individuales que no están asociados a ninguna sesión.

1. Seleccione la sección Administración de trabajos en el área de trabajo de Quantum.
2. Identifique los trabajos de tipo Session. En esta vista, puede encontrar el identificador único de una sesión en la columna Id y supervisar el estado de la sesión. Las sesiones pueden tener los siguientes estados:
   • En espera: los trabajos dentro de la sesión se están ejecutando actualmente.
   • Correcto: la sesión finalizó correctamente.
   • Tiempo de espera: si no se envía ningún nuevo trabajo dentro de la sesión durante 10 minutos, esa sesión agota el tiempo de espera. Para obtener más información, consulte Tiempos de espera de sesión.
   • Error: si se produce un error en un trabajo dentro de una sesión, esa sesión finaliza e informa del estado Error. Para obtener más información, consulte Política de fallo de trabajos en sesiones.
3. Haga clic en el nombre de una sesión para obtener más detalles.
4. Puede ver la lista de Todos los trabajos dentro de la sesión y supervisar sus estados.

Recuperar y enumerar sesiones

En la tabla siguiente se muestran los Python comandos para obtener la lista de todas las sesiones y todos los trabajos de una sesión determinada.

Por ejemplo, el código siguiente define una función que obtiene una sesión con un número mínimo de tareas. A continuación, para esa sesión, enumera todos los trabajos, el número total de trabajos y los primeros 10 trabajos.

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 o cerrar sesiones manualmente

Para crear una nueva sesión, se recomienda seguir los pasos descritos en Introducción a las sesiones. Si quiere crear sesiones manualmente en su lugar, elija la pestaña del entorno de desarrollo.

Pasar argumentos a Q#

Si la Q# operación toma argumentos de entrada, esos argumentos se pasan durante el envío del trabajo, que es Python código. Esto significa que debe dar formato a los argumentos como Q# objetos.

Cuando pasas argumentos como parámetros al trabajo, los argumentos se formatean como Q# de código cuando se llama a qsharp.compile, por lo que los valores de Python deben formatearse en una cadena como sintaxis válida de Q#.

Tenga en cuenta el siguiente Q# programa, que toma un entero, n, y una 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;
}

Quiere ejecutar la GenerateRandomBits operación tres veces con n=2 y diferentes ángulos. Puede usar el código siguiente Python para enviar tres trabajos con distintos ángulos.

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]

En este ejemplo, dado que las matrices de Python ya se imprimen como [item0, item1, ...], los argumentos de entrada coinciden con el Q# formato. Para otras Python estructuras de datos, podría necesitar más manipulación para insertar los valores de cadena en Q# de manera compatible. Por ejemplo, una Q# tupla debe estar entre paréntesis con valores separados por comas.

Tiempos de espera de sesión

Una sesión expira si no se envía ningún nuevo trabajo en 10 minutos. La sesión informa que el estado es TimedOut. Para evitar esta situación, agregue un with bloque mediante backend.open_session(name="Name"), por lo que el servicio invoca la sesión close() al final del bloque de código.

Los fragmentos de código siguientes muestran un ejemplo de una sesión que agota el tiempo de espera después de 10 minutos porque no se envían nuevos trabajos. Para evitarlo, el siguiente fragmento de código muestra cómo usar un with bloque para crear una sesión.

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

Directiva de fallo de tarea en sesiones

La directiva predeterminada para una sesión cuando se produce un error en un trabajo es finalizar esa sesión. Si envía un trabajo adicional dentro de la misma sesión, el servicio lo rechaza y la sesión notifica un estado De error. Los trabajos en curso se cancelan.

Sin embargo, este comportamiento se puede cambiar especificando una directiva de error de trabajo de job_failure_policy=SessionJobFailurePolicy.CONTINUE, en lugar del valor predeterminado SessionJobFailurePolicy.ABORT, al crear la sesión. Cuando la directiva de error del trabajo es CONTINUE, el servicio sigue aceptando trabajos. La sesión notifica un estado de Errores en este caso, que cambiará a Error una vez cerrada la sesión.

Si la sesión nunca se cierra y expira el tiempo de espera, el estado es TimedOut, incluso si los trabajos han fallado.

Por ejemplo, el siguiente programa crea una sesión con tres trabajos. Se produce un error en el primer trabajo porque especifica "garbage" como datos de entrada. Para evitar el final de la sesión en este momento, el programa muestra cómo agregar job_failure_policy=SessionJobFailurePolicy.CONTINUE al crear la sesión.

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

Contenido relacionado

• Ejecución de la computación cuántica híbrida
• Introducción a las sesiones