Q# Migración del código al QDK moderno

El Kit de desarrollo de Azure Quantum (QDK moderno), publicado en enero de 2024, es el kit de desarrollo predeterminado Q# que se usa en Visual Studio Code y el portal de Azure Quantum. Para obtener más información sobre las nuevas características y mejoras, vea Novedades del QDK moderno.

Si tiene programas existentes escritos para el Kit de desarrollo de Microsoft Quantum (QDK clásico), al menos algunos elementos deberán modificarse para las nuevas API, procesos y herramientas. Además, hay mejoras en la sintaxis del lenguaje para que la Q# codificación sea más fácil y flexible.

Este artículo le guía por los escenarios más comunes para poner el código en funcionamiento en el nuevo QDK. S

Desuso de Visual Studio como plataforma de desarrollo

El QDK moderno quita la compatibilidad con Visual Studio y las bibliotecas cuánticas de .NET asociadas. Si tiene proyectos de Visual Studio existentes, se recomienda encarecidamente migrarlos al QDK moderno mediante las instrucciones de este artículo. Para seguir usando el QDK clásico para los proyectos, consulte Continuar trabajando en el QDK clásico.

Importación de módulos desde un Q# archivo

En el caso de los programas de Python que usan Q# archivos (*.qs) para importar Q# funciones y operaciones como módulos, la sintaxis de importación ha cambiado.

En el QDK clásico, para importar y ejecutar la Random() operación desde el archivo source.qs:

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

Usaría la sintaxis de importación estándar de Python:

from Sample import Random

print(Random.simulate())

con el requisito de que source.qs y el programa de Python estuvieran en la misma carpeta.

Para importar la misma operación con el QDK moderno, defina un Q# proyecto, que le permite organizar los archivos de origen y las bibliotecas de forma más eficaz y lógica. Para obtener pasos detallados para definir un Q# proyecto, consulte Trabajar con Q# proyectos.

Una vez que haya configurado las carpetas del proyecto y creado un archivo de manifiesto simple, use qsharp.init para apuntar a la raíz del proyecto y qsharp.eval para acceder a los archivos de origen e importar el <espacio de nombres>.<>operation_name.

qsharp.init(project_root = '/MyProjectFolder')
print(qsharp.eval("Sample.Random()"))

Si la operación o función que va a importar toma valores de entrada, también se pueden pasar:

print(qsharp.eval("Sample.Random(4)"))

Ejecución del programa en el simulador local

La mayoría de los simuladores en memoria del QDK clásico han quedado en desuso, dejando el simulador disperso como el simulador local predeterminado en VS Code y el portal de Azure Quantum.

Simuladores en desuso:

• Simulador de estado completo
• Simulador de ruido
• Simulador de seguimiento
• Simulador Toffoli

Para ejecutar el simulador disperso predeterminado:

Escenario	Método
En un Q# programa de VS Code	Seleccione Ejecutar archivo.Q#
En una celda de cuaderno de Python	result=qsharp.eval("EntryPointOperation()") o result=qsharp.run("EntryPointOperation()", shots=##)
En una %%qsharp celda del cuaderno	EntryPointOperation()

Versión de cúbit aplicada

El QDK moderno exige el requisito de que los cúbits estén en el suelo o |0⟩ estado antes de liberarse al final de su ámbito. Esto es para evitar que los cúbits se vuelvan a usar en un estado inesperado al ejecutar programas en hardware cuántico.

Por ejemplo, el código siguiente desencadena un error en tiempo de ejecución:

operation MyOperation() : Result {
    use q = Qubit();
        X(q);
        return M(q);
}

y tendría que modificarse para restablecer el cúbit antes de devolver la medida:

operation MyOperation() : Result {
    use q = Qubit();
        X(q);
        let r = M(q);
        Reset(q);
        return r;
}

o use una operación que restablezca el cúbit como parte de la toma de la medida:

open Microsoft.Quantum.Measurement;
operation MyOperation() : Result {
    use q = Qubit();
    X(q);
    return MResetZ(q);
}

Configurar el perfil base

A diferencia del simulador local, los destinos de hardware de Azure Quantum aún no admiten las funcionalidades completas necesarias para ejecutar todos los Q# programas. Si va a enviar un trabajo a Azure Quantum, antes de compilar el programa, debe establecer el perfil de destino para indicar Q# qué funcionalidades admite el hardware de destino. Actualmente, solo los programas compatibles con el perfil base de QIR se pueden enviar a Azure Quantum. Tenga en cuenta que para ejecutar código en el simulador local, se puede usar cualquier configuración de perfil.

Código de VS

VS Code muestra el modo de perfil en la barra de estado de la parte inferior de Q# los archivos, ya sea QIR: Base o Sin restricciones. El modo sin restricciones es más útil para ejecutar código en el simulador. Si va a enviar un trabajo a Azure Quantum y recibe una advertencia de que un programa no está establecido para el perfil base, seleccione Sin restricciones en la barra de estado y seleccione QIR: Base como perfil.

Jupyter Notebook y Python

Para establecer el perfil base, use la qsharp.init función :

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

Nota

• La qsharp.init función reemplaza el comando magic %azure.target-capability .
• Si restablece el perfil de destino, deberá volver a ejecutar las Q# celdas o las importaciones antes de compilar.

Compilación de un Q# programa para enviar a Azure Quantum

Con el QDK moderno, el programa debe compilarse antes de enviar el trabajo a Azure Quantum.

Nota

Para escenarios paso a paso para enviar trabajos a Azure Quantum mediante Q# programas, programas de Python o cuadernos de Jupyter Notebook, consulte Envío de trabajos a Azure Quantum.

Código de VS

Q#los programas de VS Code compilan el programa automáticamente al seleccionar un destino de proveedor en el área de trabajo y selecciona Enviar programa actualQ#. Si hay errores del compilador, puede depurar el archivo presionando F5. Para más información, consulte Envío de trabajos a Azure Quantum.

Jupyter Notebook y Python

Para Jupyter Notebook y los programas de Python que usan la Workspace clase para conectarse a Azure Quantum, debe compilar el programa y, a continuación, enviarlo a Azure Quantum con el envío del trabajo.

1. Ejecute el Q# código que importó o escribió en una %%qsharp celda.

2. Use la qsharp.compile función y pase la Q# operación o función que se va a usar como punto de entrada. Por ejemplo, para este Q# programa:

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

   pasaría la MyOperation() operación como:

   MyProgram = qsharp.compile("MyOperation()")
   

3. A continuación, el resultado MyProgram compilado se pasa a Azure Quantum con la target.submit función :

   job = target.submit(MyProgram, "job name", ...)
   

Azure CLI

También puede usar la CLI de Azure para conectarse y enviar trabajos y Q# Python a Azure Quantum. En este escenario, debe guardar el programa compilado como un archivo de texto. Para obtener el procedimiento paso a paso, consulte Envío de trabajos a Azure Quantum.

Conexión a Azure Quantum

En Q# el caso de los programas de VS Code, puede conectarse al área de trabajo de Azure Quantum y enviar trabajos en VS Code.

En el caso de los programas python y Jupyter Notebook, el método de conexión predeterminado es la azure.quantum.Workspace clase , que reemplaza los comandos mágicos IQ#%azure en desuso y el qsharp.azure módulo . Para obtener ejemplos de todos estos comandos, consulte Envío de trabajos a Azure Quantum.

Comando mágico en desuso o API	Uso
%azure.connect qsharp.azure.connect()	wksp = azure.quantum.Workspace( resource_id="", location="")
%azure.target qsharp.azure.target()	target = wksp.get_targets("<target_name>")
%azure.execute qsharp.azure.execute()	job = target.submit(...) E/S sin bloqueo
%azure.submit qsharp.azure.submit()	job = target.submit(<QirInputData>, <jobName>, input_params={"count: <##>"})
%azure.jobs qsharp.azure.jobs()	wksp.list_jobs()
%azure.output qsharp.azure.output()	job.get_results()
%azure.status qsharp.azure.status()	job.details.status
%azure.quotas	wksp.get_quotas()

Otros comandos mágicos en desuso

Comando magic en desuso
%check_kata	Obsoleto
%chemistry.broombridge	Obsoleto
%chemistry.encode	Obsoleto
%chemistry.fh.add_terms	Obsoleto
%chemistry.fh.load	Obsoleto
%chemistry.inputstate.load	Obsoleto
%config	Obsoleto
%debug	Obsoleto
%experimental.build_info	Obsoleto
%kata	Obsoleto
%lsmagic	Obsoleto
%lsopen	Obsoleto
%noise_model	Obsoleto
%package	Obsoleto
%performance	Obsoleto
%project	Obsoleto
%quién	Obsoleto
%workspace	Obsoleto