Compartir a través de

Envío de programas de Q# con Visual Studio Code

  • Artículo

Aprenda a usar Visual Studio Code para crear y enviar programas de Q# al hardware cuántico real. Puede enviar trabajos de computación cuántica a Azure Quantum como un programa de Q# independiente, combinar Q# con Python en un proyecto de Q# y ejecutar un cuaderno de Jupyter Notebook.

Envío de trabajos de Q# a Azure Quantum

Aprenda a usar VS Code para ejecutar, depurar y enviar un programa de Q# a Azure Quantum.

Requisitos previos

Para obtener más información sobre la instalación, consulte Instalación del QDK en VS Code.

Carga de un programa de ejemplo de Q#

  1. En VS Code, seleccione Archivo > nuevo archivo de texto y guarde el archivo como RandomNum.qs.

  2. Abra RandomNum.qs y escriba sampley, a continuación, seleccione Ejemplo de bit aleatorio en la lista de opciones y guarde el archivo.

    Captura de pantalla del archivo Q# en Visual Studio Code que muestra la lista de ejemplos de código al escribir la palabra sample en el archivo.

Nota:

También puede abrir su propio archivo Q#. Si ejecuta un programa de Q# anterior y se produce un error, consulte Prueba y depuración.

Ejecución de un programa de Q#

  1. Para probar la ejecución del programa localmente en el simulador integrado, haga clic en Ejecutar en la lista de comandos junto a la operación de punto de entrada o presione Ctrl+F5. La salida aparecerá en la consola de depuración.

  2. Para depurar el programa antes de enviarlo a Azure Quantum, haga clic en Depurar en la lista de comandos junto a la operación de punto de entrada o presione F5. Use los controles de depuración de la parte superior para pasar, entrar y salir del código. Para obtener más información sobre la depuración de programas de Q#, vea Prueba y depuración.

    Captura de pantalla del archivo Q# en Visual Studio Code en la que se muestra dónde encontrar el objetivo de código con comandos de ejecución y depuración.

Visualización del histograma de frecuencia

El histograma de frecuencia representa la distribución de los resultados obtenidos de ejecutar un programa cuántico varias veces o "capturas". Cada barra del histograma corresponde a un posible resultado y su altura representa el número de veces que se observa el resultado. El histograma de frecuencia ayuda a visualizar la distribución de probabilidad de estos resultados.

  1. Seleccione Ver -> Paleta de comandos y escriba "histograma" que debe mostrar la opción Q#: Ejecutar archivo y mostrar histograma . También puede hacer clic en Histograma en la lista de comandos junto a la operación de punto de entrada. Seleccione esta opción para abrir la ventana histograma de Q#.

    Captura de pantalla del archivo Q# en Visual Studio Code que muestra dónde encontrar la lente de código con el comando histograma.

  2. Escriba una serie de capturas para ejecutar el programa, por ejemplo, 100 tomas y presione Entrar. El histograma se mostrará en la ventana histograma de Q#.

  3. Haga clic en el icono de configuración de la parte superior izquierda para mostrar las opciones.

    Captura de pantalla de la ventana histograma de Q# en Visual Studio Code en la que se muestra cómo mostrar la configuración.

  4. Haga clic en una barra para mostrar el porcentaje de ese resultado. En este caso, hay dos resultados posibles, 0 y 1, y el porcentaje de cada resultado está cerca del 50 %.

    Captura de pantalla de la ventana histograma de Q# en Visual Studio Code.

Sugerencia

Puede acercar el histograma mediante la rueda del mouse o un gesto del panel de seguimiento. Cuando se acerca, puede desplazar el gráfico presionando "Alt" mientras se desplaza.

Visualización del circuito cuántico

