Personalización de los target parámetros del estimador de recursos

Artículo
05/23/2024

En este artículo se muestra cómo personalizar los target parámetros del estimador de recursos de Azure Quantum para que coincidan con las características de la máquina de destino. El estimador de recursos usa estos parámetros para calcular los recursos necesarios para ejecutar un algoritmo cuántico en un equipo cuántico.

Nota:

Si tiene algún problema al trabajar con el estimador de recursos, consulte la página Solución de problemas.

Requisitos previos

Un entorno de Python con Python y Pip instalados.
La versión más reciente de Visual Studio Code o abrir VS Code en la Web.
VS Code con las extensiones kit de desarrollo de Azure Quantum, Python y Jupyter instaladas.
Los paquetes y qsharp-widgets Azure Quantum qsharp más recientes.
```
python -m pip install --upgrade qsharp qsharp-widgets 
```

Parámetros Target

El estimador de recursos calcula la estimación de recursos, como el número de cúbits y el tiempo de ejecución, que sería necesario para implementar un algoritmo cuántico determinado mediante una tecnología de cúbit determinada y con un conjunto fijo de opciones arquitectónicas.

Por lo tanto, el estimador de recursos toma un conjunto de entradas, con valores predefinidos para empezar fácilmente:

Un modelo de cúbit físico, que define las propiedades de los cúbits físicos subyacentes.
Un esquema de corrección de errores cuánticos (QEC), que es el esquema de corrección de errores cuánticos asumido.
Un presupuesto de errores, que es el error permitido general, es decir, el número de veces que el programa puede no obtener resultados.
Restricciones en el nivel de componente, que son el número de ciclos lógicos y el número de copias de fábrica de T.
Unidades de destilación para especificar algoritmos de destilación de factorías T.
Estimación de la frontera de Pareto para ejecutar varias estimaciones del número de cúbits y el tiempo de ejecución para el mismo algoritmo.

Sugerencia

Si ya conoce algunas estimaciones calculadas previamente para una operación, también puede incorporarlas y optimizar la ejecución del estimador de recursos. Para obtener más información, consulte Uso de estimaciones conocidas con el estimador de recursos.

Parámetros de cúbit físicos

Cuando el Estimador de recursos modela las suposiciones de cúbit físico, usa dos conjuntos de instrucciones físicas diferentes para operar los cúbits. El conjunto de instrucciones físicas puede ser basado en puertas o de Majorana. Un conjunto de instrucciones basado en puertas proporciona una medida de un solo cúbit, puertas de un solo cúbit (por ejemplo, puertas T) y puertas de dos cúbits. Un conjunto de instrucciones de Majorana proporciona una puerta T física, una medida de un solo cúbit y operaciones de medida conjunta de dos cúbits.

Puede elegir entre seis parámetros de cúbit predefinidos, cuatro de los cuales tienen conjuntos de instrucciones basados en puertas y dos tienen un conjunto de instrucciones de Majorana. Estos modelos de cúbits abarcan una gama de tiempos de operación y tasas de error, lo que permite una exploración suficiente de los costos de recursos necesarios para lograr aplicaciones cuánticas prácticas.

Parámetro qubit	Clase de API de Python	Descripción
`"qubit_gate_ns_e3"` , `"qubit_gate_ns_e4"`	`GATE_NS_E3` , `GATE_NS_E4`	Los tiempos de operación y las fidelidades pueden corresponder a versiones futuras de cúbits transmon superconductores o cúbits de giro, que normalmente tienen tiempos de funcionamiento en el régimen nanosegundo. Para estos cúbits, se supone que las operaciones de medición y puerta toman 50 n y 100 n, respectivamente. Se supone que las tasas de error de puerta de un solo cúbit y de dos cúbits son $10^{-3}$ como realistas targety $10^{-4}$ como optimista target para un sistema de escalado vertical.
`"qubit_gate_us_e3"` , `"qubit_gate_us_e4"`	`GATE_US_E3` , `GATE_US_E4`	Los tiempos de operación y las fidelidades pueden corresponder a versiones futuras de cúbits basados en iones, que normalmente tienen tiempos de operaciones en el régimen microsegundo. En función de las suposiciones típicas para cúbits de ion, se supone que las operaciones de medición y puerta toman 100 μs. La tasa de errores para las puertas clifford de un solo cúbit es de $10^{-3}$ como realista target y $10^{-4}$ como optimista target, mientras que la tasa de errores para las puertas no clifford de un solo cúbit (puerta T) es $10^{-6}$. Para las puertas de dos cúbits, la tasa de errores es de 10^{-3}$ como realista target y $10^{-4}$ como optimista target.
`"qubit_maj_ns_e4"` , `"qubit_maj_ns_e6"`	`MAJ_NS_E4` , `MAJ_NS_E6`	Los tiempos de operación y las fidelidades pueden corresponder a futuras versiones mejoradas de cúbits de Majorana. Para estos cúbits, se supone que las operaciones de medición y puerta toman 100 ns. Para tener en cuenta la protección topológica en el hardware, se supone que las tasas de error de medición conjunta de un solo cúbit y de dos cúbits (velocidades de error de Clifford) son $10^{-4}$ como realista targety $10^{-6}$ como optimista target. Las operaciones que no son Clifford en esta arquitectura no tienen protección topológica, la tasa de errores de las puertas T físicas que no son Clifford es del 5 %.

