target Přizpůsobení parametrů estimátoru prostředků

  • Článek

Tento článek ukazuje, jak přizpůsobit target parametry nástroje Azure Quantum Resource Estimator tak, aby odpovídaly charakteristikám počítače, které používáte target. Estimátor prostředků používá tyto parametry k odhadu prostředků potřebných ke spuštění kvantového algoritmu na kvantovém počítači.

Poznámka

Pokud při práci s nástrojem pro posouzení prostředků narazíte na nějaký problém, podívejte se na stránku Řešení potíží.

Požadavky

Cílové parametry

Estimátor prostředků vypočítá odhad prostředků, jako je počet qubitů a doba běhu, které by byly potřeba k implementaci daného kvantového algoritmu pomocí dané technologie qubitu a s pevnou sadou možností architektury.

Proto estimátor prostředků přijímá sadu vstupů s předdefinovaných hodnotami, které vám umožní snadno začít:

Parametry fyzického qubitu

Když estimátor prostředků modeluje předpoklady fyzických qubitů, používá k provozu qubitů dvě různé fyzické instrukční sady. Fyzická instrukční sada může být buď brána, nebo majorana. Instrukční sada založená na branách poskytuje měření s jedním qubitem, jedno qubitovou bránu (včetně bran T) a dvou qubitovou bránu. Instrukční sada Majorana poskytuje fyzickou bránu T, jedno qubitové měření a operace měření spojení se dvěma qubity.

Můžete si vybrat ze šesti předdefinovaných parametrů qubitu, z nichž čtyři mají sady instrukcí založené na bráně a dva s instrukční sadou Majorana. Tyto modely qubitů pokrývají celou řadu provozních dob a chybovosti, což umožňuje dostatečné zkoumání nákladů na prostředky potřebných k umožnění praktických kvantových aplikací.

Parametr Qubitu Třída rozhraní Python API Description
"qubit_gate_ns_e3" , "qubit_gate_ns_e4" GATE_NS_E3 , GATE_NS_E4 Provozní doby a věrnosti mohou odpovídat budoucím verzím supravodicích transmonových qubitů nebo qubitů spinu, které obvykle mají provozní doby v režimu nanosekund. U těchto qubitů se předpokládá, že operace hradla a měření mají 50 ns a 100 ns. Míra chyb brány s jedním a dvěma qubity se předpokládá jako hodnota $10^{-3}$ jako realistická targeta $10^{-4}$ jako optimistická target hodnota pro vertikálně navyšovaný systém.
"qubit_gate_us_e3" , "qubit_gate_us_e4" GATE_US_E3 , GATE_US_E4 Provozní doby a věrnosti můžou odpovídat budoucím verzím qubitů založených na iontech, které mají obvykle provozní doby v mikrosekundovém režimu. Na základě typických předpokladů pro iontové qubity se předpokládá, že brány a operace měření budou trvat 100 μs. Míra chyb pro cliffordská hradla s jedním qubitem je $10^{-3}$ jako realistická target a $10^{-4}$ jako optimistická target, zatímco míra chyb pro jedno qubitová ne Cliffordová hradla (brána T) je $10^{-6}$. U dvou qubitových bran je chybovost $10^{-3}$ jako realistická target a $10^{-4}$ jako optimistická target.
"qubit_maj_ns_e4" , "qubit_maj_ns_e6" MAJ_NS_E4 , MAJ_NS_E6 Provozní doby a věrnosti můžou odpovídat budoucím vylepšeným verzím qubitů Majorana. U těchto qubitů se předpokládá, že operace hradla a měření budou trvat 100 ns. Aby bylo možné zohlednit topologickou ochranu v hardwaru, míra společných měření s jedním qubitem a dvěma qubity (Cliffordovské chybovosti) se předpokládá jako $10^{-4}$ jako realistický targeta $10^{-6}$ jako optimistický target. Jiné než Cliffordovy operace v této architektuře nemají topologickou ochranu, míra chyb u fyzických bran T, které nejsou cliffordovými branami, je 5 %.

Poznámka

Pokud není zadaná jiná hodnota, výchozí hodnota pro qubitový model je "qubit_gate_ns_e3".

Kompletní předdefinované parametry qubitu jsou pro referenci následující:

{
    "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
    }
}

Předávání předdefinovaných parametrů qubitu

