Anpassa parametrarna för Resursberäknaren (Resource Estimator)

Den här artikeln visar hur du anpassar parametrarna target för Azure Quantum Resource Estimator så att de matchar de datoregenskaper som du riktar in dig på. Resource Estimator använder dessa parametrar för att uppskatta de resurser som krävs för att köra en kvantalgoritm på en kvantdator.

Förutsättningar

• En Python-miljö med Python och Pip installerade.

• Den senaste versionen av Visual Studio Code eller öppna VS Code på webben.

• VS Code med Tilläggen Azure Quantum Development Kit, Python och Jupyter installerade.

• De senaste Azure Quantum qsharp och qsharp-widgets paketen.

  python -m pip install --upgrade qsharp qsharp-widgets 
  

Målparametrar

Resource Estimator beräknar uppskattningen av resurser, till exempel antalet kvantbitar och körningstiden, vilket skulle krävas för att implementera en viss kvantalgoritm med hjälp av en viss kvantbitsteknik och med en fast uppsättning arkitekturval.

Därför tar Resource Estimator en uppsättning indata med fördefinierade värden för att enkelt komma igång:

• En fysisk qubitmodell som definierar egenskaperna för de underliggande fysiska kvantbitarna.
• Ett QEC-schema (Quantum Error Correction), som är det antagna kvantfelkorrigeringsschemat.
• En felbudget, vilket är det övergripande tillåtna antalet fel, dvs. antalet gånger programmet får misslyckas.
• Begränsningar på komponentnivå, som är antalet logiska cykler och antalet T-fabrikskopior.
• Destillationsenheter för att specificera distillationsalgoritmer för T-fabriker.
• Paretofront-uppskattning för att köra flera uppskattningar av antalet kvantbitar och körtid för samma algoritm.

Fysiska qubitparametrar

När Resource Estimator modellerar de fysiska kvantbitsantagandena använder den två olika fysiska instruktionsuppsättningar för att använda kvantbitarna. Den fysiska instruktionsuppsättningen kan vara antingen grindbaserad eller Majorana. En gatebaserad instruktionsuppsättning ger mätning av enskilda kvantbitar, enskilda kvantbitsgrindar (inklusive T-portar) och tvåkvantsbitsgrindar. En Majorana-instruktionsuppsättning ger en fysisk T-grind, enkvantsbitsmätning och tvåkvantsbits gemensamma mätoperationer.

Du kan välja mellan sex fördefinierade qubitparametrar, varav fyra har gatebaserade instruktionsuppsättningar och två med en Majorana-instruktionsuppsättning. De här kvantbitsmodellerna täcker en mängd olika driftstider och felfrekvenser, vilket möjliggör tillräcklig utforskning av de resurskostnader som behövs för att möjliggöra praktiska kvantprogram.

Parametrar för fördefinierade kvantbitsparametrar

Som referens är de fullständiga fördefinierade kvantbitsparametrarna följande:

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

Skicka fördefinierade kvantbitsparametrar

Det finns två sätt att programmatiskt ange fördefinierade kvantbitsparametrar. Du kan välja qubitmodellnamnet för qubitParams klassen när du kör qsharp.estimate. Om du till exempel vill välja "qubit_maj_ns_e6" qubitparameter skriver du:

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

Du kan också skicka kvantbitsparametrarna till EstimatorParams klassen med hjälp av QubitParams. Om du till exempel vill välja MAJ_NS_E6 qubitparameter skriver du:

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)

Anpassa fördefinierade kvantbitsparametrar

Du kan anpassa fördefinierade kvantbitsparametrar genom att ange namnet och sedan uppdatera något av de andra värdena. Om du till exempel vill minska felfrekvensen för sammätning av två kvantbitar i "qubit_maj_ns_e4" skriver du:

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

Eller så kan du skicka instruktionerna i form av en lista.

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

Qubitparametrar för Gate-baserade kvantbitar

Följande kod visar hur du anger anpassade qubitparametrar för en gatebaserad instruktionsuppsättning:

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

Qubitparametrar för Majorana-kvantbitar

En minsta mall för Majorana-baserad instruktionsuppsättning med alla nödvändiga värden är:

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