Nota:

A menos que se especifique otro valor, el valor predeterminado para el modelo de cúbit es "qubit_gate_ns_e3".

Parámetros para parámetros de cúbit predefinidos

Como referencia, los parámetros de cúbit predefinidos completos son los siguientes:

{
    "qubitParams": {
        "name": "qubit_gate_ns_e3",
        "instructionSet": "GateBased",
        "oneQubitMeasurementTime": "100 ns",
        "oneQubitGateTime": "50 ns",
        "twoQubitGateTime": "50 ns",
        "tGateTime": "50 ns",
        "oneQubitMeasurementErrorRate": 1e-3,
        "oneQubitGateErrorRate": 1e-3,
        "twoQubitGateErrorRate": 1e-3,
        "tGateErrorRate": 1e-3
    }
}

{
    "qubitParams": {
        "name": "qubit_gate_ns_e4",
        "instructionSet": "GateBased",
        "oneQubitMeasurementTime": "100 ns",
        "oneQubitGateTime": "50 ns",
        "twoQubitGateTime": "50 ns",
        "tGateTime": "50 ns",
        "oneQubitMeasurementErrorRate": 1e-4,
        "oneQubitGateErrorRate": 1e-4,
        "twoQubitGateErrorRate": 1e-4,
        "tGateErrorRate": 1e-4
    }
}

{
    "qubitParams": {
        "name": "qubit_gate_us_e3",
        "instructionSet": "GateBased",
        "oneQubitMeasurementTime": "100 µs",
        "oneQubitGateTime": "100 µs",
        "twoQubitGateTime": "100 µs",
        "tGateTime": "100 µs",
        "oneQubitMeasurementErrorRate": 1e-3,
        "oneQubitGateErrorRate": 1e-3,
        "twoQubitGateErrorRate": 1e-3,
        "tGateErrorRate": 1e-6
    }
}

{
    "qubitParams": {
        "name": "qubit_gate_us_e4",
        "instructionSet": "GateBased",
        "oneQubitMeasurementTime": "100 µs",
        "oneQubitGateTime": "100 µs",
        "twoQubitGateTime": "100 µs",
        "tGateTime": "100 µs",
        "oneQubitMeasurementErrorRate": 1e-4,
        "oneQubitGateErrorRate": 1e-4,
        "twoQubitGateErrorRate": 1e-4,
        "tGateErrorRate": 1e-6
    }
}

{
    "qubitParams": {
        "name": "qubit_maj_ns_e4",
        "instructionSet": "Majorana",
        "oneQubitMeasurementTime": "100 ns",
        "twoQubitJointMeasurementTime": "100 ns",
        "tGateTime": "100 ns",
        "oneQubitMeasurementErrorRate": 1e-4,
        "twoQubitJointMeasurementErrorRate": 1e-4,
        "tGateErrorRate": 0.05
    }
}

{
    "qubitParams": {
        "name": "qubit_maj_ns_e6",
        "instructionSet": "Majorana",
        "oneQubitMeasurementTime": "100 ns",
        "twoQubitJointMeasurementTime": "100 ns",
        "tGateTime": "100 ns",
        "oneQubitMeasurementErrorRate": 1e-6,
        "twoQubitJointMeasurementErrorRate": 1e-6,
        "tGateErrorRate": 0.01
    }
}

Pasar parámetros de cúbit predefinidos

Hay dos maneras de especificar mediante programación parámetros de cúbit predefinidos. Puede seleccionar el nombre del modelo de cúbit para la qubitParams clase al ejecutar qsharp.estimate. Por ejemplo, para seleccionar "qubit_maj_ns_e6" el parámetro qubit, escriba:

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

También puede pasar los parámetros de cúbit a la EstimatorParams clase mediante QubitParams. Por ejemplo, para seleccionar MAJ_NS_E6 el parámetro qubit, escriba:

from qsharp.estimator import EstimatorParams, QubitParams

params = EstimatorParams()
params.qubit_params.name = QubitParams.MAJ_NS_E6 # qubit_maj_ns_e6 qubit parameter

qsharp.estimate("RunProgram()", params=params)

Personalización de parámetros de cúbit predefinidos

Puede personalizar los parámetros de cúbit predefinidos especificando el nombre y actualizando cualquiera de los demás valores. Por ejemplo, para reducir la tasa de errores de la medición conjunta de dos cúbits en "qubit_maj_ns_e4", escriba:

qsharp.estimate("RunProgram()", params=
                {"qubitParams": {
                        "name": "qubit_maj_ns_e4",
                        "twoQubitJointMeasurementErrorRate": 1e-5,
                    },
                })

O bien, puede pasar las instrucciones en forma de una lista.

from qsharp.estimator import EstimatorParams, QubitParams

params = MicrosoftEstimatorParams()
params.qubit_params.name = QubitParams.MAJ_NS_E4
params.qubit_params.two_qubit_joint_measurement_error_rate = 1e-5

Parámetros de cúbits para cúbits basados en puertas

Identificador de Python	Tipo de datos	Descripción
`name`	string	Nombre del modelo de cúbits
`instruction_set`	"gate_based"	Tecnología de cúbit subyacente
`one_qubit_measurement_time`	time string	Tiempo de operación para la medición de un solo cúbit ($t_{\rm meas}$) en ns
`one_qubit_gate_time`	time string	Tiempo de operación para la puerta de un solo cúbit ($t_{\rm gate}$) en ns
`two_qubit_gate_time`	time string	Tiempo de operación para la puerta de dos cúbits en ns
`t_gate_time`	time string	Tiempo de operación para la puerta no Clifford de un solo cúbit en ns
`one_qubit_measurement_error_rate`	FLOAT	Tasa de errores para la medición de un solo cúbit
`one_qubit_gate_error_rate`	FLOAT	Tasa de errores para la puerta clifford de un solo cúbit ($p$)
`two_qubit_gate_error_rate`	FLOAT	Tasa de errores para la puerta clifford de dos cúbits
`t_gate_error_rate`	FLOAT	Tasa de errores para preparar el estado no Clifford de un solo cúbit ($p_T$)
`idle_error_rate`	FLOAT	Tasa de errores correspondiente al idiote

En el código siguiente se muestra cómo especificar parámetros de cúbit personalizados para un conjunto de instrucciones basado en puertas:

from qsharp.estimator import EstimatorParams, QubitParams,

params = EstimatorParams()

params.qubit_params.name = "your_custom_name"
params.qubit_params.instruction_set = "gate_based"
params.qubit_params.t_gate_error_rate = 0.03
params.qubit_params.t_gate_time = "10 ns"
params.qubit_params.idle_error_rate = 0.02

Nota:

Cuando no se especifica, los valores de two_qubit_gate_time y t_gate_time el valor predeterminado para one_qubit_gate_time, los valores de two_qubit_gate_error_rate y t_gate_error_rate el valor predeterminado es one_qubit_gate_error_ratey el valor de para idle_error_rate los valores predeterminados de one_qubit_measurement_error_rate.

Parámetros de cúbit para cúbits de Majorana

Identificador de Python	Tipo de datos	Descripción
`name`	string	Nombre del modelo de cúbits
`instruction_set`	"majorana"	Tecnología de cúbit subyacente
`one_qubit_measurement_time`	time string	Tiempo de operación para la medición de un solo cúbit ($t_{\rm meas}$) en ns
`two-qubit_joint_measurement_time`	time string	Tiempo de operación para la medición de dos cúbits en ns
`t_gate_time`	time string	Tiempo de operación para la puerta no Clifford de un solo cúbit en ns
`one_qubit_measurement_error_rate`	FLOAT	Tasa de errores para la medición de un solo cúbit
`two_qubit_joint_measurement_error_rate`	FLOAT	Tasa de errores para la medición de dos cúbits
`t_gate_error_rate`	FLOAT	Tasa de errores para preparar el estado no Clifford de un solo cúbit ($p_T$)
`idle_error_rate`	FLOAT	Tasa de errores correspondiente al idiote

Una plantilla mínima para el conjunto de instrucciones basado en Majorana con todos los valores necesarios es:

from qsharp.estimator import EstimatorParams, QubitParams,

params = EstimatorParams()