Existují dva způsoby, jak programově určit předdefinované parametry qubitu. Název modelu qubitu pro qubitParams třídu můžete vybrat při spuštění příkazu qsharp.estimate. Pokud například chcete vybrat "qubit_maj_ns_e6" parametr qubitu, zapište:

qsharp.estimate("RunProgram()", params=
                {"qubitParams": {
                        "name": "qubit_maj_ns_e6"
                    },
                })

Parametry EstimatorParams qubitu můžete také předat třídě pomocí QubitParamspříkazu . Pokud například chcete vybrat MAJ_NS_E6 parametr qubitu, zapište:

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)

Přizpůsobení předdefinovaných parametrů qubitu

Předdefinované parametry qubitu můžete přizpůsobit zadáním názvu a následnou aktualizací všech ostatních hodnot. Pokud například chcete snížit chybovost měření dvou qubitů v "qubit_maj_ns_e4", zapište:

qsharp.estimate("RunProgram()", params=
                {"qubitParams": {
                        "name": "qubit_maj_ns_e4",
                        "twoQubitJointMeasurementErrorRate": 1e-5,
                    },
                })

Nebo můžete předat pokyny ve formě seznamu.

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 qubitů pro qubity založené na bráně

Identifikátor Pythonu Datový typ Description
name řetězec Název modelu qubitu
instruction_set "gate_based" Základní technologie qubitů
one_qubit_measurement_time řetězec času Doba provozu měření s jedním qubitem ($t_{\rm meas}$) v ns
one_qubit_gate_time řetězec času Doba operace pro jedno qubitovou bránu ($t_{\rm gate}$) v ns
two_qubit_gate_time řetězec času Doba provozu pro dvou qubitovou bránu v ns
t_gate_time řetězec času Doba provozu pro jedno qubitovou bránu mimo Clifford v ns
one_qubit_measurement_error_rate float Míra chyb při měření s jedním qubitem
one_qubit_gate_error_rate float Míra chyb pro Cliffordovou bránu s jedním qubitem ($p$)
two_qubit_gate_error_rate float Míra chyb pro dvou qubitovou Cliffordovou bránu
t_gate_error_rate float Míra chyb při přípravě stavu jiného než Clifforda s jedním qubitem ($p_T$)
idle_error_rate float Míra chyb odpovídající nečinnosti

Následující kód ukazuje, jak zadat vlastní parametry qubitu pro instrukční sadu založenou na bráně:

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

Poznámka

Pokud nejsou zadané, výchozí hodnoty pro two_qubit_gate_time a one_qubit_gate_timet_gate_time , výchozí hodnoty pro two_qubit_gate_error_rate a t_gate_error_rate a výchozí one_qubit_gate_error_ratehodnota pro idle_error_rate se nastaví na one_qubit_measurement_error_rate.

Parametry qubitů pro qubity Majorana

Identifikátor Pythonu Datový typ Description
name řetězec Název modelu qubitu
instruction_set "majorana" Základní technologie qubitů
one_qubit_measurement_time řetězec času Doba provozu měření s jedním qubitem ($t_{\rm meas}$) v ns
two-qubit_joint_measurement_time řetězec času Provozní doba pro měření dvou qubitů v ns
t_gate_time řetězec času Doba provozu pro jedno qubitovou bránu mimo Clifford v ns
one_qubit_measurement_error_rate float Míra chyb při měření s jedním qubitem
two_qubit_joint_measurement_error_rate float Míra chyb při měření dvou qubitů
t_gate_error_rate float Míra chyb při přípravě stavu s jedním qubitem mimo Clifford ($p_T$)
idle_error_rate float Míra chyb odpovídající nečinné rychlosti

Minimální šablona pro instrukční sadu založenou na Majoraně se všemi požadovanými hodnotami je:

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

Poznámka

Pokud není zadán, hodnoty pro two_qubitJointMeasurementTime a výchozí hodnotu one_qubit_measurement_time, hodnoty pro two_qubit_joint_measurement_error_rate a t_gate_error_rate výchozí one_qubit_measurement_error_ratehodnoty pro a výchozí hodnota pro idle_error_rateone_qubit_measurement_error_ratet_gate_time hodnotu .

Pro one_qubit_measurement_error_rate a two_qubit_joint_measurement_error_ratemůžete zadat chybovost odpovídající naměřené hodnotě readouta zpracování processměření. Tyto hodnoty můžou být <double> čísla nebo dvojice čísel. Příklad:

params.qubit_params.two_qubit_joint_measurement_error_rate = \
    MeasurementErrorRate(process=0.00005, readout=0.00007)

Poznámka

Pokud v měření qubitu Majorana zadáte jednu číselnou hodnotu pro chybovost s jedním qubitem a dvěma qubity, může být míra chyb čtení i zpracování stejná.

Důležité

Všechny hodnoty, které nejsou zadané, budou mít výchozí hodnotu, například určení "qubit": {"oneQubitGateTime":"200 ns"} bude modelovat qubit založený na bráně, ve kterém je čas brány se dvěma qubity i jeden qubitový čas brány 200 ns. U jednotek je třeba zadat časové řetězce, což jsou čísla s plovoucí desetinnou čárkou s dvojitou přesností, následované mezerou a časovou jednotkou pro tyto hodnoty, kde jsou možné časové přípony ns, µs (nebo us), msa s.

Schémata oprav kvantových chyb

K provádění kvantových aplikací v praktickém měřítku by kvantové operace měly mít nízkou chybovost. Tato míra targets chyb je obvykle nad rámec možností nezpracovaných fyzických qubitů. K překonání tohoto omezení jsou dvě klíčové techniky, které tvoří stavební bloky rozsáhlých kvantových počítačů, kvantová oprava chyb (QEC) a výpočty odolné proti chybám. Zaprvé nám QEC umožňuje sestavit několik fyzických qubitů náchylných k chybám a vytvořit spolehlivější logický qubit, který zachovává kvantové informace lépe než základní fyzické qubity.

Vzdálenost kódu opravy chyb (nebo jen krátká vzdálenost kódu) je parametr, který řídí počet chyb, které lze opravit. Tedy chybovost logických qubitů a počet fyzických qubitů, které jsou potřeba k jejich kódování. Přesnost i počet fyzických qubitů se zvyšuje se vzdáleností kódu. Cílem je najít minimální vzdálenost kódu, která může dosáhnout požadované frekvence chyb pro konkrétní aplikaci.

Estimátor prostředků používá k modelování logických chyb s využitím exponenciálního modelu následující vzorec.

$$ P = a\left(\frac{p}{p^*}\right)^{\frac{d+1}{2}} $$

kde $d$ je vzdálenost kódu, $p$ je míra fyzických chyb a $p^*$ je prahová hodnota pro opravu kvantových chyb. Fyzická míra chyb $p$ se extrahuje z parametrů qubitu jako nejhorší míra chyb jakékoli fyzické operace Clifford v zařízení.

Konkrétně $p = {}$ max(one_qubit_measurement_error_rate, one_qubit_gate_error_rate, two_qubit_gate_error_rate) pro parametry qubitu s instrukční sadou založenou na bráně a $p = {}$ max(one_qubit_measurement_error_rate, two_qubit_joint_measurement_error_rate) pro parametry qubitu s instrukční sadou Majorana. Schémata QEC mají obvykle prahovou hodnotu chybovosti $p^*$ pod kterou oprava chyb potlačí chyby.

Protokol QEC Třída rozhraní PYTHON API Description
"surface_code" SURFACE_CODE Kód povrchu založený na bráně je založen na arXiv:1208.0928 a arXiv:1009.3686. Kód povrchu Majorany je založen na arXiv:1909.03002 a arXiv:2007.00307.
"floquet_code" FLOQUET_CODE Pouze pro qubity Majorana. Kód floquet je založen na arXiv:2202.11829.

Poznámka

Pokud není zadána jiná hodnota, výchozí hodnota pro schéma QEC je "surface_code".

Přesné parametry pro každé předdefinované schéma QEC (včetně předfaktorové $a$, které lze extrahovat číselně pro simulace) jsou následující.

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

Předávání předdefinovaných schémat QEC

Existují dva způsoby, jak určit předdefinovaná schémata QEC. Při spuštění qsharp.estimatemůžete pro třídu vybrat název "qecScheme" modelu QEC. Pokud například chcete vybrat floquet kód, napište:

qsharp.estimate("RunProgram()", params=
                {"qecScheme": {
                        "name": "floquet_code"
                    }
                })

Pomocí třídy můžete také předat seznam parametrů EstimatorParams odhaduQECScheme. Pokud například chcete vybrat floquet kód, napište:

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)

