target Přizpůsobení parametrů nástroje pro odhad prostředků

Článek
05/23/2024

Tento článek ukazuje, jak přizpůsobit target parametry estimátoru prostředků Azure Quantum tak, aby odpovídaly charakteristikám počítačů, na které cílíte. Estimátor prostředků pomocí těchto parametrů odhaduje prostředky potřebné ke spuštění kvantového algoritmu na kvantovém počítači.

Poznámka:

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

Požadavky

Prostředí Pythonu s nainstalovaným Pythonem a Pipem
Nejnovější verze editoru Visual Studio Code nebo otevření editoru VS Code na webu
VS Code s nainstalovanými rozšířeními Azure Quantum Development Kit, Python a Jupyter
Nejnovější balíčky a qsharp-widgets služby Azure Quantumqsharp.
```
python -m pip install --upgrade qsharp qsharp-widgets 
```

Target parametry

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

Proto estimátor prostředků vezme sadu vstupů s předem definovanými hodnotami, abyste mohli snadno začít:

Fyzický qubitový model, který definuje vlastnosti podkladových fyzických qubitů.
Schéma opravy kvantových chyb (QEC), což je předpokládané schéma oprav kvantových chyb.
Rozpočet chyb, což je celková povolená chyba, tj. počet povolených chyb, kolikrát je program povolený, se může zrušit.
Omezení na úrovni komponenty, což je počet logických cyklů a počet kopií T factory.
Destilační jednotky pro určení algoritmů pro destilační t továrny.
Paretův odhad hranice pro spuštění více odhadů počtu qubitů a modulu runtime pro stejný algoritmus.

Tip

Pokud už znáte některé předem počítané odhady pro operaci, můžete je také začlenit a optimalizovat provádění nástroje pro odhad prostředků. Další informace naleznete v tématu Použití známých odhadů s nástrojem pro odhad prostředků.

Parametry fyzického qubitu

Když Nástroj pro odhad prostředků modeluje předpoklady fyzického qubitu, používá k provozu qubitů dvě různé fyzické instrukční sady. Fyzická instrukční sada může být založená na bráně nebo Majorana. Instrukční sada založená na bráně poskytuje měření jedno qubitu, jedno qubitové brány (včetně bran T) a dvou qubitových bran. Instrukční sada Majorana poskytuje fyzickou bránu T, měření jedno qubitu a dvou qubitové společné měření.

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

