Поделиться через

target Настройка параметров оценки ресурсов

  • Статья

В этой статье показано, как настроить target параметры оценки ресурсов Azure Quantum в соответствии с характеристиками компьютера, которые вы используете target. Средство оценки ресурсов использует эти параметры для оценки ресурсов, необходимых для запуска квантового алгоритма на квантовом компьютере.

Примечание.

Если при работе с оценщиком ресурсов возникла проблема, ознакомьтесь со страницей устранения неполадок.

Необходимые компоненты

Параметры целевых расположений

Средство оценки ресурсов вычисляет оценку ресурсов, таких как количество кубитов и время выполнения, которое потребуется для реализации заданного квантового алгоритма с помощью заданной технологии кубита и с фиксированным набором вариантов архитектуры.

Поэтому оценка ресурсов принимает набор входных данных с предварительно определенными значениями, чтобы легко приступить к работе:

Совет

Если вы уже знаете некоторые предварительно вычисляемые оценки для операции, вы также можете включить их и оптимизировать выполнение оценки ресурсов. Дополнительные сведения см. в разделе "Использование известных оценок" с помощью средства оценки ресурсов.

Параметры физического кубита

Когда оценка ресурсов моделирует предположения физического кубита, для работы кубитов используется два разных набора физических инструкций. Набор физических инструкций может быть как на основе шлюза, так и на основе Майораны. Набор инструкций на основе шлюза обеспечивает однокубитное измерение, однокубитные ворота (включая 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_timeone_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_timeone_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_timetwo_qubit_gate_timeи two_qubit_joint_measurement_time, значения которых взяты из соответствующего поля из физических параметров кубита, а также переменную one_qubit_gate_timeeccDistance для расстояния кода, вычисляемого для логического кубита, на основе физических свойств кубита, порог исправления ошибок и префакторинг пересечения. Переменные времени и 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

Следующие шаги