Introducción a los programas de Q# y Visual Studio Code

En este artículo encontrará los pasos para usar VC Code para crear y enviar trabajos de Q#, Jupyter Notebook o computación cuántica de Python a Azure Quantum mediante VS Code.

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 moderno 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 sample, 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 Pruebas y depuración o Migración de programas al QDK moderno.

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 siguientes @EntryPoint()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 @EntryPoint()siguientes 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#, consulte Pruebas y depuración.

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

Trazar el 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 Vista -> Paleta de comandos y escriba "histograma" que debería mostrar la opción Q#: Ejecutar archivo y mostrar histograma . También puede hacer clic en Histograma en la lista de comandos siguientes @EntryPoint(). 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 tomas 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 superior izquierda para mostrar las opciones.

    Captura de pantalla de la ventana histograma de Q# en Visual Studio Code que 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.

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

Use las áreas de trabajo cuánticas integradas para conectarse y enviar trabajos directamente desde VS Code. En este ejemplo, enviará un trabajo al simulador de Rigetti.

  1. En el panel Explorador , expanda Áreas de trabajo cuánticas.

    Captura de pantalla de Visual Studio Code en la que se muestra cómo expandir el panel Área de trabajo de Quantum.

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

  3. Una vez conectado, expanda el área de trabajo y expanda el proveedor rigetti .

  4. Seleccione rigetti.sim.qvm como .target

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

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

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

  6. Agregue un nombre para identificar el trabajo.

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

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

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

  10. Para ver los resultados, seleccione el icono de nube 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 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 moderno 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

    import qsharp
    import azure.quantum
    
    • El qsharp módulo activa el %%qsharp comando mágico 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:

    %%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 , shotso 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]]
    

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 reinicializa 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 el 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()
    
    {'Histogram': ['[0, 0, 0, 0]',
      0.3,
      '[1, 0, 0, 0]',
      0.1,
      '[1, 1, 1, 1]',
      0.3,
      '[0, 1, 1, 1]',
      0.3]}
    
  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
    

Envío de python con trabajos de 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 moderno 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 de 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 de Q# que devuelve un número especificado por el usuario de bits aleatorios y guarde el archivo en el proyecto como source.qs.

    Nota

    Tenga en cuenta que este código de Q# no tiene una @EntryPoint función como un programa de Q# (consulte Envío de trabajos de Q# a Azure Quantum), pero requiere un espacio de nombres, a diferencia de un Jupyter Notebook (consulte Envío de trabajos de Jupyter Notebook a Azure Quantum).

    namespace Sample {
    
      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 misma carpeta, 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.

    qsharp.init(project_root = '/MyProjectRootFolder')
    print(qsharp.eval("Sample.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("Sample.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 target admite el hardware. Actualmente, ese es el perfil base. Para más información, consulte Tipos de perfil en Azure Quantum.

Nota

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

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

    qsharp.init(target_profile=qsharp.TargetProfile.Base)
    
  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("Sample.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 el Azure Portal.

  1. Agregue el código siguiente a randomNum.pyy rellene el identificador de recurso y la ubicación del á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:

    resultList = results.get("Histogram")
    for x in resultList:
        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
    

Pasos siguientes