Cómo enviar Q# programas con Visual Studio Code

Envío de los trabajos de Q# a Azure Quantum

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

Requisitos previos

Para obtener más información sobre la instalación, consulte Configuración de la QDK extensión.

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

Carga de un Q# programa de ejemplo

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.

   Visual Studio Code

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 Q# programas, vea Prueba y depuración.

   

Visualización del histograma de frecuencia

El histograma de frecuencia representa la distribución de resultados obtenidos al ejecutar un programa cuántico varias veces, o "series". 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 muestra el comando QDK: Ejecutar archivo y mostrar histograma. También puede elegir Histograma en la lista de comandos que preceden a la operación de punto de entrada. Seleccione esta opción para abrir la Q# ventana del histograma.

   

2. Introduzca un número de intentos para ejecutar el programa, por ejemplo, 100 intentos, y presione Intro. El histograma se mostrará en la ventana del Q# histograma.

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 mediciones aplicadas a ellos. Para obtener más información, consulte Diagramas de circuitos cuánticos en Visual Studio Code.

1. Seleccione Vista -> Paleta de comandos y escriba circuito, lo que muestra el comando QDK: Mostrar circuito. También puede seleccionar Circuito en la lista de comandos junto a la operación de punto de entrada.

   

2. El circuito se muestra en la ventana del Q# circuito. 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.

   

Conéctate a Azure Quantum y envía tu trabajo

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

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

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

   Nota:

   Si tiene una cadena de conexión, puede seleccionar Cadena de conexión y pegar la cadena de conexión correspondiente al Azure Quantum espacio de trabajo. 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 su target.

   

6. Seleccione el icono de reproducción situado a la derecha del target nombre para empezar a enviar el programa actual Q# .

   

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.

    

Enviar trabajos a Azure Quantum desde Jupyter Notebook

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

Requisitos previos

Para obtener más información sobre la instalación, consulte Configuración de la QDK extensión.

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

• Un entorno Python con Python y Pip instalado.

• VS Code con las extensiones Azure Quantum Development Kit, Python y Jupyter instaladas.

• La biblioteca qdkPython con los extras azure y jupyter, y el paquete ipykernel.

  python -m pip install --upgrade "qdk[azure,jupyter]" 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 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.

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

   from qdk import qsharp
   import qdk.azure
   

   • El qdk.qsharp módulo activa el %%qsharp comando mágico que permite introducir Q# código directamente en una celda.
   • El módulo qdk.azure proporciona conectividad al Azure Quantum área de trabajo.

   Nota:

   Si no se detecta el JupyterPython kernel ipykernel, entonces VS Code le solicitará que lo instale.

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

   Nota:

   Tenga en cuenta que tan pronto como escriba el comando %%qsharp mágico, la celda de la libreta de notas cambia de 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();
           results += [r];
       }
       return results
   }
   

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

   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 Python lista.

   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 qdk.widgets módulo . Este módulo proporciona un widget que representa un diagrama de circuito cuántico como una imagen SVG. Para obtener más información, consulte Diagramas de circuitos cuánticos con Jupyter Notebook.

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

from qdk.qsharp import circuit
from qdk.widgets import Circuit

Circuit(circuit("RandomNBits(4)"))

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

Compila tu trabajo utilizando el perfil base

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

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

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

   from qdk import init, TargetProfile
   
   init(target_profile=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();
           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:

   from qdk.qsharp import compile
   
   MyProgram = compile("RandomNBits(4)")
   

Conéctate a Azure Quantum y envía tu trabajo

Ahora que tiene el programa compilado en el formato correcto, cree un azure.quantum.Workspace objeto para conectarse a Azure Quantum. Usará el ID de recurso de su espacio de trabajo 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, rellena el identificador de recurso y la ubicación de tu espacio de Azure Quantum trabajo:

   from qdk.azure import Workspace
   
   MyWorkspace = 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 submit para enviar su 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 qdk.azure módulo 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 disparos para cada medición ú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 disparo. 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], ...]
  

Enviar Python con Q# tareas a Azure Quantum

Obtenga información sobre cómo usar VS Code para escribir un programa Python que llame a operaciones Q#, conectarse a Azure mediante comandos Python o CLI Azure, y enviar su trabajo.

Requisitos previos

Para obtener más información sobre la instalación, consulte Configuración de la QDK extensión.

• Un Azure Quantum área de trabajo en tu suscripción Azure. Para crear un área de trabajo, consulte Creación de un Azure Quantum área de trabajo.
• Un entorno Python con Python y Pip instalado.
• VS Code con la extensión Azure Quantum Development Kit y Python instaladas.
• La qdkPython biblioteca con el azure adicional.
• Azure CLI con la extensión más reciente Azure Quantum instalada.

Crea e importa tus Q# operaciones

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

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

2. Abra un nuevo archivo de texto, agregue el código siguiente Q# que devuelve un número especificado por el usuario de bits aleatorios y guarde el archivo en el directorio del /src 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();
           results += [r];
       }
       return results
   }
   

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

4. Agregue el código siguiente para cargar las importaciones necesarias:

   from qdk import qsharp
   from qdk.azure import Workspace
   

5. A continuación, agregue código para definir la carpeta raíz del Q# proyecto y probar la ejecución de la target operación en el simulador local. La operación se llama mediante <namespace>.<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 Python lista. 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]]
   

Compila tu trabajo utilizando el perfil base

Al ejecutar programas en el simulador cuántico local, puede enviar cualquier tipo de Q# programa. Sin embargo, Azure Quantum el hardware targets aún no admite las funcionalidades completas necesarias para ejecutar todos los Q# programas. Para compilar y enviar Q# programas a Azure Quantum, debe establecer su target perfil para indicar a Q# qué funcionalidades admite su hardware target. Actualmente, es el perfil Base o Adpative_RI. Para obtener más información, vea 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 qsharp estado, 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)")
   

Conéctate a Azure Quantum y envía tu trabajo

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