Tutorial: Envío de un programa QIR al estimador de recursos de Azure Quantum

El estimador de recursos de Azure Quantum se basa en Quantum Intermediate Representation (QIR), una especificación totalmente interoperable para programas cuánticos. QIR actúa como una interfaz común entre los lenguajes de programación cuántica y los marcos de trabajo, y targetlas plataformas de cálculo cuántico. Dado que el estimador de recursos toma un programa QIR como entrada, admite cualquier idioma que se traduzca a QIR. Por ejemplo, los SDK cuánticos y los lenguajes más populares pueden usarse, como Q# y Qiskit. En este tutorial, escribirá y enviará un programa QIR al estimador de recursos. En este tutorial se usa PyQIR para generar QIR; sin embargo, puede usar cualquier otro origen de QIR.

En este tutorial, aprenderá a:

• Conéctese al servicio Azure Quantum.
• Definición de una función para crear un trabajo de estimación de recursos a partir del código de bits qiR
• Creación de un código de bits QIR mediante el generador pyQIR
• Envío de un trabajo de QIR al estimador de recursos

Regístrese para obtener una suscripción gratuita de prueba de Azure durante 30 días.

Requisitos previos

• Una cuenta de Azure con una suscripción activa. Si no tiene una cuenta de Azure, regístrese gratuitamente y regístrese para obtener una suscripción de pago por uso.
• Un área de trabajo de Azure Quantum. Para más información, consulte Creación de un área de trabajo de Azure Quantum.
• El proveedor de Computación cuántica de Microsoft agregado al área de trabajo.

Creación de un cuaderno en el área de trabajo

1. Inicie sesión en Azure Portal y seleccione el área de trabajo de Azure Quantum.
2. En Operaciones, seleccione Cuadernos.
3. Haga clic en Mis cuadernos y haga clic en Agregar nuevo.
4. En Tipo de kernel, seleccione IPython.
5. Escriba un nombre para el archivo y haga clic en Crear archivo.

Cuando se abre el cuaderno nuevo, este crea automáticamente el código de la primera celda, en función de la información de la suscripción y del área de trabajo.

from azure.quantum import Workspace
workspace = Workspace ( 
    resource_id = "", # Your resource_id 
    location = ""  # Your workspace location (for example, "westus") 
)

Nota

A menos que se indique lo contrario, debe ejecutar cada celda en orden a medida que se cree para evitar problemas de compilación.

Haga clic en el icono triangular "reproducir" situado a la izquierda de la celda para ejecutar el código.

Carga de las importaciones necesarias

En primer lugar, debe importar algunas clases y funciones de Python de azure.quantum, qiskity pyqir. No usará Qiskit para crear circuitos cuánticos directamente, pero usará AzureQuantumJob, que se basa en el ecosistema de Qiskit. Asegúrese de que usa la versión más reciente de Qiskit. Para más información, consulte Actualización del paquete de Python azure-quantum.

from azure.quantum.qiskit import AzureQuantumProvider
from azure.quantum.qiskit.job import AzureQuantumJob
from pyqir.generator import BasicQisBuilder, SimpleModule

Conexión al servicio Azure Quantum

A continuación, cree un AzureQuantumProvider objeto mediante el workspace objeto de la celda anterior para conectarse al área de trabajo de Azure Quantum.

provider = AzureQuantumProvider(workspace)

Definición de una función para crear un trabajo de estimación de recursos a partir de QIR

El estimador de recursos es un target proveedor de computación cuántica de Microsoft. El uso del estimador de recursos es exactamente el mismo que enviar un trabajo con otro proveedor targets de software y hardware en Azure Quantum: defina el programa, establezca un targety envíe el trabajo para su cálculo.

Al enviar una solicitud de estimación de recursos para el programa, puede especificar algunos target parámetros.

• errorBudget : el presupuesto de errores permitido general.
• qecScheme : esquema de corrección de errores cuánticos (QEC)
• qubitParams : los parámetros de cúbit físicos
• constraints: restricciones en el nivel de componente.

Para obtener más información sobre los parámetros de entrada, consulte Parámetros de destino del estimador de recursos.

En este ejemplo, implementará una función genérica que toma como entrada el provider objeto que se conecta al área de trabajo de Azure Quantum y el código de bits QIR del programa cuántico. Devuelve como resultado un trabajo de Azure Quantum. Los parámetros del estimador target de recursos se pueden pasar a través de argumentos de palabra clave a la función.

