Anpassen der target Parameter des Ressourcenstimators

  • Artikel

In diesem Artikel erfahren Sie, wie Sie die target Parameter des Azure Quantum Resource Estimators so anpassen, dass sie den Computermerkmalen entsprechen, die Sie targetbenötigen. Der Ressourcenstimator verwendet diese Parameter, um die Ressourcen zu schätzen, die zum Ausführen eines Quantenalgorithmus auf einem Quantencomputer erforderlich sind.

Hinweis

Wenn beim Arbeiten mit dem Resource Estimator ein Problem aufgetreten ist, lesen Sie die Seite Problembehandlung.

Voraussetzungen

Zielparameter

Der Resource Estimator berechnet die Schätzung der Ressourcen, z. B. die Anzahl der Qubits und die Laufzeit, die erforderlich wäre, um einen bestimmten Quantenalgorithmus mit einer bestimmten Qubit-Technologie und mit einem festen Satz von Architekturoptionen zu implementieren.

Daher benötigt der Resource Estimator eine Reihe von Eingaben mit vordefinierten Werten, um Ihnen den Einstieg zu erleichtern:

Physische Qubitparameter

Wenn der Resource Estimator die physischen Qubit-Annahmen modelliert, verwendet er zwei verschiedene physische Anweisungsgruppen, um die Qubits zu betreiben. Der physische Anweisungssatz kann entweder gatterbasiert oder Majorana sein. Ein gatterbasierter Befehlssatz ermöglicht Messungen für einzelne Qubits, Gatter für einzelne Qubits (einschließlich T-Gatter) und Gatter für zwei Qubit. Ein Majorana-Anweisungssatz bietet ein physisches T-Gatter, Messungen für einzelne Qubits und gemeinsame Messungen für zwei Qubits.

Sie können aus sechs vordefinierten Qubitparametern wählen, von denen vier über gatterbasierte Anweisungssätze und zwei über einen Majorana-Anweisungssatz verfügen. Diese Qubitmodelle decken verschiedene Betriebszeiten und Fehlerraten ab und ermöglichen eine ausreichende Untersuchung der Ressourcenkosten für praktische Quantenanwendungen.

Qubit-Parameter Python-API-Klasse BESCHREIBUNG
"qubit_gate_ns_e3" , "qubit_gate_ns_e4" GATE_NS_E3 , GATE_NS_E4 Betriebszeiten und -fidelitäten können zukünftigen Versionen von supraleitenden Transmonqubits oder Spin-Qubits entsprechen, die in der Regel Betriebszeiten im Nanosekunden-Regime haben. Für diese Qubits wird angenommen, dass Gate- und Messvorgänge 50 ns bzw. 100 ns dauern. Es wird angenommen, dass die Fehlerraten für Ein- und Zwei-Qubit-Gate 10^{-3}$ als realistisch targetund 10^{-4}$ für ein hochskaliertes System optimistisch target sind.
"qubit_gate_us_e3" , "qubit_gate_us_e4" GATE_US_E3 , GATE_US_E4 Betriebszeiten und -fidelitäten können zukünftigen Versionen von Qubits entsprechen, die auf Ionen basieren, die in der Regel Betriebszeiten im Mikrosekundenregime aufweisen. Basierend auf typischen Annahmen für Ionenqubits wird angenommen, dass Gate- und Messvorgänge 100 μs dauern. Die Fehlerrate für Single-Qubit-Clifford-Gates beträgt 10^{-3}$ als realistisch target und 10^{-4}$ als optimistisch target, während die Fehlerrate für Single-Qubit-Nicht-Clifford-Gates (T-Gate) 10^{-6}$ beträgt. Bei Zwei-Qubit-Gates beträgt die Fehlerrate 10^{-3}$ als realistisch target und 10^{-4}$ als optimistisch target.
"qubit_maj_ns_e4" , "qubit_maj_ns_e6" MAJ_NS_E4 , MAJ_NS_E6 Die Betriebszeiten und -fidelitäten können zukünftigen verbesserten Versionen von Majorana-Qubits entsprechen. Für diese Qubits wird angenommen, dass Gate- und Messvorgänge 100 ns dauern. Um den topologischen Schutz in der Hardware zu berücksichtigen, wird angenommen, dass die Fehlerraten von Einzelqubit- und Zwei-Qubit-Joint-Messungen (Clifford-Fehlerraten) als realistisch target10^{-4}$ und 10^{-6}$ als optimistischer targetwert sind. Nicht Clifford-Vorgänge in dieser Architektur verfügen über keinen topologischen Schutz, die Fehlerrate für physische T-Gates ohne Clifford beträgt 5 %.

