Desarrollar programas OpenQASM en el Microsoft Quantum Development Kit

El Microsoft Quantum Development Kit (QDK) proporciona diferentes entornos de desarrollo para programas de OpenQASM con integración de Azure Quantum. En este artículo, aprenderá a desarrollar y ejecutar OpenQASM código en:

  • Extensión QDK en Visual Studio Code (VS Code)
  • Paquete QDK Python en Jupyter Notebook.

Las herramientas de desarrollo como CodeLends, IntelliSense, autocompletado de código y depuración de puntos de parada solo están disponibles en la extensión VS Code. Otras características solo están disponibles en el paquete Python. Por ejemplo, puede pasar Q# y OpenQASM invocables como objetos Python y compilar programas OpenQASM que llevan entradas a QIR.

Prerrequisitos

  • Instalación de la versión más reciente de VS Code

  • Para trabajar directamente con OpenQASM archivos, instale la versión más reciente de la QDK extensión en VS Code.

  • Para trabajar con OpenQASM en Python y Jupyter Notebook, instale la versión más reciente de la extensión Python y la extensión Jupyter en VS Code.

  • Instale la versión más reciente del qdk paquete de Python con el jupyter adicional:

    pip install --upgrade "qdk[jupyter]"

Trabajar con OpenQASM en VS Code mediante la QDK extensión

Para escribir OpenQASM código en VS Code, abra un proyecto de Q# y cree un archivo OpenQASM con la extensión .qasm. El QDK reconoce automáticamente el .qasm archivo como OpenQASMy las QDK características de OpenQASM están disponibles a medida que escribe el código.

Las siguientes características QDK están disponibles para programas OpenQASM en VS Code:

  • Finalización de código
  • Lentes de código (Run, Histogram, Estimate, Debug y Circuit)
  • Resaltado de sintaxis y características básicas de sintaxis, como la coincidencia de llaves de apertura
  • Comprobación de errores en los archivos de origen OpenQASM
  • Depuración de puntos de interrupción y ejecución de scripts para archivos de origen de OpenQASM
  • Depuración con generación de circuitos en directo
  • Integración con Azure Quantum para la presentación de trabajos cuánticos

Para ejecutar el programa OpenQASM desde VS Code, puede usar el simulador local de /QDK o puede enviar el código como trabajo a Azure Quantum.

Ejecución del código en el QDK simulador local

Para ejecutar el código OpenQASM en el simulador cuántico disperso local en VS Code, abra un archivo .qasm y, a continuación, seleccione el comando Ejecutar en la lente de código al principio del archivo. La salida del programa se muestra en el VS Code terminal.

Nota:

El QDK intenta configurar automáticamente un perfil QIR target que sea compatible con su programa. Si el perfil de QIR target no admite operaciones en su programa, recibirá errores del compilador al ejecutar su código OpenQASM. Para obtener más información sobre los perfiles de target, consulte Tipos de perfiles de target en Azure Quantum.

Programas de ejemplo integrados

QDK incluye varios ejemplos de algoritmo cuántico integrados para OpenQASM. Para probar los algoritmos de ejemplo, escriba sample en un archivo vacío .qasm . Aparece una lista de finalización que contiene los algoritmos de ejemplo. Elija un ejemplo y ejecute el código generado.

Depuración local en VS Code

QDK incluye un depurador para OpenQASM. El depurador admite la depuración de tipo puntos de interrupción y es capaz de representar el estado del programa.

Para iniciar el depurador, seleccione el comando Depurar en la lente de código.

En el modo de depuración, puede establecer puntos de interrupción en el código para ayudarle a depurar. El estado del programa se muestra en el panel EJECUTAR Y DEPURAR . Por ejemplo, puede ver los estados de las variables locales y los estados de cúbit.

Ejecute el código en Azure Quantum

