Administración de las sesiones

En este artículo, aprenderá a administrar las sesiones. Con las sesiones, puede agrupar uno o varios trabajos en un solo target, lo que le permite administrar los trabajos de forma eficaz. Para obtener más información, consulte Introducción a las sesiones.

Requisitos previos

• 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 trabajo de Azure Quantum. Para más información, consulte Creación de un área de trabajo de Azure Quantum.

• Un entorno de Python con Python y Pip instalados.

• Paquete de Azure Quantum azure-quantum . Si desea usar Qiskit o Cirq, debe instalar el azure-quantum paquete con las etiquetas [qiskit] o [cirq].

  pip install --upgrade azure-quantum[qiskit] 
  

Nota:

Las sesiones se administran con Python, incluso cuando se ejecuta Q# código insertado.

Sesiones de supervisión

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 hoja Administración de trabajos en el área de trabajo de Quantum.
2. Identifique los trabajos de tipo Session. En esta vista, puede ver el identificador único de una sesión en el identificador de columna y supervisar su estado. Los estados de una sesión son:
   • En espera: se ejecutan trabajos dentro de la sesión.
   • 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 de un estado De error. Para obtener más información, consulte Directiva de error de trabajo 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 su estado.

Recuperación y enumeración de sesiones

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

Comando	Descripción
workspace.list_sessions() o session.list_sessions()	Recupere una lista de todas las sesiones de un área de trabajo de Quantum.
workspace.get_session(sessionId) o session.get_session(sessionId)	Recupere la sesión con el identificador sessionId. Cada sesión tiene un identificador único.
workspace.list_session_jobs(sessionId) o session.list_session_jobs(sessionId)	Recupere una lista de todos los trabajos de la sesión con el identificador sessionId. Cada sesión tiene un identificador único.

Por ejemplo, el código siguiente define una función que obtiene una sesión con un número mínimo de trabajos. 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}")

Métodos manuales de apertura y cierre de sesiones

Se recomienda seguir los pasos descritos en Introducción a las sesiones para crear una nueva sesión. También puede crear manualmente sesiones.

Q# + Python

1. En primer lugar, cree un 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:

   En este momento, la sesión solo existe en el cliente y puede ver que el estado es Ninguno. Para ver el estado de la sesión, también debe crear la sesión en el servicio.

2. Para crear una sesión en el servicio, puede usar workspace.open_session(session) o session.open().

3. Puede actualizar el estado y los detalles de la sesión con session.refresh()o obteniendo un nuevo objeto de sesión de un identificador de sesión.

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

4. Puede cerrar una sesión con session.close() o workspace.close_session(session).

5. Para adjuntar la sesión a , targetpuede usar target.latest_session.

6. Puede esperar a que se complete una sesión:

   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)
   

Qiskit

1. En primer lugar, importe las credenciales del área de trabajo de Azure Quantum.

   import os
   resource_id = os.environ.get("AZURE_QUANTUM_RESOURCE_ID")
   location = os.environ.get("AZURE_QUANTUM_LOCATION")
   

2. A continuación, creará un objeto Provider.

   from azure.quantum import Workspace
   from azure.quantum.qiskit import AzureQuantumProvider
   
   workspace = Workspace (
       resource_id = resource_id,
       location = location
   )
   
   provider = AzureQuantumProvider(workspace)
   

3. Cree un back-end cuántico mediante el target que desea usar. Por ejemplo, el código siguiente crea un back-end cuántico para el simulador de IonQ. Para más información, consulte Creación de un back-end de Azure Quantum.

   ionq_simulator_backend = provider.get_backend("ionq.simulator")
   provider_backend = ionq_simulator_backend
   backend_id = provider_backend.name()
   

4. Para crear un objeto de sesión, puede usar la .open_session función .

   from azure.quantum.job.session import Session, SessionJobFailurePolicy
   session = provider_backend.open_session(name="Azure Quantum Session",
   job_failure_policy=SessionJobFailurePolicy.CONTINUE) # optional, defaults to abort
   session.open()
   
   print("Creating session")
   

5. Para adjuntar la sesión creada manualmente al back-end cuántico, puede usar session = provider_backend.latest_session.

6. Puede recuperar los trabajos de la sesión mediante session.list(jobs).

7. Puede cerrar una sesión con session.close().

8. Puede esperar a que se complete una sesión:

   print("Waiting for jobs to complete")
   
   import time
   while (session.details.status != "Succeeded" and session.details.status != "Failed" and session.details.status != "TimedOut"):
     session.refresh()
     time.sleep(5)
   print("Session status: " + session.details.status)
   

Pasar argumentos en Q#

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

Al pasar argumentos como parámetros al trabajo, se les da formato como Q# código al llamar qsharp.compilea , por lo que los valores de Python deben dar formato a una cadena como sintaxis válida 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 siguiente código de 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 estructuras de datos de Python, es posible que necesite más control para obtener los valores de cadena insertados de Q# forma 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 agota el tiempo de espera si no se envía ningún nuevo trabajo dentro de la sesión durante 10 minutos. La sesión notifica un estado de 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.

Nota:

Si hay errores o errores en el programa, puede tardar más de 10 minutos en enviar un nuevo trabajo después de que se hayan completado todos los trabajos anteriores en la sesión.

Los fragmentos de código siguientes muestran un ejemplo de tiempo de espera de una sesión 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 error de trabajo 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 se agota el tiempo de espera, el estado es TimedOut incluso si se han producido errores en los trabajos.

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