def resource_estimation_job_from_qir(provider: AzureQuantumProvider, bitcode: bytes, **kwargs):
    """A generic function to create a resource estimation job from QIR bitcode"""

    # Find the Resource Estimator target from the provider
    backend = provider.get_backend('microsoft.estimator')

    # You can provide a name for the job via keyword arguments; if not,
    # use QIR job as a default name
    name = kwargs.pop("name", "QIR job")

    # Wxtract some job specific arguments from the backend's configuration
    config = backend.configuration()
    blob_name = config.azure["blob_name"]
    content_type = config.azure["content_type"]
    provider_id = config.azure["provider_id"]
    output_data_format = config.azure["output_data_format"]

    # Finally, create the Azure Quantum jon object and return it
    return AzureQuantumJob(
        backend=backend,
        target=backend.name(),
        name=name,
        input_data=bitcode,
        blob_name=blob_name,
        content_type=content_type,
        provider_id=provider_id,
        input_data_format="qir.v1",
        output_data_format=output_data_format,
        input_params = kwargs,
        metadata={}
    )

Ejecución de un programa cuántico de ejemplo

A continuación, cree algún código de bits QIR mediante el generador pyQIR. En este ejemplo se crea una puerta S controlada con tres puertas T y dos puertas CNOT.

module = SimpleModule("Controlled S", num_qubits=2, num_results=0)
qis = BasicQisBuilder(module.builder)

[a, b] = module.qubits[0:2]
qis.t(a)
qis.t(b)
qis.cx(a, b)
qis.t_adj(b)
qis.cx(a, b)

Puede usar la función que definió anteriormente junto con la bitcode() función de PyQIR para generar un trabajo de estimación de recursos. También puede pasar argumentos específicos del estimador de recursos. En este ejemplo se usa errorBudget para establecer la tasa de errores en un 5 %. Para obtener más información sobre los target parámetros, consulte Parámetros de destino del estimador de recursos.

job = resource_estimation_job_from_qir(provider, module.bitcode(), errorBudget=0.05)
result = job.result()
result

Esta función crea una tabla que muestra los recuentos generales de recursos físicos. Para inspeccionar aún más los detalles de los costos, contrae los grupos que tienen más información. Por ejemplo, si contrae el grupo Parámetros cuánticos lógicos , puede ver más fácilmente que la distancia del código de corrección de errores es 15.

Parámetro de cúbit lógico	Valor
Esquema de QEC	surface_code
Distancia del código	5
Cúbits físicos	50
Tiempo de ciclo lógico	2us
Frecuencia de error de cúbit lógico	3.00E-5
Cruce del prefactor	0,03
Umbral de corrección de errores	0,01
Fórmula de tiempo de ciclo lógico	(4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance
Fórmula de cúbits físicos	2 * codeDistance * codeDistance

En el grupo Parámetros de cúbit físico, puede ver las propiedades de cúbit físicos que se han asumido para esta estimación. Por ejemplo, el tiempo para realizar una medición de un solo cúbit y una puerta de un solo cúbit se supone que son 100 ns y 50 ns, respectivamente.

Parámetro de cúbit físico	Valor
Nombre del cúbit	qubit_gate_ns_e3
Conjunto de instrucciones	GateBased
Tiempo de medición de un solo cúbit	100 ns
Hora de la puerta de T	50 ns
Tasa de errores de puerta de T	0,001
Tasa de errores de medición de un solo cúbit	0,001
Tiempo de puerta de un solo cúbit	50 ns
Frecuencia de error de un solo cúbit	0,001
Tiempo de la puerta de dos cúbits	50 ns
Tasa de errores de dos cúbits	0,001

Para obtener más información, consulte la lista completa de datos de salida del estimador de recursos.

Contenido relacionado

Siga explorando otras técnicas y algoritmos cuánticos:

• El tutorial Implementación del algoritmo de búsqueda de Grover muestra cómo escribir un programa de Q# que usa el algoritmo de búsqueda de Grover para resolver un problema de coloración de grafos.
• En el tutorial Exploración del entrelazamiento cuántico con Q# se muestra cómo operar en cúbits con Q# para cambiar su estado y se muestran los efectos de la superposición y el entrelazamiento.
• Quantum Katas son tutoriales autodirigidos y ejercicios de programación basados en Jupyter Notebook destinados a enseñar los elementos de la computación cuántica y la programación de Q# al mismo tiempo.