Parametr Qubitu	Python API – třída	Popis
`"qubit_gate_ns_e3"` , `"qubit_gate_ns_e4"`	`GATE_NS_E3` , `GATE_NS_E4`	Časy operací a věrnosti můžou odpovídat budoucím verzím superkondukčních qubitů transmonů nebo číselným qubitům, které obvykle mají provozní dobu v režimu nanosekundy. U těchto qubitů se předpokládá, že operace brány a měření berou 50 ns a 100 ns. Míra chyb brány s jedním qubitem a dvěma qubity se předpokládá jako realistická targethodnota $10^{-3}$ a $10^{-4}$ jako optimistická target pro škálovaný 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ů na základě iontů, které obvykle mají provozní doby v mikrosekundovém režimu. Na základě typických předpokladů pro iontové qubity se předpokládá, že operace brány a měření mají 100 μs. Míra chyb pro jedno qubitové cliffordové brány je $10^{-3}$ jako realistická target a $10^$ jako optimistická target, zatímco míra chyb pro jedno qubitové brány non-Clifford (brána T) je $10^{-4}{-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`	Časy operací a věrnosti můžou odpovídat budoucím vylepšeným verzím qubitů Majorany. U těchto qubitů se předpokládá, že operace brány a měření mají 100 ns. Aby bylo možné počítat s topologickou ochranou hardwaru, předpokládá se, že jedno-qubit a dvou qubitové společné míry měření (cliffordová chybovost) budou 10 ^$ $10^{-4}$ realističtí targeta $10^{-6}$ jako optimistická target. Operace bez Cliffordu v této architektuře nemají topologickou ochranu, míra chyb pro fyzické brány T bez Cliffordu je 5 %.

Poznámka:

Pokud nezadáte jinou hodnotu, výchozí hodnota pro model qubitu je "qubit_gate_ns_e3".

Parametry pro předdefinované parametry qubitu

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ě zadat předdefinované parametry qubitu. Při spuštění qsharp.estimatemůžete vybrat název modelu qubitu qubitParams pro třídu . Pokud například chcete vybrat "qubit_maj_ns_e6" parametr qubitu, napište:

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

Můžete také předat parametry qubitu do EstimatorParams třídy pomocí QubitParams. Pokud například chcete vybrat MAJ_NS_E6 parametr qubitu, napiš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í kterékoli z ostatních hodnot. Pokud chcete například 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 qubitu pro qubity založené na bráně

Identifikátor Pythonu	Datový typ	Popis
`name`	string	Název modelu qubitu
`instruction_set`	"gate_based"	Základní technologie qubitu
`one_qubit_measurement_time`	řetězec času	Doba provozu pro měření jednoho qubitu ($t_{\rm meas}$) v ns
`one_qubit_gate_time`	řetězec času	Doba provozu pro jedno qubitovou bránu ($t_{\rm gate}$) v ns
`two_qubit_gate_time`	řetězec času	Doba provozu pro bránu se dvěma qubity v ns
`t_gate_time`	řetězec času	Doba provozu pro jedno qubitovou bránu non-Clifford v ns
`one_qubit_measurement_error_rate`	float (číslo s plovoucí řádovou čárkou)	Míra chyb pro měření jedno qubitu
`one_qubit_gate_error_rate`	float (číslo s plovoucí řádovou čárkou)	Míra chyb pro bránu Clifford s jedním qubitem ($p$)
`two_qubit_gate_error_rate`	float (číslo s plovoucí řádovou čárkou)	Míra chyb pro bránu Cliffordu se dvěma qubity
`t_gate_error_rate`	float (číslo s plovoucí řádovou čárkou)	Míra chyb pro přípravu stavu single-qubit non-Clifford ($p_T$)
`idle_error_rate`	float (číslo s plovoucí řádovou čárkou)	Míra chyb odpovídající idlingu

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 není zadáno, hodnoty pro a výchozí hodnoty , hodnoty pro two_qubit_gate_error_rate a t_gate_error_rate výchozí one_qubit_gate_error_ratehodnoty a hodnoty pro idle_error_rate výchozí hodnoty one_qubit_measurement_error_rate.one_qubit_gate_timet_gate_time two_qubit_gate_time

Parametry qubitu pro qubity Majorana

Identifikátor Pythonu	Datový typ	Popis
`name`	string	Název modelu qubitu
`instruction_set`	"majorana"	Základní technologie qubitu
`one_qubit_measurement_time`	řetězec času	Doba provozu pro měření jednoho qubitu ($t_{\rm meas}$) v ns
`two-qubit_joint_measurement_time`	řetězec času	Doba provozu pro měření dvou qubitů v ns
`t_gate_time`	řetězec času	Doba provozu pro jedno qubitovou bránu non-Clifford v ns
`one_qubit_measurement_error_rate`	float (číslo s plovoucí řádovou čárkou)	Míra chyb pro měření jedno qubitu
`two_qubit_joint_measurement_error_rate`	float (číslo s plovoucí řádovou čárkou)	Míra chyb pro měření dvou qubitů
`t_gate_error_rate`	float (číslo s plovoucí řádovou čárkou)	Míra chyb pro přípravu stavu single-qubit non-Clifford ($p_T$)
`idle_error_rate`	float (číslo s plovoucí řádovou čárkou)	Míra chyb odpovídající idlingu

Minimální šablona pro instrukční sadu založenou na Majorana 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áno, hodnoty pro a výchozí hodnoty , hodnoty pro two_qubit_joint_measurement_error_rate a t_gate_error_rate výchozí one_qubit_measurement_error_ratehodnoty a hodnoty pro idle_error_rate výchozí hodnoty one_qubit_measurement_error_rate.one_qubit_measurement_timet_gate_time two_qubitJointMeasurementTime

Pro one_qubit_measurement_error_rate a two_qubit_joint_measurement_error_rate, můžete určit chybovosti odpovídající měrných čtení, readouta měření zpracování, process. 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 zadáte jednu číselnou hodnotu pro jedno qubit a chybovost dvou qubitů v měření qubitu Majorana, může být míra chyb čtení i procesu rovna.

Důležité

Všechny hodnoty, které nejsou zadané, budou mít výchozí hodnotu, například určením "qubit": {"oneQubitGateTime":"200 ns"} se modeluje qubit založený na bráně, ve kterém je čas brány dvou qubitů i čas brány s jedním qubitem 200 ns. U jednotek je třeba zadat časové řetězce, které jsou čísla s plovoucí desetinnou čárkou s dvojitou přesností, následovaná mezerou a časovou jednotkou pro tyto hodnoty, kde mohou být nspřípony času , µ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ízké míry chyb. Tato míra targets chyb obvykle přesahuje možnosti nezpracovaných fyzických qubitů. K vyřešení tohoto omezení jsou kvantová oprava chyb (QEC) a výpočty odolné proti chybám dvě zásadní techniky, které tvoří stavební bloky rozsáhlých kvantových počítačů. Za prvé nám QEC umožňuje vytvořit 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.

Estimátor prostředků používá následující vzorec pro modelování logických chybových sazeb pomocí exponenciálního modelu.

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

kde $a$ je překračovací předfaktor, $d$ je vzdálenost kódu, $p$ je fyzická míra chyb a $p^*$ je prahová hodnota opravy kvantových chyb. Předfaktorové $a$ je možné extrahovat číselně pro simulace.

Vzdálenost kódu $d$ je parametr, který řídí počet chyb, které lze opravit. Vzdálenost kódu proto definuje 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šují o vzdálenost kódu. Cílem schématu QEC je najít minimální vzdálenost kódu, která může dosáhnout požadované míry chyb nastavené pro konkrétní aplikaci.

Fyzická míra chyb $p$ se extrahuje z parametrů qubitu jako nejhorší chybovost jakékoli fyzické operace Clifford prováděné 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 obvykle mají prahovou hodnotu chybovosti $p^*$ pod tím, která oprava chyb potlačí chyby.

Estimátor prostředků Azure Quantum podporuje dvě předdefinovaná schémata QEC: kód povrchu a kód floketu.

Protokol QEC	Python API – třída	Popis
"`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 Majorana je založen na arXiv:1909.03002 a arXiv:2007.00307.
"`floquet_code`"	`FLOQUET_CODE`	Pouze pro qubity majorany. Kód floketu je založen na arXiv:2202.11829.

Poznámka:

Pokud nezadáte jinou hodnotu, výchozí hodnota schématu QEC je "surface_code".

Parametry pro předdefinovaná schémata QEC

Přesné parametry pro každé předdefinované schéma QEC 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 vybrat název modelu QEC pro "qecScheme" třídu . Pokud chcete například vybrat kód floketu, napište:

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

Seznam parametrů odhadu EstimatorParams můžete předat také třídě pomocí QECScheme třídy. Pokud chcete například vybrat kód floketu, 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 zadáním názvu a následnou aktualizací kterékoli z ostatních hodnot. Pokud například chcete zvýšit překračování předfaktoru v kódu floketu, napište:

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

Poznámka:

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

Přizpůsobení schémat QEC

Estimátor prostředků může abstrahovat přizpůsobené schéma QEC na základě výše uvedeného vzorce zadáním hodnot pro "crossingPrefactor" $a$ a "errorCorrectionThreshold" $p^*$. Dále je třeba zadat "logicalCycleTime", to znamená čas spuštění jedné logické operace, která závisí na vzdálenosti kódu a fyzické době operace předpoklady podkladových fyzických qubitů. Nakonec druhý vzorec vypočítá "physicalQubitsPerLogicalQubit"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>
                    }
                })