Los diagramas de circuitos cuánticos son una representación visual de las operaciones cuánticas. Muestran el flujo de cúbits a través del programa cuántico, incluidas las puertas y medidas aplicadas a ellos. Para obtener más información, consulte Diagramas de circuitos cuánticos en Visual Studio Code.

  1. Seleccione Ver -> Paleta de comandos y escriba "circuito" que debe abrir la opción Q#: Mostrar circuito . También puede hacer clic en Circuito en la lista de comandos junto a la operación de punto de entrada.

    Captura de pantalla del archivo Q# en Visual Studio Code que muestra dónde encontrar el comando del circuito de lente de código.

  2. El circuito se muestra en la ventana del circuito Q#. El diagrama de circuitos muestra un registro de cúbits que se inicializa en el estado |0⟩. A continuación, se aplica una puerta Hadamard, H, al cúbit, seguida de una operación de medición, que se representa mediante un símbolo de medidor. Para más información, consulte Convenciones de circuitos cuánticos.

    Captura de pantalla de la ventana del circuito Q# que muestra el diagrama del circuito resultante para la operación de bits aleatoria.

Conexión a Azure Quantum y envío del trabajo

Puede conectar y enviar trabajos directamente desde VS Code. En este ejemplo, enviará un trabajo al simulador de Rigetti.

  1. Seleccione Ver:> Paleta de comandos y escriba Q#: Conectarse a un área de trabajo de Azure Quantum. Presione ENTRAR.

  2. Seleccione Cuenta de Azure y siga las indicaciones para conectarse a su directorio, suscripción y área de trabajo preferidos.

    Nota:

    Si tiene un cadena de conexión, puede seleccionar Cadena de conexión y pegar el cadena de conexión correspondiente al área de trabajo de Azure Quantum. Para obtener más información, consulte Conexión a un área de trabajo de Quantum mediante un cadena de conexión.

  3. Una vez que esté conectado, en el panel Explorador , expanda Áreas de trabajo cuánticas.

  4. Expanda el área de trabajo y expanda el proveedor rigetti .

    Nota:

    Si hay un problema al conectarse a Azure Quantum, se muestra un icono de advertencia junto al nombre del área de trabajo. Mantenga el puntero sobre el nombre del área de trabajo para mostrar información de error.

  5. Seleccione rigetti.sim.qvm como .target

    Captura de pantalla de Visual Studio Code en la que se muestra cómo seleccionar El simulador de Rigetti como target.

  6. Seleccione el icono de reproducción situado a la derecha del target nombre para empezar a enviar el programa de Q# actual. Si recibe un elemento emergente, seleccione Cambiar el perfil de QIR target y continuar.

    Captura de pantalla de Visual Studio Code en la que se muestra cómo ejecutar el simulador de Rigetti como target.

  7. Agregue un nombre para identificar el trabajo.

  8. Agregue el número de tomas o el número de veces que se ejecuta el programa.

  9. Presione Entrar para enviar el trabajo. El estado del trabajo se mostrará en la parte inferior de la pantalla.

  10. Expanda Trabajos y mantenga el puntero sobre el trabajo, que muestra las horas y el estado del trabajo.

  11. Para ver los resultados, seleccione el icono de nube situado junto al nombre del trabajo para descargar los resultados del almacenamiento del área de trabajo y mostrarlos en VS Code.

    Captura de pantalla de Visual Studio Code en la que se muestra cómo descargar y ver los resultados del trabajo cuántico.

Envío de trabajos de Jupyter Notebook a Azure Quantum

Aprenda a usar VS Code para ejecutar, depurar y enviar un cuaderno de Jupyter Notebook de Q# a Azure Quantum. Los pasos de este artículo también se aplican a los cuadernos de Jupyter Notebook en el servidor o cuadernos de Jupyter Local en Azure Quantum Portal.

Requisitos previos

Para obtener más información sobre la instalación, consulte Instalación del QDK en VS Code.

Ejecución y prueba del programa en el simulador local

  1. En VS Code, seleccione Ver > Paleta de comandos y seleccione Crear: Nuevo Jupyter Notebook.

  2. En la parte superior derecha, VS Code detectará y mostrará la versión de Python y el entorno de Python virtual que se seleccionó para el cuaderno. Si tiene varios entornos de Python, es posible que tenga que seleccionar un kernel mediante el selector de kernel en la parte superior derecha. Si no se detectó ningún entorno, consulte Jupyter Notebooks in VS Code (Cuadernos de Jupyter Notebook en VS Code ) para obtener información de configuración.

  3. En la primera celda del cuaderno, ejecute el siguiente código de Python para importar los módulos necesarios:

    import qsharp