Přizpůsobení předdefinovaných schémat QEC

Předdefinovaná schémata QEC můžete přizpůsobit tak, že zadáte název a pak aktualizujete kteroukoli z ostatních hodnot. Pokud chcete například zvýšit pre-faktor přechodu v kódu floquet, napište:

qsharp.estimate("RunProgram()", params=
                {"qecScheme": {
                        "name": "floquet_code",
                        "crossingPrefactor": 0.07,
                    }
                })

Poznámka

Pokud není zadáno, hodnoty pro "logicalCycleTime" a výchozí hodnoty "oneQubitMeasurementTime"jsou , výchozí hodnota pro "errorCorrectionThreshold"0.01a výchozí hodnota pro "crossingPrefactor"0.03"physicalQubitsPerLogicalQubit" hodnotu .

Přizpůsobení schémat QEC

Nástroj Pro posouzení prostředků může abstrahovat přizpůsobené schéma QEC založené na výše uvedeném vzorci tím, že zadá hodnoty pro "crossingPrefactor" $a$ a "errorCorrectionThreshold" $p^*$. Dále je potřeba zadat "logicalCycleTime", tj. čas provedení jedné logické operace, který závisí na vzdálenosti kódu a předpokladech fyzické doby operace podkladových fyzických qubitů. Nakonec druhý vzorec vypočítá "physicalQubitsPerLogicalQubit", tj. počet fyzických qubitů potřebných ke kódování jednoho logického qubitu na základě vzdálenosti kódu.

Jako šablonu pro schémata QEC můžete použít následující kód:

qsharp.estimate("RunProgram()", params=
                {"qecScheme": {
                        "crossingPrefactor": <double>,
                        "errorCorrectionThreshold": <double>,
                        "logicalCycleTime": <formula string>,
                        "physicalQubitsPerLogicalQubit": <formula string>
                    }
                })

Uvnitř vzorců můžete použít proměnné one_qubit_gate_time, two_qubit_gate_time, one_qubit_measurement_timea two_qubit_joint_measurement_time, jejichž hodnoty jsou převzaty z odpovídajícího pole z fyzických parametrů qubitu, a také proměnnou eccDistance pro vzdálenost kódu vypočítanou pro logický qubit na základě vlastností fyzického qubitu, prahové hodnoty opravy chyb a prefactoru přechodu. Časové proměnné a eccDistance lze použít k popisu logicalCycleTime vzorce. Pro vzorec lze použít pouze vzorec physicalQubitsPerLogicalQubiteccDistance .

Rozpočet chyb

Celkový rozpočet chyby $\epsilon$ nastaví celkovou tolerovanou chybu algoritmu, tj. povolenou pravděpodobnost selhání algoritmu. Jeho globální hodnota musí být mezi 0 a 1 a výchozí hodnota je 0,001, což odpovídá 0,1 %. Jinými slovy, algoritmus může selhat maximálně jednou za 1000 spuštění. Tento parametr je vysoce specifický pro aplikaci.

Pokud například používáte Shorův algoritmus pro faktoring celých čísel, může být tolerována velká hodnota pro rozpočet chyb, protože je možné zkontrolovat, že výstupy jsou skutečně primárními faktory vstupu. Na druhou stranu může být pro algoritmus, který řeší problém s řešením, který nejde efektivně ověřit, potřeba menší rozpočet chyb.

Rozpočet chyb odpovídá součtu tří částí:

$$ \epsilon = \epsilon_{\log} + \epsilon_{\rm dis} + \epsilon_{\rm syn} $$

Pokud není zadán žádný další parametr, je rozpočet chyby $\epsilon$ rovnoměrně rozdělený a vztahuje se na chyby $\epsilon_{\log}$ pro implementaci logických qubitů, rozpočet chyby $\epsilon_{\rm dis}$ vytváří stavy T prostřednictvím destilace a rozpočet chyb $\epsilon_{\rm syn}$ syntetizuje rotační brány s libovolnými úhly.

Všimněte si, že pro destilaci a syntézu rotace jsou příslušné chybové rozpočty $\epsilon_{\rm dis}$ a $\epsilon_{\rm syn}$ rovnoměrně rozdělené mezi všechny požadované stavy T a všechny požadované rotační brány. Pokud vstupní algoritmus neobsahuje brány rotace, je rozpočet chyb rovnoměrně rozdělený na logické chyby a chyby stavu T.

