Az target Erőforrásbecslő paramétereinek testreszabása

  • Cikk

Ez a cikk bemutatja, hogyan szabhatja testre az targetAzure Quantum Resource Estimator paramétereit az Éppen targetfutó gép jellemzőinek megfelelően. Az Erőforrásbecslő ezeket a paramétereket használja a kvantum-algoritmus kvantumszámítógépen való futtatásához szükséges erőforrások becsléséhez.

Megjegyzés

Ha problémákba ütközik az Erőforrásbecslő használata közben, tekintse meg a Hibaelhárítás lapot.

Előfeltételek

Célparaméterek

Az Erőforrásbecslő kiszámítja az erőforrások becslését, például a qubitek számát és a futási időt, amelyek egy adott kvantumalgoritmus adott qubit-technológiával és rögzített architekturális választási lehetőségekkel történő implementálásához szükségesek.

Ezért az Erőforrásbecslő bemenetek készletét veszi igénybe, amelyek előre definiált értékeket tartalmaznak a kezdéshez:

Fizikai qubitparaméterek

Amikor a Resource Estimator modellezi a fizikai qubit-feltételezéseket, két különböző fizikai utasításkészletet használ a qubitek üzemeltetéséhez. A fizikai utasításkészlet lehet kapualapú vagy Majorana. A kapualapú utasításkészlet egy qubites mérést, egy qubites kapukat (beleértve a T kapukat) és két qubites kapukat biztosít. A Majorana utasításkészlet fizikai T-kaput, egy qubites mérést és két qubites közös mérési műveleteket biztosít.

Hat előre definiált qubitparaméter közül választhat, amelyek közül négy kapualapú utasításkészlettel, kettő pedig Majorana utasításkészlettel rendelkezik. Ezek a qubitmodellek számos működési időt és hibaarányt fednek le, amelyek lehetővé teszik a gyakorlati kvantumalkalmazások engedélyezéséhez szükséges erőforrásköltségek megfelelő feltárását.

Qubit paraméter Python API-osztály Description
"qubit_gate_ns_e3" , "qubit_gate_ns_e4" GATE_NS_E3 , GATE_NS_E4 A működés ideje és hűsége megfelelhet a szupravezető transmon qubitek vagy a spin qubitek jövőbeli verzióinak, amelyek általában a nanoszekundumos rendszerben rendelkeznek működési idővel. Ezen qubitek esetében a kapu- és mérési műveletek 50 ns, illetve 100 ns értéket vesznek fel. Az egy qubites és a két qubites kapu hibaaránya reálisan target$10^{-3}$ , a vertikálisan felskálázott rendszerek optimistajaként target pedig $10^{-4}$ lesz.
"qubit_gate_us_e3" , "qubit_gate_us_e4" GATE_US_E3 , GATE_US_E4 A műveleti idők és a hűségek megfelelhetnek a qubitek ionokon alapuló jövőbeli verzióinak, amelyek általában a mikroszekundumos rendszerben rendelkeznek műveleti idővel. Az ion qubitek tipikus feltételezései alapján a kapu- és mérési műveletek 100 μs-t vesznek igénybe. Az egy qubites Clifford-kapuk hibaaránya reális és optimistaként target$10^{-3}{-4}$ , míg az egy qubites nem Clifford kapuk (T kapu) hibaaránya $10^{-6}$.target A két qubites kapuk esetében a hibaarány 10 $^{-3}$ reálistarget, optimista target$10^{-4}$ .
"qubit_maj_ns_e4" , "qubit_maj_ns_e6" MAJ_NS_E4 , MAJ_NS_E6 A működés ideje és hűsége megfelelhet a Majorana qubitek jövőbeli továbbfejlesztett verzióinak. Ezen qubitek esetében a kapu- és mérési műveletek 100 ns-t vesznek igénybe. A hardver topológiai védelmének figyelembevétele érdekében az egy qubites és a két qubites közös mérési hibaarányok (Clifford-hibaarányok) reálisnaktarget, a $10{-4}^{-6}$ pedig optimistanak targetszámítanak. Ebben az architektúrában a nem Clifford-műveletek nem rendelkeznek topológiai védelemmel, a nem Clifford fizikai T kapuk hibaaránya 5%.

Megjegyzés