import azure.quantum
    • El qsharp módulo activa el %%qsharp comando magic que le permite escribir código de Q# directamente en una celda.
    • El azure-quantum módulo proporciona conectividad al área de trabajo de Azure Quantum.

    Nota:

    Si no se detecta el kernel ipykernel de Python de Jupyter, VS Code le pedirá que lo instale.

  4. Agregue otra celda y escriba este código de Q# que devuelve un número especificado por el usuario de bits aleatorios:

    Nota:

    Tenga en cuenta que tan pronto como escriba en el comando %%qsharpmagic , la celda del cuaderno cambia el tipo de Python a Q#.

    %%qsharp

operation Random() : Result {
    use q = Qubit();
    H(q);
    let result = M(q);
    Reset(q);
    return result
}

operation RandomNBits(N: Int): Result[] {
    mutable results = [];
    for i in 0 .. N - 1 {
        let r = Random();
        set results += [r];
    }
    return results
}

  5. Para probar la operación, puede usar el eval método , que puede llamar a cualquier operación de Q# definida anteriormente en el cuaderno:

    qsharp.eval("RandomNBits(4)")

    [Zero, One, One, Zero]

  6. Para ejecutar el programa en el simulador local, use el run método . Especifique el shots, o el número de veces que se va a ejecutar el programa y el simulador devuelve los resultados como una lista de Python.

    qsharp.run("RandomNBits(4)", shots=10)

    [[One, One, One, One],
[Zero, Zero, One, Zero],
[One, Zero, Zero, One],
[Zero, One, Zero, Zero],
[One, Zero, One, One],
[One, Zero, One, Zero],
[One, One, One, Zero],
[One, One, One, One],
[Zero, Zero, Zero, One],
[One, Zero, Zero, One]]

Visualización del circuito cuántico

Puede visualizar circuitos cuánticos mediante el qsharp-widgets paquete. Este paquete proporciona un widget que representa un diagrama de circuito cuántico como una imagen SVG. Para más información, consulte Diagramas de circuitos cuánticos con Cuadernos de Jupyter Notebook.

Agregue el código siguiente a una nueva celda para visualizar el circuito:

from qsharp_widgets import Circuit

Circuit(qsharp.circuit("RandomNBits(4)"))

Captura de pantalla de Jupyter Notebook en la que se muestra cómo visualizar el circuito para una operación de Q#.

Para más información, consulte Convenciones de circuitos cuánticos.

Compilación del trabajo mediante el perfil base

Al ejecutar programas en el simulador cuántico local, puede enviar cualquier tipo de programa de Q#. Sin embargo, el hardware targets de Azure Quantum aún no admite las funcionalidades completas necesarias para ejecutar todos los programas de Q#. Para compilar y enviar programas de Q# a Azure Quantum, debe establecer el target perfil para indicar a Q# qué funcionalidades admite el target hardware. Actualmente, es el perfil base. Para más información, consulte Tipos de perfil en Azure Quantum.

Para reinicializar el intérprete de Q# y compilar el programa con el perfil base:

  1. Use el init método para establecer el perfil:

    qsharp.init(target_profile=qsharp.TargetProfile.Base)

  2. Dado que reinicializó el intérprete, debe volver a ejecutar el código con el nuevo perfil:

    %%qsharp

operation Random() : Result {
    use q = Qubit();
    H(q);
    let result = M(q);
    Reset(q);
    return result
}

operation RandomNBits(N: Int): Result[] {
    mutable results = [];
    for i in 0 .. N - 1 {
        let r = Random();
        set results += [r];
    }
    return results
}

  3. A continuación, use el compile método para especificar la operación o función que es el punto de entrada del programa. Esto compila el código en formato QIR, que luego se puede enviar a cualquier hardware cuántico:

    MyProgram = qsharp.compile("RandomNBits(4)")

Conexión a Azure Quantum y envío del trabajo