params.qubit_params.name = "your_custom_name"
params.qubit_params.instruction_set = "majorana"
params.qubit_params.one_qubit_measurement_time = "10 ns"
params.qubit_params.one_qubit_measurement_error_rate = 0.01

Nota:

Cuando no se especifica, los valores de two_qubitJointMeasurementTime y t_gate_time el valor predeterminado para one_qubit_measurement_time, los valores de two_qubit_joint_measurement_error_rate y t_gate_error_rate el valor predeterminado es one_qubit_measurement_error_ratey el valor de para idle_error_rate los valores predeterminados de one_qubit_measurement_error_rate.

Para one_qubit_measurement_error_rate y two_qubit_joint_measurement_error_rate, puede especificar las tasas de error correspondientes a lecturas de medida, readout, y procesamiento de medidas, process. Estos valores pueden ser <double> números o pares de números. Por ejemplo:

params.qubit_params.two_qubit_joint_measurement_error_rate = \
    MeasurementErrorRate(process=0.00005, readout=0.00007)

Nota:

Si especifica un valor numérico único para las tasas de error de un solo cúbit y de dos cúbits en la medición de cúbits majorana, las tasas de error de lectura y proceso pueden ser iguales.

Importante

Todos los valores que no se especifican tomarán un valor predeterminado, por ejemplo, si se especifica "qubit": {"oneQubitGateTime":"200 ns"} , se modelará un cúbit basado en la puerta en el que el tiempo de la puerta de dos cúbits y el tiempo de la puerta de un cúbit son 200 ns. En el caso de las unidades, debe especificar cadenas de tiempo, que son números de punto flotante de precisión doble, seguidos de un espacio y la unidad de tiempo para estos valores, siempre que sea posible, los sufijos de hora son ns, µs (o us), msy s.

Esquemas de corrección de errores cuánticos

Para ejecutar aplicaciones cuánticas de escala práctica, las operaciones cuánticas deben tener tasas de error bajas. Estas tasas targets de errores suelen ir más allá de las funcionalidades de cúbits físicos sin procesar. Para superar esta limitación, la corrección cuántica de errores (QEC) y el cálculo tolerante a errores son dos técnicas cruciales que forman los bloques de creación de equipos cuánticos a gran escala. En primer lugar, QEC nos permite componer varios cúbits físicos propensos a errores y crear un cúbit lógico más confiable que conserva la información cuántica mejor que los cúbits físicos subyacentes.

El estimador de recursos usa la fórmula siguiente para modelar tasas de error lógicas mediante un modelo exponencial,

$$ P = a\left(\frac{p}{p^*}\right)^{\frac{d+1}{2}} $$

donde $a$ es un factor previo cruzado, $d$ es la distancia del código, $p$ es la tasa de error física y $p^*$ es el umbral de corrección de errores cuántico. El $a$ de cruce previo se puede extraer numéricamente para simulaciones.

La distancia de código $d$ es un parámetro que controla el número de errores que se pueden corregir. Por lo tanto, la distancia de código define la tasa de errores de los cúbits lógicos y el número de cúbits físicos necesarios para codificarlos. Tanto la precisión como el número de cúbits físicos aumentan con la distancia del código. El objetivo de un esquema QEC es encontrar la distancia mínima del código que puede lograr la tasa de errores necesaria establecida para una aplicación determinada.

La tasa de errores físicas $p$ se extrae de los parámetros de cúbit como la tasa de errores en el peor de los casos de cualquier operación física de Clifford realizada en el dispositivo. En concreto, $p = {}$ max(one_qubit_measurement_error_rate, one_qubit_gate_error_rate, two_qubit_gate_error_rate) para los parámetros de cúbit con un conjunto de instrucciones basado en puertas y $p = {}$ max(one_qubit_measurement_error_rate, two_qubit_joint_measurement_error_rate) para los parámetros de cúbit con un conjunto de instrucciones Majorana. Los esquemas QEC suelen tener un umbral de tasa de error $p^*$ por debajo del cual la corrección de errores suprime los errores.

El estimador de recursos de Azure Quantum admite dos esquemas QEC predefinidos: un código de superficie y un código de floquet.

Protocolo QEC	Clase de API de Python	Descripción
"`surface_code`"	`SURFACE_CODE`	El código de superficie basado en puertas se basa en arXiv:1208.0928 y arXiv:1009.3686. El código de superficie majorana se basa en arXiv:1909.03002 y arXiv:2007.00307.
"`floquet_code`"	`FLOQUET_CODE`	Solo para los cúbits de Majorana. El código de floquet se basa en arXiv:2202.11829.

Nota:

A menos que se especifique otro valor, el valor predeterminado para el esquema QEC es "surface_code".