Ha nincs megadva más érték, a qubitmodell alapértelmezett értéke a ."qubit_gate_ns_e3"

Referenciaként a teljes előre definiált qubitparaméterek a következők:

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

Előre definiált qubitparaméterek átadása

Az előre definiált qubitparaméterek programozott módon történő megadásának két módja van. A futtatáskor qsharp.estimatekiválaszthatja az qubitParams osztály qubitmodelljének nevét. A qubit paraméter kiválasztásához "qubit_maj_ns_e6" például írja be a következőt:

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

A qubitparamétereket a használatával is átadhatja az EstimatorParams osztálynakQubitParams. A qubit paraméter kiválasztásához MAJ_NS_E6 például írja be a következőt:

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)

Előre definiált qubitparaméterek testreszabása

Az előre definiált qubitparamétereket testreszabhatja a név megadásával, majd a többi érték frissítésével. Ha például csökkenteni szeretné a két qubites közös mérés "qubit_maj_ns_e4" hibaarányát, írja be a következőt:

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

Vagy egy lista formájában is átadhatja az utasításokat.

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

Qubitparaméterek kapualapú qubitekhez

Python-azonosító Adattípus Description
name sztring A qubitmodell neve
instruction_set "gate_based" Mögöttes qubit-technológia
one_qubit_measurement_time idősztring Egy qubites mérés műveleti ideje ($t_{\rm meas}$) ns-ben
one_qubit_gate_time idősztring Egy qubites kapu ($t_{\rm gate}$) műveleti ideje ns-ben
two_qubit_gate_time idősztring Két qubites kapu működési ideje ns-ben
t_gate_time idősztring Egy qubites, nem Clifford-kapu működési ideje ns-ben
one_qubit_measurement_error_rate float Egy qubites mérés hibaaránya
one_qubit_gate_error_rate float Egy qubites Clifford-kapu hibaaránya ($p$)
two_qubit_gate_error_rate float Két qubites Clifford-kapu hibaaránya
t_gate_error_rate float Hibaarány az egy qubites, nem Clifford állapot előkészítéséhez ($p_T$)
idle_error_rate float Üresjáratnak megfelelő hibaarány

Az alábbi kód bemutatja, hogyan adható meg egyéni qubitparaméter egy kapualapú utasításkészlethez:

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

Megjegyzés

Ha nincs megadva, a értéke és alapértelmezett értéketwo_qubit_gate_time, az érték two_qubit_gate_error_ratet_gate_error_rate és az alapértelmezett one_qubit_gate_error_rateértéke , az alapértelmezett érték idle_error_rate pedig a érték.one_qubit_measurement_error_rateone_qubit_gate_timet_gate_time

Qubit-paraméterek Majorana qubitekhez

Python-azonosító Adattípus Description
name sztring A qubitmodell neve
instruction_set "majorana" Mögöttes qubit-technológia
one_qubit_measurement_time idősztring Egy qubites mérés műveleti ideje ($t_{\rm meas}$) ns-ben
two-qubit_joint_measurement_time idősztring Két qubites mérés műveleti ideje ns-ben
t_gate_time idősztring Egy qubites, nem Clifford-kapu működési ideje ns-ben
one_qubit_measurement_error_rate float Egy qubites mérés hibaaránya
two_qubit_joint_measurement_error_rate float Két qubites mérés hibaaránya
t_gate_error_rate float Hibaarány az egy qubites, nem Clifford-állapot előkészítéséhez ($p_T$)
idle_error_rate float Üresjáratnak megfelelő hibaarány

A Majorana-alapú utasításkészlet minimális sablonja az összes szükséges értékkel:

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

Megjegyzés

Ha nincs megadva, a értéke és alapértelmezett értéke , a értéke two_qubit_joint_measurement_error_rate és t_gate_error_rate alapértelmezett one_qubit_measurement_error_rateértéke , az alapértelmezett érték idle_error_rate pedig a értékreone_qubit_measurement_error_rate.two_qubitJointMeasurementTimeone_qubit_measurement_timet_gate_time

A one_qubit_measurement_error_rate és two_qubit_joint_measurement_error_ratea esetében megadhatja a mérési kiolvasásoknak, readouta és a mérésfeldolgozásnak megfelelő hibaarányokat. process Ezek az értékek számok vagy számpárok lehetnek <double> . Például:

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

