Compartir a través de

Introducción a las sesiones

Las sesiones son una característica clave de la computación cuántica híbrida que permite agrupar varios trabajos de computación cuántica. Una sesión es una agrupación lógica de uno o varios trabajos enviados a un único target. Cada sesión tiene un identificador único asociado a cada trabajo de esa sesión. Las sesiones son útiles cuando desea ejecutar varios trabajos de computación cuántica en secuencia, con la capacidad de ejecutar código clásico entre trabajos cuánticos.

En este artículo se explica la arquitectura de las sesiones en la computación cuántica híbrida y cómo crear una nueva sesión.

Requisitos previos

Para crear una sesión, necesita los siguientes 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 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

    o

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

¿Qué es una sesión?

En las sesiones, el recurso de proceso de cliente se puede mover a la nube, lo que da lugar a una menor latencia y a la capacidad de repetir la ejecución del circuito cuántico con distintos parámetros. Los trabajos se pueden agrupar lógicamente en una sesión y los trabajos de esa sesión se pueden priorizar en los trabajos que no son de sesión. Aunque los estados de cúbit no se conservan entre trabajos, una sesión permite tiempos de cola más cortos para trabajos y problemas de ejecución más largos.

Las sesiones permiten organizar varios trabajos de computación cuántica con la capacidad de ejecutar código clásico entre trabajos cuánticos. Podrá ejecutar algoritmos complejos para organizar y realizar un seguimiento mejor de los trabajos de computación cuántica individuales.

Un escenario de usuario clave en el que es posible que quiera combinar trabajos en una sesión es algoritmos cuánticos con parámetros , donde la salida de un trabajo de computación cuántica informa a los parámetros del siguiente trabajo de computación cuántica. Los ejemplos más comunes de este tipo de algoritmo son Variational Quantum Eigensolvers (VQE) y Quantum Approximate Optimization Algorithms (QAOA).

Hardware admitido

Las sesiones se admiten en todos los proveedores de hardware de computación cuántica. En algunos casos, los trabajos que se envían dentro de una sesión se les da prioridad en la cola de ese target. Para obtener más información, consulte Comportamiento de destino.

Creación de una sesión

Para crear una sesión, siga estos pasos:

En este ejemplo se muestra cómo crear una sesión con Q# código insertado mediante un Jupyter Notebook en Visual Studio Code (VS Code). También puede crear sesiones mediante un Python programa que invoque un programa adyacente Q# .

Nota:

Las sesiones se administran con Python, incluso cuando se está ejecutando código en línea Q#.

  1. En VS Code, abra el menú Ver y elija Paleta de comandos.

  2. Introduzca y seleccione Crear: Nuevo Jupyter Notebook.

  3. En la parte superior derecha, VS Code detectará y mostrará la versión de Python y el entorno virtual Python seleccionado para el cuaderno. Si tiene varios Python entornos, es posible que tenga que seleccionar un núcleo mediante el selector de núcleo ubicado en la parte superior derecha. Si no se detectó un entorno, consulte Jupyter Notebook en VS Code para detalles sobre la configuración.

  4. En la primera celda del cuaderno, ejecute el código siguiente:

    from qdk.azure import Workspace

workspace = Workspace(
    resource_id = "", # add your resource ID
    location = "", # add your location, for example "westus"
)

  5. Agregue una nueva celda en el cuaderno e importe el qsharpPython paquete:

    from qdk import qsharp

  6. Elija su cuántico target. En este ejemplo, target es el simulador de IonQ.

    target = workspace.get_targets("ionq.simulator")

  7. Seleccione las configuraciones del target perfil, ya sea Base, Adaptive_RIo Unrestricted.

    qsharp.init(target_profile=qsharp.TargetProfile.Base) # or qsharp.TargetProfile.Adaptive_RI, qsharp.TargetProfile.Unrestricted

    Nota:

    Adaptive_RI target actualmente se admiten trabajos de perfil en Quantinuum targets. Para más información, consulte Computación cuántica híbrida integrada.

  8. Escriba el Q# programa. Por ejemplo, el siguiente Q# programa genera un bit aleatorio. Para ilustrar el uso de argumentos de entrada, este programa toma un entero, ny una matriz de ángulos, angle, como entrada.

    %%qsharp
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;
}

  9. A continuación, creará una sesión. Supongamos que quiere ejecutar la GenerateRandomBit operación tres veces, por lo que se usa target.submit para enviar la Q# operación con los target datos y repetir el código tres veces: en un escenario real, puede que desee enviar diferentes programas en lugar del mismo código.

    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]

    Importante

    Cuando pasas argumentos como parámetros a la tarea, los argumentos están formateados en la expresión Q# cuando se llama a qsharp.compile. Esto significa que debe dar formato a los argumentos como Q# objetos. En este ejemplo, dado que los arrays en Python ya se muestran utilizando el formato [item0, item1, ...], los argumentos de entrada son compatibles con el formato Q#. En el caso de otras Python estructuras de datos, pueda necesitar más manejos para obtener los valores de cadena insertados en Q# de manera compatible.

  10. Una vez creada una sesión, puede usar workspace.list_session_jobs para recuperar una lista de todos los trabajos de la sesión. Para obtener más información, consulte Administración de sesiones.

Comportamiento objetivo

Cada proveedor de hardware cuántico define su propia heurística para administrar mejor la priorización de trabajos dentro de una sesión.

Quantinuum

Si decide enviar trabajos dentro de su sesión a Quantinuum target, su sesión tiene acceso exclusivo al hardware siempre que los trabajos se pongan en cola con un intervalo de un minuto entre cada uno. Después, los trabajos se aceptan y gestionan con la lógica de la puesta en cola y priorización estándar.

Contenido relacionado

  • Last updated on