Ve vzorcích můžete použít proměnné , , two_qubit_gate_timea two_qubit_joint_measurement_timeone_qubit_measurement_time, jejichž hodnoty jsou převzaty one_qubit_gate_timez odpovídajícího pole z parametrů fyzického qubitu, stejně jako 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 předfaktoru křížku. Časové proměnné a eccDistance lze je použít k popisu logicalCycleTime vzorce. Pro vzorec lze použít pouze vzorec physicalQubitsPerLogicalQubit eccDistance .

Rozpočet chyb

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

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

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

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

Logické chyby $\epsilon_{\log}$ jsou chyba implementace logických qubitů, chyba stavu T $\epsilon_{\rm dis}$ je chyba vytváření stavů T prostřednictvím destilace a chyba rotační brány $\epsilon_{\rm syn}$ je chyba syntetizace rotačních bran s libovolnými úhly.

Poznámka:

Pokud nezadáte jinou hodnotu, rozpočet chyb $\epsilon$ se rovnoměrně rozdělí mezi logickou chybu, chybu stavu T a chybu brány rotace.

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

Předávání rozpočtu chyb

Rozpočet chyb můžete zadat dvěma způsoby nastavením čísla mezi 0 a 1. Při spuštění qsharp.estimatemůžete předat rozpočet chyb . 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 EstimatorParams rozpoč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 chyb. Součet všech hodnot je celkový rozpočet chyb a musí být v rozmezí od 0 do 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 ke snížení modulu runtime.

