Ejercicio: Primeros pasos con el estimador de recursos de Azure Quantum

8 minutos

En la unidad anterior, ha aprendido que el estimador de recursos de Azure Quantum toma tres parámetros de entrada principales: los parámetros cuánticos físicos, el esquema de corrección de errores cuánticos (QEC) y el presupuesto de errores.

Ahora vamos a practicar con el estimador de recursos. En esta unidad, usará el Estimador de recursos para calcular los requisitos de recursos físicos de un programa cuántico simple.

Instalación de los paquetes necesarios

Para usar el estimador de recursos, instale los paquetes más recientes qsharp y qsharp-widgets de Python desde el Kit de desarrollo de Azure Quantum (QDK).

python -m pip install --upgrade qsharp qsharp-widgets

Si aún no ha instalado la extensión QDK para Visual Studio Code (VS Code), consulte Instalación de la extensión QDK.

Creación del algoritmo cuántico en un cuaderno de Jupyter Notebook

Vamos a escribir el algoritmo cuántico en un cuaderno de Jupyter Notebook. Para crear un cuaderno de Jupyter Notebook con el QDK en VS Code, siga estos pasos:

Abra VS Code.
Abra el menú Ver y, a continuación, elija Paleta de comandos. Aparece un cuadro de entrada.
En el cuadro de entrada, escriba y elija Crear: Nuevo cuaderno de Jupyter Notebook.
En la primera celda del cuaderno, importe el qsharp paquete y la EstimateDetails función :
```
import qsharp
from qsharp_widgets import EstimateDetails
```
Elija el botón + Código para agregar una nueva celda.

Copie el código siguiente RandomBit en la nueva celda:

%%qsharp
/// # Sample
/// Random Bit
///
/// # Description
/// This Q# program generates a random bit by setting a qubit in a superposition
/// of the computational basis states |0〉 and |1〉, and returning the measurement
/// result.

    operation RandomBit() : Result {
        // Qubits are only accessible for the duration of the scope where they
        // are allocated and are automatically released at the end of the scope.
        use qubit = Qubit();

        // Set the qubit in superposition by applying a Hadamard transformation.
        H(qubit);

        // Measure the qubit. There is a 50% probability of measuring either 
        // `Zero` or `One`.
        let result = M(qubit);

        // Reset the qubit so it can be safely released.
        Reset(qubit);
        return result;
    }

Estimación de recursos para el algoritmo cuántico

Ejecute el estimador de recursos para calcular los recursos físicos necesarios para ejecutar la RandomBit operación. Si no especifica ningún parámetro, el Estimador de recursos usa los siguientes valores de parámetro predeterminados:

qubit_gate_ns_e3 para el modelo de cúbits
surface_code para el código de corrección de errores
0.001 para el presupuesto de errores

Para ejecutar el estimador de recursos, siga estos pasos:

Agregue una nueva celda y copie el código siguiente en esa celda:
```
result = qsharp.estimate("RandomBit()")

EstimateDetails(result)
```
La qsharp.estimate función crea un objeto de resultado que contiene información del estimador de recursos. Pasamos result a la función EstimateDetails, que muestra un conjunto de tablas desplegables que contienen la salida del Estimador de recursos.
Expanda la primera tabla, denominada Estimaciones de recursos físicos. En esta tabla se muestra el tiempo de ejecución, las operaciones cuánticas confiables por segundo y el número de cúbits necesarios para ejecutar el algoritmo.

Estimación de recursos físicos Importancia

Entorno de ejecución 2 microsegundos

rQOPS 3,00 M

Cúbits físicos 300

La RandomBit operación requiere 300 cúbits físicos y toma dos microsegundos para ejecutarse.
Elija de nuevo la lista desplegable Estimaciones de recursos físicos para contraer la tabla.

Estimación de recursos físicos	Importancia
Entorno de ejecución	2 microsegundos
rQOPS	3,00 M
Cúbits físicos	300

Para inspeccionar las demás tablas, elija una lista desplegable para expandir la tabla correspondiente. Por ejemplo, elija la lista desplegable Parámetros cuánticos lógicos . En esta tabla se muestra que la distancia del código es 5 y que hay 50 cúbits físicos por cúbit lógico.

