Personalizar os target parâmetros do Avaliador de Recursos

Artigo
08/06/2024

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

Observação

Se você tiver algum problema ao trabalhar com o Avaliador de recursos, confira a página Solução de problemas.

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 do Azure Quantum Development Kit, Python e Jupyter instaladas.
O Azure Quantum qsharp e qsharp-widgets os pacotes mais recentes.
```
python -m pip install --upgrade qsharp qsharp-widgets 
```

Parâmetros Target

O Avaliador 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 usando uma determinada tecnologia de qubit e com um conjunto fixo de opções de arquitetura.

Portanto, o Avaliador 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, ou seja, 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 de fábricas T.
Estimativa de fronteira de Pareto para executar várias estimativas de número de qubits e tempo de execução para o mesmo algoritmo.

Dica

Se você já conhece algumas estimativas pré-calculadas para uma operação, também pode incorporá-las e otimizar a execução do Avaliador de Recursos. Para obter mais informações, consulte Como usar estimativas conhecidas com o Avaliador de Recursos.

Parâmetros físicos de qubit

Quando o Avaliador de Recursos modela as suposições físicas de qubits, ele usa dois conjuntos de instruções físicas diferentes para operar os qubits. O conjunto de instruções físicas pode ser baseado em porta ou Majorana. Um conjunto de instruções baseado em porta fornece medição de qubit único, portas de qubit único (incluindo portas T) e portas 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.

É possível escolher entre seis parâmetros de qubit predefinidos: quatro deles têm conjuntos de instruções baseados em porta e dois têm um conjunto de instruções Majorana. Esses modelos de qubit abrangem uma variedade de tempos de operação e taxas de erro, permitindo uma exploração suficiente dos custos dos recursos necessários para permitir aplicativos quânticos práticos.

Parâmetro de qubit	Classe de API Python	Descrição
`"qubit_gate_ns_e3"` , `"qubit_gate_ns_e4"`	`GATE_NS_E3` , `GATE_NS_E4`	Os tempos de operação e as fidelidades podem corresponder a versões futuras de qubits transmon supercondutores, ou qubits de spin, que normalmente têm tempos de operação no regime de nanossegundos. Para esses qubits, presume-se que as operações de porta e medição levem 50 ns e 100 ns, respectivamente. As taxas de erro de porta de qubit único e dois qubits são consideradas $10^{-3}$ como realistas targete $10^{-4}$ como otimistas target para um sistema ampliado.
`"qubit_gate_us_e3"` , `"qubit_gate_us_e4"`	`GATE_US_E3` , `GATE_US_E4`	Os tempos de operação e as fidelidades podem corresponder a versões futuras de qubits baseados em íons, que normalmente têm tempos de operação no regime de microssegundos. Com base em suposições típicas para qubits de íons, presume-se que as operações de porta e medição levem 100 μs. A taxa de erro para portas Clifford de qubit único é $10^{-3}$ como realista target e $10^{-4}$ como otimista target, enquanto a taxa de erro para portas não-Clifford de qubit único (porta T) é $10^{-6}$. Para portas de dois qubits, a taxa de erro é $10^{-3}$ como realista target e $10^{-4}$ como otimista target.
`"qubit_maj_ns_e4"` , `"qubit_maj_ns_e6"`	`MAJ_NS_E4` , `MAJ_NS_E6`	Os tempos de operação e as fidelidades podem corresponder a futuras versões aprimoradas dos qubits do Majorana. Para esses qubits, supõe-se que as operações de porta e medição levem 100 ns. Para levar em conta a proteção topológica no hardware, as taxas de erro de medição conjunta de qubit único e dois qubits (taxas de erro de Clifford) são consideradas $10^{-4}$ como um realista targete $10^{-6}$ como um otimista target. As operações não Clifford nesta arquitetura não têm proteção topológica, a taxa de erro para portas T físicas não Clifford é de 5%.

Observação

A menos que outro valor seja especificado, o valor padrão para o modelo de qubit é "qubit_gate_ns_e3".

Parâmetros para parâmetros de qubit 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
    }
}

Passando parâmetros de qubit predefinidos

Há duas maneiras de especificar programaticamente parâmetros de qubit predefinidos. Você pode selecionar o nome do modelo de qubit para a qubitParams classe ao executar qsharp.estimateo . Por exemplo, para selecionar "qubit_maj_ns_e6" o parâmetro qubit, escreva:

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

Você também pode passar os parâmetros de qubit para a EstimatorParams classe usando QubitParams. Por exemplo, para selecionar MAJ_NS_E6 o parâmetro qubit, escreva:

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)

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 da medição conjunta de dois qubits em "qubit_maj_ns_e4", escreva:

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 = MicrosoftEstimatorParams()
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

