target De parameters van de resource-estimator aanpassen

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.

Vereisten

• Een Python-omgeving waarop Python en Pip zijn geïnstalleerd.

• De nieuwste versie van Visual Studio Code of open VS Code op het web.

• VS Code waarop de Azure Quantum Development Kit, Python en Jupyter-extensies zijn geïnstalleerd.

• De nieuwste qdk Python-bibliotheek met de extra jupyter.

  python -m pip install --upgrade "qdk[jupyter]"
  

Doelparameters

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 op een kwantumcomputer met een bepaalde qubittechnologie en vaste set architectuurkeuzen.

De resource estimator neemt een reeks invoerwaarden met vooraf gedefinieerde waarden om u eenvoudig aan de slag te laten gaan:

• Een fysiek qubitmodel, waarmee de eigenschappen van de onderliggende fysieke qubits worden gedefinieerd.
• Een QEC-schema (Quantum Error Correction), het veronderstelde kwantumfoutcorrectieschema.
• Een foutbudget, de algemene toegestane fout, gedefinieerd als het aantal keren dat het programma mag mislukken.
• Beperkingen op onderdeelniveau, het aantal logische cycli en het aantal T-factorykopieën.
• Destillatie-eenheden om T factory-destillatiealgoritmen op te geven.
• Pareto grens schatting om meerdere schattingen uit te voeren voor het aantal qubits en runtime voor hetzelfde algoritme.

Parameters voor fysieke qubits

Wanneer de Resource Estimator de veronderstellingen van fysieke qubits modelleert, worden twee verschillende fysieke instructiesets gebruikt om op de qubits te werken. 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.

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. Een manier is om de naam van het qubit-model voor de qubitParams klasse te selecteren wanneer u qsharp.estimate uitvoert. Als u bijvoorbeeld de "qubit_maj_ns_e6" qubitparameter wilt selecteren, schrijft u de volgende code:

from qdk import qsharp

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

Een andere manier is om de qubitparameters door te geven aan de EstimatorParams klasse met behulp van QubitParams. Als u bijvoorbeeld de MAJ_NS_E6 qubitparameter wilt selecteren, schrijft u de volgende code:

from qdk import qsharp
from qdk.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 twee qubit-gezamenlijke metingen in qubit_maj_ns_e4wilt verlagen, schrijft u de volgende code:

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 = EstimatorParams()
params.qubit_params.name = QubitParams.MAJ_NS_E4
params.qubit_params.two_qubit_joint_measurement_error_rate = 1e-5

Parameters van qubits voor op poorten gebaseerde qubits

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

from qdk.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

Qubitparameters voor Majorana-qubits

Een minimumsjabloon voor een instructieset op basis van Majorana met alle vereiste waarden is:

from qdk.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

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)

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 om logische foutpercentages te modelleren met behulp van een exponententieel model,

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

waarbij $a$ een kruisingsprefactor is, $d$ de afstandscode, $k$ een macht van de afstandscoëfficiënt is (meestal ingesteld op 0), $p$ de fysieke foutmarge en $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.

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

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 EstimatorParams. Als u bijvoorbeeld de floquetcode wilt selecteren, schrijft u:

from qdk import qsharp
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,
                    }
                })

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$, de distanceCoefficientPower $k$en de "errorCorrectionThreshold" $p^*$. U moet ook de "logicalCycleTime"tijd opgeven om één logische bewerking uit te voeren en 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 om één logische qubit te coderen 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>,
                        "distanceCoefficientPower": <integer>,
                        "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 physicalQubitsPerLogicalQubitkan alleen de eccDistance formule 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.

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.

Geef het foutbudget door

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 qdk import qsharp
from qdk.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 qdk.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.

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

from qdk.estimator import EstimatorParams

params = EstimatorParams()

params.constraints.max_duration = "1 s"
params.constraints.logical_depth_factor = 1.5
params.constraints.max_t_factories = 10

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 qdk.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.

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 DistillationUnitSpecification

from qdk.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.

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. Zo ja, dan overschrijft het de waarden van logical_qubit_specification wanneer ze worden toegepast bij de eerste ronde van distillatie. De waarde <protocol specific parameters> die vereist is voor logical_qubit_specification_first_round_override moet het volgende schema hebben:

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

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 qdk.widgets import EstimatesOverview

EstimatesOverview(result)

Volgende stappen

• Inzicht in de resultaten van de resource-estimator
• Uw eerste resourceraming uitvoeren
• Verschillende manieren om de resource-estimator uit te voeren
• Grote programma's verwerken met de resource-estimator
• Zelfstudie: De resources van een kwantumchemieprobleem schatten