target Dostosowywanie parametrów narzędzia do szacowania zasobów

  • Artykuł

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 targettworzysz. 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ędzie do szacowania zasobów, zapoznaj się ze stroną Rozwiązywanie problemów.

Wymagania wstępne

Parametry docelowe

Narzędzie do szacowania zasobów oblicza szacowanie zasobów, takie jak liczba kubitów i czas wykonywania, który byłby wymagany do zaimplementowania danego algorytmu kwantowego przy użyciu danej technologii kubitu i ze stałym zestawem 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ę:

Parametry kubitu fizycznego

Gdy narzędzie do szacowania zasobów modeluje założenia kubitu fizycznego, 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 pojedynczego kubitu, bramy z pojedynczym kubitem (w tym bramy T) i bramy z dwoma kubitami. Zestaw instrukcji Majorana zapewnia fizyczną bramę T, pomiar z pojedynczym kubitem i operacje pomiaru dwubitowego kubitu.

Można wybrać spośród sześciu wstępnie zdefiniowanych parametrów kubitu, z których cztery mają zestawy instrukcji opartych 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 Klasa interfejsu API języka Python Opis
"qubit_gate_ns_e3" , "qubit_gate_ns_e4" GATE_NS_E3 , GATE_NS_E4 Czasy operacji i wierności mogą odpowiadać przyszłym wersjom nadprzewodzących kubitów transmonowych lub kubitów spinu, które zwykle mają czasy działania w systemie nanosekund. W przypadku tych kubitów zakłada się, że operacje bramy i pomiaru zajmują odpowiednio 50 ns i 100 ns. Zakłada się, że współczynnik błędów bramy z pojedynczym kubitem i dwiema kubitami wynosi 10^$ jako realistyczny targeti $10^{-3}{-4}$ jako optymistyczny target dla skalowanego w górę systemu.
"qubit_gate_us_e3" , "qubit_gate_us_e4" GATE_US_E3 , GATE_US_E4 Czasy operacji i wierności 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 jonów zakłada się, że operacje bramy i pomiarów przyjmują 100 μs. Współczynnik błędów dla bram Clifforda z jednym kubitem wynosi $10^{-3}$ jako realistyczny target i $10^{-4}$ jako optymistyczny target, podczas gdy stawka błędu dla bram z pojedynczym kubitem spoza Cliffordu (brama T) wynosi $10^{-6}$. W przypadku bram dwóch kubitów stawka błędu wynosi $10^{-3}$ jako realistyczna target i $10^{-4}$ jako optymistyczna target.
"qubit_maj_ns_e4" , "qubit_maj_ns_e6" MAJ_NS_E4 , MAJ_NS_E6 Czasy działania i wierności 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 pomiaru jednokrotnego i dwóch kubitów (stawki błędów Cliffordu) zakłada się, że wartość $10^{-4}$ jest realistyczna targeti $10^{-6}$ jako optymistyczna target. Operacje inne niż Clifford w tej architekturze nie mają ochrony topologicznej, szybkość błędów dla fizycznych bram T spoza Cliffordu wynosi 5%.

Uwaga

Chyba że określono inną wartość, domyślną wartością modelu kubitu jest "qubit_gate_ns_e3".

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 EstimatorParams można również przekazać do 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 dowolną z innych wartości. Aby na przykład zmniejszyć współczynnik błędów dwubitowego pomiaru stawów 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 formie 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 ciąg Nazwa modelu kubitu
instruction_set "gate_based" Podstawowa technologia kubitu
one_qubit_measurement_time ciąg czasu Czas operacji pomiaru pojedynczego kubitu ($t_{\rm meas}$) w ns
one_qubit_gate_time ciąg czasu Czas działania bramy pojedynczej kubitu ($t_{\rm gate}$) w ns
two_qubit_gate_time ciąg czasu Czas działania bramy dwu kubitowej w ns
t_gate_time ciąg czasu Czas działania bramy spoza Klifordu z jednym kubitem w ns
one_qubit_measurement_error_rate float Szybkość błędów pomiaru pojedynczego kubitu
one_qubit_gate_error_rate float Współczynnik błędów dla bramy Clifforda z pojedynczym kubitem ($p$)
two_qubit_gate_error_rate float Współczynnik błędów bramy Clifforda z dwoma kubitami
t_gate_error_rate float Szybkość błędów w celu przygotowania stanu spoza klifordu pojedynczego kubitu ($p_T$)
idle_error_rate float Współczynnik błędów odpowiadający 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 domyślne one_qubit_gate_timewartości , wartości dla two_qubit_gate_error_rate i t_gate_error_ratet_gate_time domyślne one_qubit_gate_error_ratedo , oraz 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 ciąg Nazwa modelu kubitu
instruction_set "majorana" Podstawowa technologia kubitu
one_qubit_measurement_time ciąg czasu Czas operacji pomiaru pojedynczego kubitu ($t_{\rm meas}$) w ns
two-qubit_joint_measurement_time ciąg czasu Czas operacji dla pomiarów dwóch kubitów w ns
t_gate_time ciąg czasu Czas działania bramy spoza Klifordu z jednym kubitem w ns
one_qubit_measurement_error_rate float Współczynnik błędów dla pomiaru pojedynczego kubitu
two_qubit_joint_measurement_error_rate float Współczynnik błędów dla pomiaru dwóch kubitów
t_gate_error_rate float Współczynnik błędów przygotowywania stanu nieklibitowego innego niż Clifford ($p_T$)
idle_error_rate float Współczynnik błędów odpowiadający bezczynności