Ahora que tiene el programa compilado en el formato correcto, cree un azure.quantum.Workspace objeto para conectarse a Azure Quantum. Usará el identificador de recurso del área de trabajo de Azure Quantum para conectarse. El identificador de recurso y la ubicación se pueden copiar de la página de información general del área de trabajo en Azure Portal.

  1. En una nueva celda, rellene el identificador de recurso y la ubicación del área de trabajo de Azure Quantum:

    MyWorkspace = azure.quantum.Workspace(
    resource_id = "MyResourceID",
    location = "MyLocation"
)

  2. Use el get_targets método para ver el hardware targets disponible en el área de trabajo:

    MyTargets = MyWorkspace.get_targets()
print("This workspace's targets:")
MyTargets

  3. Seleccione :rigetti.sim.qvmtarget

    MyTarget = MyWorkspace.get_targets("rigetti.sim.qvm")

  4. Por último, use el método para enviar el submit programa con sus parámetros y mostrar los resultados:

    job = MyTarget.submit(MyProgram, "MyQuantumJob", shots=100)
job.get_results()

    {'[0, 1, 1, 1]': 0.08,
 '[1, 1, 0, 0]': 0.1,
 '[0, 0, 1, 0]': 0.04,
 '[0, 1, 0, 0]': 0.05,
 '[1, 0, 1, 0]': 0.05,
 '[1, 0, 0, 0]': 0.07,
 '[0, 1, 0, 1]': 0.07,
 '[1, 0, 1, 1]': 0.07,
 '[0, 0, 0, 0]': 0.08,
 '[1, 1, 1, 0]': 0.05,
 '[0, 0, 0, 1]': 0.1,
 '[0, 0, 1, 1]': 0.04,
 '[0, 1, 1, 0]': 0.09,
 '[1, 0, 0, 1]': 0.04,
 '[1, 1, 1, 1]': 0.05,
 '[1, 1, 0, 1]': 0.02}

  5. Todas las propiedades del trabajo son accesibles en job.details, por ejemplo:

    print(job.details)
print("\nJob name:", job.details.name)
print("Job status:", job.details.status)
print("Job ID:", job.details.id)

    {'additional_properties': {'isCancelling': False}, 'id': '0150202e-9638-11ee-be2f-b16153380354', 'name': 'MyQuantumJob', 'provider_id': 'rigetti'...}
Job name: MyQuantumJob
Job status: Succeeded
Job ID: 0150202e-9638-11ee-be2f-b16153380354

Detalles adicionales del trabajo

El azure.quantum paquete de Python incluye métodos adicionales para mostrar datos de trabajo más detallados.

  • job.get_results_histogram(): este método devuelve un diccionario de los resultados y el recuento de capturas para cada medida única. Por ejemplo, los resultados del trabajo anterior serían

    print(job.get_results_histogram()) 

    {   
    '[0, 1, 1, 1]' : {'Outcome' : [0, 1, 1, 1], 'Count' : 8},  
    '[1, 1, 0, 0]' : {'Outcome' : [1, 1, 0, 0], 'Count' : 10},
    '[0, 0, 1, 0]' : {'Outcome' : [0, 0, 1, 0], 'Count' : 4},
    '[0, 1, 0, 0]' : {'Outcome' : [0, 1, 0, 0], 'Count' : 5},
    '[1, 0, 1, 0]' : {'Outcome' : [1, 0, 1, 0], 'Count' : 5},  
    '[1, 0, 0, 0]' : {'Outcome' : [1, 0, 0, 0], 'Count' : 7},
    '[0, 1, 0, 1]' : {'Outcome' : [0, 1, 0, 1], 'Count' : 7},
    '[1, 0, 1, 1]' : {'Outcome' : [1, 0, 1, 1], 'Count' : 7},
    '[0, 0, 0, 0]' : {'Outcome' : [0, 0, 0, 0], 'Count' : 8},  
    '[1, 1, 1, 0]' : {'Outcome' : [1, 1, 1, 0], 'Count' : 5},
    '[0, 0, 0, 1]' : {'Outcome' : [0, 0, 0, 1], 'Count' : 10},
    '[0, 0, 1, 1]' : {'Outcome' : [0, 0, 1, 1], 'Count' : 4},
    '[0, 1, 1, 0]' : {'Outcome' : [0, 1, 1, 0], 'Count' : 9},  
    '[1, 0, 0, 1]' : {'Outcome' : [1, 0, 0, 1], 'Count' : 4},
    '[1, 1, 1, 1]' : {'Outcome' : [1, 1, 1, 1], 'Count' : 5},
    '[1, 1, 0, 1]' : {'Outcome' : [1, 1, 0, 1], 'Count' : 2}
}

  • job.get_results_shots() : este método devuelve una lista de cada resultado de captura. Por ejemplo, los resultados del trabajo anterior serían

    print(job.get_results_shots()) 

    [ [0, 1, 1, 1], [1, 0, 1, 1], [0, 0, 1, 1], [1, 1, 0, 1], [1, 0, 0, 0], [1, 0, 1, 1], [1, 1, 0, 1], ...]