Para ejecutar programas OpenQASM en Azure Quantumtargets, necesita un espacio de trabajo Azure Quantum. Para crear un Azure Quantum área de trabajo, consulte Creación de un Azure Quantum área de trabajo.

Para enviar tareas de OpenQASM a Azure Quantum desde VS Code, debe conectarse a su espacio de trabajo de Azure Quantum. Para conectarse al área de trabajo desde VS Code, consulte Conectarse con una cadena de conexión.

Para enviar un OpenQASM trabajo a Azure Quantum desde VS Code, siga estos pasos:

  1. Abra el archivo qasm que contiene su programa en VS Code.
  2. Seleccione el icono Microsoft Quantum para abrir el panel Microsoft Quantum.
  3. Expanda la lista desplegable QUANTUM WORKSPACES (ÁREAS DE TRABAJO CUÁNTICAS ) y seleccione el área de trabajo.
  4. Despliegue el menú desplegable Proveedores y elija un proveedor; a continuación, elija el target en el que desea ejecutar su trabajo. Por ejemplo, envíe el trabajo al rigetti.svm.simtarget para ejecutar el programa en el simulador de back-end de Rigetti. Para obtener más información sobre el proveedor y target la disponibilidad, consulte Agregar o quitar un proveedor en un área de trabajo existente.
  5. Seleccione el icono de reproducción situado junto al target nombre.
  6. Para enviar la tarea, introduzca valores en los campos Nombre de la tarea y Número de capturas.

Para ver las horas y el estado de un trabajo, expanda la lista desplegable Trabajos y mantenga el puntero sobre el nombre del trabajo. Para descargar los resultados del trabajo, seleccione los iconos de histograma o texto junto al nombre del trabajo.

Trabajar con OpenQASM en Python y Jupyter Notebook

Con el QDK paquete de Python, puede ejecutar OpenQASM código directamente y pasar OpenQASM circuitos como operaciones a programas de Q#. Escriba su OpenQASM código como una cadena de Python y luego use esa cadena para ejecutar, importar o compilar su OpenQASM código en el entorno Python.

Ejecute OpenQASM directamente en Python

Para ejecutar OpenQASM código directamente, use la run función desde el qdk.openqasm módulo. Por ejemplo, el código siguiente ejecuta 10 tomas en el simulador local de un programa simple OpenQASM con ruido:

from qdk import BitFlipNoise
from qdk.openqasm import run

qasm_code = """
    include "stdgates.inc";
    qubit[2] q;
    reset q;
    h q[0];
    cx q[0], q[1];
    bit c = measure q[1];
    """

results = run(qasm_code, shots=10, noise=BitFlipNoise(0.1))
print(results)

Llamar a un programa OpenQASM en Q#

Puede usar la función para almacenar un programa /> :

from qdk import qsharp
from qdk.openqasm import import_openqasm

qasm_code = """
    include "stdgates.inc";
    qubit[2] q;
    reset q;
    h q[0];
    cx q[0], q[1];
    bit c = measure q[1];
    """

import_openqasm(qasm_code, name="bell")

Cuando bell forma parte de su entorno, puede ejecutarlo directamente desde una celda de Q#:

%%qsharp

use qs = Qubit[2];
bell(qs)

También puede usar la funcionalidad del QDK paquete con bell, como simulación ruidosa, representación de circuitos y generación de código.

Programas con parámetros OpenQASM

La celda siguiente crea un circuito OpenQASM que toma un ángulo theta como entrada y, a continuación, llama al circuito como una función de Python:

from qdk.openqasm import import_openqasm, ProgramType

qasm_code = """
    include "stdgates.inc";
    input float theta;
    qubit[2] q;
    rx(theta) q[0];
    rx(-theta) q[1];
    bit[2] c;
    c = measure q;
    """

import_openqasm(qasm_code, name="parameterized_circuit", program_type=ProgramType.File)

from qdk.code.qasm_import import parameterized_circuit

parameterized_circuit(1.57)

Pasar un OpenQASM programa a Q#