Hinweis

Sofern kein anderer Wert angegeben wird, ist "qubit_gate_ns_e3"der Standardwert für das Qubitmodell .

Als Referenz sind die vollständigen vordefinierten Qubit-Parameter wie folgt:

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

Übergeben vordefinierter Qubitparameter

Es gibt zwei Möglichkeiten, vordefinierte Qubitparameter programmgesteuert anzugeben. Sie können den Namen des Qubitmodells für die qubitParams Klasse auswählen, wenn Sie ausführen qsharp.estimate. Um beispielsweise den Qubit-Parameter auszuwählen "qubit_maj_ns_e6" , schreiben Sie Folgendes:

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

Sie können die Qubitparameter auch mit QubitParamsan die EstimatorParams -Klasse übergeben. Um beispielsweise den Qubit-Parameter auszuwählen MAJ_NS_E6 , schreiben Sie Folgendes:

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)

Anpassen vordefinierter Qubitparameter

Sie können vordefinierte Qubitparameter anpassen, indem Sie den Namen angeben und dann einen der anderen Werte aktualisieren. Um beispielsweise die Fehlerrate bei der Messung von Zwei-Qubit-Gelenken in "qubit_maj_ns_e4" zu verringern, schreiben Sie Folgendes:

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

Oder Sie können die Anweisungen in Form einer Liste übergeben.

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

Qubitparameter für Gate-basierte Qubits

Python-Bezeichner Datentyp BESCHREIBUNG
name Zeichenfolge Name für das Qubitmodell
instruction_set "gate_based" Zugrunde liegende Qubit-Technologie
one_qubit_measurement_time Zeitzeichenfolge Vorgangszeit für die Einzelqubitmessung ($t_{\rm meas}$) in ns
one_qubit_gate_time Zeitzeichenfolge Vorgangszeit für Single-Qubit-Gate ($t_{\rm gate}$) in ns
two_qubit_gate_time Zeitzeichenfolge Betriebszeit für Zwei-Qubit-Gate in ns
t_gate_time Zeitzeichenfolge Betriebszeit für Single-Qubit-Nicht-Clifford-Gate in ns
one_qubit_measurement_error_rate float Fehlerrate bei Einzelqubitmessung
one_qubit_gate_error_rate float Fehlerrate für Single-Qubit-Clifford-Gate ($p$)
two_qubit_gate_error_rate float Fehlerrate für Zwei-Qubit-Clifford-Gate
t_gate_error_rate float Fehlerrate zum Vorbereiten des Single-Qubit-Non-Clifford-Zustands ($p_T$)
idle_error_rate float Fehlerrate gemäß Leerlauf

Der folgende Code zeigt, wie benutzerdefinierte Qubitparameter für einen gatebasierten Befehlssatz angegeben werden:

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

Hinweis

Wenn nicht angegeben, werden die Werte für und standardmäßig one_qubit_gate_timeauf , die Werte für two_qubit_gate_error_rate und t_gate_error_rate standardwert auf one_qubit_gate_error_rateund der Wert für idle_error_rate standardwerte auf festgelegtone_qubit_measurement_error_rate.t_gate_timetwo_qubit_gate_time

Qubitparameter für Majorana-Qubits

