Delen via

target De parameters van de resource-estimator aanpassen

  • Artikel

In dit artikel wordt beschreven hoe u de target parameters van de Azure Quantum Resource Estimator kunt aanpassen aan de machinekenmerken die u wilt instellen. De resource-estimator gebruikt deze parameters om de resources te schatten die nodig zijn om een kwantumalgoritmen uit te voeren op een kwantumcomputer.

Notitie

Als er een probleem optreedt tijdens het werken met de resource-estimator, raadpleegt u de pagina Probleemoplossing.

Vereisten

Target Parameters

De resource-estimator berekent de schatting van resources, zoals het aantal qubits en de uitvoeringstijd, dat nodig zou zijn om een bepaald kwantumalgoritme te implementeren met behulp van een bepaalde qubit-technologie en met een vaste set architectuurkeuzen.

Daarom gebruikt de resource-estimator een set invoer, met vooraf gedefinieerde waarden om u eenvoudig op weg te helpen:

  • Een fysiek qubitmodel, waarmee de eigenschappen van de onderliggende fysieke qubits worden gedefinieerd.
  • Een QEC-schema (Quantum Error Correction), het veronderstelde kwantumfoutcorrectieschema.
  • Een foutbudget, dat de algemene toegestane fout is, dat wil gezegd, het aantal keren dat het programma niet kan worden gebruikt.
  • Beperkingen op onderdeelniveau, het aantal logische cycli en het aantal exemplaren van de T-fabriek.
  • Distillatie-eenheden om T factory's destillatiealgoritmen op te geven.
  • Pareto grens schatting om meerdere schattingen van het aantal qubits en runtime voor hetzelfde algoritme uit te voeren.

Tip

Als u al een aantal vooraf berekende schattingen voor een bewerking kent, kunt u deze ook opnemen en de uitvoering van de resource-estimator optimaliseren. Zie Hoe u bekende schattingen gebruikt met de resource-estimator voor meer informatie.

Parameters voor fysieke qubits

Wanneer de Resource Estimator de veronderstellingen van fysieke qubits modelleert, worden twee verschillende fysieke instructiesets gebruikt om de qubits te bedienen. De fysieke instructieset kan gate-based of Majorana zijn. Een instructieset op basis van poorten biedt meting van één qubit, enkele qubitpoorten (inclusief T-poorten) en twee qubitpoorten. Een Majorana-instructieset biedt een fysieke T-gate, single-qubit-meting en twee qubit-gezamenlijke meetbewerkingen.

U kunt kiezen uit zes vooraf gedefinieerde qubitparameters, waarvan vier op poorten gebaseerde instructiesets en twee met een Majorana-instructieset. Deze qubitmodellen hebben betrekking op een reeks bewerkingstijden en foutpercentages, waardoor de resourcekosten die nodig zijn voor het inschakelen van praktische kwantumtoepassingen voldoende worden onderzocht.