Identificador Python	Tipo de dados	Descrição
`name`	string	Nome do modelo de qubit
`instruction_set`	"gate_based"	Tecnologia de qubit subjacente
`one_qubit_measurement_time`	cadeia de caracteres de tempo	Tempo de operação para medição de qubit único ($t_{\rm meas}$) em ns
`one_qubit_gate_time`	cadeia de caracteres de tempo	Tempo de operação para porta de qubit único ($t_{\rm gate}$) em ns
`two_qubit_gate_time`	cadeia de caracteres de tempo	Tempo de operação para porta de dois qubits em ns
`t_gate_time`	cadeia de caracteres de tempo	Tempo de operação para porta não Clifford de qubit único em ns
`one_qubit_measurement_error_rate`	float	Taxa de erro para medição de qubit único
`one_qubit_gate_error_rate`	float	Taxa de erro para porta Clifford de qubit único ($p$)
`two_qubit_gate_error_rate`	float	Taxa de erro para porta Clifford de dois qubits
`t_gate_error_rate`	float	Taxa de erro para preparar o estado não Clifford de qubit único ($p_T$)
`idle_error_rate`	float	Taxa de erro correspondente à marcha lenta sem carga

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

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

Observação

Quando não especificado, os valores para two_qubit_gate_time e t_gate_time padrão para one_qubit_gate_time, os valores para two_qubit_gate_error_rate e t_gate_error_rate padrão para one_qubit_gate_error_rate, e o valor para idle_error_rate padrões para one_qubit_measurement_error_rate.

Parâmetros de qubit para qubits Majorana

Identificador Python	Tipo de dados	Descrição
`name`	string	Nome do modelo de qubit
`instruction_set`	"majorana"	Tecnologia de qubit subjacente
`one_qubit_measurement_time`	cadeia de caracteres de tempo	Tempo de operação para medição de qubit único ($t_{\rm meas}$) em ns
`two-qubit_joint_measurement_time`	cadeia de caracteres de tempo	Tempo de operação para medição de dois qubits em ns
`t_gate_time`	cadeia de caracteres de tempo	Tempo de operação para porta não Clifford de qubit único em ns
`one_qubit_measurement_error_rate`	float	Taxa de erro para medição de qubit único
`two_qubit_joint_measurement_error_rate`	float	Taxa de erro para medição de dois qubits
`t_gate_error_rate`	float	Taxa de erro para preparar o estado não Clifford de qubit único ($p_T$)
`idle_error_rate`	float	Taxa de erro correspondente à marcha lenta sem carga

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

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

Observação

Quando não especificado, os valores para two_qubitJointMeasurementTime e t_gate_time padrão para one_qubit_measurement_time, os valores para two_qubit_joint_measurement_error_rate e t_gate_error_rate padrão para one_qubit_measurement_error_rate, e o valor para idle_error_rate padrões para one_qubit_measurement_error_rate.

Para one_qubit_measurement_error_rate e two_qubit_joint_measurement_error_rate, você pode especificar as taxas de erro correspondentes à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)

Observação

Se você especificar um único valor numérico para taxas de erro de qubit único e dois qubits na medição de qubit de Majorana, as taxas de erro de leitura e de processo poderão ser iguais.

Importante

Todos os valores que não são especificados terão um valor padrão, por exemplo, especificar "qubit": {"oneQubitGateTime":"200 ns"} modelará um qubit baseado em porta no qual o tempo de porta de dois qubits e o tempo de porta de um qubit são 200 ns. Para unidades, você precisa especificar cadeias de tempo, que são números de ponto flutuante de precisão dupla, seguidos por um espaço e a unidade de tempo para esses valores, onde os sufixos de tempo possíveis são ns, µs (ou us), ms, e s.

Esquemas de correção de erros quânticos

Para executar aplicativos quânticos em escala prática, as operações quânticas devem ter baixas taxas de erro. Normalmente, essa taxa targets de erro está 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 criar um qubit lógico mais confiável que preserva as informações quânticas melhor do que os qubits físicos subjacentes.

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

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

onde $a$ é um pré-fator de cruzamento, $d$ é a distância do código, $p$ é a taxa de erro físico e $p^*$ é o limite de correção de erro quântico. O pré-fator de cruzamento $a$ pode ser extraído numericamente para simulações.

O código distance $d$ é um parâmetro que controla o número de erros que podem ser corrigidos. Assim, a distância do código define a taxa de erro dos qubits lógicos e o número de qubits físicos necessários para codificá-los. A precisão e 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 do código que pode atingir a taxa de erro necessária definida para um aplicativo específico.

A taxa de erro físico $p$ é extraída dos parâmetros de qubit como a taxa de erro de pior caso de qualquer operação física de Clifford executada 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 porta 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 os erros.