Python-Bezeichner Datentyp BESCHREIBUNG
name Zeichenfolge Name für das Qubitmodell
instruction_set "majorana" Zugrunde liegende Qubit-Technologie
one_qubit_measurement_time Zeitzeichenfolge Vorgangszeit für die Einzelqubitmessung ($t_{\rm meas}$) in ns
two-qubit_joint_measurement_time Zeitzeichenfolge Betriebszeit für zwei Qubitmessungen in ns
t_gate_time Zeitzeichenfolge Betriebszeit für Single-Qubit-Nicht-Clifford-Gate in ns
one_qubit_measurement_error_rate float Fehlerrate bei Einzel-Qubit-Messung
two_qubit_joint_measurement_error_rate float Fehlerrate bei der Zwei-Qubit-Messung
t_gate_error_rate float Fehlerrate zum Vorbereiten des Single-Qubit-Non-Clifford-Zustands ($p_T$)
idle_error_rate float Fehlerrate im Leerlauf

Eine Mindestvorlage für den Majorana-basierten Befehlssatz mit allen erforderlichen Werten ist:

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

Hinweis

Wenn nicht angegeben, werden die Werte für two_qubitJointMeasurementTime und t_gate_time standardmäßig one_qubit_measurement_timeauf , die Werte für two_qubit_joint_measurement_error_rate und t_gate_error_rate standardwert auf one_qubit_measurement_error_rateund der Wert für idle_error_rate standardmäßig auf one_qubit_measurement_error_ratefestgelegt.

Für one_qubit_measurement_error_rate und two_qubit_joint_measurement_error_ratekönnen Sie die Fehlerraten angeben, die den Messauslesevorgängen, readoutund der Messverarbeitung processentsprechen. Diese Werte können entweder <double> Zahlen oder Zahlenpaare sein. Beispiel:

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

Hinweis

Wenn Sie in der Majorana-Qubitmessung einen einzelnen numerischen Wert für Die Fehlerraten von Einzel- und Zwei-Qubit angeben, können die Lese- und Prozessfehlerraten gleich sein.

Wichtig

Alle Werte, die nicht angegeben sind, verwenden einen Standardwert, z. B. wird ein gatebasiertes Qubit modelliert "qubit": {"oneQubitGateTime":"200 ns"} , bei dem sowohl die Zwei-Qubit-Gatezeit als auch die 1-Qubit-Gatezeit 200 ns sind. Für Einheiten müssen Sie Zeitzeichenfolgen angeben, bei denen es sich um Gleitkommazahlen mit doppelter Genauigkeit handelt, gefolgt von einem Leerzeichen und der Zeiteinheit für solche Werte, sofern mögliche Zeitsuffixe ns, µs (oder us), msund ssind.

Schemas zur Quantenfehlerkorrektur

Um Quantenanwendungen im praktischen Maßstab auszuführen, sollten Quantenvorgänge niedrige Fehlerraten aufweisen. Diese Fehlerrate targets geht in der Regel über die Möglichkeiten von rohen physischen Qubits hinaus. Um diese Einschränkung zu überwinden, sind quantenfehlerkorrektur (QEC) und fehlertolerante Berechnungen zwei wichtige Techniken, die die Bausteine großer Quantencomputer bilden. Erstens ermöglicht QEC es uns, mehrere fehleranfällige physische Qubits zu erstellen und ein zuverlässigeres logisches Qubit zu erstellen, das Quanteninformationen besser beibewahrt als die zugrunde liegenden physischen Qubits.

Der Fehlerkorrekturcodeabstand (oder nur kurz code distance) ist ein Parameter, der die Anzahl der Fehler steuert, die korrigiert werden können. Daher die Fehlerrate der logischen Qubits und die Anzahl der physischen Qubits, die für die Codierung erforderlich sind. Sowohl die Genauigkeit als auch die Anzahl physischer Qubits erhöhen sich mit dem Codeabstand. Das Ziel besteht darin, den minimalen Codeabstand zu ermitteln, der die erforderliche Fehlerrate erreichen kann, die für eine bestimmte Anwendung festgelegt wurde.

Die Ressourcenschätzung verwendet die folgende Formel zum Modellieren logischer Fehlerraten mithilfe eines exponentiellen Modells:

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

Dabei ist $d$ der Codeabstand, $p$ die physische Fehlerrate und $p^*$ der Schwellenwert für die Quantenfehlerkorrektur. Die physische Fehlerrate $p$ wird aus den Qubitparametern als fehlerrate im schlimmsten Fall eines physischen Clifford-Vorgangs im Gerät extrahiert.

