Personalizar os target parâmetros do Estimador de Recursos

Este artigo mostra como personalizar os target parâmetros do Azure Quantum Resource Estimator para corresponder às características da máquina que você está segmentando. O Estimador de Recursos usa esses parâmetros para estimar os recursos necessários para executar um algoritmo quântico em um computador quântico.

Pré-requisitos

• Um ambiente Python com Python e Pip instalados.

• A versão mais recente do Visual Studio Code ou abra o VS Code na Web.

• VS Code com as extensões Azure Quantum Development Kit, Python e Jupyter instaladas.

• A mais recente qdk biblioteca Python com o jupyter extra.

  python -m pip install --upgrade "qdk[jupyter]"
  

Parâmetros-alvo

O Estimador de Recursos calcula a estimativa de recursos, como o número de qubits e o tempo de execução, que seriam necessários para implementar um determinado algoritmo quântico em um computador quântico com uma determinada tecnologia de qubit e conjunto fixo de escolhas arquitetônicas.

O Estimador de Recursos usa um conjunto de entradas, com valores predefinidos para você começar facilmente:

• Um modelo de qubit físico, que define as propriedades dos qubits físicos subjacentes.
• Um esquema de correção de erro quântico (QEC), que é o esquema de correção de erro quântico assumido.
• Um orçamento de erro, que é o erro geral permitido, definido como o número de vezes que o programa pode falhar.
• Restrições no nível do componente, que são o número de ciclos lógicos e o número de cópias de fábrica T.
• Unidades de destilação para especificar algoritmos de destilação da fábrica T.
• Estimativa de fronteira de Pareto para executar várias estimativas para o número de qubits e tempo de execução para o mesmo algoritmo.

Parâmetros de qubit físico

Quando o Estimador de Recursos modela as suposições de qubit físico, ele usa dois conjuntos de instruções físicas diferentes para operar nos qubits. O conjunto de instruções físicas pode ser baseado em portões ou no modelo Majorana. Um conjunto de instruções baseado em portões fornece medição de qubit único, portões de qubit único (incluindo portões T) e portões de dois qubits. Um conjunto de instruções Majorana fornece uma porta T física, medição de qubit único e operações de medição conjunta de dois qubits.

Você pode escolher entre seis parâmetros de qubit predefinidos, quatro dos quais têm conjuntos de instruções baseados em portas e dois com um conjunto de instruções Majorana. Esses modelos de qubit cobrem uma gama de tempos de operação e taxas de erro, permitindo a exploração suficiente dos custos de recursos necessários para permitir aplicações quânticas práticas.

Parâmetros de qubits predefinidos

Para referência, os parâmetros de qubit predefinidos completos são os seguintes:

{
    "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
    }
}

Transmitir parâmetros de qubit predefinidos

Há duas maneiras de especificar programaticamente parâmetros de qubit predefinidos. Uma maneira é selecionar o nome do modelo de qubit para a qubitParams classe quando se executa qsharp.estimate. Por exemplo, para selecionar o "qubit_maj_ns_e6" parâmetro qubit, escreva o seguinte código:

from qdk import qsharp

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

Outra maneira é passar os parâmetros qubit para a EstimatorParams classe usando QubitParams. Por exemplo, para selecionar o MAJ_NS_E6 parâmetro qubit, escreva o seguinte código:

from qdk import qsharp
from qdk.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)

Personalizar parâmetros de qubit predefinidos

Você pode personalizar parâmetros de qubit predefinidos especificando o nome e, em seguida, atualizando qualquer um dos outros valores. Por exemplo, para diminuir a taxa de erro de medições de juntas de dois qubits no qubit_maj_ns_e4, escreva o seguinte código:

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

Ou, você pode passar as instruções na forma de uma lista.

from qsharp.estimator import EstimatorParams, QubitParams

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

Parâmetros de Qubit para qubits baseados em porta