Megjegyzés

Ha egyetlen numerikus értéket ad meg az egy qubites és a két qubites hibaarányokhoz a Majorana qubitmérésben, akkor az olvasási és a folyamathibák aránya is egyenlő lehet.

Fontos

A nem megadott értékek alapértelmezett értéket vesznek fel, például a megadásával "qubit": {"oneQubitGateTime":"200 ns"} egy kapualapú qubitet modelleznek, amelyben a két qubites kapuidő és az egy qubites kapuidő egyaránt 200 ns. Az egységek esetében meg kell adnia az idősztringeket, amelyek dupla pontosságú lebegőpontos számok, majd egy szóköz és az ilyen értékek időegysége, ahol lehetséges, az idő utótagjai a következők ns: , µs (vagy us), msés s.

Kvantumhibák korrekciós sémái

A gyakorlatban nagy léptékű kvantumalkalmazások végrehajtásához a kvantumműveletnek alacsony hibaarányúnak kell lennie. Ezek a hibaarányok targets általában túlmutatnak a nyers fizikai qubitek képességein. A korlátozás leküzdéséhez a kvantumhibák korrekciója (QEC) és a hibatűrő számítások két alapvető technika, amelyek a nagy léptékű kvantumszámítógépek építőelemeit alkotják. Először is a QEC lehetővé teszi, hogy több hibalehetőséget okozó fizikai qubitet állítsunk össze, és egy megbízhatóbb logikai qubitet hozzunk létre, amely jobban megőrzi a kvantumadatokat, mint a mögöttes fizikai qubitek.

A hibajavítási kód távolsága (röviden kódtávolság) egy paraméter, amely a javítható hibák számát szabályozza. Így a logikai qubitek hibaaránya és a kódolásukhoz szükséges fizikai qubitek száma. A kód távolságával mind a pontosság, mind a fizikai qubitek száma nő. A cél annak a minimális kódtávolságnak a megkeresése, amely képes elérni az adott alkalmazáshoz beállított hibaarányt.

Az Erőforrásbecslő az alábbi képletet használja a logikai hibaarányok exponenciális modellel történő modellezéséhez,

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

ahol $d$ a kód távolsága, $p$ a fizikai hibaarány, $p^*$ pedig a kvantumhibák korrekciós küszöbértéke. A rendszer a $p$ fizikai hibaarányt nyeri ki a qubitparaméterekből, mivel a legrosszabb esetben az eszköz fizikai Clifford-műveleteinek aránya a legrosszabb.

A $p = {}$ max(one_qubit_measurement_error_rate, one_qubit_gate_error_rate, ) two_qubit_gate_error_ratea kapualapú utasításkészlettel rendelkező qubitparaméterekhez, a $p = {}$ max(one_qubit_measurement_error_rate, two_qubit_joint_measurement_error_rate) pedig a Majorana utasításkészlettel rendelkező qubitparaméterekhez. A QEC-sémák általában $p^*$ hibaarány-küszöbértéket eredményeznek, amely alatt a hibajavítás elnyomja a hibákat.

QEC protokoll Python API-osztály Description
"surface_code" SURFACE_CODE A kapualapú felületkód alapja az arXiv:1208.0928 és az arXiv:1009.3686. A Majorana felületkódja az arXiv:1909.03002 és az arXiv:2007.00307 kódon alapul.
"floquet_code" FLOQUET_CODE Csak Majorana qubitekhez. A floquet kód alapja arXiv:2202.11829.

Megjegyzés

Ha nincs megadva más érték, a QEC-séma alapértelmezett értéke a "surface_code".

Az egyes előre definiált QEC-sémák pontos paraméterei (beleértve a szimulációkhoz numerikusan kinyerhető $a$ keresztezési előtényezőt is) a következők.

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

Előre definiált QEC-sémák átadása

Az előre definiált QEC-sémák kétféleképpen határozhatók meg. A futtatásakor qsharp.estimatekiválaszthatja az osztály QEC-modellnevét"qecScheme". A floquet kód kiválasztásához például írja be a következőt:

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

A osztály használatával a becslési paraméterek listáját is átadhatja az EstimatorParams osztálynakQECScheme. A floquet kód kiválasztásához például írja be a következőt:

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)