För one_qubit_measurement_error_rate och two_qubit_joint_measurement_error_ratekan du ange de felfrekvenser som motsvarar mätningsläsningar, readout, och mätningsbearbetning, process. Dessa värden kan vara antingen <double> tal eller par med tal. Till exempel:

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

Korrigeringsscheman för kvantfel

För att köra kvantprogram i praktisk skala bör kvantåtgärder ha låga felfrekvenser. Dessa felfrekvenser targets ligger vanligtvis utanför kapaciteterna hos råa fysiska kvantbitar. För att övervinna den här begränsningen är kvantfelkorrigering (QEC) och feltolerant beräkning två viktiga tekniker som utgör byggstenarna för storskaliga kvantdatorer. För det första gör QEC att vi kan skapa flera felbenägna fysiska kvantbitar och skapa en mer tillförlitlig logisk kvantbit som bevarar kvantinformation bättre än de underliggande fysiska kvantbitarna.

Resursberäknaren använder följande formel för att modellera logiska felfrekvenser med hjälp av en exponentiell modell.

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

där $a$ är en korsande förfaktor, $d$ är kodavståndet, $k$ är en avståndskoefficientkraft (vanligtvis inställd på 0), $p$ är den fysiska felfrekvensen och $p^*$ är tröskelvärdet för kvantfelkorrigering. Korsningsförfaktorn $a$ kan extraheras numeriskt för simuleringar.

Kodavståndet $d$ är en parameter som styr antalet fel som kan korrigeras. Därför definierar kodavstånd felfrekvensen för de logiska kvantbitarna och antalet fysiska kvantbitar som krävs för att koda dem. Både noggrannhet och antalet fysiska kvantbitar ökar med kodavstånd. Målet med ett QEC-schema är att hitta det minsta kodavstånd som kan uppnå den felfrekvens som krävs för ett visst program.

Den fysiska felfrekvensen $p$ extraheras från kvantbitsparametrarna som den värsta felfrekvensen för alla fysiska Clifford-åtgärder som utförs på enheten. I synnerhet $p = {}$ max(one_qubit_measurement_error_rate, one_qubit_gate_error_rate, two_qubit_gate_error_rate) för qubitparametrar med en gatebaserad instruktionsuppsättning och $p = {}$ max(one_qubit_measurement_error_rate, two_qubit_joint_measurement_error_rate) för qubitparametrar med en Majorana-instruktionsuppsättning. QEC-scheman har vanligtvis ett tröskelvärde för felfrekvens $p^*$ under vilket felkorrigering undertrycker fel.

Azure Quantum Resource Estimator stöder två fördefinierade QEC-scheman: en ytkod och en floquet-kod.

Parametrar för fördefinierade QEC-scheman

De exakta parametrarna för varje fördefinierat QEC-schema är följande.

{
    "qubitParams": {
        "instructionSet": "GateBased",
    }
    "qecScheme": {
        "name": "surface_code",
        "errorCorrectionThreshold": 0.01,
        "crossingPrefactor": 0.03,
        "distanceCoefficientPower": 0,
        "logicalCycleTime": "(4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance",
        "physicalQubitsPerLogicalQubit": "2 * codeDistance * codeDistance"
    }
}

{
    "qubitParams": {
        "instructionSet": "Majorana",
    }
    "qecScheme": {
        "name": "surface_code",
        "errorCorrectionThreshold": 0.0015,
        "crossingPrefactor": 0.08,
        "distanceCoefficientPower": 0,
        "logicalCycleTime": "20 * oneQubitMeasurementTime * codeDistance",
        "physicalQubitsPerLogicalQubit": "2 * codeDistance * codeDistance"
    }
}

{
    "qubitParams": {
        "instructionSet": "Majorana",
    }
    "qecScheme": {
        "name": "floquet_code",
        "errorCorrectionThreshold": 0.01,
        "crossingPrefactor": 0.07,
        "distanceCoefficientPower": 0,
        "logicalCycleTime": "3 * oneQubitMeasurementTime * codeDistance",
        "physicalQubitsPerLogicalQubit": "4 * codeDistance * codeDistance + 8 * (codeDistance - 1)"
    }
}

