Personalizar os target parâmetros do Avaliador de Recursos

  • Artigo

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á targetusando. 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, marcar a página Solução de problemas.

Pré-requisitos

Parâmetros de destino

O Avaliador de Recursos calcula a estimativa de recursos, como o número de qubits e o tempo de execução, o que seria necessário para implementar um determinado algoritmo quântico usando uma determinada tecnologia 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 começar facilmente:

Parâmetros de qubit físico

Quando o Avaliador de Recursos modela as suposições físicas do qubit, 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 Qubit Classe de API do 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 rotação, que normalmente têm tempos de operação no regime de nanossegundos. Para esses qubits, presume-se que as operações de portão e medida levem 50 ns e 100 ns, respectivamente. As taxas de erro de portão de qubit único e de dois qubits são consideradas us$ 10^{-3}$ como realista targete US$ 10^{-4}$ como otimista target para um sistema escalonado.
"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 com base em íons, que normalmente têm tempos de operações no regime de microssegundos. Com base em suposições típicas para qubits de íons, as operações de portão e medição são consideradas 100 μs. A taxa de erro para portões Clifford de qubit único é de US$ 10^{-3}$ como realista target e US$ 10^{-4}$ como otimista target, enquanto a taxa de erro para portões não Clifford de qubit único é de US$ 10^{-6}$. Para portões 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 versões aprimoradas futuras de qubits Majorana. Para esses qubits, presume-se que as operações de porta e medida levem 100 ns. Para considerar a proteção topológica no hardware, as taxas de erro de medida conjunta de qubit único e de dois qubits (taxas de erro clifford) são consideradas $10^{-4}$ como realista targete $10^{-6}$ como otimista target. As operações não Clifford nesta arquitetura não têm proteção topológica, a taxa de erro para portões T físicos não Clifford é de 5%.

Observação

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

Para referência, os parâmetros 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 qubit predefinidos

Há duas maneiras de especificar programaticamente parâmetros qubit predefinidos. Você pode selecionar o nome do modelo qubit para a qubitParams classe ao executar qsharp.estimate. 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 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 qubit predefinidos

Você pode personalizar parâmetros qubit predefinidos especificando o nome e atualizando qualquer um dos outros valores. Por exemplo, para diminuir a taxa de erro da medida 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 qubit para qubits baseados em gate

Identificador do Python Tipo de dados Descrição
name string Nome do modelo qubit
instruction_set "gate_based" Tecnologia 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 portão de qubit único ($t_{\rm gate}$) em ns
two_qubit_gate_time cadeia de caracteres de tempo Tempo de operação para portão de dois qubits em ns
t_gate_time cadeia de caracteres de tempo Tempo de operação para portão 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 o portão Clifford de qubit único ($p$)
two_qubit_gate_error_rate FLOAT Taxa de erro para o portão 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 à idling

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

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 especificados, os valores de e padrão one_qubit_gate_timepara two_qubit_gate_time , os valores de e t_gate_error_rate padrão para one_qubit_gate_error_ratetwo_qubit_gate_error_rate e o valor para padrão one_qubit_measurement_error_ratepara idle_error_rate .t_gate_time

Parâmetros qubit para qubits Majorana

Identificador do Python Tipo de dados Descrição
name string Nome do modelo qubit
instruction_set "majorana" Tecnologia 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 portão 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 à idling

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 especificados, os valores de e padrão one_qubit_measurement_timepara two_qubitJointMeasurementTime , os valores de e t_gate_error_rate padrão para one_qubit_measurement_error_ratetwo_qubit_joint_measurement_error_rate e o valor para padrão one_qubit_measurement_error_ratepara idle_error_rate .t_gate_time

Para one_qubit_measurement_error_rate e two_qubit_joint_measurement_error_rate, você pode especificar as taxas de erro correspondentes a leituras de medida, readoute processamento de medida, 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 medida do qubit 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, a especificação "qubit": {"oneQubitGateTime":"200 ns"} modelará um qubit baseado em portão no qual a hora do portão de dois qubits e a hora do portão de um qubit são de 200 ns. Para unidades, você precisa especificar cadeias de caracteres 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), mse s.

Esquemas de correção de erros quânticos

Para executar aplicativos quânticos de escala prática, as operações quânticas devem ter baixas taxas de erro. Normalmente, essa taxa targets de erros está além dos recursos de qubits físicos brutos. Para superar essa limitação, a QEC (correção de erros quânticos) e a computação tolerante a falhas são duas técnicas cruciais que formam os blocos de construção de computadores quânticos em larga 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 melhor as informações quânticas do que os qubits físicos subjacentes.

A distância do código de correção de erro (ou apenas a distância de código para abreviar) é um parâmetro que controla o número de erros que podem ser corrigidos. Assim, 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. A meta é localizar a distância mínima do código que pode atingir a taxa de erro necessária definida para um aplicativo específico.

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

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

em que $d$ é a distância do código, $p$ é a taxa de erro física e $p^*$ é o limite de correção de erro quântico. A taxa de erro física $p$ é extraída dos parâmetros qubit como a taxa de erro de pior caso de qualquer operação clifford física no dispositivo.

Em particular, $p = {}$ max(one_qubit_measurement_error_rate, one_qubit_gate_error_rate, two_qubit_gate_error_rate) para parâmetros qubit com um conjunto de instruções baseado em portão e $p = {}$ max(one_qubit_measurement_error_rate, two_qubit_joint_measurement_error_rate) para parâmetros 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 erro suprime erros.