Parámetros para esquemas QEC predefinidos

Los parámetros exactos de cada esquema QEC predefinido son los siguientes.

{
    "qubitParams": {
        "instructionSet": "GateBased",
    }
    "qecScheme": {
        "name": "surface_code",
        "errorCorrectionThreshold": 0.01,
        "crossingPrefactor": 0.03,
        "logicalCycleTime": "(4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance",
        "physicalQubitsPerLogicalQubit": "2 * codeDistance * codeDistance"
    }
}

{
    "qubitParams": {
        "instructionSet": "Majorana",
    }
    "qecScheme": {
        "name": "surface_code",
        "errorCorrectionThreshold": 0.0015,
        "crossingPrefactor": 0.08,
        "logicalCycleTime": "20 * oneQubitMeasurementTime * codeDistance",
        "physicalQubitsPerLogicalQubit": "2 * codeDistance * codeDistance"
    }
}

{
    "qubitParams": {
        "instructionSet": "Majorana",
    }
    "qecScheme": {
        "name": "floquet_code",
        "errorCorrectionThreshold": 0.01,
        "crossingPrefactor": 0.07,
        "logicalCycleTime": "3 * oneQubitMeasurementTime * codeDistance",
        "physicalQubitsPerLogicalQubit": "4 * codeDistance * codeDistance + 8 * (codeDistance - 1)"
    }
}

Paso de esquemas de QEC predefinidos

Hay dos maneras de especificar esquemas de QEC predefinidos. Puede seleccionar el nombre del modelo QEC para la "qecScheme" clase al ejecutar qsharp.estimate. Por ejemplo, para seleccionar el código de floquet, escriba:

qsharp.estimate("RunProgram()", params=
                {"qecScheme": {
                        "name": "floquet_code"
                    }
                })

También puede pasar una lista de parámetros de estimación a la clase mediante laQECScheme clase .EstimatorParams Por ejemplo, para seleccionar el código de floquet, escriba:

from qsharp.estimator import EstimatorParams, QubitParams, QECScheme,

params = EstimatorParams()
params.items.qec_scheme.name = QECScheme.FLOQUET_CODE # floquet code QEC scheme

qsharp.estimate("RunProgram()", params=params)

Personalización de esquemas de QEC predefinidos

Puede personalizar esquemas de QEC predefinidos especificando el nombre y actualizando cualquiera de los otros valores. Por ejemplo, para aumentar el factor previo del cruce en el código de floquet, escriba:

qsharp.estimate("RunProgram()", params=
                {"qecScheme": {
                        "name": "floquet_code",
                        "crossingPrefactor": 0.07,
                    }
                })

Nota:

Cuando no se especifica, los valores de "logicalCycleTime" y "physicalQubitsPerLogicalQubit" el valor predeterminado para "oneQubitMeasurementTime", el valor "errorCorrectionThreshold" de los valores predeterminados 0.01es y el valor de "crossingPrefactor" los valores predeterminados para 0.03.

Personalización de los esquemas de QEC

El estimador de recursos puede abstraer un esquema QEC personalizado basado en la fórmula anterior proporcionando valores para el "crossingPrefactor" $a$ y el "errorCorrectionThreshold" $p^*$. Además, debe especificar , "logicalCycleTime"es decir, el tiempo para ejecutar una sola operación lógica, que depende de la distancia de código y de las suposiciones de tiempo de operación física de los cúbits físicos subyacentes. Por último, una segunda fórmula calcula , "physicalQubitsPerLogicalQubit"es decir, el número de cúbits físicos necesarios para codificar un cúbit lógico en función de la distancia del código.

Puede usar el código siguiente como plantilla para esquemas QEC:

qsharp.estimate("RunProgram()", params=
                {"qecScheme": {
                        "crossingPrefactor": <double>,
                        "errorCorrectionThreshold": <double>,
                        "logicalCycleTime": <formula string>,
                        "physicalQubitsPerLogicalQubit": <formula string>
                    }
                })

Dentro de las fórmulas, puede usar las variables , , y , cuyos valores se toman del campo correspondiente de los parámetros de cúbit físico, así como la variable eccDistance para la distancia de código calculada para el cúbit lógico, en función de las propiedades de cúbit físico, el umbral de corrección de errores y el prefactor de cruce.two_qubit_joint_measurement_timeone_qubit_measurement_timetwo_qubit_gate_timeone_qubit_gate_time Las variables de hora y eccDistance se pueden usar para describir la logicalCycleTime fórmula. Para la fórmula physicalQubitsPerLogicalQubit solo eccDistance se puede usar .