Előre definiált QEC-sémák testreszabása

Az előre definiált QEC-sémákat testre szabhatja a név megadásával, majd a többi érték frissítésével. Ha például növelni szeretné a keresztezési előtényezőt a floquet kódban, írja be a következőt:

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

Megjegyzés

Ha nincs megadva, a értéke és alapértelmezett értéke , az alapértelmezett érték "errorCorrectionThreshold" a értékre0.01, az alapértelmezett érték pedig "crossingPrefactor" a értékre0.03."logicalCycleTime""oneQubitMeasurementTime""physicalQubitsPerLogicalQubit"

A QEC-sémák testreszabása

Az Erőforrás-becslő a fenti képlet alapján absztrakcióra képes egy testre szabott QEC-sémát a $a$ és a "crossingPrefactor""errorCorrectionThreshold" $p^*$ értékeinek megadásával. Emellett meg kell adnia a "logicalCycleTime", azaz az egyetlen logikai művelet végrehajtásának idejét, amely a kód távolságától és a mögöttes fizikai qubitek fizikai műveleti időfeltevéseitől függ. Végül egy második képlet kiszámítja a "physicalQubitsPerLogicalQubit", azaz az egy logikai qubit kódolásához szükséges fizikai qubitek számát a kód távolsága alapján.

A QEC-sémákhoz az alábbi kódot használhatja sablonként:

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

A képletekben használhatja a , two_qubit_gate_time, one_qubit_measurement_timeés two_qubit_joint_measurement_timeváltozókatone_qubit_gate_time, amelyek értékei a fizikai qubit paramétereinek megfelelő mezőjéből származnak, valamint a logikai qubithez kiszámított kódtávolság változóját eccDistance a fizikai qubit tulajdonságai, a hibajavítási küszöbérték és a keresztelőtag alapján. Az időváltozók, és eccDistance a képlet leírására logicalCycleTime használhatók. A képlethez physicalQubitsPerLogicalQubit csak a eccDistance használható.

Hibakeret

A teljes hibakeret ($\epsilon$) az algoritmus általánosan tolerált hibáját állítja be, azaz az algoritmus megengedett meghibásodási valószínűségét. A globális értéknek 0 és 1 között kell lennie, az alapértelmezett érték pedig 0,001, amely 0,1%-nak felel meg. Más szóval az algoritmus legfeljebb 1000 végrehajtás során meghiúsulhat. Ez a paraméter kifejezetten alkalmazásspecifikus.

Ha például a Shor algoritmust futtatja az egész számok faktorálásához, a hibakeret nagy értéke tolerálható, mivel ellenőrizheti, hogy a kimenetek valóban a bemenet elsődleges tényezői-e. Másfelől kisebb hibakeretre lehet szükség ahhoz, hogy egy algoritmus megoldjon egy problémát egy olyan megoldással, amely nem ellenőrizhető hatékonyan.

A hibakeret három rész összegének felel meg:

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

Ha nincs további megadva, a $\epsilon$ hibakeret egyenletesen oszlik el, és a $\epsilon_{\log}$ hibákra vonatkozik a logikai qubitek implementálásához, a $\epsilon_{\rm dis}$ hiba lepárláson keresztül hozza létre a T-állapotokat, a $\epsilon_{\rm syn}$ hibakeret pedig tetszőleges szögekkel szintetizálja a rotációs kapukat.

Vegye figyelembe, hogy a lepárlás és a forgásszintézis esetében a megfelelő $\epsilon_{\rm dis}$ és $\epsilon_{\rm syn}$ hibakeretek egységesen vannak elosztva az összes szükséges T-állapot és az összes szükséges rotációs kapu között. Ha a bemeneti algoritmusban nincsenek rotációs kapuk, a hibakeretet a rendszer egységesen logikai hibákra és T-állapothibákra osztja el.

Hibakeret átadása

A hibakeretet kétféleképpen adhatja meg egy 0 és 1 közötti szám beállításával. A futtatásakor qsharp.estimateátadhatja a hibakeretet. Ha például egy 1/3-os hibakeretet szeretne kiválasztani, írja be a következőt:

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

A hiba költségvetési paramétereit a osztálynakEstimatorParams is átadhatja.

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)