O seguinte código mostra como especificar parâmetros de qubit personalizados para um conjunto de instruções baseado em porta:

from qdk.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

Parâmetros de Qubit para qubits de Majorana

Um modelo mínimo para um conjunto de instruções baseado em Majorana com todos os valores necessários é:

from qdk.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

Para one_qubit_measurement_error_rate e two_qubit_joint_measurement_error_rate, você pode especificar as taxas de erro que correspondem às leituras de medição, readout, e processamento de medição, process. Esses valores podem ser <double> números ou pares de números. Por exemplo:

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

Esquemas quânticos de correção de erros

Para executar aplicações quânticas em escala prática, as operações quânticas devem ter baixas taxas de erro. Essas taxas targets de erro normalmente estão além dos recursos dos qubits físicos brutos. Para superar essa limitação, a correção de erros quânticos (QEC) e a computação tolerante a falhas são duas técnicas cruciais que formam os blocos de construção de computadores quânticos de grande escala. Primeiro, o QEC nos permite compor vários qubits físicos propensos a erros e construir um qubit lógico mais confiável que preserva as informações quânticas melhor do que os qubits físicos subjacentes.

O Estimador de Recursos usa a seguinte fórmula para modelar taxas de erro lógico usando um modelo exponencial,

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

onde $a$ é um pré-fator de cruzamento, $d$ é a distância do código, $k$ é uma potência do coeficiente de distância (normalmente definido como 0), $p$ é a taxa de erro físico e $p^*$ é o limiar de correção de erro quântico. O pré-fator de cruzamento $a$ pode ser extraído numericamente para simulações.

A distância de código $d$ é um parâmetro que controla o número de erros que podem ser corrigidos. Assim, a distância de código define a taxa de erro dos qubits lógicos e o número de qubits físicos necessários para codificá-los. Tanto a precisão quanto o número de qubits físicos aumentam com a distância do código. O objetivo de um esquema QEC é encontrar a distância mínima de código que pode atingir a taxa de erro necessária definida para uma aplicação específica.

A taxa de erro físico $p$ é extraída dos parâmetros qubit como a taxa de erro do pior caso de qualquer operação física de Clifford realizada no dispositivo. Em particular, $p = {}$ max(one_qubit_measurement_error_rate, one_qubit_gate_error_rate, two_qubit_gate_error_rate) para parâmetros de qubit com um conjunto de instruções baseado em portas, e $p = {}$ max(one_qubit_measurement_error_rate, two_qubit_joint_measurement_error_rate) para parâmetros de qubit com um conjunto de instruções Majorana. Os esquemas QEC normalmente têm um limite de taxa de erro $p^*$ abaixo do qual a correção de erros suprime erros.

O Azure Quantum Resource Estimator suporta dois esquemas QEC predefinidos: um código de superfície e um código de floquet.

Parâmetros para esquemas de QEC predefinidos

Os parâmetros exatos para cada esquema QEC predefinido são os seguintes.

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

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

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

Aprovação de esquemas de QEC predefinidos

Há duas maneiras de especificar esquemas QEC predefinidos. Você pode selecionar o nome do modelo QEC ao executar "qecScheme" para a qsharp.estimate classe. Por exemplo, para selecionar o código do floquet, escreva:

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

Você também pode passar uma lista de parâmetros de estimativa para a EstimatorParams classe usando a QECScheme classe. Por exemplo, para selecionar o código do floquet, escreva:

from qdk import qsharp
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)

Personalizar esquemas QEC predefinidos

Você pode personalizar esquemas QEC predefinidos especificando o nome e, em seguida, atualizando qualquer um dos outros valores. Por exemplo, para aumentar o pré-fator de cruzamento no código do floquet, escreva:

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

Personalize os seus esquemas QEC