Insbesondere $p = {}$ max(one_qubit_measurement_error_rate, one_qubit_gate_error_rate, two_qubit_gate_error_rate) für Qubitparameter mit einem gatebasierten Befehlssatz und $p = {}$ max(one_qubit_measurement_error_rate, two_qubit_joint_measurement_error_rate) für Qubitparameter mit einem Majorana-Anweisungssatz. QEC-Schemas weisen in der Regel einen Fehlerratenschwellenwert $p^*$ auf, unter dem Fehlerkorrektur Fehler unterdrückt.

QEC-Protokoll Python-API-Klasse Beschreibung
"surface_code" SURFACE_CODE Der gatebasierte Oberflächencode basiert auf arXiv:1208.0928 und arXiv:1009.3686. Der Majorana-Oberflächencode basiert auf arXiv:1909.03002 und arXiv:2007.00307.
"floquet_code" FLOQUET_CODE Nur für Majorana-Qubits. Der Floquet-Code basiert auf arXiv:2202.11829.

Hinweis

Sofern kein anderer Wert angegeben ist, lautet der Standardwert für das QEC-Schema "surface_code".

Die genauen Parameter für jedes vordefinierte QEC-Schema (einschließlich eines kreuzenden Vorfaktors $a$, der für Simulationen numerisch extrahiert werden kann) sind die folgenden.

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

Übergeben vordefinierter QEC-Schemas

Es gibt zwei Möglichkeiten, vordefinierte QEC-Schemas anzugeben. Sie können den QEC-Modellnamen für die "qecScheme" -Klasse auswählen, wenn Sie ausführen qsharp.estimate. Um beispielsweise den Floquetcode auszuwählen, schreiben Sie Folgendes:

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

Sie können auch mithilfe der -Klasse eine Liste von Schätzparametern an die QECSchemeEstimatorParams -Klasse übergeben. Um beispielsweise den Floquetcode auszuwählen, schreiben Sie Folgendes:

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)

Anpassen vordefinierter QEC-Schemas

Sie können vordefinierte QEC-Schemas anpassen, indem Sie den Namen angeben und dann alle anderen Werte aktualisieren. Wenn Sie z. B. den Überquerungsvorfaktor im Floquetcode erhöhen möchten, schreiben Sie Folgendes:

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

Hinweis

Wenn nicht angegeben, werden die Werte für "logicalCycleTime" und "physicalQubitsPerLogicalQubit" standardmäßig "oneQubitMeasurementTime"auf , der Wert für "errorCorrectionThreshold" standardmäßig auf 0.01festgelegt, und der Wert für "crossingPrefactor" ist standardmäßig auf 0.03festgelegt.

Anpassen Ihrer QEC-Schemas

Der Resource Estimator kann ein angepasstes QEC-Schema basierend auf der obigen Formel abstrahieren, indem Werte für die "crossingPrefactor" $a$ und die "errorCorrectionThreshold" $p^*$ angegeben werden. Darüber hinaus müssen Sie angeben "logicalCycleTime", d. h. die Zeit für die Ausführung eines einzelnen logischen Vorgangs, die von der Codeentfernung und den Annahmen der physischen Vorgangszeit der zugrunde liegenden physischen Qubits abhängt. Schließlich berechnet eine zweite Formel die "physicalQubitsPerLogicalQubit", d. h. die Anzahl der physischen Qubits, die zum Codieren eines logischen Qubits basierend auf dem Codeabstand erforderlich sind.

Sie können den folgenden Code als Vorlage für QEC-Schemas verwenden:

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

Innerhalb der Formeln können Sie die Variablen one_qubit_gate_time, two_qubit_gate_time, one_qubit_measurement_timeund two_qubit_joint_measurement_timeverwenden, deren Werte aus dem entsprechenden Feld aus den physischen Qubitparametern stammen, sowie die Variable eccDistance für den Codeabstand, der für das logische Qubit berechnet wird, basierend auf den physischen Qubiteigenschaften, dem Fehlerkorrekturschwellenwert und dem Überquerungs-Präfaktor. Die Zeitvariablen und eccDistance können verwendet werden, um die logicalCycleTime Formel zu beschreiben. Für die Formel physicalQubitsPerLogicalQubit kann nur der eccDistance verwendet werden.