Qubitparameter Python-API-klasse Beschrijving
"qubit_gate_ns_e3" , "qubit_gate_ns_e4" GATE_NS_E3 , GATE_NS_E4 Bewerkingstijden en betrouwbaarheid kunnen overeenkomen met toekomstige versies van supergeleidende transmon-qubits of kring qubits, die doorgaans bewerkingstijden hebben in het nanoseconde-regime. Voor deze qubits worden poort- en meetbewerkingen uitgegaan van respectievelijk 50 ns en 100 ns. Foutpercentages met één qubit en twee qubitpoorten worden verondersteld $10^{-3}$ als realistisch targette zijn en $10^{-4}$ als optimistisch target voor een opgeschaald systeem.
"qubit_gate_us_e3" , "qubit_gate_us_e4" GATE_US_E3 , GATE_US_E4 Bewerkingstijden en betrouwbaarheid kunnen overeenkomen met toekomstige versies van qubits op basis van ionen, die doorgaans bewerkingstijden hebben in het microseconde-regime. Op basis van typische veronderstellingen voor ion-qubits worden poort- en meetbewerkingen verondersteld om 100 μs te nemen. Foutpercentage voor single-qubit Clifford-poorten is $10^{-3}$ als realistisch target en $10^{-4}$ als optimistisch target, terwijl de foutpercentage voor niet-Clifford-poorten (T-poort) $ 10^{-6}$ is. Voor poorten met twee qubits is de foutsnelheid $10^{-3}$ als realistisch target en $10^{-4}$ als optimistisch target.
"qubit_maj_ns_e4" , "qubit_maj_ns_e6" MAJ_NS_E4 , MAJ_NS_E6 Bewerkingstijden en betrouwbaarheid kunnen overeenkomen met toekomstige verbeterde versies van Majorana-qubits. Voor deze qubits worden poort- en meetbewerkingen verondersteld om 100 ns te nemen. Om rekening te houden met topologische bescherming in de hardware, worden single-qubit- en twee-qubit-foutpercentages (Clifford-foutpercentages) verondersteld $10^{-4}$ als realistisch targette zijn en $10^{-6}$ als optimistisch target. Niet-Clifford-bewerkingen in deze architectuur hebben geen topologische bescherming, foutpercentage voor fysieke T-poorten van niet-Clifford is 5%.

Notitie

Tenzij er een andere waarde is opgegeven, is "qubit_gate_ns_e3"de standaardwaarde voor het qubitmodel.

Parameters voor vooraf gedefinieerde qubitparameters

Ter referentie zijn de volledige vooraf gedefinieerde qubitparameters als volgt:

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

Vooraf gedefinieerde qubitparameters doorgeven

Er zijn twee manieren om programmatisch vooraf gedefinieerde qubitparameters op te geven. U kunt de naam van het qubitmodel voor de klasse selecteren wanneer u qubitParams deze uitvoert qsharp.estimate. Als u bijvoorbeeld de qubitparameter wilt selecteren "qubit_maj_ns_e6" , schrijft u:

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

U kunt de qubitparameters ook doorgeven aan de EstimatorParams klasse met behulp van QubitParams. Als u bijvoorbeeld de qubitparameter wilt selecteren MAJ_NS_E6 , schrijft u:

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)

Vooraf gedefinieerde qubitparameters aanpassen

U kunt vooraf gedefinieerde qubitparameters aanpassen door de naam op te geven en vervolgens een van de andere waarden bij te werken. Als u bijvoorbeeld de foutfrequentie van een gezamenlijke meting van twee qubits in 'qubit_maj_ns_e4' wilt verlagen, schrijft u:

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

U kunt ook de instructies doorgeven in de vorm van een lijst.

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

Qubitparameters voor qubits op basis van poort

Python-id Gegevenstype Beschrijving
name tekenreeks Naam voor het qubitmodel
instruction_set "gate_based" Onderliggende qubittechnologie
one_qubit_measurement_time tijdtekenreeks Bewerkingstijd voor meting met één qubit ($t_{\rm meas}$) in ns
one_qubit_gate_time tijdtekenreeks Bewerkingstijd voor poort met één qubit ($t_{\rm gate}$) in ns
two_qubit_gate_time tijdtekenreeks Bewerkingstijd voor twee qubitpoorten in ns
t_gate_time tijdtekenreeks Bewerkingstijd voor niet-Clifford-poort met één qubit in ns
one_qubit_measurement_error_rate zwevend Foutpercentage voor meting met één qubit
one_qubit_gate_error_rate zwevend Foutpercentage voor single-qubit Clifford-poort ($p$)
two_qubit_gate_error_rate zwevend Foutpercentage voor gate van twee qubit Clifford
t_gate_error_rate zwevend Foutpercentage voor het voorbereiden van de status single-qubit non-Clifford ($p_T$)
idle_error_rate zwevend Foutpercentage dat overeenkomt met inactiviteit