O Avaliador de Recursos do Azure Quantum dá suporte a dois esquemas QEC predefinidos: um código de superfície e um código floquet.

Protocolo QEC	Classe de API Python	Descrição
"`surface_code`"	`SURFACE_CODE`	O código de superfície baseado em porta é baseado em arXiv:1208.0928 e arXiv:1009.3686. O código de superfície Majorana é baseado em arXiv:1909.03002 e arXiv:2007.00307.
"`floquet_code`"	`FLOQUET_CODE`	Apenas para qubits Majorana. O código floquet é baseado em arXiv:2202.11829.

Observação

A menos que outro valor seja especificado, o valor padrão para o esquema QEC é "surface_code".

Parâmetros para esquemas 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,
        "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)"
    }
}

Passando esquemas QEC predefinidos

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

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 floquet, escreva:

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

Observação

Quando não especificado, os valores de "logicalCycleTime" e "physicalQubitsPerLogicalQubit" padrão para "oneQubitMeasurementTime", o valor "errorCorrectionThreshold" de defaults para 0.01, e o valor de "crossingPrefactor" defaults para 0.03.

Personalize seus esquemas QEC

O Avaliador de Recursos pode abstrair um esquema QEC personalizado com base na fórmula acima, fornecendo valores para o "crossingPrefactor" $a$ e o "errorCorrectionThreshold" $p^*$. Além disso, você precisa especificar o "logicalCycleTime", ou seja, o tempo para executar uma única operação lógica, que depende da distância do código e das suposições de tempo de operação física dos qubits físicos subjacentes. Por fim, uma segunda fórmula calcula o "physicalQubitsPerLogicalQubit", ou seja, 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 modelo para esquemas QEC:

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

Dentro das fórmulas, você pode usar as variáveis , , e , cujos valores são obtidos do campo correspondente dos parâmetros físicos do qubit, bem como a variável eccDistance para a distância do código calculada para o qubit lógico, com base nas propriedades físicas do qubit, no limite de correção de erros e no pré-fator de cruzamento.two_qubit_joint_measurement_timeone_qubit_measurement_timetwo_qubit_gate_timeone_qubit_gate_time 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 erros

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. Esse parâmetro é altamente específico do aplicativo.

Por exemplo, se você estiver executando o algoritmo de Shor para fatorar números inteiros, um valor grande para o orçamento de erro pode ser tolerado, pois é possível verificar se as saídas são de fato os fatores primos da entrada. Por outro lado, um orçamento de erros menor pode ser necessário para um algoritmo que resolve um problema com uma solução, pois não é possível realizar a verificação de maneira 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}$ é o erro de implementação de qubits lógicos, o erro de estado T $\epsilon_{\rm dis}$ é o erro de produzir estados T por meio de destilação e o erro de porta de rotação $\epsilon_{\rm syn}$ é o erro de sintetizar portas de rotação com ângulos arbitrários.

Observação

A menos que outro valor seja especificado, o orçamento de erro $\epsilon$ é distribuído uniformemente entre o erro lógico, o erro de estado T e o erro de porta de rotação.

Observe que, para síntese de destilação e rotação, os respectivos orçamentos de erro $\epsilon_{\rm dis}$ e $\epsilon_{\rm syn}$ são distribuídos uniformemente entre todos os estados T necessários e todas as portas de rotação necessárias, respectivamente. 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.

Orçamento de erro de aprovação

Há duas maneiras de especificar o orçamento de erro definindo um número entre 0 e 1. Você pode passar o orçamento de erro ao executar qsharp.estimateo . 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 qsharp.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 total de erros e deve estar entre 0 e 1. Se um algoritmo quântico não contiver T estados ou rotações, 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 T estados e rotações:

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

Restrições

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

Parâmetro	Tipo de dados	Descrição
`logical_depth_factor`	float	Controle o tempo de execução. Se tiver um valor maior que 1, o número inicial de ciclos lógicos, também chamado de profundidade lógica, é multiplicado por esse número. Ao reduzir `logical_depth_factor`, você pode aumentar o número de invocações da fábrica T em um determinado momento, resultando em menos cópias da fábrica T necessárias para produzir o mesmo número de estados T. Quando você reduz o número de cópias de fábrica T, o tempo de execução do algoritmo aumenta de acordo. O fator de dimensionamento para o tempo de execução total pode ser maior, pois a taxa de erro lógico necessária aumenta devido ao número adicional de ciclos.
`max_t_factories`	Número inteiro	Número máximo de cópias de fábrica T. O Avaliador de Recursos determina os recursos necessários selecionando o número ideal de cópias de fábrica T que minimiza o número de qubits físicos usados, sem considerar a sobrecarga de tempo. O `max_t_factories` parâmetro limita o número máximo de cópias e, portanto, ajusta o número de ciclos lógicos de acordo. Para obter mais informações, consulte Estimativa física da fábrica T.
`max_duration`	cadeia de caracteres de tempo	Tempo de execução máximo para o algoritmo. O Avaliador de Recursos aceita apenas uma restrição de `max_duration` or `max_physical_qubits` no momento, mas não duas. Se `max_duration` for especificado, o Avaliador de Recursos tentará encontrar a melhor estimativa entre `max_physical_qubits` as soluções restritas pelo número máximo especificado.
`max_physical_qubits`	Número inteiro	Número máximo de qubits físicos para o algoritmo. O Avaliador de Recursos aceita apenas uma restrição de `max_duration` or `max_physical_qubits` no momento, mas não duas. Se `max_physical_qubits` for especificado, o Avaliador de Recursos tentará encontrar a melhor estimativa entre `max_duration` as soluções restritas pelo número máximo especificado.

