Compartir a través de

Diferentes tipos de target perfiles en Azure Quantum

Los dispositivos cuánticos siguen siendo una tecnología emergente y, desafortunadamente, no todos ellos pueden ejecutar todos los programas de Q#. Por lo tanto, debe tener en cuenta algunas restricciones mientras desarrolla programas cuánticos. Los target tipos de perfil definen las capacidades de los dispositivos cuánticos que utilizas target con tus programas de Q#. El Kit de desarrollo de Quantum (QDK) tiene un conjunto de diferentes target tipos de perfil, que admiten todas las funcionalidades de los dispositivos cuánticos actuales que están disponibles en Azure Quantum.

En este artículo se describen los distintos tipos de perfiles de target Azure Quantum, sus limitaciones y cómo configurarlos en el QDK.

Perfiles de destino y sus limitaciones

Actualmente, Azure Quantum y QDK administran diferentes target perfiles, en función de su capacidad de ejecutar programas de representación intermedia cuántica (QIR).

  • Unrestricted: Este perfil puede ejecutar cualquier QIR programa y, por tanto, cualquier programa de Q#, dentro de los límites de memoria para simuladores o el número de cúbits para equipos cuánticos físicos.
  • Base: Este perfil puede ejecutar cualquier programa de Q# que no requiera el uso de los resultados de las mediciones de cúbits para controlar el flujo del programa. Dentro de un programa de Q# destinado a este tipo de QPU, los valores de tipo Result no admiten la comparación de igualdad.
  • Adaptive RI: Este perfil tiene una capacidad limitada de usar los resultados de las mediciones de cúbits para controlar el flujo del programa. Dentro de un programa de Q# destinado a este tipo de QPU, se pueden comparar valores de tipo Result como parte de condiciones dentro if de las sentencias en las operaciones, lo que permite la medición a mitad del circuito.
  • Adaptive RIF: Este perfil tiene las mismas funcionalidades que el Adaptive RI perfil, pero también admite operaciones de punto flotante.

Creación y ejecución de programas para perfil Unrestrictedtarget

Unrestricted target Los perfiles pueden ejecutar todo el programa de Q#, por lo que puede escribir código de Q# sin necesidad de tener en cuenta las restricciones de funcionalidad. Azure Quantum no proporciona ningún dispositivo targets real que admita este perfil. Sin embargo, puede ejecutar Unrestricted programas de Q# que tengan este perfil en los simuladores que se proporcionan con el QDK.

Configuración del Unrestrictedtarget perfil

Si no establece manualmente su perfil QIRtarget, entonces el compilador establece automáticamente el perfil target. El compilador elige el perfil más restrictivo que todavía permite que el programa se ejecute en el dispositivo target de Azure Quantum que elija.

Para establecer manualmente el QIRtarget perfil en Sin restricciones, elija una de las siguientes opciones:

  • Si configura un proyecto de Q#, agregue el siguiente comando al archivo del qsharp.json proyecto:

    {
  "targetProfile": "unrestricted"
}

  • Si trabaja en un .qs archivo que no forma parte de un proyecto de Q#, establezca el perfil directamente en el target código de Q#. Para ello, incluya @EntryPoint(Unrestricted) justo antes de la operación de punto de entrada en el programa, incluso cuando esa operación sea la predeterminada Main.

  • En Python, llame el método qdk.init para establecer el perfil target.

    from qdk import init, TargetProfile

init(target_profile=TargetProfile.Unrestricted)

Creación y ejecución de programas para perfil Basetarget

Base target Los perfiles pueden ejecutar una amplia variedad de aplicaciones de Q#, con la restricción que no pueden usar los resultados de las mediciones de cúbits para controlar el flujo del programa. En concreto, los valores de tipo Result no admiten la comparación de igualdad.

Por ejemplo, no puede ejecutar la siguiente FlipQubitOnZero operación en :Basetarget

    @EntryPoint(Base)
    operation FlipQubitOnZero() : Unit {
        use q = Qubit();
        if M(q) == Zero {
            X(q);
        }
    }

La operación FlipQubitOnZero falla cuando se ejecuta este código en un Basetarget porque el dispositivo target no puede usar el resultado de una medición de cúbit para llevar a cabo la lógica condicional mientras se ejecuta el algoritmo cuántico. Si planea ejecutar algoritmos en un Basetarget dispositivo, asegúrese de que el código no contiene ningún if bloque para la bifurcación condicional que dependa de cúbits medidos para evaluar una condición lógica.

Configuración del Basetarget perfil

Para establecer manualmente el QIRtarget perfil en Base, elija una de las siguientes opciones:

  • Si configura un proyecto de Q#, agregue el siguiente comando al archivo del qsharp.json proyecto:

    {
  "targetProfile": "base"
}

  • Si trabaja en un .qs archivo que no forma parte de un proyecto de Q#, establezca el perfil directamente en el target código de Q#. Para ello, incluya @EntryPoint(Base) justo antes de la operación de punto de entrada en el programa, incluso cuando esa operación sea la predeterminada Main.

  • En Python, llame el método qdk.init para establecer el perfil target.

    from qdk import init, TargetProfile