Fehlerbudget

Das Gesamtfehlerbudget $\epsilon$ legt den insgesamt tolerierten Fehler für den Algorithmus fest, d. h. die zulässige Fehlerwahrscheinlichkeit des Algorithmus. Der globale Wert muss zwischen 0 und 1 liegen, und der Standardwert ist 0,001, was 0,1 % entspricht. Anders ausgedrückt: Der Algorithmus darf maximal einmal in 1.000 Ausführungen fehlschlagen. Dieser Parameter ist äußerst anwendungsspezifisch.

Wenn Sie z. B. den Shor-Algorithmus für die Faktorisierung ganzer Zahlen ausführen, kann ein großer Wert für das Fehlerbudget toleriert werden, da überprüft werden kann, ob die Ausgaben tatsächlich die Hauptfaktoren der Eingabe sind. Andererseits kann ein kleineres Fehlerbudget für einen Algorithmus erforderlich sein, der ein Problem mit einer Lösung löst, das nicht so einfach überprüft werden kann.

Das Fehlerbudget entspricht der Summe aus drei Teilen:

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

Wenn keine weitere Angabe erfolgt, wird das Fehlerbudget $\epsilon$ einheitlich verteilt und gilt für Fehler $\epsilon_{\log}$ zum Implementieren logischer Qubits, das Fehlerbudget $\epsilon_{\rm dis}$ erzeugt T-Zustände durch Destillation und ein Fehlerbudget $\epsilon_{\rm syn}$ zum Synthetisieren von Rotationsgates mit beliebigen Winkeln.

Beachten Sie, dass für die Destillation und Rotationssynthese die jeweiligen Fehlerbudgets $\epsilon_{\rm dis}$ und $\epsilon_{\rm syn}$ gleichmäßig auf alle erforderlichen T-Zustände bzw. alle erforderlichen Rotationsgates verteilt sind. Wenn im Eingabealgorithmus keine Rotationsgates vorhanden sind, wird das Fehlerbudget einheitlich auf logische Fehler und T-Zustandsfehler verteilt.

Übergeben des Fehlerbudgets

Es gibt zwei Möglichkeiten, das Fehlerbudget anzugeben, indem Sie eine Zahl zwischen 0 und 1 festlegen. Sie können das Fehlerbudget übergeben, wenn Sie ausführen qsharp.estimate. Wenn Sie beispielsweise ein Fehlerbudget von 1/3 auswählen möchten, schreiben Sie Folgendes:

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

Sie können auch die Fehlerbudgetparameter an die EstimatorParams -Klasse übergeben.

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)

Außerdem können Sie jede Komponente des Fehlerbudgets einzeln angeben. Die Summe aller Werte entspricht dem Gesamtfehlerbudget und muss zwischen 0 und 1 betragen. Wenn ein Quantenalgorithmus keine T-Zustände oder Drehungen enthält, können die Werte von t_states und rotations 0 bzw. sein.

Der folgende Code zeigt, wie sie den Fehlerbudgetparameter mit T-Zuständen und Drehungen angeben:

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

Einschränkungen

Sie können die "constraints" -Klasse verwenden, um Einschränkungen auf der T-Factory-Komponentenebene anzuwenden. Durch das Anpassen der Einschränkungen können Sie die Schätzungen optimieren, um die Anzahl der Qubits oder die Laufzeit zu reduzieren.

