target Dostosowywanie parametrów narzędzia do szacowania zasobów
W tym artykule pokazano, jak dostosować target parametry narzędzia do szacowania zasobów usługi Azure Quantum w celu dopasowania do właściwości maszyny, które są przeznaczone dla Ciebie. Narzędzie do szacowania zasobów używa tych parametrów do oszacowania zasobów wymaganych do uruchomienia algorytmu kwantowego na komputerze kwantowym.
Uwaga
Jeśli wystąpi jakikolwiek problem podczas pracy z narzędziem do szacowania zasobów, zapoznaj się ze stroną Rozwiązywanie problemów.
Wymagania wstępne
Środowisko języka Python z zainstalowanym językiem Python i programem .
Najnowsza wersja programu Visual Studio Code lub otwórz program VS Code w sieci Web.
Program VS Code z zainstalowanymi rozszerzeniami Azure Quantum Development Kit, Python i Jupyter .
Najnowsze pakiety i
qsharp-widgetsusługi Azure Quantumqsharp.python -m pip install --upgrade qsharp qsharp-widgets
Target Parametry
Narzędzie do szacowania zasobów oblicza szacowanie zasobów, takie jak liczba kubitów i czas wykonywania, które byłyby wymagane do zaimplementowania danego algorytmu kwantowego przy użyciu danej technologii kubitu i stałego zestawu wyborów architektury.
W związku z tym narzędzie do szacowania zasobów pobiera zestaw danych wejściowych ze wstępnie zdefiniowanymi wartościami, aby łatwo rozpocząć pracę:
- Model kubitu fizycznego, który definiuje właściwości bazowych kubitów fizycznych.
- Schemat poprawki błędów kwantowych (QEC), który jest zakładanym schematem korekty błędów kwantowych.
- Budżet błędu, który jest ogólnym dozwolonym błędem, czyli liczbą przypadków, gdy program może usunąć elementy.
- Ograniczenia na poziomie składnika, które są liczbą cykli logicznych i liczbą kopii fabrycznych T.
- Jednostki destylacyjne do określania algorytmów destylowania fabryk T.
- Szacowanie granic Pareto w celu uruchomienia wielu oszacowań liczby kubitów i środowiska uruchomieniowego dla tego samego algorytmu.
Napiwek
Jeśli znasz już wstępnie obliczone oszacowania dla operacji, możesz je również uwzględnić i zoptymalizować wykonywanie narzędzia do szacowania zasobów. Aby uzyskać więcej informacji, zobacz How to use known estimates with the Resource Estimator (Jak używać znanych oszacowań za pomocą narzędzia do szacowania zasobów).
Parametry kubitu fizycznego
Gdy narzędzie do szacowania zasobów modeluje założenia fizyczne kubitu, używa dwóch różnych zestawów instrukcji fizycznych do obsługi kubitów. Zestaw instrukcji fizycznych może być oparty na bramie lub Majorana. Zestaw instrukcji oparty na bramie zapewnia pomiar z jednym kubitem, bramy jednokrotne (w tym bramy T) i bramy dwukabitowe. Zestaw instrukcji Majorana zapewnia fizyczną bramę T, pomiar z jednym kubitem i operacje pomiarów stawów z dwoma kubitami.
Możesz wybrać spośród sześciu wstępnie zdefiniowanych parametrów kubitu, z których cztery mają zestawy instrukcji oparte na bramie i dwa z zestawem instrukcji Majorana. Te modele kubitów obejmują szereg czasów operacji i współczynników błędów, umożliwiając wystarczającą eksplorację kosztów zasobów potrzebnych do włączenia praktycznych aplikacji kwantowych.
| Parametr kubitu | Python API, klasa | opis |
|---|---|---|
"qubit_gate_ns_e3" , "qubit_gate_ns_e4" |
GATE_NS_E3 , GATE_NS_E4 |
Czasy operacji i wierność mogą odpowiadać przyszłym wersjom nadprzewodzącego kubitów transmonowych lub kubitów spinu, które zwykle mają czasy operacji w systemie nanosekund. W przypadku tych kubitów zakłada się, że operacje bram i pomiarów mają odpowiednio 50 ns i 100 ns. Zakłada się, że współczynnik błędów bramy z jednym kubitem i dwiema kubitami wynosi $10^{-3}$ jako realistyczne target, a $10^{-4}$ jako optymistyczny target dla skalowanego systemu w górę. |
"qubit_gate_us_e3" , "qubit_gate_us_e4" |
GATE_US_E3 , GATE_US_E4 |
Czasy operacji i wierność mogą odpowiadać przyszłym wersjom kubitów na podstawie jonów, które zwykle mają czasy operacji w systemie mikrosekund. W oparciu o typowe założenia dotyczące kubitów jonowych zakłada się, że operacje bramy i pomiaru przyjmują 100 μs. Współczynnik błędów dla bram Cliffordu z jednym kubitem wynosi $10^{-3}$ jako realistyczny target i $10^{-4}$ jako optymistyczny target, podczas gdy współczynnik błędów dla bram spoza Cliffordu (brama T) pojedynczego kubitu wynosi $10^{-6}$. W przypadku bram z dwoma kubitami współczynnik błędów wynosi $10^{-3}$ jako realistyczny target i $10^{-4}$ jako optymistyczny target. |
"qubit_maj_ns_e4" , "qubit_maj_ns_e6" |
MAJ_NS_E4 , MAJ_NS_E6 |
Czasy operacji i wierność mogą odpowiadać przyszłym ulepszonym wersjom kubitów Majorana. W przypadku tych kubitów zakłada się, że operacje bramy i pomiaru zajmują 100 ns. Aby uwzględnić ochronę topologiczną w sprzęcie, współczynnik błędów jednostki jednokubitowej i dwóch kubitów (współczynnik błędów Clifforda) przyjmuje się, że wartość $10^{-4}$ jest realistyczna target, a $10^{-6}$ jako optymistyczna targetwartość . Operacje inne niż Clifford w tej architekturze nie mają ochrony topologicznej, współczynnik błędów dla bram fizycznych T innych niż Clifford wynosi 5%. |
Uwaga
Jeśli nie zostanie określona inna wartość, wartość domyślna dla modelu kubitu to "qubit_gate_ns_e3".
Parametry dla wstępnie zdefiniowanych parametrów kubitu
Do celów referencyjnych pełne wstępnie zdefiniowane parametry kubitu są następujące:
{
"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
}
}
Przekazywanie wstępnie zdefiniowanych parametrów kubitu
Istnieją dwa sposoby programowego określania wstępnie zdefiniowanych parametrów kubitu. Podczas uruchamiania qsharp.estimatepolecenia możesz wybrać nazwę modelu kubitu qubitParams dla klasy . Aby na przykład wybrać "qubit_maj_ns_e6" parametr kubitu, napisz:
qsharp.estimate("RunProgram()", params=
{"qubitParams": {
"name": "qubit_maj_ns_e6"
},
})
Parametry kubitu można również przekazać do EstimatorParams klasy przy użyciu polecenia QubitParams. Aby na przykład wybrać MAJ_NS_E6 parametr kubitu, napisz:
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)
Dostosowywanie wstępnie zdefiniowanych parametrów kubitu
Możesz dostosować wstępnie zdefiniowane parametry kubitu, określając nazwę, a następnie aktualizując dowolne inne wartości. Aby na przykład zmniejszyć szybkość błędów dwubitowego pomiaru stawu kubitowego w ciągu "qubit_maj_ns_e4", napisz:
qsharp.estimate("RunProgram()", params=
{"qubitParams": {
"name": "qubit_maj_ns_e4",
"twoQubitJointMeasurementErrorRate": 1e-5,
},
})
Możesz też przekazać instrukcje w postaci listy.
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
Parametry kubitu dla kubitów opartych na bramie
| Identyfikator języka Python | Typ danych | opis |
|---|---|---|
name |
string | Nazwa modelu kubitu |
instruction_set |
"gate_based" | Podstawowa technologia kubitu |
one_qubit_measurement_time |
ciąg czasu | Czas operacji dla pomiaru pojedynczego kubitu ($t_{\rm meas}$) w ns |
one_qubit_gate_time |
ciąg czasu | Czas działania bramy z jednym kubitem ($t_{\rm gate}$) w ns |
two_qubit_gate_time |
ciąg czasu | Czas działania bramki z dwoma kubitami w ns |
t_gate_time |
ciąg czasu | Czas działania bramy spoza Cliffordu z jednym kubitem w ns |
one_qubit_measurement_error_rate |
liczba zmiennoprzecinkowa | Szybkość błędów dla pomiaru pojedynczego kubitu |
one_qubit_gate_error_rate |
liczba zmiennoprzecinkowa | Współczynnik błędów dla bramy Clifforda z jednym kubitem ($p$) |
two_qubit_gate_error_rate |
liczba zmiennoprzecinkowa | Szybkość błędów bramy Clifforda z dwoma kubitami |
t_gate_error_rate |
liczba zmiennoprzecinkowa | Szybkość błędów przygotowywania stanu spoza klifordu z jednym kubitem ($p_T$) |
idle_error_rate |
liczba zmiennoprzecinkowa | Szybkość błędów odpowiadająca bezczynności |
Poniższy kod pokazuje, jak określić niestandardowe parametry kubitu dla zestawu instrukcji opartych na bramie:
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
Uwaga
Jeśli nie zostanie określony, wartości dla two_qubit_gate_time i t_gate_time domyślne wartości one_qubit_gate_time, wartości dla two_qubit_gate_error_rate i t_gate_error_rate wartości domyślnej one_qubit_gate_error_ratena , i wartość dla idle_error_rate wartości domyślnych .one_qubit_measurement_error_rate
Parametry kubitu dla kubitów Majorana
| Identyfikator języka Python | Typ danych | opis |
|---|---|---|
name |
string | Nazwa modelu kubitu |
instruction_set |
"majorana" | Podstawowa technologia kubitu |
one_qubit_measurement_time |
ciąg czasu | Czas operacji dla pomiaru pojedynczego kubitu ($t_{\rm meas}$) w ns |
two-qubit_joint_measurement_time |
ciąg czasu | Czas operacji dla pomiaru dwóch kubitów w ns |
t_gate_time |
ciąg czasu | Czas działania bramy spoza Cliffordu z jednym kubitem w ns |
one_qubit_measurement_error_rate |
liczba zmiennoprzecinkowa | Szybkość błędów dla pomiaru pojedynczego kubitu |
two_qubit_joint_measurement_error_rate |
liczba zmiennoprzecinkowa | Szybkość błędów dla pomiaru dwóch kubitów |
t_gate_error_rate |
liczba zmiennoprzecinkowa | Szybkość błędów przygotowywania stanu spoza klifordu z jednym kubitem ($p_T$) |
idle_error_rate |
liczba zmiennoprzecinkowa | Szybkość błędów odpowiadająca bezczynności |
Minimalny szablon zestawu instrukcji opartych na majoranie ze wszystkimi wymaganymi wartościami to:
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
Uwaga
Jeśli nie zostanie określony, wartości dla two_qubitJointMeasurementTime i t_gate_time domyślne wartości one_qubit_measurement_time, wartości dla two_qubit_joint_measurement_error_rate i t_gate_error_rate wartości domyślnej one_qubit_measurement_error_ratena , i wartość dla idle_error_rate wartości domyślnych .one_qubit_measurement_error_rate
W przypadku one_qubit_measurement_error_rate parametrów i two_qubit_joint_measurement_error_ratemożna określić współczynniki błędów odpowiadające odczytom pomiarów, readouti przetwarzaniu pomiarów. process Te wartości mogą być <double> liczbami lub parami liczb. Na przykład:
params.qubit_params.two_qubit_joint_measurement_error_rate = \
MeasurementErrorRate(process=0.00005, readout=0.00007)
Uwaga
Jeśli określisz pojedynczą wartość liczbową dla liczby błędów pojedynczego kubitu i dwóch kubitów w pomiarze kubitu Majorana, współczynniki błędów odczytu i procesu mogą być równe.
Ważne
Wszystkie wartości, które nie są określone, będą przyjmować wartość domyślną, na przykład określając "qubit": {"oneQubitGateTime":"200 ns"} , że modeluje kubit oparty na bramie kubit, w którym zarówno czas bramy dwubitowej, jak i czas bramy z jednym kubitem to 200 ns. W przypadku jednostek należy określić ciągi czasowe, które są liczbami zmiennoprzecinkowymi o podwójnej precyzji, a następnie spacją i jednostką czasową dla takich wartości, gdzie możliwe sufiksy czasu to ns, µs (lub us), msi s.
Schematy poprawek błędów kwantowych
Aby wykonywać praktyczne aplikacje kwantowe, operacje kwantowe powinny mieć niskie współczynniki błędów. Te współczynniki targets błędów są zwykle poza możliwościami pierwotnych kubitów fizycznych. Aby przezwyciężyć to ograniczenie, kwantowa korekta błędów (QEC) i obliczenia odporne na błędy to dwie kluczowe techniki, które tworzą bloki konstrukcyjne komputerów kwantowych na dużą skalę. Po pierwsze, QEC umożliwia tworzenie wielu kubitów fizycznych podatnych na błędy i tworzenie bardziej niezawodnego kubitu logicznego, który zachowuje informacje kwantowe lepiej niż bazowe fizyczne kubity.
Narzędzie do szacowania zasobów używa następującej formuły do modelowania logicznych współczynników błędów przy użyciu modelu wykładniczego,
$$ P = a\left(\frac{p}{p^*}\right)^{\frac{d+1}{2}} $$
gdzie $a$ jest przeprawą przedskładnikową, $d$ to odległość kodu, $p$ to fizyczna szybkość błędów, a $p^*$ to próg korekty błędu kwantowego. Przeprawa przedskładnikowa $a$ można wyodrębnić liczbowo dla symulacji.
Odległość kodu $d$ to parametr, który kontroluje liczbę błędów, które można poprawić. W związku z tym odległość kodu definiuje szybkość błędów kubitów logicznych i liczbę fizycznych kubitów wymaganych do ich zakodowania. Zarówno dokładność, jak i liczba kubitów fizycznych zwiększają się z odległością kodu. Celem schematu QEC jest znalezienie minimalnej odległości kodu, która może osiągnąć wymagany współczynnik błędów ustawiony dla określonej aplikacji.
Współczynnik błędów fizycznych $p$ jest wyodrębniany z parametrów kubitu jako najgorszy przypadek współczynnik błędów dowolnej fizycznej operacji Clifford wykonanej na urządzeniu. W szczególności $p = {}$ max(one_qubit_measurement_error_rate, one_qubit_gate_error_rate, two_qubit_gate_error_rate) dla parametrów kubitu z zestawem instrukcji opartych na bramie i $p = {}$ max(one_qubit_measurement_error_rate, two_qubit_joint_measurement_error_rate) dla parametrów kubitu z zestawem instrukcji Majorana. Schematy QEC zazwyczaj mają próg współczynnika błędów $p^*$, poniżej którego korekta błędów pomija błędy.
Narzędzie do szacowania zasobów usługi Azure Quantum obsługuje dwa wstępnie zdefiniowane schematy QEC: kod powierzchni i kod floquet.
| Protokół QEC | Python API, klasa | opis |
|---|---|---|
"surface_code" |
SURFACE_CODE |
Kod powierzchni oparty na bramie jest oparty na arXiv:1208.0928 i arXiv:1009.3686. Kod powierzchni Majorana jest oparty na arXiv:1909.03002 i arXiv:2007.00307. |
"floquet_code" |
FLOQUET_CODE |
Tylko w przypadku kubitów Majorana. Kod floquet jest oparty na arXiv:2202.11829. |
Uwaga
Chyba że określono inną wartość, domyślną wartością schematu QEC jest "surface_code".
Parametry dla wstępnie zdefiniowanych schematów QEC
Dokładne parametry dla każdego wstępnie zdefiniowanego schematu QEC są następujące.
{
"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)"
}
}
Przekazywanie wstępnie zdefiniowanych schematów QEC
Istnieją dwa sposoby określania wstępnie zdefiniowanych schematów QEC. Podczas uruchamiania "qecScheme" qsharp.estimatemożna wybrać nazwę modelu QEC dla klasy . Aby na przykład wybrać kod floquet, napisz:
qsharp.estimate("RunProgram()", params=
{"qecScheme": {
"name": "floquet_code"
}
})
Możesz również przekazać listę parametrów szacowania do klasy przy użyciuQECScheme klasy .EstimatorParams Aby na przykład wybrać kod floquet, napisz:
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)
Dostosowywanie wstępnie zdefiniowanych schematów QEC
Możesz dostosować wstępnie zdefiniowane schematy QEC, określając nazwę, a następnie aktualizując dowolne inne wartości. Aby na przykład zwiększyć wskaźnik wstępny przejścia w kodzie floquet, napisz:
qsharp.estimate("RunProgram()", params=
{"qecScheme": {
"name": "floquet_code",
"crossingPrefactor": 0.07,
}
})
Uwaga
Jeśli nie zostanie określona, wartości dla "logicalCycleTime" i "physicalQubitsPerLogicalQubit" wartości domyślnej "oneQubitMeasurementTime"na , wartość "errorCorrectionThreshold" dla wartości domyślnych 0.01to , i wartość dla "crossingPrefactor" wartości domyślnych .0.03
Dostosowywanie schematów QEC
Narzędzie do szacowania zasobów może abstrakować dostosowany schemat QEC na podstawie powyższej formuły, podając wartości dla "crossingPrefactor" $a$ i "errorCorrectionThreshold" $p^*$. Ponadto należy określić "logicalCycleTime"wartość , czyli czas wykonania pojedynczej operacji logicznej, która zależy od odległości kodu i założeń czasu operacji fizycznej bazowych kubitów fizycznych. Na koniec druga formuła oblicza "physicalQubitsPerLogicalQubit"wartość , czyli liczbę kubitów fizycznych wymaganych do zakodowania jednego kubitu logicznego na podstawie odległości kodu.
Możesz użyć następującego kodu jako szablonu dla schematów QEC:
qsharp.estimate("RunProgram()", params=
{"qecScheme": {
"crossingPrefactor": <double>,
"errorCorrectionThreshold": <double>,
"logicalCycleTime": <formula string>,
"physicalQubitsPerLogicalQubit": <formula string>
}
})
Wewnątrz formuł można użyć zmiennych , , i two_qubit_joint_measurement_time, których wartości są pobierane z odpowiedniego pola z parametrów kubitu fizycznego, a także zmiennej eccDistance dla odległości kodu obliczonej dla kubitu logicznego na podstawie właściwości fizycznych kubitów, progu korekty błędu i przedskładnikowego one_qubit_measurement_timeprzejścia. two_qubit_gate_timeone_qubit_gate_time Zmienne czasowe i eccDistance mogą służyć do opisywania formuły logicalCycleTime . Dla formuły physicalQubitsPerLogicalQubit można używać tylko formuły eccDistance .
Budżet błędu
Całkowity budżet błędu $\epsilon$ ustawia ogólny tolerowany błąd dla algorytmu, czyli dozwolone prawdopodobieństwo niepowodzenia algorytmu. Jego wartość globalna musi należeć do zakresu od 0 do 1, a wartość domyślna to 0,001, co odpowiada 0,1%. Innymi słowy, algorytm może zakończyć się niepowodzeniem maksymalnie raz w 1000 wykonaniach. Ten parametr jest bardzo specyficzny dla aplikacji.
Na przykład jeśli używasz algorytmu Shora do faktorowania liczb całkowitych, duża wartość budżetu błędu może być tolerowana, ponieważ można sprawdzić, czy dane wyjściowe są rzeczywiście głównymi czynnikami danych wejściowych. Z drugiej strony może być potrzebny mniejszy budżet błędów dla algorytmu rozwiązywania problemu z rozwiązaniem, którego nie można skutecznie zweryfikować.
Budżet błędu odpowiada sumie trzech części:
$$ \epsilon = \epsilon_{\log} + \epsilon_{\rm dis} + \epsilon_{\rm syn} $$
Błędy logiczne $\epsilon_{\log}$ to błąd implementacji kubitów logicznych, błąd stanu T $\epsilon_{\rm dis}$ jest błędem tworzenia stanów T przez destylację, a błąd bramki rotacji $\epsilon_{\rm syn}$ jest błędem syntezowania bram z dowolnymi kątami.
Uwaga
Jeśli nie określono inną wartość, budżet błędu $\epsilon$ jest równomiernie rozłożony między błąd logiczny, błąd stanu T i błąd bramy rotacji.
Należy pamiętać, że w przypadku syntezy destylowania i rotacji odpowiednie budżety błędów $\epsilon_{\rm dis}$ i $\epsilon_{\rm syn}$ są równomiernie rozłożone między wszystkie wymagane stany T i wszystkie wymagane bramy rotacji, odpowiednio. Jeśli w algorytmie wejściowym nie ma bram rotacji, budżet błędu jest równomiernie rozłożony na błędy logiczne i błędy stanu T.
Przekazywanie budżetu błędów
Istnieją dwa sposoby określania budżetu błędów przez ustawienie liczby z zakresu od 0 do 1. Budżet błędów można przekazać podczas uruchamiania qsharp.estimatepolecenia . Aby na przykład wybrać budżet błędów 1/3, zapisz:
qsharp.estimate("RunProgram()", params=
{'errorBudget': 0.333
})
Parametry budżetu błędu można również przekazać do EstimatorParams klasy .
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)
Ponadto można indywidualnie określić każdy składnik budżetu błędu. Suma wszystkich wartości to całkowity budżet błędów i musi należeć do przedziału od 0 do 1. Jeśli algorytm kwantowy nie zawiera stanów lub rotacji T, wartości t_states i rotations mogą być odpowiednio równe 0.
Poniższy kod pokazuje, jak określić parametr budżetu błędu ze stanami I rotacjami języka 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
Ograniczenia
Możesz użyć "constraints" klasy , aby zastosować ograniczenia na poziomie składnika fabryki T. Dostosowując ograniczenia, można zoptymalizować oszacowania w celu zmniejszenia liczby kubitów lub zmniejszenia środowiska uruchomieniowego.
| Parametr | Typ danych | opis |
|---|---|---|
logical_depth_factor |
liczba zmiennoprzecinkowa | Kontrolowanie czasu wykonywania. Jeśli ma wartość większą niż 1, początkowa liczba cykli logicznych, nazywana również głębokością logiczną, jest mnożona przez tę liczbę. Dzięki zmniejszeniu logical_depth_factorwartości można zwiększyć liczbę wywołań fabryki T w danym czasie, co powoduje zmniejszenie liczby kopii fabrycznych T potrzebnych do produkcji tej samej liczby stanów T. Po zmniejszeniu liczby kopii fabrycznych języka T środowisko uruchomieniowe algorytmu zwiększa się odpowiednio. Współczynnik skalowania całkowitego środowiska uruchomieniowego może być większy, ponieważ wymagana liczba błędów logicznych zwiększa się z powodu dodatkowej liczby cykli. |
max_t_factories |
integer | Maksymalna liczba kopii fabrycznych T. Narzędzie do szacowania zasobów określa wymagane zasoby, wybierając optymalną liczbę kopii fabrycznych T, która minimalizuje liczbę używanych kubitów fizycznych bez uwzględniania nakładu pracy. Parametr max_t_factories ogranicza maksymalną liczbę kopii i dlatego odpowiednio dostosowuje liczbę cykli logicznych. Aby uzyskać więcej informacji, zobacz Szacowanie fizyczne fabryki T. |
max_duration |
ciąg czasu | Maksymalny czas wykonywania algorytmu. Narzędzie do szacowania zasobów akceptuje tylko jedno z max_duration ograniczeń lub max_physical_qubits w tym czasie, ale nie dwa. Jeśli max_duration zostanie określony, narzędzie do szacowania zasobów próbuje znaleźć najlepsze oszacowanie dla max_physical_qubits rozwiązań ograniczonych przez określoną maksymalną liczbę. |
max_physical_qubits |
integer | Maksymalna liczba kubitów fizycznych dla algorytmu. Narzędzie do szacowania zasobów akceptuje tylko jedno z max_duration ograniczeń lub max_physical_qubits w tym czasie, ale nie dwa. Jeśli max_physical_qubits zostanie określony, narzędzie do szacowania zasobów próbuje znaleźć najlepsze oszacowanie dla max_duration rozwiązań ograniczonych przez określoną maksymalną liczbę. |
Poniższy kod pokazuje, jak określić ograniczenia dla algorytmu kwantowego:
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
Uwaga
Jeśli podana wartość lub max_duration max_physical_qubits jest za mała, aby znaleźć możliwe rozwiązanie, narzędzie do szacowania zasobów zwraca błąd. Jeśli nie określono ani max_duration max_physical_qubits ograniczeń, narzędzie do szacowania zasobów ma na celu znalezienie rozwiązania z najkrótszym czasem.
Napiwek
Możesz użyć funkcji max_duration i max_physical_qubits wpłynąć na przestrzeń rozwiązania, potencjalnie znaleźć rozwiązania z dłuższym środowiskiem uruchomieniowym, ale mniejszą liczbę kubitów w porównaniu z rozwiązaniami bez tych ograniczeń. Istnieje kompromis między środowiskiem uruchomieniowym a liczbą kubitów, a ten kompromis może być skutecznie zarządzany dla niektórych algorytmów, z różnymi wpływami na różne algorytmy. Tabela IV w [arXiv:2211.07629] ilustruje efektywne wykorzystanie kompromisu między liczbą kubitów a środowiskiem uruchomieniowym dla algorytmów dynamiki kwantowej. Aby uzyskać więcej informacji, zobacz Przykład szacowania zasobów kwantowych z czasem lub liczbą ograniczeń kubitów.
Jednostki destylacyjne
Można podać specyfikacje algorytmów destylowania fabryk T z klasą DistillationUnitSpecification. Specyfikacja może być wstępnie zdefiniowana lub niestandardowa. Możesz określić wstępnie zdefiniowaną specyfikację, wybierając nazwę jednostki destylacyjnej: 15-1 RM lub 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)
W obu przypadkach notacja 15-1 oznacza 15 stanów wejściowych T i 1 stan wyjściowy T. Jednostka 15-1 space-efficient destylowania używa mniejszej liczby kubitów niż 15-1 RM , ale wymaga więcej środowiska uruchomieniowego. Aby uzyskać więcej informacji, zobacz Tabela VI.
Napiwek
Użycie wstępnie zdefiniowanych jednostek destylowania zapewnia lepszą wydajność w porównaniu z jednostkami niestandardowymi.
Dostosowywanie jednostek destylowania
Możesz dostosować własne jednostki destylacyjne. Dokładne parametry jednostek destylowania są następujące.
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"
}
})
Oczekuje się, że wszystkie parametry liczbowe będą dodatnie. Parametr displayName określa sposób wyświetlania jednostki destylacji w wynikach wyjściowych.
Poniższy kod pokazuje, jak określić parametry jednostki destylowania dla algorytmu kwantowego przy użyciu DistillationUnitSpecification klasy i ProtocolSpecificDistillationUnitSpecification klasy.
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
Formuły dla failure_probability_formula output_error_rate_formula i są formułami niestandardowymi z podstawowymi operacjami arytmetycznymi, stałymi i tylko trzema parametrami:
clifford_error_rate, oznaczono również jakoc.readout_error_rate, oznaczono również jakor.input_error_rate, oznaczono również jakoz.
Zapoznaj się z poniższymi przykładami formuł niestandardowych korzystających z długiej i krótkiej notacji. Te przykłady ilustrują formuły używane domyślnie w ramach standardowej implementacji.
| Parametr | Długa formuła | Krótka formuła |
|---|---|---|
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" |
Co najmniej jeden z parametrów physical_qubit_specification lub logical_qubit_specification powinien zostać podany. Jeśli podano tylko te pierwsze, jednostkę destylacji można zastosować do kubitów fizycznych. Jeśli podano tylko te ostatnie, jednostkę destylacji można zastosować do kubitów logicznych. W przypadku podania obu tych opcji jednostka destylacji może być stosowana do obu typów kubitów.
Parametr logical_qubit_specification_first_round_override można podać tylko wtedy, gdy logical_qubit_specification jest określony. Jeśli tak, zastępuje wartości logical_qubit_specification w przypadku zastosowania w pierwszej rundzie destylowania. Wartość <protocol specific parameters> wymagana dla logical_qubit_specification_first_round_override programu powinna być zgodna ze schematem:
{
"numUnitQubits": <int>,
"durationInQubitCycleTime": <double>
}
Szacowanie granic Pareto
Podczas szacowania zasobów algorytmu należy wziąć pod uwagę kompromis między liczbą kubitów fizycznych a środowiskiem uruchomieniowym algorytmu. Możesz rozważyć alokację jak największej liczby kubitów fizycznych, aby zmniejszyć środowisko uruchomieniowe algorytmu. Jednak liczba kubitów fizycznych jest ograniczona przez liczbę kubitów fizycznych dostępnych na sprzęcie kwantowym. Zrozumienie kompromisu między środowiskiem uruchomieniowym a skalowaniem systemu jest jednym z ważniejszych aspektów szacowania zasobów.
Szacowanie granic Pareto zawiera wiele oszacowań dla tego samego algorytmu, z których każdy pokazuje kompromisy między liczbą kubitów a środowiskiem uruchomieniowym.
Uwaga
Jeśli uruchomisz narzędzie do szacowania zasobów w programie Visual Studio Code przy użyciu Q#opcji : Oblicz szacunki zasobów, szacowanie granic Pareto jest domyślnie włączone.
Jeśli uruchomisz narzędzie do szacowania zasobów w języku Python, musisz określić "estimateType" parametr jako "frontier".
result = qsharp.estimate("RunProgram()", params=
{"qubitParams": { "name": "qubit_maj_ns_e4" },
"qecScheme": { "name": "surface_code" },
"estimateType": "frontier", # Pareto frontier estimation
}
)
Jeśli chcesz zwizualizować wyniki szacowania granic Pareto, możesz użyć EstimatesOverview funkcji . Te funkcje wyświetlają wyniki szacowania granic w tabeli i diagramie czasu kosmicznego. Aby uzyskać więcej informacji, zobacz Diagram czasu kosmicznego.
from qsharp_widgets import EstimatesOverview
EstimatesOverview(result)
Uwaga
Jeśli wystąpi jakikolwiek problem podczas pracy z narzędziem do szacowania zasobów, zapoznaj się ze stroną Rozwiązywanie problemów lub skontaktuj się z .AzureQuantumInfo@microsoft.com