Partilhar via

Personalizar os target parâmetros do Estimador de Recursos

  • Artigo

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.

Nota

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

Pré-requisitos

Target Parâmetros

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 usando uma determinada tecnologia de qubit e com um conjunto fixo de escolhas arquitetônicas.

Portanto, 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, ou seja, o número de vezes que o programa tem permissão para malsucedido.
  • 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.

Gorjeta

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

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 os qubits. O conjunto de instruções físicas pode ser baseado em portões 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.

Você pode escolher entre seis parâmetros de qubit predefinidos, quatro dos quais têm conjuntos de instruções baseados em porta 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âmetro Qubit Classe API Python Description
"qubit_gate_ns_e3" , "qubit_gate_ns_e4" GATE_NS_E3 , GATE_NS_E4 Os tempos de operação e fidelidades podem corresponder a versões futuras de qubits transmon supercondutores, ou qubits spin, que normalmente têm tempos de operação no regime de nanossegundos. Para estes qubits, presume-se que as operações de gate e medição levem 50 ns e 100 ns, respectivamente. As taxas de erro de porta de qubit único e de dois qubits são assumidas como $10^{-3}$ como um realista targete $10^{-4}$ como um 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 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 pressupostos típicos para qubits de íons, as operações de gate e medição levam 100 μs. A taxa de erro para portões Clifford de qubit único é de $10^{-3}$ como realista target e $10^{-4}$ como otimista target, enquanto a taxa de erro para portões Clifford não-Clifford de qubit único (portão T) é de $10^{-6}$. Para portas de dois qubits, a taxa de erro é de $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 fidelidades podem corresponder a futuras versões melhoradas de qubits Majorana. Para estes qubits, presume-se que as operações de gate 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 assumidas como $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%.

Nota

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 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 classe durante a qubitParams execução qsharp.estimatedo . 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 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 Gate

Identificador Python Tipo de dados Description
name string Nome do modelo qubit
instruction_set "gate_based" Tecnologia de qubit subjacente
one_qubit_measurement_time Cadeia de tempo Tempo de operação para medição de qubit único ($t_{\rm meas}$) em ns
one_qubit_gate_time Cadeia de tempo Tempo de operação para porta de qubit único ($t_{\rm gate}$) em ns
two_qubit_gate_time Cadeia de tempo Tempo de operação para porta de dois qubits em ns
t_gate_time Cadeia de tempo Tempo de operação para portão não-Clifford de qubit único em ns
one_qubit_measurement_error_rate flutuante Taxa de erro para medição de qubit único
one_qubit_gate_error_rate flutuante Taxa de erro para o portão Clifford de qubit único ($p$)
two_qubit_gate_error_rate flutuante Taxa de erro para o portão Clifford de dois qubits
t_gate_error_rate flutuante Taxa de erro para preparar o estado não-Clifford de qubit único ($p_T$)
idle_error_rate flutuante 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 gate:

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

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 de Majorana

Identificador Python Tipo de dados Description
name string Nome do modelo qubit
instruction_set "Majorana" Tecnologia de qubit subjacente
one_qubit_measurement_time Cadeia de tempo Tempo de operação para medição de qubit único ($t_{\rm meas}$) em ns
two-qubit_joint_measurement_time Cadeia de tempo Tempo de operação para medição de dois qubits em ns
t_gate_time Cadeia de tempo Tempo de operação para portão não-Clifford de qubit único em ns
one_qubit_measurement_error_rate flutuante Taxa de erro para medição de qubit único
two_qubit_joint_measurement_error_rate flutuante Taxa de erro para medição de dois qubits
t_gate_error_rate flutuante Taxa de erro para preparar o estado não-Clifford de qubit único ($p_T$)
idle_error_rate flutuante 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

Nota

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)

Nota

Se você especificar um único valor numérico para taxas de erro de qubit único e de 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 tais valores, onde os sufixos de tempo possíveis são ns, µs (ou us), mse s.

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 = 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 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_ratetwo_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 erros.

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

Protocolo QEC Classe API Python Description
"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 de Majorana é baseado em arXiv:1909.03002 e arXiv:2007.00307.
"floquet_code" FLOQUET_CODE Apenas para qubits de Majorana. O código do floquet é baseado em arXiv:2202.11829.

Nota

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

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

Aprovação de esquemas de 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.estimateo . 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 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,
                    }
                })

Nota

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

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$ 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. Finalmente, 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_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}$ é o erro 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 o erro de porta de rotação $\epsilon_{\rm syn}$ é o erro de sintetizar portas de rotação com ângulos arbitrários.

Nota

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

Observe que, para destilação e síntese de rotação, os respetivos orçamentos de erro $\epsilon_{\rm dis}$ e $\epsilon_{\rm syn}$ são uniformemente distribuídos 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 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 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 tempo de execução.

Parâmetro Tipo de dados Description
logical_depth_factor flutuante 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_factoro , 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 tempo de execução do algoritmo aumenta de acordo. O fator de dimensionamento para o tempo de execução total pode ser maior, porque a taxa de erro lógico necessária aumenta devido ao número adicional de ciclos.
max_t_factories integer Número máximo de cópias T de fábrica. O Estimador 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 em conformidade. Para obter mais informações, consulte Estimativa física de fábrica T.
max_duration Cadeia de tempo Tempo de execução máximo para o algoritmo. O Estimador de Recursos aceita apenas uma ou max_duration max_physical_qubits restrições no momento, mas não duas. Se max_duration for especificado, o Estimador de Recursos tentará encontrar a melhor estimativa para max_physical_qubits entre as soluções limitadas pelo número máximo especificado.
max_physical_qubits integer Número máximo de qubits físicos para o algoritmo. O Estimador de Recursos aceita apenas uma ou max_duration max_physical_qubits restrições no momento, mas não duas. Se max_physical_qubits for especificado, o Estimador de Recursos tentará encontrar a melhor estimativa para max_duration entre as soluções limitadas 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

Nota

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

Gorjeta

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 um trade-off entre o tempo de execução e o número de qubits, e esse trade-off pode ser gerenciado de forma eficiente 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 Estimativa quântica de recursos com amostra de 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 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.

Gorjeta

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

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 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. Estes 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 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 caso se aplicado na primeira série 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 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.

Nota

Se você executar o Estimador 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 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 qsharp_widgets import EstimatesOverview

EstimatesOverview(result)

Nota

Se tiver algum problema ao trabalhar com o Estimador de Recursos, consulte a página Resolução de problemas ou contacte AzureQuantumInfo@microsoft.com.

Próximos passos