Parameter Datentyp BESCHREIBUNG
logical_depth_factor float Steuern sie die Ausführungszeit. Wenn der Wert größer als 1 ist, wird die anfängliche Anzahl logischer Zyklen, auch als logische Tiefe bezeichnet, mit dieser Zahl multipliziert. Wenn Sie reduzieren logical_depth_factor, können Sie die Anzahl der Aufrufe der T-Factory in einem bestimmten Zeitraum erhöhen, was dazu führt, dass weniger T-Factory-Kopien erforderlich sind, um die gleiche Anzahl von T-Zuständen zu erzeugen. Wenn Sie die Anzahl der T-Factorykopien reduzieren, erhöht sich die Laufzeit des Algorithmus entsprechend. Der Skalierungsfaktor für die Gesamtlaufzeit kann größer sein, da die erforderliche logische Fehlerrate aufgrund der zusätzlichen Anzahl von Zyklen zunimmt.
max_t_factories integer Maximale Anzahl von T Factory-Kopien. Der Ressourcenschätzunger bestimmt die erforderlichen Ressourcen, indem die optimale Anzahl von T-Factorykopien ausgewählt wird, die die Anzahl der verwendeten physischen Qubits minimiert, ohne den Zeitaufwand zu berücksichtigen. Der max_t_factories Parameter begrenzt die maximale Anzahl von Kopien und passt daher die Anzahl logischer Zyklen entsprechend an. Weitere Informationen finden Sie unter T Factory Physical Estimation.For more information, see T factory physical estimation.
max_duration Zeitzeichenfolge Maximale Laufzeit für den Algorithmus. Der Ressourcenstimator akzeptiert nur eine oder-Einschränkung max_durationmax_physical_qubits zu diesem Zeitpunkt, aber nicht zwei. Wenn max_duration angegeben wird, versucht der Resource Estimator, die beste Schätzung für max_physical_qubits unter lösungen zu finden, die durch die angegebene maximale Anzahl eingeschränkt sind.
max_physical_qubits integer Maximale Anzahl physischer Qubits für den Algorithmus. Der Ressourcenstimator akzeptiert nur eine oder-Einschränkung max_durationmax_physical_qubits zu diesem Zeitpunkt, aber nicht zwei. Wenn max_physical_qubits angegeben wird, versucht der Resource Estimator, die beste Schätzung für max_duration unter lösungen zu finden, die durch die angegebene maximale Anzahl eingeschränkt sind.

Der folgende Code zeigt, wie Sie die Einschränkungen für einen Quantenalgorithmus angeben:

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

Hinweis

Wenn der für max_duration oder max_physical_qubits bereitgestellte Wert zu klein ist, um eine realisierbare Lösung zu finden, gibt der Resource Estimator einen Fehler zurück. Wenn weder max_duration noch max_physical_qubits Einschränkungen angegeben werden, zielt der Resource Estimator darauf ab, eine Lösung mit der kürzesten Zeit zu finden.

Tipp

Sie können max_duration und verwenden, max_physical_qubits um den Lösungsraum zu beeinflussen und möglicherweise Lösungen mit einer längeren Laufzeit, aber einer geringeren Anzahl von Qubits im Vergleich zu Lösungen ohne diese Einschränkungen zu finden. Es besteht ein Kompromiss zwischen Der Laufzeit und der Anzahl der Qubits, und dieser Kompromiss kann für einige Algorithmen effizient verwaltet werden, mit unterschiedlichen Auswirkungen auf verschiedene Algorithmen. Tabelle IV in [arXiv:2211.07629] veranschaulicht die effektive Nutzung des Kompromisses zwischen der Anzahl der Qubits und der Laufzeit für Quantendynamikalgorithmen. Weitere Informationen finden Sie unter Quantum resource estimation with time or number of qubits constraints sample.

Destillationseinheiten

Sie können Spezifikationen für T-Fabriken-Destillationsalgorithmen mit der DistillationUnitSpecification -Klasse bereitstellen. Die Spezifikation kann entweder vordefiniert oder benutzerdefinierter sein. Sie können eine vordefinierte Spezifikation angeben, indem Sie den Namen der Destillationseinheit auswählen: 15-1 RM oder 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 beiden Fällen steht die Notation 15-1 für 15 T-Eingangszustände und einen T-Ausgabezustand. Die 15-1 space-efficient-Destillationseinheit verwendet weniger Qubits als 15-1 RM, erfordert jedoch mehr Laufzeit. Weitere Informationen finden Sie in Tabelle VI.

Tipp

Die Verwendung vordefinierter Destillationseinheiten bietet eine bessere Leistung im Vergleich zu benutzerdefinierten Einheiten.