Presupuesto de errores

El presupuesto total de errores $\epsilon$ establece el error tolerado general para el algoritmo, es decir, la probabilidad de error permitida del algoritmo. Su valor global debe estar comprendido entre 0 y 1 y el valor predeterminado es 0,001, que corresponde al 0,1 %. En otras palabras, el algoritmo puede producir un error máximo de una vez en 1000 ejecuciones. Este parámetro es muy específico de la aplicación.

Por ejemplo, si está ejecutando el algoritmo de Shor para factorizar enteros, se puede tolerar un valor grande para el presupuesto de errores, ya que uno puede comprobar que las salidas son realmente los factores primos de la entrada. Por otro lado, es posible que se necesite un presupuesto de errores más pequeño en el caso de un algoritmo que resuelva un problema con una solución, que no se puede comprobar de forma eficaz.

El presupuesto de errores corresponde a la suma de tres partes:

$$ \epsilon = \epsilon_{\log} + \epsilon_{\rm dis} + \epsilon_{\rm syn} $$

Los errores lógicos $\epsilon_{\log}$ son el error de implementación de cúbits lógicos, el error de estado T $\epsilon_{\rm dis}$ es el error de producir estados T a través de la destilación y el error de puerta de rotación $\epsilon_{\rm syn}$ es el error de sintetizar puertas de rotación con ángulos arbitrarios.

Nota:

A menos que se especifique otro valor, el presupuesto de errores $\epsilon$ se distribuye uniformemente entre el error lógico, el error de estado T y el error de puerta de rotación.

Tenga en cuenta que para la destilación y la síntesis de rotación, los respectivos presupuestos de errores $\epsilon_{\rm dis}$ y $\epsilon_{\rm syn}$ se distribuyen uniformemente entre todos los estados T necesarios y todas las puertas de rotación necesarias, respectivamente. Si no hay puertas de rotación en el algoritmo de entrada, el presupuesto de errores se distribuye uniformemente a errores lógicos y errores de estado T.

Paso del presupuesto de errores

Hay dos maneras de especificar el presupuesto de errores estableciendo un número entre 0 y 1. Puede pasar el presupuesto de errores al ejecutar qsharp.estimate. Por ejemplo, para seleccionar un presupuesto de errores de 1/3, escriba:

qsharp.estimate("RunProgram()", params=
                {'errorBudget': 0.333
                })

También puede pasar los parámetros de presupuesto de error a la EstimatorParams clase .

from qsharp.estimator import EstimatorParams, QubitParams, QECScheme,

params = EstimatorParams()
params.items.error_budget = 0.333 # error budget of 1/3

qsharp.estimate("RunProgram()", params=params)

Además, puede especificar individualmente cada componente del presupuesto de errores. La suma de todos los valores es el presupuesto total de errores y debe estar comprendido entre 0 y 1. Si un algoritmo cuántico no contiene estados T o rotaciones, los valores de t_states y rotations pueden ser 0 respectivamente.

En el código siguiente se muestra cómo especificar el parámetro de presupuesto de errores con estados T y rotaciones:

from qsharp.estimator import EstimatorParams, QubitParams,

params = EstimatorParams()
params.error_budget.logical = 0.01
params.error_budget.t_states = 0.02
params.error_budget.rotations = 0.03

Restricciones

Puede usar la "constraints" clase para aplicar restricciones en el nivel de componente de fábrica de T. Al ajustar las restricciones, puede optimizar las estimaciones para reducir el número de cúbits o para reducir el runtime.

Parámetro	Tipo de datos	Descripción
`logical_depth_factor`	FLOAT	Controlar el tiempo de ejecución. Si tiene un valor mayor que 1, el número inicial de ciclos lógicos, también denominado profundidad lógica, se multiplica por este número. Al reducir `logical_depth_factor`, puede aumentar el número de invocación de la factoría de T en un tiempo determinado, lo que da lugar a menos copias de fábrica de T necesarias para producir el mismo número de estados T. Al reducir el número de copias de fábrica de T, el tiempo de ejecución del algoritmo aumenta en consecuencia. El factor de escala del tiempo de ejecución total puede ser mayor, ya que la tasa de errores lógica necesaria aumenta debido al número adicional de ciclos.
`max_t_factories`	integer	Número máximo de copias de fábrica de T. El estimador de recursos determina los recursos necesarios seleccionando el número óptimo de copias de fábrica de T que minimiza el número de cúbits físicos usados, sin tener en cuenta la sobrecarga de tiempo. El `max_t_factories` parámetro limita el número máximo de copias y, por tanto, ajusta el número de ciclos lógicos en consecuencia. Para obtener más información, consulte Estimación física de fábrica de T.
`max_duration`	time string	Tiempo de ejecución máximo para el algoritmo. El estimador de recursos solo acepta una de las `max_duration` restricciones o `max_physical_qubits` en el momento, pero no dos. Si `max_duration` se especifica , el estimador de recursos intenta encontrar la mejor estimación de `max_physical_qubits` entre las soluciones restringidas por el número máximo especificado.
`max_physical_qubits`	integer	Número máximo de cúbits físicos para el algoritmo. El estimador de recursos solo acepta una de las `max_duration` restricciones o `max_physical_qubits` en el momento, pero no dos. Si `max_physical_qubits` se especifica , el estimador de recursos intenta encontrar la mejor estimación de `max_duration` entre las soluciones restringidas por el número máximo especificado.