Minimalny szablon zestawu instrukcji opartych na wersji Majorana 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 parametru two_qubitJointMeasurementTime i domyślnie one_qubit_measurement_timemają wartość , wartości two_qubit_joint_measurement_error_rate dla i t_gate_error_rate domyślnie one_qubit_measurement_error_ratemają wartość , a wartość dla idle_error_rate wartości domyślnych to one_qubit_measurement_error_ratet_gate_time .

Dla parametrów one_qubit_measurement_error_rate 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 współczynników błędów z jednym kubitem 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ślenie "qubit": {"oneQubitGateTime":"200 ns"} modelu kubitu opartego na bramie, w którym zarówno czas bramy z dwoma kubitami, jak i czas bramy z jednym kubitem to 200 ns. W przypadku jednostek należy określić ciągi czasu, które są liczbami zmiennoprzecinkowymi o podwójnej precyzji, a następnie przestrzeń i jednostkę czasu dla takich wartości, gdzie to możliwe sufiksy czasu to ns, µs (lub us), msi s.

Schematy korekty błędów kwantowych

Aby wykonywać praktyczne aplikacje kwantowe, operacje kwantowe powinny mieć niskie współczynniki błędów. Ten współczynnik targets błędów zazwyczaj wykracza poza możliwości nieprzetworzonych fizycznych kubitów. 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.

Odległość kodu korekty błędu (lub tylko odległość kodu dla krótkiego) jest parametrem, który kontroluje liczbę błędów, które można poprawić. W związku z tym szybkość błędów kubitów logicznych i liczba fizycznych kubitów wymaganych do ich zakodowania. Zarówno dokładność, jak i liczba kubitów fizycznych rosną wraz z odległością kodu. Celem jest znalezienie minimalnej odległości kodu, która może osiągnąć wymagany współczynnik błędów ustawiony dla określonej aplikacji.

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 $d$ to odległość kodu, $p$ jest współczynnikiem błędów fizycznych, a $p^*$ to próg korekty błędu kwantowego. Współczynnik błędów fizycznych $p$ jest wyodrębniany z parametrów kubitu jako najgorsza liczba błędów dowolnego fizycznego działania Clifforda 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 zwykle mają próg współczynnika błędów $p^*$, poniżej którego korekta błędów pomija błędy.

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 opiera się na arXiv:2202.11829.

Uwaga

Jeśli nie zostanie określona inna wartość, wartość domyślna schematu QEC to "surface_code".

Poniżej przedstawiono dokładne parametry dla każdego wstępnie zdefiniowanego schematu QEC (w tym przeprawy $a$, które można wyodrębnić numerycznie na potrzeby symulacji).

{
    "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.estimatepolecenia możesz 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 EstimatorParams klasy przy użyciu QECScheme klasy . 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 dowolną z pozostałych 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ślony, wartości parametru i domyślnie "oneQubitMeasurementTime"mają wartość , wartość "errorCorrectionThreshold"0.01domyślna to , a wartość dla "crossingPrefactor" wartości domyślnych to 0.03."physicalQubitsPerLogicalQubit""logicalCycleTime"

Dostosowywanie schematów QEC

Narzędzie do szacowania zasobów może utworzyć abstrakcję dostosowanego schematu QEC na podstawie powyższej formuły, podając wartości dla "crossingPrefactor" $a$ i "errorCorrectionThreshold" $p^*$. Ponadto należy określić "logicalCycleTime", czyli czas wykonywania 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ę fizycznych kubitów 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>
                    }
                })