Parametr	Datový typ	Popis
`logical_depth_factor`	float (číslo s plovoucí řádovou čárkou)	Řídí 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 vynásobí tímto číslem. Snížením `logical_depth_factor`můžete zvýšit počet vyvolání továrny T v daném čase, což vede k menšímu počtu kopií výroby T 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 požadovaná logická míra chyb se zvyšuje kvůli dalšímu počtu cyklů.
`max_t_factories`	integer	Maximální počet kopií T factory. Nástroj pro odhad prostředků určuje prostředky potřebné výběrem optimálního počtu kopií T factory, které minimalizují počet použitých fyzických qubitů bez ohledu na časová režie. 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 naleznete v tématu Fyzický odhad T factory.
`max_duration`	řetězec času	Maximální doba běhu pro algoritmus Estimátor prostředků přijímá pouze jedno z `max_duration` omezení `max_physical_qubits` v době, ale ne dvě. Pokud `max_duration` je zadáno, estimátor prostředků se pokusí najít nejlepší odhad pro `max_physical_qubits` řešení omezená maximálním číslem.
`max_physical_qubits`	integer	Maximální počet fyzických qubitů pro algoritmus Estimátor prostředků přijímá pouze jedno z `max_duration` omezení `max_physical_qubits` v době, ale ne dvě. Pokud `max_physical_qubits` je zadáno, estimátor prostředků se pokusí najít nejlepší odhad pro `max_duration` řešení omezená maximálním číslem.

Následující kód ukazuje, jak určit omezení kvantového algoritmu:

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 příliš malá k nalezení vhodného řešení, vrátí estimátor prostředků chybu. Pokud nejsou zadána žádná max_duration omezení ani max_physical_qubits omezení, cílem estimátoru prostředků je najít řešení s nejkratší dobou.

Tip

Můžete použít max_duration max_physical_qubits a ovlivnit prostor řešení, potenciálně najít řešení s delším modulem runtime, ale menší počet qubitů v porovnání s řešeními bez těchto omezení. Mezi modulem runtime a počtem qubitů existuje kompromis a tento kompromis lze efektivně spravovat u některých algoritmů s různými účinky na různé algoritmy. Tabulka IV v tabulce [arXiv:2211.07629] znázorňuje 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 časem nebo počtem vzorků omezení qubitů.

Destilační jednotky

Můžete poskytnout specifikace pro algoritmy pro destilační algoritmy t továren s DistillationUnitSpecification třídou. 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 notace 15-1 představuje 15 vstupních stavů T a 1 výstupní T stav. Destilační 15-1 space-efficient jednotka používá méně qubitů, než 15-1 RM ale 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 oproti vlastním jednotkám.

Přizpůsobení destilačních jednotek

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 způsob zobrazení destilační jednotky ve výsledcích výstupu.

Následující kód ukazuje, jak určit parametry destilační jednotky 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, také označeno jako c.
readout_error_rate, také označeno jako r.
input_error_rate, také označeno 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 ilustrují vzorce používané ve výchozím nastavení ve standardní implementaci.

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í jednotka, lze destilační jednotku použít na fyzické qubity. Pokud je k dispozici pouze ten 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 zadán. Pokud ano, přepíše hodnoty logical_qubit_specification v případě použití v prvním kole destilace. Hodnota <protocol specific parameters> , která se vyžaduje pro logical_qubit_specification_first_round_override toto schéma:

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

Paretův odhad hranice

Při odhadu 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 dobu běhu algoritmu. Počet fyzických qubitů je však omezený počtem fyzických qubitů dostupných v 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ů.

Odhad paretovské hranice poskytuje více odhadů pro stejný algoritmus, přičemž každý zobrazuje kompromisy mezi počtem qubitů a modulem runtime.

Poznámka:

Pokud spustíte nástroj pro odhad prostředků v editoru Visual Studio Code pomocí Q#možnosti : Calculate Resource Estimates (Vypočítat odhady prostředků), je ve výchozím nastavení povolený odhad paretovské hranice.

Pokud spustíte estimátor prostředků v Pythonu, musíte parametr zadat "estimateType" 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 odhadu paretovské hranice, můžete použít EstimatesOverview funkci. Tyto funkce zobrazují výsledky odhadu hranic v tabulce a v diagramu prostorového času. Další informace najdete v diagramu prostorového času.

from qsharp_widgets import EstimatesOverview

EstimatesOverview(result)

Poznámka:

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

Sdílet prostřednictvím

target Přizpůsobení parametrů nástroje pro odhad prostředků

Požadavky

Target parametry

Parametry fyzického qubitu

Parametry pro předdefinované parametry qubitu

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

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

Parametry qubitu pro qubity založené na bráně

Parametry qubitu pro qubity Majorana

Schémata oprav kvantových chyb

Parametry pro předdefinovaná schémata QEC

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

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

Přizpůsobení schémat QEC

Rozpočet chyb

Předávání rozpočtu chyb

Omezení

Destilační jednotky

Přizpůsobení destilačních jednotek

Paretův odhad hranice

Další kroky

Váš názor

Další materiály