Protocolo QEC Classe de API do Python Descrição
"surface_code" SURFACE_CODE O código de superfície baseado em portão é 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 Somente 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".

Os parâmetros exatos para cada esquema QEC predefinido (incluindo um prefator de cruzamento $a$, que pode ser extraído numericamente para simulações) 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 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 e padrão para , o valor para "errorCorrectionThreshold" o padrão é 0.01e o valor para defaults para "crossingPrefactor"0.03."logicalCycleTime""oneQubitMeasurementTime""physicalQubitsPerLogicalQubit"

Personalizar 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 um 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 one_qubit_gate_time, two_qubit_gate_time, one_qubit_measurement_timee two_qubit_joint_measurement_time, cujos valores são obtidos do campo correspondente dos parâmetros de 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 físicas do qubit, no limite de correção de erro e no prefator de cruzamento. As variáveis de tempo e eccDistance podem ser usadas para descrever a logicalCycleTime fórmula. Para a fórmula physicalQubitsPerLogicalQubit , somente o eccDistance pode ser usado.

Orçamento de erros

O orçamento total de erros $\epsilon$ define o erro total 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, que corresponde a 0,1%. Em outras palavras, o algoritmo tem permissão para 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 do Shor para considerar inteiros, um valor grande para o orçamento de erro poderá ser tolerado, pois pode-se marcar que as saídas são, de fato, os principais fatores 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} $$

Se não for especificado, o orçamento de erro $\epsilon$ será distribuído uniformemente e se aplicará aos erros $\epsilon_{\log}$ para implementar qubits lógicos, o orçamento de erro $\epsilon_{\rm dis}$ produzirá estados T por meio da destilação e um orçamento de erro $\epsilon_{\rm syn}$ para sintetizar portões de rotação com ângulos arbitrários.

Observe que, para destilação e síntese de 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 todos os portões de rotação necessários, respectivamente. Se não houver portões 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.

Aprovação do orçamento de erros

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.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 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 estados T 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 estados T 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 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 runtime.

Parâmetro Tipo de dados Descrição
logical_depth_factor FLOAT Controlar o tempo de execução. Se ele tiver um valor maior que 1, o número inicial de ciclos lógicos, também chamado de profundidade lógica, será multiplicado por esse número. Ao reduzir logical_depth_factor, você pode aumentar o número de invocação da fábrica T em um determinado tempo, resultando em menos cópias de 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 runtime do algoritmo aumenta adequadamente. O fator de dimensionamento para o runtime total pode ser maior, pois a taxa de erro lógica necessária aumenta devido ao número adicional de ciclos.
max_t_factories 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 adequadamente. Para obter mais informações, consulte Estimativa física de fábrica T.
max_duration cadeia de caracteres de tempo Runtime máximo para o algoritmo. O Avaliador de Recursos aceita apenas uma das max_duration restrições ou 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 inteiro Número máximo de qubits físicos para o algoritmo. O Avaliador de Recursos aceita apenas uma das max_duration restrições ou 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 para max_duration ou max_physical_qubits for muito pequeno para encontrar uma solução viável, o Avaliador de Recursos retornará um erro. Se nem max_duration restrições max_physical_qubits forem especificadas, o Avaliador de Recursos pretende encontrar uma solução com o menor tempo.

Dica

Você pode usar max_duration e max_physical_qubits para influenciar o espaço da solução, potencialmente encontrando soluções com runtime 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 runtime e o número de qubits, e essa compensação pode ser gerenciada com eficiência para alguns algoritmos, com efeitos variados em algoritmos diferentes. A Tabela IV em [arXiv:2211.07629] ilustra a utilização efetiva da compensação entre o número de qubits e o runtime para algoritmos de dinâmica quântica. Para obter mais informações, consulte Estimativa de recursos quânticos com tempo ou número de exemplo de restrições 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 fornece melhor desempenho em comparação com as personalizadas.

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

Todos os parâmetros numéricos devem ser positivos. O displayName especifica como a unidade de destilação será exibida nos resultados da saída.

O código a seguir mostra como especificar os parâmetros de unidade de destilação para um algoritmo quântico usando a DistillationUnitSpecification classe e a 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 indicado como c.
  • readout_error_rate, também indicado como r.
  • input_error_rate, também indicado como z.

Consulte os exemplos a seguir de fórmulas personalizadas usando notação longa e curta. Esses exemplos ilustram fórmulas usadas por padrão dentro da 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ó poderá ser fornecido se logical_qubit_specification for especificado. Nesse caso, ele substitui os valores de logical_qubit_specification caso seja aplicado na primeira rodada de destilação. O valor <protocol specific parameters> necessário para logical_qubit_specification_first_round_override deve 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 runtime 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. Entender a compensação entre o runtime e a escala do sistema é um dos aspectos mais importantes da estimativa de recursos.

A estimativa de fronteira 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 opção Q#: Calcular Estimativas de Recursos, a estimativa de fronteira pareto será habilitada por padrão.

Se você executar o Avaliador de Recursos no 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 do Pareto, poderá usar a EstimatesOverview função . Essas funções exibem os resultados da estimativa de fronteira na tabela e 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, marcar a página Solução de problemas ou entre em contato com AzureQuantumInfo@microsoft.com.

Próximas etapas