Envío de trabajos de Python con Q# a Azure Quantum

Aprenda a usar VS Code para escribir un programa de Python que llame a operaciones de Q#, conéctese a Azure mediante los comandos de Python o la CLI de Azure y envíe el trabajo.

Requisitos previos

Para obtener más información sobre la instalación, consulte Instalación del QDK en VS Code.

Creación e importación de las operaciones de Q#

Con el qsharp paquete, puede almacenar las funciones y las operaciones en archivos Q# y crear proyectos de Q# que le permitan llamar a cualquiera de ellos desde el código de Python. Esto resulta especialmente útil cuando necesita iniciar un programa que toma parámetros de entrada.

  1. Siga los pasos para crear un proyecto de Q#.

  2. Abra un nuevo archivo de texto, agregue el siguiente código Q# que devuelve un número especificado por el usuario de bits aleatorios y guarde el archivo en el directorio /src del proyecto como Source.qs.

    
    operation Random() : Result {
    use q = Qubit();
    H(q);
    let result = M(q);
    Reset(q);
    return result
}

operation RandomNBits(N: Int): Result[] {
    mutable results = [];
    for i in 0 .. N - 1 {
        let r = Random();
        set results += [r];
    }
    return results
}

  3. En la carpeta raíz del proyecto (con el archivo qsharp.json ), abra otro archivo y guárdelo como randomNum.py.

  4. Agregue el código siguiente para importar los qsharp módulos y azure.quantum .

    import qsharp
import azure.quantum

  5. A continuación, agregue código para definir la carpeta raíz del proyecto de Q# y probar la ejecución de la target operación en el simulador local. El espacio de nombres> llama a <la operación.<operation_name( )> y, en este caso, se pasa el número de bits aleatorios que se van a devolver.

    Nota:

    Dado que no se especificó ningún espacio de nombres en Source.qs, el compilador usa el nombre de archivo como espacio de nombres predeterminado: Source.RandomNBits(). Para obtener más información, vea Proyectos y espacios de nombres implícitos.

    qsharp.init(project_root = '../MyProjectRootFolder')
print(qsharp.eval("Source.RandomNBits(4)"))

    [Zero, One, One, Zero]

  6. También puede probar la operación con el run método , que pasa un parámetro adicional shots y devuelve los resultados en una lista de Python. En randomNum.py, reemplace la instrucción print anterior por lo siguiente:

    result = qsharp.run("Source.RandomNBits(4)", shots=10)
for x in result:
    print(x)

    [[One, One, One, One],
[Zero, Zero, One, Zero],
[One, Zero, Zero, One],
[Zero, One, Zero, Zero],
[One, Zero, One, One],
[One, Zero, One, Zero],
[One, One, One, Zero],
[One, One, One, One],
[Zero, Zero, Zero, One],
[One, Zero, Zero, One]]

Compilación del trabajo mediante el perfil base

Al ejecutar programas en el simulador cuántico local, puede enviar cualquier tipo de programa de Q#. Sin embargo, el hardware targets de Azure Quantum aún no admite las funcionalidades completas necesarias para ejecutar todos los programas de Q#. Para compilar y enviar programas de Q# a Azure Quantum, debe establecer el target perfil para indicar a Q# qué funcionalidades admite el target hardware. Actualmente, es el Base perfil o Adpative_RI . Para más información, consulte Tipos de perfil en Azure Quantum.

Nota:

En el caso de los programas de Q# solo en VS Code, VS Code establece el Base perfil automáticamente.

  1. Use el init método para establecer el perfil:

    qsharp.init(project_root = '../MyProjectRootFolder', target_profile=qsharp.TargetProfile.Base)

    Nota:

    Dado que reinicializa el estado de qsharp, debe volver a establecer el project_root parámetro para que el compilador sepa dónde encontrar la RandomNBits operación. Esto también podría haberse realizado en el paso 5 del procedimiento anterior.

  2. A continuación, use el compile método para especificar la operación o función que es el punto de entrada del programa. Después, el programa compilado se puede enviar a cualquier hardware cuántico:

    MyProgram = qsharp.compile("Source.RandomNBits(4)")

Conexión a Azure Quantum y envío del trabajo

Puede conectarse a Azure Quantum y enviar el trabajo mediante un objeto creado por Workspace Python o conectarse y enviar el trabajo mediante la CLI de Azure. El uso de la CLI de Azure requiere que guarde el programa compilado como un archivo de texto y envíe ese archivo mediante un comando de la CLI.

Ahora que tiene el programa compilado en el formato correcto, cree un azure.quantum.Workspace objeto para conectarse a Azure Quantum. Usará el identificador de recurso del área de trabajo de Azure Quantum para conectarse. El identificador de recurso y la ubicación se pueden copiar de la página de información general del área de trabajo en Azure Portal.

  1. Agregue el código siguiente a randomNum.py, rellenando el identificador y la ubicación del recurso desde el área de trabajo de Azure Quantum:

    workspace = azure.quantum.Workspace(
    resource_id = "MyResourceID",
    location = "MyLocation"
)

  2. Use el get_targets método para mostrar el hardware targets disponible en el área de trabajo:

    MyTargets = workspace.get_targets()
print("This workspace's targets:")
for x in MyTargets:
    print(x)

  3. Seleccione :rigetti.sim.qvmtarget

    MyTarget = workspace.get_targets("rigetti.sim.qvm")

  4. Por último, use el método para enviar el submit programa con sus parámetros. Los resultados del trabajo se devuelven como un diccionario de Python.

    job = MyTarget.submit(MyProgram, "MyPythonJob", shots=100)
results = job.get_results()
print("\nResults: ", results)

  5. Para extraer solo los valores y mostrarlos:

    for x in results:
    print(x)

    [0, 0, 0, 0]
0.3
[1, 0, 0, 0]
0.1
[1, 1, 1, 1]
0.3
[0, 1, 1, 1]
0.3

  6. Todas las propiedades del trabajo son accesibles en job.details, por ejemplo:

    print(job.details)
print("\nJob name:", job.details.name)
print("Job status:", job.details.status)
print("Job ID:", job.details.id)

    {'additional_properties': {'isCancelling': False}, 'id': '0fc396d2-97dd-11ee-9958-6ca1004ff31f', 'name': 'MyPythonJob', 'provider_id': 'rigetti'...}
Job name: MyPythonJob
Job status: Succeeded
Job ID: fc396d2-97dd-11ee-9958-6ca1004ff31f

Detalles adicionales del trabajo

El azure.quantum paquete de Python incluye métodos adicionales para mostrar datos de trabajo más detallados.

  • job.get_results_histogram(): este método devuelve un diccionario de los resultados y el recuento de capturas para cada medida única. Por ejemplo, los resultados del trabajo anterior serían

    results = job.get_results_histogram()
for x in results.items():
    print(x)

    {   
    '[0, 0, 0, 0]' : {'Outcome' : [0, 0, 0, 0], 'Count' : 30},  
    '[1, 0, 0, 0]' : {'Outcome' : [1, 0, 0, 0], 'Count' : 10},
    '[1, 1, 1, 1]' : {'Outcome' : [1, 1, 1, 1], 'Count' : 30},
    '[0, 1, 1, 1]' : {'Outcome' : [0, 1, 1, 1], 'Count' : 30}
}

  • job.get_results_shots() : este método devuelve una lista de cada resultado de captura. Por ejemplo, los resultados del trabajo anterior serían

    print(job.get_results_shots()) 

    [ [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1], [1, 1, 1, 1], [1, 0, 0, 0], [0, 1, 1, 1], [0, 0, 0, 0], ...]

Contenido relacionado