A hibakeret minden összetevőjét külön-külön is megadhatja. Az összes érték összege a hiba teljes költségvetése, és 0 és 1 között kell lennie. Ha egy kvantum-algoritmus nem tartalmaz T állapotokat vagy rotációkat, akkor a és rotations az értéke t_states 0 lehet.

Az alábbi kód bemutatja, hogyan adhatja meg a hiba költségvetési paraméterét T állapotokkal és rotációkkal:

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

Korlátozások

A "constraints" osztály használatával kényszereket alkalmazhat a T-gyár összetevőszintjén. A korlátozások módosításával optimalizálhatja a becsléseket a qubitek számának csökkentése vagy a futtatókörnyezet csökkentése érdekében.

Paraméter Adattípus Leírás
logical_depth_factor float A végrehajtási idő szabályozása. Ha 1-nél nagyobb értékkel rendelkezik, a logikai ciklusok kezdeti számát , más néven logikai mélységet megszorozzák ezzel a számmal. A csökkentésével logical_depth_factornövelheti a T-gyár meghívásának számát egy adott idő alatt, ami kevesebb T-gyárpéldányt eredményez, amelyek ugyanannak a T-állapotnak a előállításához szükségesek. Ha csökkenti a T-gyári példányok számát, az algoritmus futásideje ennek megfelelően nő. A teljes futtatókörnyezet skálázási tényezője nagyobb lehet, mivel a szükséges logikai hibaarány a további ciklusok száma miatt nő.
max_t_factories egész szám A T-gyár példányainak maximális száma. Az Erőforrásbecslő a szükséges erőforrásokat úgy határozza meg, hogy kiválasztja a T-gyári másolatok optimális számát, amely minimálisra csökkenti a felhasznált fizikai qubitek számát, az időterhelés figyelembe vétele nélkül. A max_t_factories paraméter korlátozza a példányok maximális számát, ezért ennek megfelelően módosítsa a logikai ciklusok számát. További információkért lásd a T factory fizikai becslését ismertető cikket.
max_duration idősztring Az algoritmus maximális futtatókörnyezete. Az erőforrásbecslő csak egy max_duration vagy max_physical_qubits több korlátozást fogad el, de nem kettőt. Ha max_duration meg van adva, az erőforrásbecslő megpróbálja megtalálni a legjobb becslést max_physical_qubits a megadott maximális számmal korlátozott megoldások között.
max_physical_qubits egész szám Az algoritmushoz tartozó fizikai qubitek maximális száma. Az erőforrásbecslő csak egy max_duration vagy max_physical_qubits több korlátozást fogad el, de nem kettőt. Ha max_physical_qubits meg van adva, az erőforrásbecslő megpróbálja megtalálni a legjobb becslést max_duration a megadott maximális számmal korlátozott megoldások között.

Az alábbi kód bemutatja, hogyan adhatja meg a kvantum-algoritmusok korlátait:

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

Megjegyzés

Ha a vagy max_physical_qubits számára megadott max_duration érték túl kicsi ahhoz, hogy megvalósítható megoldást találjon, az Erőforrás-becslés hibát ad vissza. Ha nincs megadva sem max_durationmax_physical_qubits korlátozás, az Erőforrás-becslés célja, hogy a legrövidebb idő alatt megoldást találjon.

Tipp

A és a használatával max_durationmax_physical_qubits befolyásolhatja a megoldási területet, így hosszabb futásidejű, de kevesebb qubitet tartalmazó megoldásokat találhat a korlátozások nélküli megoldásokhoz képest. Létezik kompromisszum a futtatókörnyezet és a qubitek száma között, és ez a kompromisszum hatékonyan kezelhető bizonyos algoritmusok esetében, és eltérő hatással van a különböző algoritmusokra. Az [arXiv:2211.07629] iv. táblázata a qubitek száma és a kvantumdinamika-algoritmusok futtatókörnyezete közötti kompromisszum hatékony kihasználtságát szemlélteti. További információ: Kvantumerőforrás-becslés idő vagy qubit-kényszerek száma mintával .

Desztillációs egységek

A T-gyárak desztillációs algoritmusainak specifikációit a DistillationUnitSpecification osztályban adhatja meg. A specifikáció lehet előre definiált vagy egyéni. Előre definiált specifikációt a desztillációs egység nevének kiválasztásával adhat meg: 15-1 RM vagy 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)