Parámetro de cúbit lógico	Importancia
Esquema de QEC	`surface_code`
Distancia del código	5
Cúbits físicos	50
Tiempo de ciclo lógico	2 microsegundos
Tasa de errores de cúbit lógico	3.00e-5
Factor previo de cruce	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`

Use el campo jobParams para acceder a todos los parámetros de destino que puede pasar al trabajo y para examinar los valores predeterminados de los parámetros que no especifique. Cree una nueva celda y copie el código siguiente en esa celda:
```
result['jobParams']
```

Ejecute la nueva celda e inspeccione la salida:

{'qecScheme': {'name': 'surface_code',
  'errorCorrectionThreshold': 0.01,
  'crossingPrefactor': 0.03,
  'distanceCoefficientPower': 0,
  'logicalCycleTime': '(4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance',
  'physicalQubitsPerLogicalQubit': '2 * codeDistance * codeDistance',
  'maxCodeDistance': 50},
 'errorBudget': 0.001,
 'qubitParams': {'instructionSet': 'GateBased',
  'name': 'qubit_gate_ns_e3',
  'oneQubitMeasurementTime': '100 ns',
  'oneQubitGateTime': '50 ns',
  'twoQubitGateTime': '50 ns',
  'tGateTime': '50 ns',
  'oneQubitMeasurementErrorRate': 0.001,
  'oneQubitGateErrorRate': 0.001,
  'twoQubitGateErrorRate': 0.001,
  'tGateErrorRate': 0.001,
  'idleErrorRate': 0.001},
 'constraints': {'maxDistillationRounds': 3},
 'estimateType': 'singlePoint'}

Para este algoritmo, el estimador de recursos usa el qubit_gate_ns_e3 modelo de cúbits, el surface_code código de corrección de errores y 0.001 para el presupuesto de errores. Estos son los valores predeterminados de estos parámetros porque no especificó sus valores al llamar al estimador de recursos.

Cambie los valores predeterminados y vuelva a calcular los recursos.

Para ejecutar el estimador con valores de parámetro distintos de los valores predeterminados, especifique otros valores para los parámetros al llamar al estimador de recursos. Vamos a cambiar el modelo de cúbits, el esquema QEC y el presupuesto de errores.

Cambio del modelo de cúbits

Calcule el costo para ejecutar el mismo algoritmo en una máquina majorana. Para ello, pase el parámetro qubitParams con el campo name establecido en qubit_maj_ns_e6 cuando llame al Estimador de Recursos.

En una nueva celda, copie y ejecute el código siguiente:

result_maj = qsharp.estimate("RandomBit()", params={
                "qubitParams": {
                    "name": "qubit_maj_ns_e6"
                }})

EstimateDetails(result_maj)

Expanda las listas desplegables de la salida para explorar cómo difieren los costos de recursos de la máquina Majorana en comparación con la máquina basada en puertas.

Cambio del esquema QEC

A continuación, calcule el costo del mismo algoritmo en una máquina Majorana con un esquema QEC de Floquet. Para ello, pase el parámetro qecScheme con el campo name establecido en floquet_code cuando llame al Estimador de Recursos.

En una nueva celda, copie y ejecute el código siguiente:

result_maj = qsharp.estimate("RandomBit()", params={
                "qubitParams": {
                    "name": "qubit_maj_ns_e6"
                },
                "qecScheme": {
                    "name": "floquet_code"
                }})

EstimateDetails(result_maj)

Expanda las listas desplegables de la salida para explorar cómo difieren los costos de recursos para el esquema QEC de Floquet en comparación con el esquema de código de superficie.

Cambio del presupuesto de errores

Por último, calcule el costo de los mismos parámetros que la estimación anterior, pero aumente el presupuesto de errores a 10%. Para ello, pase el errorBudget parámetro con el valor establecido en 0.1 cuando llame al Estimador de recursos.

En una nueva celda, copie y ejecute el código siguiente:

result_maj = qsharp.estimate("RandomBit()", params={
                "qubitParams": {
                    "name": "qubit_maj_ns_e6"
                },
                "qecScheme": {
                    "name": "floquet_code"
                },
                "errorBudget": 0.1})

EstimateDetails(result_maj)

¡Felicidades! Ha usado correctamente el estimador de recursos para calcular los recursos físicos necesarios para ejecutar un algoritmo cuántico simple. También ha personalizado los parámetros para ver cómo afectan a las estimaciones de recursos.

En la siguiente unidad, se calculan los recursos necesarios para un programa cuántico mucho más complejo: algoritmo de Shor.

Comentarios

¿Le ha resultado útil esta página?