De volgende code laat zien hoe u aangepaste qubitparameters opgeeft voor een instructieset op basis van een poort:

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

Notitie

Wanneer dit niet is opgegeven, worden de two_qubit_gate_error_rate waarden voor two_qubit_gate_time en t_gate_time one_qubit_gate_timestandaard ingesteld op , en one_qubit_gate_error_ratet_gate_error_rate de waarde voor idle_error_rate standaardwaarden ingesteld one_qubit_measurement_error_rateop .

Qubitparameters voor Majorana-qubits

Python-id Gegevenstype Beschrijving
name tekenreeks Naam voor het qubitmodel
instruction_set "majorana" Onderliggende qubittechnologie
one_qubit_measurement_time tijdtekenreeks Bewerkingstijd voor meting met één qubit ($t_{\rm meas}$) in ns
two-qubit_joint_measurement_time tijdtekenreeks Bewerkingstijd voor meting van twee qubits in ns
t_gate_time tijdtekenreeks Bewerkingstijd voor niet-Clifford-poort met één qubit in ns
one_qubit_measurement_error_rate zwevend Foutpercentage voor meting met één qubit
two_qubit_joint_measurement_error_rate zwevend Foutpercentage voor meting van twee qubits
t_gate_error_rate zwevend Foutpercentage voor het voorbereiden van de status single-qubit non-Clifford ($p_T$)
idle_error_rate zwevend Foutpercentage dat overeenkomt met inactiviteit

Een minimumsjabloon voor op Majorana gebaseerde instructieset met alle vereiste waarden is:

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

Notitie

Wanneer dit niet is opgegeven, worden de two_qubit_joint_measurement_error_rate waarden voor two_qubitJointMeasurementTime en t_gate_time one_qubit_measurement_timestandaard ingesteld op , en one_qubit_measurement_error_ratet_gate_error_rate de waarde voor idle_error_rate standaardwaarden ingesteld one_qubit_measurement_error_rateop .

Voor one_qubit_measurement_error_rate en two_qubit_joint_measurement_error_rate, kunt u de foutpercentages opgeven die overeenkomen met metingsleesbewerkingen, readouten meetverwerking, process. Deze waarden kunnen getallen of paren getallen zijn <double> . Bijvoorbeeld:

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

Notitie

Als u één numerieke waarde opgeeft voor foutpercentages met één qubit en twee qubits in majorana-qubitmeting, kunnen zowel de lees- als procesfoutpercentages gelijk zijn.

Belangrijk

Alle waarden die niet zijn opgegeven, nemen bijvoorbeeld een standaardwaarde, waarbij het opgeven een op een poort gebaseerde qubit modelleert "qubit": {"oneQubitGateTime":"200 ns"} waarin zowel de tijd van de twee qubitpoort als de tijd van de één qubitpoort 200 ns is. Voor eenheden moet u tijdtekenreeksen opgeven, die drijvendekommanummers met dubbele precisie zijn, gevolgd door een spatie en de tijdseenheid voor dergelijke waarden, waar mogelijke tijdachtervoegsels nszijn , µs (of us), msen s.

Kwantumfoutcorrectieschema's

Als u praktische kwantumtoepassingen wilt uitvoeren, moeten kwantumbewerkingen lage foutpercentages hebben. Deze foutpercentages targets vallen doorgaans buiten de mogelijkheden van onbewerkte fysieke qubits. Om deze beperking te overwinnen, zijn kwantumfoutcorrectie (QEC) en fouttolerante berekeningen twee cruciale technieken die de bouwstenen vormen van grootschalige kwantumcomputers. Ten eerste kunnen we met QEC meerdere foutgevoelige fysieke qubits opstellen en een betrouwbaardere logische qubit bouwen die kwantuminformatie beter bewaart dan de onderliggende fysieke qubits.

De resource-estimator gebruikt de volgende formule voor het modelleren van logische foutpercentages met behulp van een exponentiële model,

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