Överföra fördefinierade QEC-scheman

Det finns två sätt att ange fördefinierade QEC-scheman. Du kan välja QEC-modellnamnet för "qecScheme" klassen när du kör qsharp.estimate. Om du till exempel vill välja floquet-koden skriver du:

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

Du kan också skicka en lista över uppskattningsparametrar till EstimatorParams klass genom att använda QECScheme klass. Om du till exempel vill välja floquet-koden skriver du:

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)

Anpassa fördefinierade QEC-scheman

Du kan anpassa fördefinierade QEC-scheman genom att ange namnet och sedan uppdatera något av de andra värdena. Om du till exempel vill öka korsningsförfaktorn i floquet-koden skriver du:

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

Anpassa dina QEC-scheman

Resursberäknaren kan abstrahera ett anpassat QEC-schema baserat på formeln ovan genom att ange värden för "crossingPrefactor" $a$, distanceCoefficientPower $k$och "errorCorrectionThreshold" $p^*$. Dessutom måste du ange "logicalCycleTime", det vill säga tiden för att köra en enda logisk operation, som beror på kodavståndet och antagandena om den fysiska operationstiden för underliggande fysiska kvantbitar. Slutligen beräknar "physicalQubitsPerLogicalQubit"en andra formel det antal fysiska kvantbitar som krävs för att koda en logisk qubit baserat på kodavståndet.

Du kan använda följande kod som en mall för QEC-scheman:

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

I formler kan du använda variablerna one_qubit_gate_time, , two_qubit_gate_timeone_qubit_measurement_time, och two_qubit_joint_measurement_time, vars värden hämtas från motsvarande fält från de fysiska kvantbitsparametrarna, samt variabeln eccDistance för kodavståndet som beräknas för den logiska kvantbiten, baserat på de fysiska kvantbitsegenskaperna, tröskelvärdet för felkorrigering och korsande prefaktor. Tidsvariablerna och eccDistance kan användas för att beskriva formeln logicalCycleTime . För formeln physicalQubitsPerLogicalQubitkan endast eccDistance användas.

Felbudget

Den totala felbudgeten $\epsilon$ anger det övergripande tolererade felet för algoritmen, d.v.s. algoritmens tillåtna felsannolikhet. Det globala värdet måste vara mellan 0 och 1 och standardvärdet är 0,001, vilket motsvarar 0,1 %. Med andra ord tillåts algoritmen att misslyckas högst en gång i 1 000 körningar. Den här parametern är mycket programspecifik.

Om du till exempel kör Shor-algoritmen för att räkna ut heltal kan ett stort värde för felbudgeten tolereras eftersom man kan kontrollera att utdata verkligen är de främsta faktorerna för indata. Å andra sidan kan en mindre felbudget behövas för en algoritm som löser ett problem med en lösning, som inte kan verifieras effektivt.

Felbudgeten motsvarar summan av tre delar:

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

De logiska felen $\epsilon_{\log}$ är felet med att implementera logiska kvantbitar, T-tillståndsfelet $\epsilon_{\rm dis}$ är felet att producera T-tillstånd genom destillation och rotationsgrindsfelet $\epsilon_{\rm syn}$ är felet att syntetisera rotationsportar med godtyckliga vinklar.

Observera att för destillation och rotationssyntes är respektive felbudgetar $\epsilon_{\rm dis}$ och $\epsilon_{\rm syn}$ jämnt fördelade mellan alla nödvändiga T-tillstånd respektive alla nödvändiga rotationsportar. Om det inte finns rotationsportar i indataalgoritmen distribueras felbudgeten jämnt till logiska fel och T-tillståndsfel.

Överskrida felbudget

Det finns två sätt att ange felbudgeten genom att ange ett tal mellan 0 och 1. Du kan överskrida felbudgeten när du kör qsharp.estimate. Om du till exempel vill välja en felbudget på 1/3 skriver du:

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

Du kan också skicka felbudgetparametrarna till EstimatorParams klassen.

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)

Du kan också ange varje komponent i felbudgeten individuellt. Summan av alla värden är den totala felbudgeten och måste vara mellan 0 och 1. Om en kvantalgoritm inte innehåller T-tillstånd eller rotationer kan värdena t_states för respektive rotations 0 vara 0.