O código a seguir mostra como especificar as restrições para um algoritmo quâ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

Observação

Se o valor fornecido max_duration ou max_physical_qubits for muito pequeno para encontrar uma solução viável, o Avaliador de Recursos retornará um erro. Se as restrições nem max_duration max_physical_qubits forem especificadas, o Avaliador de Recursos terá como objetivo encontrar uma solução com o menor tempo.

Dica

Você pode usar max_duration e max_physical_qubits influenciar o espaço da solução, potencialmente encontrando soluções com tempo de execução mais longo, mas um número menor de qubits em comparação com soluções sem essas restrições. Existe uma compensação entre o tempo de execução e o número de qubits, e essa compensação pode ser gerenciada com eficiência para alguns algoritmos, com efeitos variados em diferentes algoritmos. A Tabela IV em [arXiv:2211.07629] ilustra a utilização efetiva do trade-off entre o número de qubits e o tempo de execução para algoritmos de dinâmica quântica. Para obter mais informações, consulte Exemplo de estimativa de recursos quânticos com restrições de tempo ou número de qubits .

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 qsharp.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 unidade de destilação 15-1 space-efficient usa menos qubits do que 15-1 RM, mas requer mais runtime. Para saber mais, confira Tabela VI.

Dica

O uso de unidades de destilação predefinidas oferece melhor desempenho em comparação com as personalizadas.

Personalize 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 e a DistillationUnitSpecification ProtocolSpecificDistillationUnitSpecification classe.

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

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. Esses exemplos ilustram fórmulas usadas por padrão na implementação padrão.

Parâmetro	Fórmula longa	Fórmula curta
`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"

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 poderá ser aplicada a qubits físicos. Se apenas o último for fornecido, a unidade de destilação poderá ser aplicada a qubits lógicos. Se ambos forem fornecidos, a unidade de destilação poderá 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, substitui os valores de logical_qubit_specification no caso de ser aplicado na primeira rodada de destilação. O valor <protocol specific parameters> necessário deve logical_qubit_specification_first_round_override seguir o esquema:

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

Estimativa de 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 runtime 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 aspectos 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 runtime.

Observação

Se você executar o Avaliador de Recursos no Visual Studio Code usando a Q#opção : Calcular Estimativas de Recursos , a estimativa de fronteira de Pareto será habilitada por padrão.

Se você executar o Avaliador de recursos 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
                    }
                )

Para visualizar os resultados da estimativa de fronteira de Pareto, é possível usar a EstimatesOverview função. Esta função exibe os resultados da estimativa de fronteira em uma tabela e em um diagrama de espaço-tempo. Para obter mais informações, consulte Diagrama de espaço-tempo.

from qsharp_widgets import EstimatesOverview

EstimatesOverview(result)

Observação

Se você tiver algum problema ao trabalhar com o Avaliador de recursos, verifique a página Solução de problemas ou entre em contato com AzureQuantumInfo@microsoft.com.

Compartilhar via

Personalizar os target parâmetros do Avaliador de Recursos

Pré-requisitos

Parâmetros Target

Parâmetros físicos de qubit

Parâmetros para parâmetros de qubit predefinidos

Passando parâmetros de qubit predefinidos

Personalizar parâmetros de qubit predefinidos

Parâmetros de qubit para qubits baseados em porta

Parâmetros de qubit para qubits Majorana

Esquemas de correção de erros quânticos

Parâmetros para esquemas QEC predefinidos

Passando esquemas QEC predefinidos

Personalizar esquemas QEC predefinidos

Personalize seus esquemas QEC

Orçamento de erros

Orçamento de erro de aprovação

Restrições

Unidades de destilação

Personalize suas unidades de destilação

Estimativa de fronteira de Pareto

Próximas etapas

Comentários

Recursos adicionais