Předání rozpočtu chyb

Existují dva způsoby, jak určit rozpočet chyb nastavením čísla mezi 0 a 1. Rozpočet chyb můžete předat při spuštění příkazu qsharp.estimate. Pokud například chcete vybrat rozpočet chyby 1/3, napište:

qsharp.estimate("RunProgram()", params=
                {'errorBudget': 0.333
                })

Do třídy můžete také předat parametry EstimatorParamsrozpočtu chyby.

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)

Můžete také jednotlivě určit každou komponentu rozpočtu chyby. Součet všech hodnot je celkový rozpočet chyb a musí být mezi 0 a 1. Pokud kvantový algoritmus neobsahuje stavy T nebo rotace, pak hodnoty t_states a rotations mohou být 0.

Následující kód ukazuje, jak zadat parametr rozpočtu chyby se stavy T a obměny:

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

Omezení

Třídu můžete použít "constraints" k použití omezení na úrovni komponent T factory . Úpravou omezení můžete optimalizovat odhady směrem ke snížení počtu qubitů nebo snížení běhu.

Parametr Datový typ Popis
logical_depth_factor float Ovládejte dobu provádění. Pokud má hodnotu větší než 1, počáteční počet logických cyklů, označovaný také jako logická hloubka, se tímto číslem vynásobí. Snížením logical_depth_factorhodnoty můžete zvýšit počet vyvolání T továrny v daném čase, což vede k menšímu počtu kopií T factory potřebných k vytvoření stejného počtu stavů T. Když snížíte počet kopií T factory, modul runtime algoritmu se odpovídajícím způsobem zvýší. Faktor škálování pro celkový modul runtime může být větší, protože kvůli dalšímu počtu cyklů se zvyšuje požadovaná logická míra chyb.
max_t_factories integer Maximální počet kopií T factory. Nástroj Pro posouzení prostředků určuje požadované prostředky výběrem optimálního počtu kopií T factory, který minimalizuje počet použitých fyzických qubitů, bez ohledu na čas. Parametr max_t_factories omezuje maximální počet kopií, a proto odpovídajícím způsobem upravte počet logických cyklů. Další informace najdete v tématu Fyzický odhad T factory.
max_duration řetězec času Maximální doba běhu algoritmu. Estimátor prostředků přijímá v okamžiku pouze jedno omezení max_duration nebo max_physical_qubits , ale ne dvě. Pokud max_duration je zadána, nástroj Pro posouzení prostředků se pokusí najít nejlepší odhad mezi max_physical_qubits řešeními omezený maximálním zadaným počtem.
max_physical_qubits integer Maximální počet fyzických qubitů pro algoritmus Estimátor prostředků přijímá v okamžiku pouze jedno omezení max_duration nebo max_physical_qubits , ale ne dvě. Pokud max_physical_qubits je zadána, nástroj Pro posouzení prostředků se pokusí najít nejlepší odhad mezi max_duration řešeními omezený maximálním zadaným počtem.

Následující kód ukazuje, jak určit omezení pro kvantový algoritmus:

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

Poznámka

Pokud je hodnota zadaná max_duration nebo max_physical_qubits je příliš malá na to, aby bylo možné najít proveditelné řešení, vrátí nástroj Pro odhad prostředků chybu. Pokud nejsou zadána žádná max_durationmax_physical_qubits omezení, cílem nástroje Pro posouzení prostředků je najít řešení s nejkratším časem.

Tip

Můžete použít max_duration a max_physical_qubits k ovlivnění prostoru řešení a potenciálně najít řešení s delším modulem runtime, ale menším počtem qubitů ve srovnání s řešeními bez těchto omezení. Existuje kompromis mezi modulem runtime a počtem qubitů a tento kompromis lze efektivně spravovat u některých algoritmů s různými účinky na různé algoritmy. Tabulka IV v [arXiv:2211.07629] ukazuje efektivní využití kompromisu mezi počtem qubitů a modulem runtime pro algoritmy kvantové dynamiky. Další informace najdete v tématu Odhad kvantových prostředků s ukázkami omezení času nebo počtu qubitů .

Destilační jednotky

Pomocí třídy můžete zadat specifikace pro algoritmy DistillationUnitSpecificationdestilace továren T. Specifikace může být buď předdefinovaná, nebo vlastní. Předdefinovanou specifikaci můžete zadat tak, že vyberete název destilační jednotky: 15-1 RM nebo 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)