Följande kod visar hur du anger felbudgetparametern med T-tillstånd och rotationer:

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

Begränsningar

Du kan använda "constraints" klassen för att tillämpa begränsningar på T-fabrikskomponentnivån . Genom att justera begränsningar kan du optimera uppskattningarna för att minska antalet kvantbitar eller minska körtiden.

Följande kod visar hur du anger begränsningarna för en kvantalgoritm:

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

Destillationsenheter

Du kan ange specifikationer för T-fabrikers destillationsalgoritmer med DistillationUnitSpecification klassen . Specifikationen kan vara antingen fördefinierad eller anpassad. Du kan ange en fördefinierad specifikation genom att välja destillationsenhetens namn: 15-1 RM eller 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)

I båda fallen står notation 15-1 för 15 indata-T-tillstånd och 1 utdata-T-tillstånd. Destillationsenheten 15-1 space-efficient använder färre qubits än 15-1 RM men kräver längre körtid. Mer information finns i Tabell VI.

Anpassa destillationsenheterna

Du kan anpassa dina egna destillationsenheter. De exakta parametrarna för destillationsenheterna är följande.

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

Alla numeriska parametrar förväntas vara positiva. displayName Anger hur destillationsenheten ska visas i utdataresultatet.

Följande kod visar hur du anger destillationsenhetens parametrar för en kvantalgoritm med hjälp av DistillationUnitSpecification klassen och ProtocolSpecificDistillationUnitSpecification klassen.

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

Formler för failure_probability_formula och output_error_rate_formula är anpassade formler med grundläggande aritmetiska åtgärder, konstanter och endast tre parametrar:

• clifford_error_rate, även betecknad som c.
• readout_error_rate, även betecknad som r.
• input_error_rate, även betecknad som z.

Se följande exempel på anpassade formler med lång och kort notation. De här exemplen illustrerar formler som används som standard i standardimplementeringen.

Minst en av parametrarna physical_qubit_specification eller logical_qubit_specification bör anges. Om endast den förstnämnda tillhandahålls kan destillationsenheten tillämpas på fysiska kvantbitar. Om endast den senare tillhandahålls kan destillationsenheten tillämpas på logiska kvantbitar. Om båda tillhandahålls kan destillationsenheten tillämpas på båda typerna av kvantbitar.

Parametern logical_qubit_specification_first_round_override kan endast anges om logical_qubit_specification den har angetts. I så fall åsidosätter den värdena logical_qubit_specification ifall de tillämpas vid första omgången av destillationen. <protocol specific parameters> Värdet som krävs för logical_qubit_specification_first_round_override bör följa schemat:

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

Gränsuppskattning för Pareto

När du beräknar resurserna för en algoritm är det viktigt att överväga kompromissen mellan antalet fysiska kvantbitar och algoritmens körning. Du kan överväga allokering av så många fysiska kvantbitar som möjligt för att minska körningen av algoritmen. Antalet fysiska kvantbitar begränsas dock av antalet fysiska kvantbitar som är tillgängliga i kvantmaskinvaran. Att förstå kompromissen mellan körtid och systemskala är en av de mer betydelsefulla aspekterna av resursestimering.

Pareto-gränsuppskattningen ger flera uppskattningar för samma algoritm, där varje uppskattning visar avvägningar mellan antalet kvantbitar och körtiden.

Om du kör resursestimatorn i Python måste du ange parametern "estimateType" som "frontier".

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

Om du vill visualisera resultatet av Gränsuppskattningen i Pareto kan du använda EstimatesOverview funktionen. Den här funktionen visar resultatet av gränsuppskattning i tabellen och ett tidsdiagram. Mer information finns i Diagram över tidsrymd.

from qsharp_widgets import EstimatesOverview

EstimatesOverview(result)

Nästa steg

• Förstå resultatet av resursestimatorn
• Kör din första resursuppskattning
• Olika sätt att köra Resource Estimator
• Hantera stora program med Resource Estimator
• Självstudie: Beräkna resurserna för ett kvantkemiproblem