O Estimador de Recursos pode abstrair um esquema QEC personalizado com base na fórmula acima, fornecendo valores para o "crossingPrefactor" $a$, o distanceCoefficientPower $k$ e o "errorCorrectionThreshold" $p^*$. Você também precisa especificar o "logicalCycleTime", que é o tempo para executar uma única operação lógica e que depende da distância do código e das suposições de tempo de operação física dos qubits físicos subjacentes. Finalmente, uma segunda fórmula calcula o "physicalQubitsPerLogicalQubit", que é o número de qubits físicos necessários para codificar um qubit lógico com base na distância do código.

Você pode usar o seguinte código como um modelo para esquemas QEC:

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

Dentro das fórmulas, você pode usar as variáveis one_qubit_gate_time, two_qubit_gate_time, one_qubit_measurement_time, e two_qubit_joint_measurement_time, cujos valores são retirados do campo correspondente dos parâmetros qubit físicos, bem como a variável eccDistance para a distância de código calculada para o qubit lógico, com base nas propriedades do qubit físico, no limiar de correção de erro e no pré-fator de cruzamento. As variáveis de tempo e eccDistance podem ser usadas para descrever a logicalCycleTime fórmula. Para a fórmula physicalQubitsPerLogicalQubit, apenas o eccDistance pode ser usado.

Orçamento de erro

O orçamento de erro total $\epsilon$ define o erro geral tolerado para o algoritmo, ou seja, a probabilidade de falha permitida do algoritmo. Seu valor global deve estar entre 0 e 1, e o valor padrão é 0,001, o que corresponde a 0,1%. Em outras palavras, o algoritmo pode falhar no máximo uma vez em 1000 execuções. Este parâmetro é altamente específico da aplicação.

Por exemplo, se você estiver executando o algoritmo de Shor para fatoração de inteiros, um grande valor para o orçamento de erro pode ser tolerado, pois pode-se verificar se as saídas são realmente os fatores primordiais da entrada. Por outro lado, um orçamento de erro menor pode ser necessário para um algoritmo resolver um problema com uma solução, que não pode ser verificada de forma eficiente.

O orçamento de erro corresponde à soma de três partes:

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

Os erros lógicos $\epsilon_{\log}$ são os erros de implementar qubits lógicos, o erro de estado T $\epsilon_{\rm dis}$ é o erro de produzir estados T através de destilação, e os erros de porta de rotação $\epsilon_{\rm syn}$ são os erros de sintetizar portas de rotação com ângulos arbitrários.

Observe que, para a destilação e para a síntese de rotação, os respetivos orçamentos de erro $\epsilon_{\rm dis}$ e $\epsilon_{\rm syn}$ são distribuídos uniformemente entre todos os estados T necessários e, respetivamente, todas as portas de rotação necessárias. Se não houver portas de rotação no algoritmo de entrada, o orçamento de erro será distribuído uniformemente para erros lógicos e erros de estado T.

Aprovar o orçamento de erro

Há duas maneiras de especificar o orçamento de erro definindo um número entre 0 e 1. Você pode passar o orçamento para erros ao executar qsharp.estimate. Por exemplo, para selecionar um orçamento de erro de 1/3, escreva:

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

Você também pode passar os parâmetros de orçamento de erro para a EstimatorParams classe.

from qdk import qsharp
from qdk.estimator import EstimatorParams, QubitParams, QECScheme

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

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

Além disso, você pode especificar individualmente cada componente do orçamento de erro. A soma de todos os valores é o orçamento de erro total e deve estar entre 0 e 1. Se um algoritmo quântico não contém estados T ou rotações, então os valores de t_states e rotations podem ser 0 respectivamente.

O código a seguir mostra como especificar o parâmetro de orçamento de erro com estados T e rotações:

from qdk.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

Restrições

Você pode usar a "constraints" classe para aplicar restrições no nível do componente de fábrica T. Ao ajustar as restrições, você pode otimizar as estimativas para reduzir o número de qubits ou para reduzir o tempo de execução.

O código a seguir mostra como especificar as restrições para um algoritmo quântico:

from qdk.estimator import EstimatorParams

