target Настройка параметров оценки ресурсов
В этой статье показано, как настроить target параметры оценки ресурсов Azure Quantum в соответствии с характеристиками компьютера, которые вы используете target. Средство оценки ресурсов использует эти параметры для оценки ресурсов, необходимых для запуска квантового алгоритма на квантовом компьютере.
Примечание.
Если при работе с оценщиком ресурсов возникла проблема, ознакомьтесь со страницей устранения неполадок.
Необходимые компоненты
Среда Python с установленным Python и Pip .
Последняя версия Visual Studio Code или откройте VS Code в Интернете.
VS Code с установленными расширениями Jupyter для Azure Quantum Development Kit, Python и Jupyter .
Последние версии Azure Quantum
qsharp
иqsharp-widgets
пакетов.python -m pip install --upgrade qsharp qsharp-widgets
Параметры целевых расположений
Средство оценки ресурсов вычисляет оценку ресурсов, таких как количество кубитов и время выполнения, которое потребуется для реализации заданного квантового алгоритма с помощью заданной технологии кубита и с фиксированным набором вариантов архитектуры.
Поэтому оценка ресурсов принимает набор входных данных с предварительно определенными значениями, чтобы легко приступить к работе:
- Физическая модель кубита, которая определяет свойства базовых физических кубитов.
- Схема исправления квантовых ошибок (QEC), которая является предполагаемой схемой исправления квантовых ошибок.
- Бюджет ошибок, который является общей разрешенной ошибкой, то есть количество раз, когда программа допускает отмену.
- Ограничения на уровне компонента, которые являются числом логических циклов и числом копий фабрики T.
- Единицы дистилляции для указания алгоритмов дистилляции фабрик T.
- Оценка границ Pareto для выполнения нескольких оценок количества кубитов и среды выполнения для одного и того же алгоритма.
Совет
Если вы уже знаете некоторые предварительно вычисляемые оценки для операции, вы также можете включить их и оптимизировать выполнение оценки ресурсов. Дополнительные сведения см. в разделе "Использование известных оценок" с помощью средства оценки ресурсов.
Параметры физического кубита
Когда оценка ресурсов моделирует предположения физического кубита, для работы кубитов используется два разных набора физических инструкций. Набор физических инструкций может быть как на основе шлюза, так и на основе Майораны. Набор инструкций на основе шлюза обеспечивает однокубитное измерение, однокубитные ворота (включая T-шлюзы) и двухкубитные шлюзы. Набор инструкций Majorana предоставляет физические T-шлюзы, однокубитные измерения и операции измерения с двумя кубитами.
Вы можете выбрать шесть предопределенных параметров кубита, четыре из которых имеют наборы инструкций на основе шлюза и два с набором инструкций Majorana. Эти модели кубитов охватывают диапазон времени операции и частоту ошибок, что позволяет достаточно исследовать затраты на ресурсы, необходимые для обеспечения практических квантовых приложений.
Параметр Кубита | Класс API Python | Description |
---|---|---|
"qubit_gate_ns_e3" , "qubit_gate_ns_e4" |
GATE_NS_E3 , GATE_NS_E4 |
Время операции и точность могут соответствовать будущим версиям сверхпроводящих кубитов или кубитов спина, которые обычно имеют время операции в режиме nanosecond. Для этих кубитов предполагается, что операции с воротами и измерениями принимают 50 ns и 100 ns соответственно. Ставки ошибок с одним кубитом и двумя кубитами считаются $10^$ реалистичным, и $10^{-3}{-4}$ targetв качестве оптимистичного target для масштабируемой системы. |
"qubit_gate_us_e3" , "qubit_gate_us_e4" |
GATE_US_E3 , GATE_US_E4 |
Время операций и точность могут соответствовать будущим версиям кубитов на основе ионов, которые обычно имеют время операций в режиме микросекунда. На основе типичных предположений для кубитов ионов предполагается, что операции с воротами и измерениями принимают 100 мкс. Частота ошибок для однокубитных ворот Clifford составляет $ 10^$ как реалистичный target и $ 10^{-4}{-3}$ как оптимистичныйtarget, в то время как скорость ошибок для однокубитных ворот не Клиффорд (T ворота) составляет $ 10^{-6}$. Для двухкубитных ворот скорость ошибок составляет $10^$ как реалистичная target и $10^{-3}{-4}$ в качестве оптимистичногоtarget. |
"qubit_maj_ns_e4" , "qubit_maj_ns_e6" |
MAJ_NS_E4 , MAJ_NS_E6 |
Время операции и точность могут соответствовать будущим улучшенным версиям кубитов Майораны. Для этих кубитов предполагается, что операции с воротами и измерениями принимают 100 ns. Для учета топологической защиты в оборудовании, однокубитных и двухкубитных коэффициентов ошибок измерения совместного измерения (ставки ошибок Clifford) предполагается, что $10^{-4}$ является реалистичным target, и $10^{-6}$ как оптимистичный target. Не клиффордские операции в этой архитектуре не имеют топологической защиты, частота ошибок для не-Клиффорд физических T шлюзов составляет 5%. |
Примечание.
Если другое значение не указано, значение по умолчанию для модели кубита не указано "qubit_gate_ns_e3"
.
Параметры для предопределенных параметров кубита
Для справки полные предопределенные параметры кубита приведены следующим образом:
{
"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
}
}
Передача предопределенных параметров кубита
Существует два способа программного указания предопределенных параметров кубита. При выполнении qubitParams
qsharp.estimate
можно выбрать имя модели кубита для класса. Например, чтобы выбрать "qubit_maj_ns_e6"
параметр кубита, напишите:
qsharp.estimate("RunProgram()", params=
{"qubitParams": {
"name": "qubit_maj_ns_e6"
},
})
Вы также можете передать параметры кубита в EstimatorParams
класс с помощью QubitParams
. Например, чтобы выбрать MAJ_NS_E6
параметр кубита, напишите:
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)
Настройка предопределенных параметров кубита
Вы можете настроить предопределенные параметры кубита, указав имя, а затем обновив любые другие значения. Например, чтобы уменьшить частоту ошибок двухкубитного совместного измерения в "qubit_maj_ns_e4", напишите:
qsharp.estimate("RunProgram()", params=
{"qubitParams": {
"name": "qubit_maj_ns_e4",
"twoQubitJointMeasurementErrorRate": 1e-5,
},
})
Кроме того, вы можете передать инструкции в виде списка.
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
Параметры Кубита для кубитов на основе шлюзов
Идентификатор Python | Тип данных | Description |
---|---|---|
name |
строка | Имя модели кубита |
instruction_set |
"gate_based" | Базовая технология кубита |
one_qubit_measurement_time |
строка времени | Время операции для измерения с одним кубитом ($t_{\rm meas}$) в ns |
one_qubit_gate_time |
строка времени | Время операции для однокубитных шлюзов ($t_{\rm gate}$) в ns |
two_qubit_gate_time |
строка времени | Время операции для двух кубитовых ворот в ns |
t_gate_time |
строка времени | Время операции для однокубитных ворот без Клиффорда в ns |
one_qubit_measurement_error_rate |
с плавающей запятой | Частота ошибок для измерения с одним кубитом |
one_qubit_gate_error_rate |
с плавающей запятой | Частота ошибок для однокубитных ворот Clifford ($p$) |
two_qubit_gate_error_rate |
с плавающей запятой | Частота ошибок для ворот с двумя кубитами Клиффорд |
t_gate_error_rate |
с плавающей запятой | Частота ошибок для подготовки состояния без Клиффорда с одним кубитом ($p_T$) |
idle_error_rate |
с плавающей запятой | Частота ошибок, соответствующая простою |
В следующем коде показано, как указать настраиваемые параметры кубита для набора инструкций на основе шлюза:
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
Примечание.
Если значение не указано, значения для и t_gate_time
по умолчанию , значения для two_qubit_gate_error_rate
и t_gate_error_rate
по умолчанию , а также значение по умолчанию для idle_error_rate
значений one_qubit_measurement_error_rate
по умолчаниюone_qubit_gate_time
one_qubit_gate_error_rate
.two_qubit_gate_time
Параметры Кубита для кубитов Майораны
Идентификатор Python | Тип данных | Description |
---|---|---|
name |
строка | Имя модели кубита |
instruction_set |
"майорана" | Базовая технология кубита |
one_qubit_measurement_time |
строка времени | Время операции для измерения с одним кубитом ($t_{\rm meas}$) в ns |
two-qubit_joint_measurement_time |
строка времени | Время операции для измерения двух кубитов в ns |
t_gate_time |
строка времени | Время операции для однокубитных ворот без Клиффорда в ns |
one_qubit_measurement_error_rate |
с плавающей запятой | Частота ошибок для измерения с одним кубитом |
two_qubit_joint_measurement_error_rate |
с плавающей запятой | Частота ошибок для измерения двух кубитов |
t_gate_error_rate |
с плавающей запятой | Частота ошибок для подготовки состояния без Клиффорда с одним кубитом ($p_T$) |
idle_error_rate |
с плавающей запятой | Частота ошибок, соответствующая простою |
Минимальный шаблон для набора инструкций на основе Majorana со всеми необходимыми значениями:
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
Примечание.
Если значение не указано, значения для и t_gate_time
по умолчанию , значения для two_qubit_joint_measurement_error_rate
и t_gate_error_rate
по умолчанию , а также значение по умолчанию для idle_error_rate
значений one_qubit_measurement_error_rate
по умолчаниюone_qubit_measurement_time
one_qubit_measurement_error_rate
.two_qubitJointMeasurementTime
Для one_qubit_measurement_error_rate
иtwo_qubit_joint_measurement_error_rate
, можно указать частоту ошибок, соответствующую считываниям измерений, readout
и обработке измерений. process
Эти значения могут быть либо числами, либо <double>
парами чисел. Рассмотрим пример.
params.qubit_params.two_qubit_joint_measurement_error_rate = \
MeasurementErrorRate(process=0.00005, readout=0.00007)
Примечание.
Если указать одно числовое значение для однокубитных и двухкубитных скоростей ошибок в измерении majorana qubit, скорость чтения и обработки может быть равной.
Внимание
Все значения, которые не указаны, принимают значение по умолчанию, например, указывая "qubit": {"oneQubitGateTime":"200 ns"}
, будет моделировать шлюз на основе шлюза, в котором время двух кубитов и однокубитное время шлюза равно 200 ns. Для единиц необходимо указать строки времени, которые являются числами с плавающей запятой двойной точности, а затем пробелом и единицей времени для таких значений, где возможны суффиксы ns
времени , µs
(или us
) ms
и s
.
Схемы исправления квантовых ошибок
Для выполнения практических квантовых приложений квантовые операции должны иметь низкие частоты ошибок. Эта частота targets ошибок обычно выходит за рамки возможностей необработанных физических кубитов. Чтобы преодолеть это ограничение, исправление квантовых ошибок (QEC) и отказоустойчивое вычисление являются двумя важными методами, которые образуют стандартные блоки крупномасштабных квантовых компьютеров. Во-первых, QEC позволяет создавать несколько подверженных ошибкам физических кубитов и создавать более надежный логический кубит, который сохраняет квантовую информацию лучше, чем базовые физические кубиты.
В средстве оценки ресурсов используется следующая формула для моделирования логических ошибок с помощью экспоненциальной модели.
$$ P = a\left(\frac{p}{p^*}\right)^{\frac{d+1}{2}} $$
где $a$ является префактором пересечения, $d$ — это расстояние кода, $p$ — это физическая частота ошибок, а $p^*$ — порог исправления квантовых ошибок. Префактор пересечения $a$ можно извлечь числовым образом для моделирования.
Расстояние кода $d$ — это параметр, который определяет количество ошибок, которые можно исправить. Таким образом, расстояние кода определяет частоту ошибок логических кубитов и количество физических кубитов, необходимых для их кодирования. Точность и количество физических кубитов увеличиваются на расстоянии кода. Цель схемы QEC — найти минимальное расстояние кода, которое может достичь требуемой частоты ошибок для конкретного приложения.
Физическая частота ошибок $p$ извлекается из параметров кубита в качестве наихудшей частоты ошибок любой физической операции Clifford, выполняемой на устройстве. В частности, $p = {}$ max(one_qubit_measurement_error_rate
, one_qubit_gate_error_rate
) two_qubit_gate_error_rate
для параметров кубита с набором инструкций на основе шлюза и $p = {}$ max(one_qubit_measurement_error_rate
, two_qubit_joint_measurement_error_rate
) для параметров кубита с набором инструкций Majorana. Схемы QEC обычно имеют пороговое значение частоты ошибок $p^*$ ниже, что исправление ошибок подавляет ошибки.
Оценка ресурсов Azure Quantum поддерживает две предопределенные схемы QEC: код поверхности и флокетный код.
Протокол QEC | Класс API Python | Description |
---|---|---|
"surface_code " |
SURFACE_CODE |
Код поверхности на основе ворот основан на arXiv:1208.0928 и arXiv:1009.3686. Код поверхности Majorana основан на arXiv:1909.03002 и arXiv:2007.00307. |
"floquet_code " |
FLOQUET_CODE |
Только для кубитов Майораны. Код floquet основан на arXiv:2202.11829. |
Примечание.
Если другое значение не указано, значение по умолчанию для схемы QEC равно "surface_code".
Параметры для предопределенных схем QEC
Ниже приведены точные параметры для каждой предопределенной схемы QEC.
{
"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)"
}
}
Передача предопределенных схем QEC
Существует два способа указать предопределенные схемы QEC. При запуске qsharp.estimate
можно выбрать имя модели QEC для "qecScheme"
класса. Например, чтобы выбрать флокотный код, напишите:
qsharp.estimate("RunProgram()", params=
{"qecScheme": {
"name": "floquet_code"
}
})
Вы также можете передать список параметров оценки классу с помощью QECScheme
класса.EstimatorParams
Например, чтобы выбрать флокотный код, напишите:
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)
Настройка предопределенных схем QEC
Вы можете настроить предопределенные схемы QEC, указав имя, а затем обновив любые другие значения. Например, чтобы увеличить префактор пересечения в флокетном коде, напишите:
qsharp.estimate("RunProgram()", params=
{"qecScheme": {
"name": "floquet_code",
"crossingPrefactor": 0.07,
}
})
Примечание.
Если значение не указано, значения для и "physicalQubitsPerLogicalQubit"
по умолчанию , значение по умолчанию для "errorCorrectionThreshold"
значений по умолчанию и значение "crossingPrefactor"
по умолчанию0.03
"oneQubitMeasurementTime"
0.01
."logicalCycleTime"
Настройка схем QEC
Оценка ресурсов может абстрагирование настраиваемой схемы QEC на основе приведенной выше формулы, указав значения для "crossingPrefactor"
$a$ и "errorCorrectionThreshold"
$p^*$. Кроме того, необходимо указать "logicalCycleTime"
время выполнения одной логической операции, которая зависит от расстояния кода и допущений физического времени операции базовых физических кубитов. Наконец, вторая формула вычисляет "physicalQubitsPerLogicalQubit"
, то есть количество физических кубитов, необходимых для кодирования одного логического кубита на основе расстояния кода.
В качестве шаблона для схем QEC можно использовать следующий код:
qsharp.estimate("RunProgram()", params=
{"qecScheme": {
"crossingPrefactor": <double>,
"errorCorrectionThreshold": <double>,
"logicalCycleTime": <formula string>,
"physicalQubitsPerLogicalQubit": <formula string>
}
})
В формулах можно использовать переменные , one_qubit_measurement_time
two_qubit_gate_time
и two_qubit_joint_measurement_time
, значения которых взяты из соответствующего поля из физических параметров кубита, а также переменную one_qubit_gate_time
eccDistance
для расстояния кода, вычисляемого для логического кубита, на основе физических свойств кубита, порог исправления ошибок и префакторинг пересечения. Переменные времени и eccDistance
могут использоваться для описания формулы logicalCycleTime
. Для формулы можно использовать только eccDistance
те physicalQubitsPerLogicalQubit
же формулы.
Бюджет ошибок
Общий бюджет ошибок $\epsilon$ задает общую допустимую ошибку для алгоритма, то есть допустимую вероятность сбоя алгоритма. Его глобальное значение должно быть от 0 до 1, а значение по умолчанию — 0,001, которое соответствует 0,1%. Другими словами, алгоритм может завершиться сбоем не более одного раза в 1000 выполнений. Этот параметр является очень конкретным приложением.
Например, если вы используете алгоритм Shor для факторинга целых чисел, большое значение бюджета ошибок может быть разрешено, так как можно проверить, что выходные данные действительно являются основными факторами входных данных. С другой стороны, для решения проблемы с решением может потребоваться меньший бюджет ошибок, который не может быть эффективно проверен.
Бюджет ошибки соответствует сумме трех частей:
$$ \epsilon = \epsilon_{\log} + \epsilon_{\rm dis} + \epsilon_{\rm syn} $$
Логические ошибки $\epsilon_{\log}$ — это ошибка реализации логических кубитов, ошибка состояния T $\epsilon_{\rm dis}$ — это ошибка производства состояний T через дистилляцию, а ошибка ворот поворота $\epsilon_{\rm syn}$ — это ошибка синтеза ворот поворота с произвольными углами.
Примечание.
Если не указано другое значение, бюджет ошибки $\epsilon$ равномерно распределяется между логической ошибкой, ошибкой состояния T и ошибкой шлюза поворота.
Обратите внимание, что для синтеза дистилляции и вращения соответствующие бюджеты ошибок $\epsilon_{\rm dis}$ и $\epsilon_{\rm syn}$ равномерно распределяются между всеми необходимыми состояниями T и всеми необходимыми шлюзами поворота соответственно. Если в входном алгоритме нет ворот поворота, бюджет ошибок равномерно распределяется по логическим ошибкам и ошибкам состояния T.
Передача бюджета ошибок
Существует два способа указать бюджет ошибок, задав число от 0 до 1. При выполнении qsharp.estimate
можно передать бюджет ошибок. Например, чтобы выбрать бюджет ошибки 1/3, напишите:
qsharp.estimate("RunProgram()", params=
{'errorBudget': 0.333
})
Вы также можете передать параметры бюджета ошибок в EstimatorParams
класс.
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)
Кроме того, можно отдельно указать каждый компонент бюджета ошибок. Сумма всех значений — это общий бюджет ошибок и должен составлять от 0 до 1. Если квантовый алгоритм не содержит состояния T или повороты, значения t_states
и rotations
могут быть соответственно 0.
В следующем коде показано, как указать параметр бюджета ошибки с состояниями T и поворотами:
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
Ограничения
Класс можно использовать "constraints"
для применения ограничений на уровне компонента фабрики T. Изменив ограничения, можно оптимизировать оценки, чтобы уменьшить количество кубитов или сократить время выполнения.
Параметр | Тип данных | Description |
---|---|---|
logical_depth_factor |
с плавающей запятой | Управление временем выполнения. Если значение больше 1, начальное число логических циклов, также называемое логической глубиной, умножается на это число. logical_depth_factor Уменьшая количество вызовов фабрики T в определенное время, можно увеличить число копий фабрики T, необходимых для производства того же количества состояний T. При уменьшении числа копий фабрики T среда выполнения алгоритма увеличивается соответствующим образом. Коэффициент масштабирования для общей среды выполнения может быть больше, так как требуемая логическая частота ошибок увеличивается из-за дополнительного числа циклов. |
max_t_factories |
integer | Максимальное количество копий фабрики T. Оценка ресурсов определяет ресурсы, необходимые при выборе оптимального количества копий фабрики T, которые минимизирует количество используемых физических кубитов, не учитывая затраты на время. Параметр max_t_factories ограничивает максимальное количество копий и, следовательно, корректирует количество логических циклов соответствующим образом. Дополнительные сведения см. в разделе "Физическая оценка фабрики T". |
max_duration |
строка времени | Максимальная среда выполнения для алгоритма. Оценка ресурсов принимает только одно или max_duration ограничение в то время, max_physical_qubits но не два. Если max_duration задано, средство оценки ресурсов пытается найти лучшую оценку для max_physical_qubits решения, ограниченного максимальным числом. |
max_physical_qubits |
integer | Максимальное количество физических кубитов для алгоритма. Оценка ресурсов принимает только одно или max_duration ограничение в то время, max_physical_qubits но не два. Если max_physical_qubits задано, средство оценки ресурсов пытается найти лучшую оценку для max_duration решения, ограниченного максимальным числом. |
В следующем коде показано, как указать ограничения для квантового алгоритма:
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
Примечание.
Если указанное или max_physical_qubits
слишком малое значениеmax_duration
, чтобы найти возможное решение, средство оценки ресурсов возвращает ошибку. Если ни ограничения не max_duration
max_physical_qubits
указаны, средство оценки ресурсов стремится найти решение с коротким временем.
Совет
Вы можете использовать max_duration
и max_physical_qubits
влиять на пространство решений, потенциально находить решения с более длительной средой выполнения, но меньшее количество кубитов по сравнению с решениями без этих ограничений. Существует компромисс между средой выполнения и числом кубитов, и этот компромисс можно эффективно управлять для некоторых алгоритмов с различными эффектами. Таблица IV в [arXiv:2211.07629] иллюстрирует эффективное использование компромисса между количеством кубитов и средой выполнения для квантовых динамических алгоритмов. Дополнительные сведения см. в статье "Оценка ресурсов Quantum с временем или числом ограничений кубитов".
Единицы дистилляции
Вы можете указать спецификации для алгоритмов дистилляции фабрик T с классомDistillationUnitSpecification
. Спецификация может быть предварительно определенной или настраиваемой. Вы можете указать предопределенную спецификацию, выбрав имя единицы дистилляции: 15-1 RM
или 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)
В обоих случаях нотация 15-1 означает 15 входных состояний T и 1 выходного состояния T. Единица 15-1 space-efficient
дистилляции использует меньше кубитов, чем 15-1 RM
требует больше времени выполнения. Дополнительные сведения см. в таблице VI.
Совет
Использование предопределенных единиц дистилляции обеспечивает более высокую производительность по сравнению с пользовательскими.
Настройка единиц дистилляции
Вы можете настроить собственные единицы дистилляции. Ниже приведены точные параметры для единиц дистилляции.
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"
}
})
Ожидается, что все числовые параметры будут положительными. Указывает displayName
, как будет отображаться единица дистилляции в выходных результатах.
В следующем коде показано, как указать параметры единицы дистилляции для квантового алгоритма с помощью DistillationUnitSpecification
класса и ProtocolSpecificDistillationUnitSpecification
класса.
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
Формулы для failure_probability_formula
и output_error_rate_formula
являются настраиваемыми формулами с основными арифметическими операциями, константами и только тремя параметрами:
clifford_error_rate
, также обозначается какc
.readout_error_rate
, также обозначается какr
.input_error_rate
, также обозначается какz
.
См. следующие примеры пользовательских формул с использованием длинной и короткой нотации. В этих примерах показаны формулы, используемые по умолчанию в стандартной реализации.
Параметр | Длинная формула | Короткая формула |
---|---|---|
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" |
По крайней мере один из параметров physical_qubit_specification
или logical_qubit_specification
должен быть предоставлен. Если предоставлено только прежнее, единица дистилляции может применяться к физическим кубитам. Если предоставлено только последнее, единица дистилляции может применяться к логическим кубитам. При наличии обоих элементов можно применить дистилляцию к обоим типам кубитов.
Параметр logical_qubit_specification_first_round_override
можно указать только в том случае, если logical_qubit_specification
он указан. Если да, он переопределяет значения logical_qubit_specification
в случае применения в первом раунде дистилляции. Необходимое значение <protocol specific parameters>
logical_qubit_specification_first_round_override
должно соответствовать схеме:
{
"numUnitQubits": <int>,
"durationInQubitCycleTime": <double>
}
Оценка границ Парето
При оценке ресурсов алгоритма важно учитывать компромисс между количеством физических кубитов и средой выполнения алгоритма. Можно рассмотреть возможность выделения как можно больше физических кубитов, чтобы уменьшить среду выполнения алгоритма. Однако количество физических кубитов ограничено количеством физических кубитов, доступных в квантовом оборудовании. Понимание компромисса между средой выполнения и системным масштабированием является одним из более важных аспектов оценки ресурсов.
Оценка границ Pareto предоставляет несколько оценок для одного и того же алгоритма, каждый из которых показывает компромиссы между числом кубитов и средой выполнения.
Примечание.
Если вы запускаете средство оценки ресурсов в Visual Studio Code с помощью Q#параметра "Вычисление оценки ресурсов", оценка границ Pareto включена по умолчанию.
Если вы запускаете средство оценки ресурсов в Python, необходимо указать "estimateType"
параметр как "frontier"
.
result = qsharp.estimate("RunProgram()", params=
{"qubitParams": { "name": "qubit_maj_ns_e4" },
"qecScheme": { "name": "surface_code" },
"estimateType": "frontier", # Pareto frontier estimation
}
)
Если вы хотите визуализировать результаты оценки границ Pareto, можно использовать функцию EstimatesOverview
. Эти функции отображают результаты оценки границ в таблице и схеме времени. Дополнительные сведения см. на схеме пространства времени.
from qsharp_widgets import EstimatesOverview
EstimatesOverview(result)
Примечание.
Если при работе с оценщиком ресурсов возникла проблема, ознакомьтесь со страницей "Устранение неполадок" или обратитесь к ней.AzureQuantumInfo@microsoft.com