En el código siguiente se muestra cómo especificar las restricciones de un algoritmo cuántico:

from qsharp.estimator import EstimatorParams

params = EstimatorParams()

params.constraints.max_duration = "1 s"
params.constraints.logical_depth_factor = 1.5
params.constraints.max_t_factories = 10

Nota:

Si el valor proporcionado a max_duration o max_physical_qubits es demasiado pequeño para encontrar una solución factible, el estimador de recursos devuelve un error. Si no se especifican ni max_duration max_physical_qubits restricciones, el Estimador de recursos pretende encontrar una solución con el menor tiempo.

Sugerencia

Puede usar max_duration y max_physical_qubits para influir en el espacio de la solución, posiblemente encontrar soluciones con un tiempo de ejecución más largo, pero un número menor de cúbits en comparación con las soluciones sin estas restricciones. Existe un equilibrio entre el tiempo de ejecución y el número de cúbits, y esta compensación se puede administrar eficazmente para algunos algoritmos, con efectos variables en distintos algoritmos. La tabla IV de [arXiv:2211.07629] ilustra el uso efectivo del equilibrio entre el número de cúbits y el tiempo de ejecución para los algoritmos de dinámica cuántica. Para más información, consulte Estimación de recursos cuánticos con el tiempo o el número de restricciones de cúbits de ejemplo.

Unidades de destilación

Puede proporcionar especificaciones para los algoritmos de destilación de fábricas de T con la DistillationUnitSpecification clase . La especificación puede ser predefinida o personalizada. Para especificar una especificación predefinida, seleccione el nombre de la unidad de destilación: 15-1 RM o 15-1 space-efficient.

from qsharp.estimator import EstimatorParams, DistillationUnitSpecification

params = EstimatorParams()
unit = DistillationUnitSpecification()
unit.name = "15-1 RM" # predefined distillation unit

params.distillation_unit_specifications.append(unit)

En ambos casos, la notación 15-1 significa 15 estados de entrada T y 1 estado de salida T. La unidad de destilación 15-1 space-efficient usa menos cúbits que 15-1 RM, pero requiere más runtime. Para obtener más información, consulte Tabla VI.

Sugerencia

El uso de unidades de destilación predefinidas proporciona un mejor rendimiento en comparación con los personalizados.

Personalización de las unidades de destilación

Puede personalizar sus propias unidades de destilación. Los parámetros exactos de las unidades de destilación son los siguientes.

qsharp.estimate("RunProgram()", params=
                    {"distillationUnitSpecifications": {
                        "displayName": <string>, 
                        "numInputTs": <int>,
                        "numOutputTs": <int>,
                        "failureProbabilityFormula": <string>,
                        "outputErrorRateFormula": <string>,
                        "physicalQubitSpecification": <protocol specific parameters>, 
                        "logicalQubitSpecification": <protocol specific parameters>, 
                        "logicalQubitSpecificationFirstRoundOverride": <protocol specific parameters>, # Only if "logicalQubitSpecification"
                        }
                })

Se espera que todos los parámetros numéricos sean positivos. displayName especifica cómo se mostrará la unidad de destilación en los resultados de salida.

En el código siguiente se muestra cómo especificar los parámetros de unidad de destilación para un algoritmo cuántico mediante la clase y laProtocolSpecificDistillationUnitSpecification clase .DistillationUnitSpecification

from qsharp.estimator import EstimatorParams, DistillationUnitSpecification, ProtocolSpecificDistillationUnitSpecification

params = EstimatorParams()
unit = DistillationUnitSpecification()
unit.display_name = "T"
unit.failure_probability_formula = "c"
unit.output_error_rate_formula = "r"
unit.num_input_ts = 1
unit.num_output_ts = 2