waarbij $a$ een kruising vooraf is, is $d$ de codeafstand, $p$ de fysieke foutsnelheid en is $p^*$ de drempelwaarde voor kwantumfoutcorrectie. De kruising vooraf-factor $a$ kan numeriek worden geëxtraheerd voor simulaties.

De codeafstand $d$ is een parameter die het aantal fouten bepaalt dat kan worden gecorrigeerd. Codeafstand definieert dus de foutsnelheid van de logische qubits en het aantal fysieke qubits dat nodig is om ze te coderen. Zowel nauwkeurigheid als het aantal fysieke qubits nemen toe met codeafstand. Het doel van een QEC-schema is om de minimale codeafstand te vinden die de vereiste foutfrequentie voor een bepaalde toepassing kan bereiken.

De fysieke foutsnelheid $p$ wordt geëxtraheerd uit de qubitparameters als de slechtste foutpercentage van een fysieke Clifford-bewerking die op het apparaat wordt uitgevoerd. Met name $p = {}$ max(one_qubit_measurement_error_rate, one_qubit_gate_error_rate, ) two_qubit_gate_error_ratevoor qubitparameters met een instructieset op basis van poorten en $p = {}$ max(one_qubit_measurement_error_rate, two_qubit_joint_measurement_error_rate) voor qubitparameters met een Majorana-instructieset. QEC-schema's hebben doorgaans een drempelwaarde voor foutpercentages $p^*$ waaronder foutcorrectie fouten onderdrukt.

De Azure Quantum Resource Estimator ondersteunt twee vooraf gedefinieerde QEC-schema's: een surface-code en een floquetcode.

QEC-protocol Python-API-klasse Beschrijving
"surface_code" SURFACE_CODE De oppervlaktecode op basis van poorten is gebaseerd op arXiv:1208.0928 en arXiv:1009.3686. De Majorana-surfacecode is gebaseerd op arXiv:1909.03002 en arXiv:2007.00307.
"floquet_code" FLOQUET_CODE Alleen voor Majorana-qubits. De floquetcode is gebaseerd op arXiv:2202.11829.

Notitie

Tenzij er een andere waarde is opgegeven, is de standaardwaarde voor het QEC-schema 'surface_code'.

Parameters voor vooraf gedefinieerde QEC-schema's

De exacte parameters voor elk vooraf gedefinieerd QEC-schema zijn het volgende.

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

Vooraf gedefinieerde QEC-schema's doorgeven

Er zijn twee manieren om vooraf gedefinieerde QEC-schema's op te geven. U kunt de naam van het QEC-model voor de "qecScheme" klasse selecteren wanneer u deze uitvoert qsharp.estimate. Als u bijvoorbeeld de floquetcode wilt selecteren, schrijft u:

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

U kunt ook een lijst met schattingsparameters doorgeven aan de klasse met behulp van de QECScheme klasse.EstimatorParams Als u bijvoorbeeld de floquetcode wilt selecteren, schrijft u:

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)

Vooraf gedefinieerde QEC-schema's aanpassen

U kunt vooraf gedefinieerde QEC-schema's aanpassen door de naam op te geven en vervolgens een van de andere waarden bij te werken. Als u bijvoorbeeld de kruising vooraf in de floquet-code wilt verhogen, schrijft u:

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

Notitie

Wanneer dit niet is opgegeven, worden de waarden voor "logicalCycleTime" en "oneQubitMeasurementTime""physicalQubitsPerLogicalQubit" standaard ingesteld op , de waarde voor "errorCorrectionThreshold" standaardwaarden 0.01en de waarde voor "crossingPrefactor" standaardwaarden .0.03

Uw QEC-schema's aanpassen