V obou případech znamená notace 15-1 15 vstupních stavů T a 1 výstupní stav T. Destilační 15-1 space-efficient jednotka používá méně qubitů, ale 15-1 RM vyžaduje více modulu runtime. Další informace najdete v tématu Tabulka VI.

Tip

Použití předdefinovaných destilačních jednotek poskytuje lepší výkon v porovnání s vlastními jednotkami.

Přizpůsobení jednotek destilace

Můžete si přizpůsobit vlastní destilační jednotky. Přesné parametry pro destilační jednotky jsou následující.

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

Očekává se, že všechny číselné parametry budou kladné. Určuje displayName , jak se destilační jednotka zobrazí ve výstupních výsledcích.

Následující kód ukazuje, jak zadat parametry jednotky destilace pro kvantový algoritmus pomocí DistillationUnitSpecification třídy a ProtocolSpecificDistillationUnitSpecification třídy.

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

Vzorce pro failure_probability_formula a output_error_rate_formula jsou vlastní vzorce se základními aritmetickými operacemi, konstantami a pouze třemi parametry:

  • clifford_error_rate, označuje se také jako c.
  • readout_error_rate, označuje se také jako r.
  • input_error_rate, označuje se také jako z.

Podívejte se na následující příklady vlastních vzorců používajících dlouhý a krátký zápis. Tyto příklady znázorňují vzorce používané ve výchozím nastavení v rámci standardní implementace.

Parametr Dlouhý vzorec Krátký vzorec
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"

Alespoň jeden z parametrů physical_qubit_specification nebo logical_qubit_specification by měl být poskytnut. Pokud je k dispozici pouze první, lze destilační jednotku použít na fyzické qubity. Pokud je k dispozici pouze to druhé, lze destilační jednotku použít na logické qubity. Pokud jsou k dispozici oba typy qubitů, lze destilační jednotku použít na oba typy qubitů.

Parametr logical_qubit_specification_first_round_override lze zadat pouze v případě, že logical_qubit_specification je zadaný. Pokud ano, přepíše hodnoty logical_qubit_specification v případě, že jsou použity v prvním kole destilace. Hodnota <protocol specific parameters> požadovaná pro logical_qubit_specification_first_round_override by měla odpovídat schématu:

{
    "numUnitQubits": <int>,
    "durationInQubitCycleTime": <double>
}

Paretův odhad hranice

Při odhadování prostředků algoritmu je důležité zvážit kompromis mezi počtem fyzických qubitů a modulem runtime algoritmu. Můžete zvážit přidělení co největšího počtu fyzických qubitů, abyste snížili běh algoritmu. Počet fyzických qubitů je však omezený počtem fyzických qubitů dostupných na kvantovém hardwaru. Pochopení kompromisu mezi modulem runtime a škálováním systému je jedním z důležitějších aspektů odhadu prostředků.

Paretův odhad hranice poskytuje více odhadů pro stejný algoritmus, z nichž každý ukazuje kompromisy mezi počtem qubitů a modulem runtime.

Poznámka

Pokud nástroj Pro posouzení prostředků spustíte v editoru Visual Studio Code pomocí Q#možnosti : Vypočítat odhady prostředků , paretův odhad hranice je ve výchozím nastavení povolený.

Pokud spustíte Nástroj pro posouzení prostředků v Pythonu "estimateType" , musíte zadat parametr jako "frontier".

result = qsharp.estimate("RunProgram()", params=
                    {"qubitParams": { "name": "qubit_maj_ns_e4" },
                    "qecScheme": { "name": "surface_code" },
                    "estimateType": "frontier", # Pareto frontier estimation
                    }
                )

Pokud chcete vizualizovat výsledky paretovského odhadu EstimatesOverview hranice, můžete použít funkci . Tato funkce zobrazí výsledky odhadu hranic v tabulce a prostoroprostorovém diagramu. Další informace najdete v tématu Prostoroprostorový diagram.

from qsharp_widgets import EstimatesOverview

EstimatesOverview(result)

Poznámka

Pokud při práci s nástrojem pro posouzení prostředků narazíte na nějaký problém, podívejte se na stránku Řešení potíží nebo se obraťte na AzureQuantumInfo@microsoft.com.

Další kroky