physical_qubit_specification = ProtocolSpecificDistillationUnitSpecification()
physical_qubit_specification.num_unit_qubits = 1
physical_qubit_specification.duration_in_qubit_cycle_time = 2
unit.physical_qubit_specification = physical_qubit_specification

Las fórmulas de failure_probability_formula y output_error_rate_formula son fórmulas personalizadas con operaciones aritméticas básicas, constantes y solo tres parámetros:

clifford_error_rate, también se indica como c.
readout_error_rate, también se indica como r.
input_error_rate, también se indica como z.

Consulte los ejemplos siguientes de fórmulas personalizadas con notación larga y corta. En estos ejemplos se muestran las fórmulas que se usan de forma predeterminada en la implementación estándar.

Parámetro	Fórmula larga	Fórmula corta
`failure_probability_formula`	"15.0 * input_error_rate + 356.0 * clifford_error_rate"	"15.0 * z + 356.0 * c"
`output_error_rate_formula`	"35.0 * input_error_rate ^ 3 + 7.1 * clifford_error_rate"	"35.0 * z ^ 3 + 7.1 * c"

Se debe proporcionar al menos uno de los parámetros physical_qubit_specification o logical_qubit_specification . Si solo se proporciona la anterior, la unidad de destilación se puede aplicar a cúbits físicos. Si solo se proporciona este último, la unidad de destilación se puede aplicar a cúbits lógicos. Si se proporcionan ambos, la unidad de destilación se puede aplicar a ambos tipos de cúbits.

El parámetro logical_qubit_specification_first_round_override solo se puede proporcionar si logical_qubit_specification se especifica. Si es así, invalida los valores de logical_qubit_specification en caso de aplicarse en la primera ronda de destilación. El valor <protocol specific parameters> necesario para logical_qubit_specification_first_round_override debe seguir el esquema :

{
    "numUnitQubits": <int>,
    "durationInQubitCycleTime": <double>
}

Estimación de la frontera de Pareto

Al calcular los recursos de un algoritmo, es importante tener en cuenta el equilibrio entre el número de cúbits físicos y el tiempo de ejecución del algoritmo. Podría considerar la asignación de tantos cúbits físicos como sea posible para reducir el tiempo de ejecución del algoritmo. Sin embargo, el número de cúbits físicos está limitado por el número de cúbits físicos disponibles en el hardware cuántico. Comprender el equilibrio entre el tiempo de ejecución y la escala del sistema es uno de los aspectos más importantes de la estimación de recursos.

La estimación de la frontera de Pareto proporciona varias estimaciones para el mismo algoritmo, cada una de las cuales muestra inconvenientes entre el número de cúbits y el tiempo de ejecución.

Nota:

Si ejecuta el estimador de recursos en Visual Studio Code mediante la Q#opción : Calcular estimaciones de recursos, la estimación de frontera de Pareto está habilitada de forma predeterminada.

Si ejecuta el estimador de recursos en Python, debe especificar el "estimateType" parámetro como "frontier".

result = qsharp.estimate("RunProgram()", params=
                    {"qubitParams": { "name": "qubit_maj_ns_e4" },
                    "qecScheme": { "name": "surface_code" },
                    "estimateType": "frontier", # Pareto frontier estimation
                    }
                )

Si desea visualizar los resultados de la estimación de pareto frontier, puede usar la EstimatesOverview función . Esta función muestra los resultados de la estimación de frontera en la tabla y un diagrama de tiempo espaciador. Para obtener más información, vea Diagrama de tiempo espaciador.

from qsharp_widgets import EstimatesOverview

EstimatesOverview(result)

Nota:

Si tiene algún problema al trabajar con el estimador de recursos, consulte la página Solución de problemas o póngase en contacto con AzureQuantumInfo@microsoft.com.

Compartir a través de

Personalización de los target parámetros del estimador de recursos

Requisitos previos

Parámetros Target

Parámetros de cúbit físicos

Parámetros para parámetros de cúbit predefinidos

Pasar parámetros de cúbit predefinidos

Personalización de parámetros de cúbit predefinidos

Parámetros de cúbits para cúbits basados en puertas

Parámetros de cúbit para cúbits de Majorana

Esquemas de corrección de errores cuánticos

Parámetros para esquemas QEC predefinidos

Paso de esquemas de QEC predefinidos

Personalización de esquemas de QEC predefinidos

Personalización de los esquemas de QEC

Presupuesto de errores

Paso del presupuesto de errores

Restricciones

Unidades de destilación

Personalización de las unidades de destilación

Estimación de la frontera de Pareto

Pasos siguientes

Comentarios

Recursos adicionales