De resource-estimator kan een aangepast QEC-schema abstraheren op basis van de bovenstaande formule door waarden op te geven voor de "crossingPrefactor" $a$ en de "errorCorrectionThreshold" $p^*$. Verder moet u de tijd opgeven voor het "logicalCycleTime"uitvoeren van één logische bewerking, die afhankelijk is van de codeafstand en de veronderstellingen van de fysieke bewerkingstijd van de onderliggende fysieke qubits. Ten slotte berekent een tweede formule het "physicalQubitsPerLogicalQubit"aantal fysieke qubits dat is vereist voor het coderen van één logische qubit op basis van de codeafstand.

U kunt de volgende code gebruiken als sjabloon voor QEC-schema's:

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

In de formules kunt u de variabelen one_qubit_gate_time, two_qubit_gate_time, en one_qubit_measurement_timetwo_qubit_joint_measurement_time, waarvan de waarden worden opgehaald uit het corresponderende veld van de fysieke qubitparameters, evenals de variabele eccDistance voor de codeafstand die is berekend voor de logische qubit, op basis van de fysieke qubiteigenschappen, de drempelwaarde voor foutcorrectie en de kruisingsvoorfactor. De tijdvariabelen en eccDistance kunnen worden gebruikt om de logicalCycleTime formule te beschrijven. Voor de formule kan alleen de eccDistance formule physicalQubitsPerLogicalQubit worden gebruikt.

Foutbudget

Het totale foutbudget $\epsilon$ stelt de totale getolereerde fout voor het algoritme in, dat wil gezegd, de toegestane foutkans van het algoritme. De globale waarde moet tussen 0 en 1 zijn en de standaardwaarde is 0,001, wat overeenkomt met 0,1%. Met andere woorden, het algoritme mag maximaal één keer in 1000 uitvoeringen mislukken. Deze parameter is zeer specifiek voor toepassingen.

Als u bijvoorbeeld het algoritme van Shor uitvoert voor het factoren van gehele getallen, kan een grote waarde voor het foutbudget worden getolereerd, omdat men kan controleren of de uitvoer inderdaad de belangrijkste factoren van de invoer zijn. Aan de andere kant kan een kleiner foutbudget nodig zijn voor het oplossen van een probleem met een oplossing, dat niet efficiënt kan worden geverifieerd.

Het foutbudget komt overeen met de som van drie delen:

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

De logische fouten $\epsilon_{\log}$ is de fout bij het implementeren van logische qubits, de T-statusfout $\epsilon_{\rm dis}$ is de fout van het produceren van T-statussen via distillatie en de rotatiepoortfout $\epsilon_{\rm syn}$ is de fout van het synthetiseren van draaipoorten met willekeurige hoeken.

Notitie

Tenzij er een andere waarde is opgegeven, wordt het foutbudget $\epsilon$ uniform verdeeld over de logische fout, T-statusfout en draaipoortfout.

Houd er rekening mee dat voor distillatie- en rotatiesynthese de respectieve foutbudgetten $\epsilon_{\rm dis}$ en $\epsilon_{\rm syn}$ uniform worden verdeeld over alle vereiste T-statussen en alle vereiste draaipoorten. Als het invoeralgoritmen geen draaipoorten bevatten, wordt het foutenbudget uniform verdeeld over logische fouten en T-statusfouten.

Foutbudget doorgeven

Er zijn twee manieren om het foutbudget op te geven door een getal tussen 0 en 1 in te stellen. U kunt het foutbudget doorgeven wanneer het wordt uitgevoerd qsharp.estimate. Als u bijvoorbeeld een foutbudget van 1/3 wilt selecteren, schrijft u:

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

U kunt de foutbudgetparameters ook doorgeven aan de EstimatorParams klasse.

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)

U kunt ook elk onderdeel van het foutbudget afzonderlijk opgeven. De som van alle waarden is het totale foutbudget en moet tussen 0 en 1 zijn. Als een kwantumalgoritmen geen T-statussen of rotaties bevatten, zijn de waarden van t_states respectievelijk rotations 0.

De volgende code laat zien hoe u de parameter voor het foutbudget met T-statussen en rotaties opgeeft:

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

