Envío de programas de Q# con Visual Studio 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 en VS Code.

• Un área de trabajo de Azure Quantum en la suscripción de Azure. Para crear un área de trabajo, consulte Creación de un área de trabajo de Azure Quantum.
• La versión más reciente de Visual Studio Code o abrir VS Code en la Web.
• La última versión de la extensión Kit de desarrollo de Azure Quantum.

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.

   

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.

   

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#.

   

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.

   

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 %.

   

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.

   

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.

   

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

   

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.

   

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.

    

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.

• Un área de trabajo de Azure Quantum en la suscripción de Azure. Para crear un área de trabajo, consulte Creación de un área de trabajo de Azure Quantum.

• Un entorno de Python con Python y Pip instalados.

• VS Code con las extensiones kit de desarrollo de Azure Quantum, Python y Jupyter instaladas.

• Los paquetes de Azure Quantum qsharp, , y azure-quantum y el ipykernel qsharp-widgetspaquete.

  python -m pip install --upgrade qsharp qsharp-widgets azure-quantum ipykernel
  

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)"))

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.

• Un área de trabajo de Azure Quantum en la suscripción de Azure. Para crear un área de trabajo, consulte Creación de un área de trabajo de Azure Quantum.
• Un entorno de Python con Python y Pip instalados.
• VS Code con el Kit de desarrollo de Azure Quantum y la extensión de Python instaladas.
• Azure Quantum qsharp y azure-quantum los paquetes.
• CLI de Azure con la extensión de Azure Quantum más reciente instalada.

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.

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.