Mindkét esetben a 15-1 jelölés 15 bemeneti T állapotot és 1 kimeneti T állapotot jelent. A 15-1 space-efficient lepárlási egység kevesebb qubitet használ, mint 15-1 RM amennyit használ, de több futtatókörnyezetet igényel. További információ: VI. táblázat.

Tipp

Az előre definiált desztillációs egységek jobb teljesítményt biztosítanak az egyéniekkel összehasonlítva.

A lepárlási egységek testreszabása

Testreszabhatja a saját lepárlóegységeit. A desztillációs egységek pontos paraméterei a következők.

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

Minden numerikus paraméternek pozitívnak kell lennie. A displayName megadja, hogyan jelenik meg a lepárlási egység a kimeneti eredményekben.

Az alábbi kód bemutatja, hogyan adhatja meg a kvantumalgoritmus desztillációsegység-paramétereit az osztály és az DistillationUnitSpecificationProtocolSpecificDistillationUnitSpecification osztály használatával.

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

A és output_error_rate_formula képletek failure_probability_formula egyéni képletek alapszintű aritmetikai műveletekkel, állandókkal és csak három paraméterrel:

  • clifford_error_rate, a is a következőképpen van jelölve c: .
  • readout_error_rate, a is a következőképpen van jelölve r: .
  • input_error_rate, a is a következőképpen van jelölve z: .

Tekintse meg az alábbi példákat a hosszú és rövid jelölést használó egyéni képletekre. Ezek a példák az alapértelmezés szerint a standard implementációban használt képleteket szemléltetik.

Paraméter Hosszú képlet Rövid képlet
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"

Legalább egy paramétert physical_qubit_specificationlogical_qubit_specification meg kell adni. Ha csak az előbbi van megadva, a desztillációs egység alkalmazható fizikai qubitekre. Ha csak az utóbbi van megadva, a lepárlási egység alkalmazható logikai qubitekre. Ha mindkettő meg van adva, a desztillációs egység mindkét qubittípusra alkalmazható.

A paraméter logical_qubit_specification_first_round_override csak akkor adható meg, ha logical_qubit_specification meg van adva. Ha igen, felülbírálja az értékeket logical_qubit_specification abban az esetben, ha a lepárlás első fordulójában alkalmazzák. A szükséges logical_qubit_specification_first_round_override értéknek <protocol specific parameters> követnie kell a sémát:

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

Pareto-határbecslés

Egy algoritmus erőforrásainak becslésekor fontos figyelembe venni a fizikai qubitek száma és az algoritmus futásideje közötti kompromisszumot. Érdemes lehet a lehető legtöbb fizikai qubitet lefoglalni az algoritmus futásidejének csökkentése érdekében. A fizikai qubitek számát azonban a kvantumhardverben elérhető fizikai qubitek száma korlátozza. Az erőforrás-becslés egyik legfontosabb szempontja a futtatókörnyezet és a rendszerskálázás közötti kompromisszum megértése.

A Pareto határbecslés több becslést is biztosít ugyanahhoz az algoritmushoz, amelyek mindegyike a qubitek száma és a futtatókörnyezet közötti kompromisszumokat mutatja.

Megjegyzés

Ha az Erőforrás-becslést a Visual Studio Code-ban a Q#: Erőforrás-becslések kiszámítása lehetőséggel futtatja, a Pareto-határbecslés alapértelmezés szerint engedélyezve van.

Ha a Pythonban futtatja az Erőforrásbecslőt, a paramétert "estimateType" a következőként kell megadnia: "frontier".

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

Ha a Pareto-határbecslés eredményeit szeretné megjeleníteni, használhatja a függvényt EstimatesOverview . Ez a függvény megjeleníti a határbecslés eredményeit a táblázatban és egy téridő-diagramot. További információ: Téridő diagram.

from qsharp_widgets import EstimatesOverview

EstimatesOverview(result)

Megjegyzés

Ha probléma merül fel az Erőforrásbecslő használata során, tekintse meg a Hibaelhárítás lapot, vagy lépjen kapcsolatba a következővel AzureQuantumInfo@microsoft.com: .

Következő lépések