Beperkingen

U kunt de "constraints" klasse gebruiken om beperkingen toe te passen op het onderdeelniveau van T Factory . Door beperkingen aan te passen, kunt u de schattingen optimaliseren voor het verminderen van het aantal qubits of het verminderen van de runtime.

Parameter Gegevenstype Beschrijving
logical_depth_factor zwevend De uitvoeringstijd beheren. Als de waarde groter is dan 1, wordt het eerste aantal logische cycli, ook wel logische diepte genoemd, vermenigvuldigd met dit getal. Door te verminderen logical_depth_factor, kunt u het aantal aanroepen van de T-fabriek in een bepaalde tijd verhogen, wat resulteert in minder T-fabriekskopieën die nodig zijn om hetzelfde aantal T-statussen te produceren. Wanneer u het aantal T Factory-kopieën vermindert, neemt de algoritmeruntime dienovereenkomstig toe. De schaalfactor voor de totale runtime kan groter zijn, omdat het vereiste logische foutpercentage toeneemt vanwege het extra aantal cycli.
max_t_factories geheel getal Maximum aantal T-fabriekskopieën. De resource-estimator bepaalt de resources die vereist zijn door het optimale aantal T Factory-kopieën te selecteren waarmee het aantal gebruikte fysieke qubits wordt geminimaliseerd, zonder rekening te houden met de tijdsoverhead. De max_t_factories parameter beperkt het maximum aantal exemplaren en past daarom het aantal logische cycli dienovereenkomstig aan. Zie de fysieke schatting van T Factory voor meer informatie.
max_duration tijdtekenreeks Maximale runtime voor het algoritme. De resource-estimator accepteert slechts één van max_duration of max_physical_qubits beperkingen op het moment, maar niet twee. Als max_duration dit is opgegeven, probeert de resource-estimator de beste schatting te vinden voor max_physical_qubits oplossingen die zijn beperkt door het opgegeven maximumaantal.
max_physical_qubits geheel getal Maximum aantal fysieke qubits voor het algoritme. De resource-estimator accepteert slechts één van max_duration of max_physical_qubits beperkingen op het moment, maar niet twee. Als max_physical_qubits dit is opgegeven, probeert de resource-estimator de beste schatting te vinden voor max_duration oplossingen die zijn beperkt door het opgegeven maximumaantal.

De volgende code laat zien hoe u de beperkingen voor een kwantumalgoritmen opgeeft:

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

Notitie

Als de waarde die is opgegeven aan max_duration of max_physical_qubits te klein is om een haalbare oplossing te vinden, retourneert de resource-estimator een fout. Als er geen beperkingen max_duration of max_physical_qubits beperkingen zijn opgegeven, is de resource-estimator erop gericht om een oplossing met de kortste tijd te vinden.

Tip

U kunt de oplossingsruimte gebruiken max_duration en max_physical_qubits beïnvloeden, mogelijk oplossingen vinden met langere runtime, maar een kleiner aantal qubits vergeleken met oplossingen zonder deze beperkingen. Er bestaat een afweging tussen runtime en het aantal qubits, en deze afweging kan efficiënt worden beheerd voor sommige algoritmen, met verschillende effecten op verschillende algoritmen. Tabel IV in [arXiv:2211.07629] illustreert het effectieve gebruik van de afweging tussen het aantal qubits en runtime voor kwantumdynamische algoritmen. Zie De schatting van kwantumresources met tijd of aantal qubitsbeperkingen voor meer informatie.

Destillatie-eenheden

U kunt specificaties opgeven voor T factory's destillatiealgoritmen met de DistillationUnitSpecification klasse. De specificatie kan vooraf gedefinieerd of aangepast zijn. U kunt een vooraf gedefinieerde specificatie opgeven door de naam van de distillatie-eenheid te selecteren: 15-1 RM of 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)