Con el QDK paquete de Python, puede pasar directamente un programa OpenQASM a un programa de Q#. Por ejemplo, el código siguiente crea un OpenQASM programa llamado Entangle y, a continuación, usa Entangle como una operación en un programa de Q#:

from qdk.openqasm import import_openqasm
from qdk import qsharp

qasm_code = """
    include "stdgates.inc";
    qubit[2] qs;
    h qs[0];
    cx qs[0], qs[1];
    """

import_openqasm(qasm_code, name="Entangle")

qsharp.eval("{ use qs = Qubit[2]; Entangle(qs); MResetEachZ(qs) }")

Al importar Q# e importar OpenQASM programas en un entorno de Python con qsharp.eval y import_openqasm, estos programas se convierten en objetos Python a los que puede llamar en el código de Python. Por ejemplo, el código siguiente crea un programa de Q# denominado TestAntiCorrelation y pasa el EntangleOpenQASM programa a TestAntiCorrelation:

qsharp.eval("""
    operation TestAntiCorrelation(entangler : Qubit[] => Unit) : Result[] {
        use qs = Qubit[2];
        X(qs[1]);
        entangler(qs);
        MResetEachZ(qs)
    }
    """)

from qdk.code import Entangle, TestAntiCorrelation

TestAntiCorrelation(Entangle)

Compilar programas OpenQASM en QIR

Puede compilar código de OpenQASM en Quantum Intermediate Representation (QIR) con la función compile.

Por ejemplo, la celda siguiente compila código para un circuito con parámetros OpenQASM en QIR:

from qdk import TargetProfile
from qdk.openqasm import import_openqasm, ProgramType
from qdk import qsharp

qsharp.init(target_profile=TargetProfile.Base)

qasm_code = """
    include "stdgates.inc";
    input float theta;
    qubit[2] q;
    rx(theta) q[0];
    rx(-theta) q[1];
    bit[2] c;
    c = measure q;
    """

import_openqasm(qasm_code, name="parameterized_circuit", program_type=ProgramType.File)

from qdk.code.qasm_import import parameterized_circuit

bound_compilation = qsharp.compile(parameterized_circuit, 1.57)
print(bound_compilation)

Nota:

Para compilar programas OpenQASM que aceptan variables de entrada en QIR, debe utilizar el paquete de Python QDK. No se pueden compilar programas parametrizados OpenQASM en QIR con la extensión QDK en VS Code.

Enviar OpenQASM programas a Azure Quantum

Para enviar un programa OpenQASM para que se ejecute en un(a) Azure Quantumtarget, compile el código OpenQASM a QIR y, a continuación, envíe el QIR para ejecutarlo en Azure Quantum.

Por ejemplo, compile un circuito de entrelazamiento simple en QIR.

from qdk.openqasm import compile

qasm_code = """
    include "stdgates.inc";
    bit[2] c;
    qubit[2] q;
    h q[0];
    cx q[0], q[1];
    c = measure q;
"""

qir_compilation = compile(qasm_code)

Para ejecutar un trabajo de QIR para Azure Quantum, conéctese a su espacio de trabajo cuántico y envíe el trabajo a uno de los targets disponibles en su espacio de trabajo. Por ejemplo, envíe el QIR de entrelazado para que se ejecute en el simulador de back-end IonQ.

from qdk.azure import Workspace 

workspace = Workspace(resource_id="") # Add the resource ID of your workspace

target = workspace.get_targets('ionq.simulator')
job = target.submit(qir_compilation, shots=100)

print("Job submitted. Waiting for results...")

results = job.get_results()
print(results)

Desarrollo continuo OpenQASM en QDK

La compatibilidad con OpenQASM en QDK está en curso.

Para obtener una lista de las características de OpenQASM que están en desarrollo en QDK, consulte Limitaciones y problemas conocidos en la wiki del repositorio de QDK GitHub.

  • Last updated on