params = EstimatorParams()

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

Unidades de destilação

Você pode fornecer especificações para algoritmos de destilação de fábricas T com a DistillationUnitSpecification classe. A especificação pode ser predefinida ou personalizada. Você pode especificar uma especificação predefinida selecionando o nome da unidade de destilação: 15-1 RM ou 15-1 space-efficient.

from qdk.estimator import EstimatorParams, DistillationUnitSpecification

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

params.distillation_unit_specifications.append(unit)

Em ambos os casos, a notação 15-1 significa 15 estados T de entrada e 1 estado T de saída. A 15-1 space-efficient unidade de destilação usa menos qubits do que 15-1 RM , mas requer mais tempo de execução. Para obter mais informações, consulte a Tabela VI.

Personalize as suas unidades de destilação

Você pode personalizar suas próprias unidades de destilação. Os parâmetros exatos para as unidades de destilação são os seguintes:

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"
                        }
                })

Espera-se que todos os parâmetros numéricos sejam positivos. O displayName especifica como a unidade de destilação será exibida nos resultados de saída.

O código a seguir mostra como especificar os parâmetros da unidade de destilação para um algoritmo quântico usando a classe DistillationUnitSpecification e a classe ProtocolSpecificDistillationUnitSpecification.

from qdk.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

As fórmulas para failure_probability_formula e output_error_rate_formula são fórmulas personalizadas com operações aritméticas básicas, constantes e apenas três parâmetros:

• clifford_error_rate, também denotado como c.
• readout_error_rate, também denotado como r.
• input_error_rate, também denotado como z.

Veja os exemplos a seguir de fórmulas personalizadas usando notação longa e curta. Estes exemplos ilustram fórmulas usadas por padrão dentro da implementação padrão.

Pelo menos um dos parâmetros physical_qubit_specification ou logical_qubit_specification deve ser fornecido. Se apenas o primeiro for fornecido, a unidade de destilação pode ser aplicada a qubits físicos. Se apenas este último for fornecido, a unidade de destilação pode ser aplicada a qubits lógicos. Se ambos forem fornecidos, a unidade de destilação pode ser aplicada a ambos os tipos de qubits.

O parâmetro logical_qubit_specification_first_round_override só pode ser fornecido se logical_qubit_specification for especificado. Em caso afirmativo, anula os valores de logical_qubit_specification quando aplicado na primeira fase de destilação. O valor <protocol specific parameters> necessário para logical_qubit_specification_first_round_override deve ter o seguinte esquema:

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

Estimativa da fronteira de Pareto

Ao estimar os recursos de um algoritmo, é importante considerar a compensação entre o número de qubits físicos e o tempo de execução do algoritmo. Você pode considerar a alocação do maior número possível de qubits físicos para reduzir o tempo de execução do algoritmo. No entanto, o número de qubits físicos é limitado pelo número de qubits físicos disponíveis no hardware quântico. Compreender a compensação entre tempo de execução e escala do sistema é um dos aspetos mais importantes da estimativa de recursos.

A estimativa de fronteira de Pareto fornece várias estimativas para o mesmo algoritmo, cada uma mostrando compensações entre o número de qubits e o tempo de execução.

Se você executar o Resource Estimator em Python, precisará especificar o "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
                    }
                )

Se você quiser visualizar os resultados da estimativa de fronteira de Pareto, você pode usar a EstimatesOverview função. Esta função exibe os resultados da estimativa de fronteira em tabela e um diagrama espaço-temporal. Para obter mais informações, consulte Diagrama espaço-temporal.

from qdk.widgets import EstimatesOverview

EstimatesOverview(result)

Próximos passos

• Compreender os resultados do Estimador de Recursos
• Execute sua primeira estimativa de recursos
• Diferentes maneiras de executar o Estimador de Recursos
• Lidar com programas grandes com o Estimador de Recursos
• Tutorial: Estimar os recursos de um problema de química quântica