In beide gevallen staat notatie 15-1 voor 15 invoer-T-statussen en 1 uitvoer T-status. De 15-1 space-efficient distillatie-eenheid gebruikt minder qubits dan 15-1 RM maar vereist meer runtime. Zie Tabel VI voor meer informatie.

Tip

Het gebruik van vooraf gedefinieerde distillatie-eenheden biedt betere prestaties vergeleken met aangepaste eenheden.

Uw distillatie-eenheden aanpassen

U kunt uw eigen distillatie-eenheden aanpassen. De exacte parameters voor de distillatie-eenheden zijn de volgende.

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

Naar verwachting zijn alle numerieke parameters positief. De displayName geeft aan hoe de distillatie-eenheid wordt weergegeven in uitvoerresultaten.

De volgende code laat zien hoe u de parameters voor de distillatie-eenheid voor een kwantumalgoritmen opgeeft met behulp van de klasse en deProtocolSpecificDistillationUnitSpecification klasse.DistillationUnitSpecification

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

De formules voor failure_probability_formula en output_error_rate_formula zijn aangepaste formules met eenvoudige rekenkundige bewerkingen, constanten en slechts drie parameters:

  • clifford_error_rate, ook aangeduid als c.
  • readout_error_rate, ook aangeduid als r.
  • input_error_rate, ook aangeduid als z.

Zie de volgende voorbeelden van aangepaste formules met behulp van lange en korte notatie. Deze voorbeelden illustreren formules die standaard worden gebruikt in de standaard implementatie.

Parameter Lange formule Korte formule
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"

Ten minste één van de parameters physical_qubit_specification of logical_qubit_specification moet worden opgegeven. Als alleen de vroegere wordt verstrekt, kan de distillatie-eenheid worden toegepast op fysieke qubits. Als alleen de laatste wordt verstrekt, kan de distillatie-eenheid worden toegepast op logische qubits. Als beide worden verstrekt, kan de distillatie-eenheid worden toegepast op beide typen qubits.

De parameter logical_qubit_specification_first_round_override kan alleen worden opgegeven als logical_qubit_specification deze is opgegeven. Als dat het geval is, overschrijft het de waarden van logical_qubit_specification in het geval dat bij de eerste ronde van distillatie wordt toegepast. De waarde <protocol specific parameters> waarvoor is vereist logical_qubit_specification_first_round_override , moet het schema volgen:

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

Schatting van paretogrens

Bij het schatten van de resources van een algoritme is het belangrijk om rekening te houden met het verschil tussen het aantal fysieke qubits en de runtime van het algoritme. U kunt overwegen om zoveel mogelijk fysieke qubits toe te kennen om de runtime van het algoritme te verminderen. Het aantal fysieke qubits wordt echter beperkt door het aantal fysieke qubits dat beschikbaar is in de kwantumhardware. Inzicht in de balans tussen runtime en systeemschaal is een van de belangrijkste aspecten van de schatting van resources.

De pareto grensraming biedt meerdere schattingen voor hetzelfde algoritme, elk met afwegingen tussen het aantal qubits en de runtime.

Notitie

Als u de resource-estimator in Visual Studio Code uitvoert met behulp van de Q#optie Resourceschattingen berekenen, is de schatting van de grens pareto standaard ingeschakeld.

Als u de resource-estimator uitvoert in Python, moet u de "estimateType" parameter opgeven als "frontier".

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

Als u de resultaten van pareto grensraming wilt visualiseren, kunt u de EstimatesOverview functie gebruiken. Met deze functies worden de resultaten van de grensraming in een tabel en een tijddiagram weergegeven. Zie het diagram ruimtetijd voor meer informatie.

from qsharp_widgets import EstimatesOverview

EstimatesOverview(result)

Notitie

Als er een probleem optreedt tijdens het werken met de resource-estimator, bekijkt u de pagina Probleemoplossing of neemt u contact op AzureQuantumInfo@microsoft.com.

Volgende stappen