W formułach można użyć zmiennych one_qubit_gate_time, two_qubit_gate_time, one_qubit_measurement_timei two_qubit_joint_measurement_time, których wartości są pobierane z odpowiedniego pola z parametrów kubitu fizycznego, a także zmiennej eccDistance odległości kodu obliczonej dla kubitu logicznego na podstawie fizycznych właściwości kubitu, progu korekty błędu i wstępnego refaktoryzacji przejścia. Zmienne czasowe i eccDistance mogą służyć do opisania formuły logicalCycleTime . Dla formuły physicalQubitsPerLogicalQubiteccDistance można używać tylko formuły.

Budżet błędów

Łączny budżet błędów $\epsilon$ ustawia ogólny tolerowany błąd dla algorytmu, czyli dozwolone prawdopodobieństwo niepowodzenia algorytmu. Jego wartość globalna musi należeć do przedziału 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.

Jeśli na przykład używasz algorytmu Shora do faktorowania liczb całkowitych, duża wartość budżetu błędów 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} $$

Jeśli nie zostanie jeszcze określony, budżet błędu $\epsilon$ jest równomiernie rozłożony i ma zastosowanie do błędów $\epsilon_{\log}$ w celu zaimplementowania kubitów logicznych, budżet błędu $\epsilon_{\rm dis}$ generuje stany T poprzez destylację, a budżet błędu $\epsilon_{\rm syn}$ do syntetyzowania bram rotacji z dowolnymi kątami.

Należy pamiętać, że w przypadku syntezy destylacji 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 bramki rotacji, odpowiednio. Jeśli w algorytmie wejściowym nie ma bram rotacji, budżet błędów 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 polecenia qsharp.estimate. 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łędów. Suma wszystkich wartości jest łącznym budżetem 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 kierunku zmniejszenia liczby kubitów lub zmniejszenia środowiska uruchomieniowego.

Parametr Typ danych Opis
logical_depth_factor float Kontroluj czas 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ę. logical_depth_factorZmniejszając wartość , 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 liczba całkowita Maksymalna liczba kopii fabrycznych T. Narzędzie do szacowania zasobów określa zasoby wymagane przez wybranie optymalnej liczby kopii fabrycznych T, które minimalizują liczbę użytych 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 jeden 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 maksymalną liczbę określoną.
max_physical_qubits liczba całkowita Maksymalna liczba kubitów fizycznych dla algorytmu. Narzędzie do szacowania zasobów akceptuje tylko jeden 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 maksymalną liczbę określoną.

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 wartość podana dla max_duration elementu lub max_physical_qubits jest zbyt mała, aby znaleźć możliwe rozwiązanie, narzędzie do szacowania zasobów zwróci błąd. Jeśli nie określono ani max_durationmax_physical_qubits ograniczeń, narzędzie do szacowania zasobów ma na celu znalezienie rozwiązania z najkrótszym czasem.

Porada

Można używać elementów max_duration i max_physical_qubits wpływać na przestrzeń rozwiązania, potencjalnie znajdować 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żna skutecznie zarządzać dla niektórych algorytmów, z różnym wpływem 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 destylacji 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 T wyjścia. 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.

Porada

Użycie wstępnie zdefiniowanych jednostek destylowania zapewnia lepszą wydajność w porównaniu z jednostkami niestandardowymi.

Dostosowywanie jednostek destylacji

Możesz dostosować własne jednostki destylacyjne. Dokładne parametry jednostek destylacji 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 destylacji 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 i failure_probability_formulaoutput_error_rate_formula są formułami niestandardowymi z podstawowymi operacjami arytmetycznymi, stałymi i tylko trzema parametrami:

  • clifford_error_rate, oznaczono również jako c.
  • readout_error_rate, oznaczono również jako r.
  • input_error_rate, oznaczono również jako z.

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 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 fizycznych kubitów. Jeśli podano tylko te ostatnie, jednostkę destylacji można zastosować do kubitów logicznych. Jeśli podano oba typy kubitów, jednostkę destylacji można zastosować 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 destylacji. Wartość <protocol specific parameters> wymagana dla logical_qubit_specification_first_round_override elementu 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ą fizycznych kubitów 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ę fizycznych kubitów 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 zapewnia 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 Visual Studio Code przy użyciu Q#opcji : Oblicz szacowanie 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 przestrzeni. Aby uzyskać więcej informacji, zobacz Diagram czasu przestrzeni.

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

Następne kroki