init(target_profile=TargetProfile.Base)

Soportado targets para Basetarget el perfil

Por ahora, Azure Quantum proporciona acceso a lo siguiente Basetargets:

Provider Simulador QPU
IonQ ionq.simulator ionq.qpu.*
Rigetti rigetti.sim.* rigetti.qpu.*

Para más información sobre estos proveedores en Azure Quantum, consulte Proveedor de IonQ y Proveedor de Rigetti.

Creación y ejecución de programas para perfil Adaptive RItarget

Adaptive RI target perfiles pueden ejecutar una variedad más ancha de aplicaciones de Q# que Base perfiles, pero todavía tienen algunas limitaciones. A diferencia de los perfiles Basetarget, Adaptive RItargets admiten medidas de circuito medio.

Con las medidas del circuito medio, puede medir de forma selectiva los cúbits en cualquier punto del programa cuántico, no solo el final. A continuación, puede usar los resultados de medición para otras operaciones del programa, como la bifurcación condicional con if bloques. Los qubits que mides a mitad del circuito colapsan a un estado clásico (cero o uno), pero los qubits no medidos permanecen en su estado cuántico.

Cuando se mide un cúbit en Q#, se devuelve un valor de tipo Result . Si desea usar este resultado en una instrucción condicional, debe comparar directamente en la instrucción condicional. Los bloques condicionales correspondientes no pueden contener instrucciones return ni set.

Por ejemplo, se permite el siguiente código de Q# en :Adaptive RItarget

@EntryPoint(Adaptive_RI)
operation MeasureQubit(q : Qubit) : Result { 
    return M(q); 
}

operation SetToZero(q : Qubit) : Unit {
     if MeasureQubit(q) == One { X(q); }
}

Configuración del Adaptive RItarget perfil

Para establecer manualmente el QIRtarget perfil en Adaptive RI, elija una de las siguientes opciones:

  • Si configura un proyecto de Q#, agregue el siguiente comando al archivo del qsharp.json proyecto:

    {
  "targetProfile": "adaptive_ri"
}

  • Si trabaja en un .qs archivo que no forma parte de un proyecto de Q#, establezca el perfil directamente en el target código de Q#. Para ello, incluya @EntryPoint(Adaptive_RI) justo antes de la operación de punto de entrada en el programa, incluso cuando esa operación sea la predeterminada Main.

  • En Python, llame el método qdk.init para establecer el perfil target.

    from qdk import init, TargetProfile

init(target_profile=TargetProfile.Adaptive_RI)

Soportado targets para Adaptive RItarget el perfil

Por ahora, Quantinuum es el único proveedor de Azure Quantum que tiene Adaptive RItargets.

  • Emuladores:quantinuum.sim.h2-1e y quantinuum.sim.h2-2e
  • QPU:quantinuum.qpu.h2-1 y quantinuum.qpu.h2-2

Para más información sobre las ofertas de Quantinuum en Azure Quantum, consulte Quantinuum Emulators (Emuladores de Quantinuum).

Creación y ejecución de programas para perfil Adaptive RIFtarget

Adaptive RIF target perfiles tienen todas las capacidades de Adaptive RI, pero también admiten programas de Q# que contienen cálculos de punto flotante.

Por ejemplo, se permite el siguiente código de Q# en :Adaptive RIFtarget

@EntryPoint(Adaptive_RIF)
operation DynamicFloat() : Double {
    use q = Qubit();
    H(q);
    mutable f = 0.0;
    if M(q) == One {
        f = 0.5;
    }
    Reset(q);
    return f;
}

Configuración del Adaptive RIFtarget perfil

Para establecer manualmente el QIRtarget perfil en Adaptive RIF, elija una de las siguientes opciones:

  • Si configura un proyecto de Q#, agregue el siguiente comando al archivo del qsharp.json proyecto:

    {
  "targetProfile": "adaptive_rif"
}

  • Si trabaja en un .qs archivo que no forma parte de un proyecto de Q#, establezca el perfil directamente en el target código de Q#. Para ello, incluya @EntryPoint(Adaptive_RIF) justo antes de la operación de punto de entrada en el programa, incluso cuando esa operación sea la predeterminada Main.

  • En Python, llame el método qdk.init para establecer el perfil target.

    from qdk import init, TargetProfile

init(target_profile=TargetProfile.Adaptive_RIF)

Soportado targets para Adaptive RIFtarget el perfil

Por ahora, Azure Quantum no tiene Adaptive RIFtargets. Sin embargo, puede ejecutar programas para Adaptive RIFtargets en el simulador local en el QDK.

  • Last updated on