Anpassen Ihrer Destillationseinheiten

Sie können Ihre eigenen Destillationseinheiten anpassen. Die genauen Parameter für die Destillationseinheiten sind die folgenden.

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

Es wird erwartet, dass alle numerischen Parameter positiv sind. Gibt displayName an, wie die Destillationseinheit in Ausgabeergebnissen angezeigt wird.

Der folgende Code zeigt, wie die Destillationseinheitsparameter für einen Quantenalgorithmus mithilfe der DistillationUnitSpecification -Klasse und der ProtocolSpecificDistillationUnitSpecification -Klasse angegeben werden.

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

Die Formeln für failure_probability_formula und output_error_rate_formula sind benutzerdefinierte Formeln mit einfachen arithmetischen Vorgängen, Konstanten und nur drei Parametern:

  • clifford_error_rate, wird auch als cbezeichnet.
  • readout_error_rate, wird auch als rbezeichnet.
  • input_error_rate, wird auch als zbezeichnet.

Sehen Sie sich die folgenden Beispiele für benutzerdefinierte Formeln mit langer und kurzer Notation an. Diese Beispiele veranschaulichen Formeln, die standardmäßig in der Standardimplementierung verwendet werden.

Parameter Lange Formel Kurze Formel
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"

Mindestens einer der Parameter physical_qubit_specificationlogical_qubit_specification oder sollte angegeben werden. Wenn nur ersteres bereitgestellt wird, kann die Destillationseinheit auf physische Qubits angewendet werden. Wenn nur letzteres bereitgestellt wird, kann die Destillationseinheit auf logische Qubits angewendet werden. Wenn beides angegeben ist, kann die Destillationseinheit auf beide Arten von Qubits angewendet werden.

Der Parameter logical_qubit_specification_first_round_override kann nur angegeben werden, wenn logical_qubit_specification angegeben ist. Wenn dies der Fall ist, werden die Werte von logical_qubit_specification außer Kraft gesetzt, wenn sie bei der ersten Destillationsrunde angewendet werden. Der Wert <protocol specific parameters> , für logical_qubit_specification_first_round_override den erforderlich ist, sollte dem Schema folgen:

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

Pareto-Grenzschätzung

Beim Schätzen der Ressourcen eines Algorithmus ist es wichtig, den Kompromiss zwischen der Anzahl der physischen Qubits und der Laufzeit des Algorithmus zu berücksichtigen. Sie könnten die Zuordnung von so vielen physischen Qubits wie möglich in Betracht ziehen, um die Laufzeit des Algorithmus zu reduzieren. Die Anzahl der physischen Qubits wird jedoch durch die Anzahl der physischen Qubits begrenzt, die in der Quantenhardware verfügbar sind. Das Verständnis des Kompromisses zwischen Laufzeit und Systemskalierung ist einer der wichtigsten Aspekte der Ressourcenschätzung.

Die Pareto-Grenzschätzung bietet mehrere Schätzungen für denselben Algorithmus, wobei jeweils Kompromisse zwischen der Anzahl der Qubits und der Laufzeit angezeigt werden.

Hinweis

Wenn Sie den Resource Estimator in Visual Studio Code mit der Option : Berechnen vonQ# Ressourcenschätzungen ausführen, ist die Pareto-Grenzschätzung standardmäßig aktiviert.

Wenn Sie den Resource Estimator in Python ausführen, müssen Sie den "estimateType" Parameter als "frontier"angeben.

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

Wenn Sie die Ergebnisse der Pareto-Grenzschätzung visualisieren möchten, können Sie die EstimatesOverview Funktion verwenden. Diese Funktion zeigt die Ergebnisse der Grenzschätzung in einer Tabelle und einem Raum-Zeit-Diagramm an. Weitere Informationen finden Sie unter Raumzeitdiagramm.

from qsharp_widgets import EstimatesOverview

EstimatesOverview(result)

Hinweis

Wenn beim Arbeiten mit dem Resource Estimator ein Problem aufgetreten ist, lesen Sie die Seite Problembehandlung, oder wenden Sie sich an AzureQuantumInfo@microsoft.com.

Nächste Schritte