Personnaliser les target paramètres de l’estimateur de ressources

  • Article

Cet article explique comment personnaliser les target paramètres de l’estimateur de ressources Azure Quantum pour qu’ils targetcorrespondent aux caractéristiques de la machine que vous utilisez. L’estimateur de ressources utilise ces paramètres pour estimer les ressources nécessaires à l’exécution d’un algorithme quantique sur un ordinateur quantique.

Notes

Si vous rencontrez un problème lors de l’utilisation de l’estimateur de ressources, case activée la page Résolution des problèmes.

Prérequis

Paramètres de la cible

L’estimateur de ressources calcule l’estimation des ressources, comme le nombre de qubits et le temps d’exécution, qui serait nécessaire pour implémenter un algorithme quantique donné à l’aide d’une technologie de qubit donnée et avec un ensemble fixe de choix architecturaux.

Par conséquent, l’estimateur de ressources prend un ensemble d’entrées, avec des valeurs prédéfinies pour vous aider à démarrer facilement :

Paramètres de qubit physiques

Lorsque l’estimateur de ressources modélise les hypothèses de qubit physique, il utilise deux jeux d’instructions physiques différents pour faire fonctionner les qubits. Le jeu d’instructions physiques peut être basé sur une porte ou Majorana. Un jeu d’instructions basé sur une porte fournit une mesure à qubit unique, des portes à qubit unique (y compris des portes T) et des portes à deux qubits. Un jeu d’instructions Majorana fournit une porte T physique, une mesure à qubit unique et des opérations de mesure conjointes à deux qubits.

Vous pouvez choisir parmi six paramètres de qubit prédéfinis, dont quatre ont des jeux d’instructions basés sur des portes et deux avec un jeu d’instructions Majorana. Ces modèles de qubit couvrent un éventail de temps d’opération et de taux d’erreur, ce qui facilite l’exploration des coûts de ressources nécessaires pour permettre des applications quantiques pratiques.

Paramètre Qubit Classe d’API Python Description
"qubit_gate_ns_e3" , "qubit_gate_ns_e4" GATE_NS_E3 , GATE_NS_E4 Les temps d’opération et les fidélités peuvent correspondre à des versions ultérieures de qubits transmon supraconducteurs, ou qubits de spin, qui ont généralement des temps d’opération dans le régime nanosecondes. Pour ces qubits, les opérations de porte et de mesure prennent respectivement 50 ns et 100 ns. Les taux d’erreur à un seul qubit et à deux qubits sont supposés être $10^{-3}$ comme un réaliste targetet $10^{-4}$ comme optimiste target pour un système mis à l’échelle.
"qubit_gate_us_e3" , "qubit_gate_us_e4" GATE_US_E3 , GATE_US_E4 Les durées d’opération et les fidélités peuvent correspondre à des versions ultérieures de qubits basés sur des ions, qui ont généralement des temps d’opération dans le régime de microsecondes. Sur la base d’hypothèses typiques pour les qubits d’ions, les opérations de porte et de mesure sont supposées prendre 100 μs. Le taux d’erreur pour les portes Clifford à qubit unique est de $10^{-3}$ en tant que réaliste target et de $10^{-4}$ en tant qu’optimiste target, tandis que le taux d’erreur pour les portes non Clifford à qubit unique (T gate) est $10^{-6}$. Pour les portes à deux qubits, le taux d’erreur est de $10^{-3}$ comme réaliste target et $10^{-4}$ comme optimiste target.
"qubit_maj_ns_e4" , "qubit_maj_ns_e6" MAJ_NS_E4 , MAJ_NS_E6 Les durées d’opération et les fidélités peuvent correspondre à de futures versions améliorées des qubits Majorana. Pour ces qubits, les opérations de porte et de mesure sont supposées prendre 100 ns. Pour prendre en compte la protection topologique dans le matériel, les taux d’erreur de mesure conjointe à un qubit et à deux qubits (taux d’erreur de Clifford) sont supposés être de $10^{-4}$ comme réaliste targetet de $10^{-6}$ comme optimiste target. Les opérations autres que Clifford dans cette architecture n’ont pas de protection topologique, le taux d’erreur pour les portes T physiques non Clifford est de 5 %.

Notes

Sauf si une autre valeur est spécifiée, la valeur par défaut du modèle qubit est "qubit_gate_ns_e3".

Pour référence, les paramètres de qubit prédéfinis complets sont les suivants :

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

Passage de paramètres de qubit prédéfinis

Il existe deux façons de spécifier par programmation des paramètres de qubit prédéfinis. Vous pouvez sélectionner le nom du modèle qubit pour la classe lors de l’exécution qubitParamsqsharp.estimatede . Par exemple, pour sélectionner "qubit_maj_ns_e6" le paramètre qubit, écrivez :

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

Vous pouvez également passer les paramètres de qubit à la classe à l’aide EstimatorParamsQubitParamsde . Par exemple, pour sélectionner MAJ_NS_E6 le paramètre qubit, écrivez :

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)

Personnaliser les paramètres de qubit prédéfinis

Vous pouvez personnaliser les paramètres de qubit prédéfinis en spécifiant le nom, puis en mettant à jour l’une des autres valeurs. Par exemple, pour réduire le taux d’erreur de la mesure conjointe à deux qubits dans « qubit_maj_ns_e4 », écrivez :

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

Vous pouvez également transmettre les instructions sous la forme d’une liste.

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

Paramètres de qubit pour les qubits basés sur la porte

Identificateur Python Type de données Description
name string Nom du modèle qubit
instruction_set « gate_based » Technologie de qubit sous-jacente
one_qubit_measurement_time chaîne de temps Durée d’opération pour la mesure d’un qubit ($t_{\rm meas}$) dans ns
one_qubit_gate_time chaîne de temps Durée d’opération de la porte à qubit unique ($t_{\rm gate}$) dans ns
two_qubit_gate_time chaîne de temps Durée d’opération de la porte à deux qubits dans ns
t_gate_time chaîne de temps Durée d’opération pour la porte non Clifford à qubit unique dans ns
one_qubit_measurement_error_rate float Taux d’erreur pour la mesure d’un qubit
one_qubit_gate_error_rate float Taux d’erreur pour la porte Clifford à qubit unique ($p$)
two_qubit_gate_error_rate float Taux d’erreur pour la porte Clifford à deux qubits
t_gate_error_rate float Taux d’erreur pour préparer un état non Clifford à qubit unique ($p_T$)
idle_error_rate float Taux d’erreur correspondant à la non-activité

Le code suivant montre comment spécifier des paramètres de qubit personnalisés pour un jeu d’instructions basé sur une porte :

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

Notes

Quand elles ne sont pas spécifiées, les valeurs par défaut de et de , les valeurs par défaut one_qubit_gate_error_ratede two_qubit_gate_error_rate et t_gate_error_rate de , et la valeur par défaut pour idle_error_rate les valeurs par défaut sont one_qubit_measurement_error_rate.t_gate_timetwo_qubit_gate_timeone_qubit_gate_time

Paramètres de qubit pour les qubits Majorana

Identificateur Python Type de données Description
name string Nom du modèle qubit
instruction_set « majorana » Technologie de qubit sous-jacente
one_qubit_measurement_time chaîne de temps Durée d’opération pour la mesure d’un qubit ($t_{\rm meas}$) dans ns
two-qubit_joint_measurement_time chaîne de temps Durée d’opération pour la mesure à deux qubits en ns
t_gate_time chaîne de temps Durée d’opération pour la porte non Clifford à qubit unique dans ns
one_qubit_measurement_error_rate float Taux d’erreur pour la mesure d’un qubit
two_qubit_joint_measurement_error_rate float Taux d’erreur pour la mesure à deux qubits
t_gate_error_rate float Taux d’erreur pour préparer l’état non Clifford d’un qubit unique ($p_T$)
idle_error_rate float Taux d’erreur correspondant à la idylage

Un modèle minimal pour le jeu d’instructions basé sur Majorana avec toutes les valeurs requises est :

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

Notes

Lorsqu’ils ne sont pas spécifiés, les valeurs pour two_qubitJointMeasurementTime et t_gate_time par défaut sur one_qubit_measurement_time, les valeurs pour two_qubit_joint_measurement_error_rate et t_gate_error_rate par défaut sur one_qubit_measurement_error_rate, et la valeur pour idle_error_rate les valeurs par défaut est one_qubit_measurement_error_rate.

Pour one_qubit_measurement_error_rate et two_qubit_joint_measurement_error_rate, vous pouvez spécifier les taux d’erreur correspondant aux lectures de mesure, readoutet le traitement des mesures, process. Ces valeurs peuvent être des <double> nombres ou des paires de nombres. Par exemple :

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

Notes

Si vous spécifiez une seule valeur numérique pour les taux d’erreur à un qubit et à deux qubits dans la mesure du qubit Majorana, les taux d’erreur de lecture et de traitement peuvent être égaux.

Important

Toutes les valeurs qui ne sont pas spécifiées prennent une valeur par défaut, par exemple, la spécification "qubit": {"oneQubitGateTime":"200 ns"} modélisera un qubit basé sur la porte dans lequel l’heure de la porte à deux qubits et l’heure de la porte à un qubit sont toutes deux de 200 ns. Pour les unités, vous devez spécifier des chaînes de temps, qui sont des nombres à virgule flottante double précision, suivis d’un espace et de l’unité de temps pour ces valeurs, lorsque les suffixes de temps possibles sont ns, µs (ou us), mset s.

Schémas de correction des erreurs quantiques

Pour exécuter des applications quantiques à l’échelle pratique, les opérations quantiques doivent avoir de faibles taux d’erreur. Ces taux targets d’erreur dépassent généralement les capacités des qubits physiques bruts. Pour surmonter cette limitation, la correction des erreurs quantiques (QEC) et le calcul à tolérance de panne sont deux techniques cruciales qui constituent les blocs de construction des ordinateurs quantiques à grande échelle. Tout d’abord, QEC nous permet de composer plusieurs qubits physiques sujets aux erreurs et de créer un qubit logique plus fiable qui conserve les informations quantiques mieux que les qubits physiques sous-jacents.

La distance du code de correction d’erreur (ou simplement la distance du code pour une courte durée) est un paramètre qui contrôle le nombre d’erreurs qui peuvent être corrigées. Ainsi, le taux d’erreur des qubits logiques et le nombre de qubits physiques requis pour les encoder. La précision et le nombre de qubits physiques augmentent avec la distance du code. L’objectif est de trouver la distance minimale du code qui peut atteindre le taux d’erreur défini pour une application particulière.

L’estimateur de ressources utilise la formule suivante pour modéliser les taux d’erreurs logiques à l’aide d’un modèle exponentiel,

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

où $d$ correspond à la distance du code, $p$ est le taux d’erreur physique et $p^*$ est le seuil de correction des erreurs quantiques. Le taux d’erreur physique $p$ est extrait des paramètres qubit comme le taux d’erreur du pire cas toute opération Clifford physique dans l’appareil.

En particulier, $p = {}$ max(one_qubit_measurement_error_rate, one_qubit_gate_error_rate, two_qubit_gate_error_rate) pour les paramètres qubit avec un jeu d’instructions basé sur une porte, et $p = {}$ max(one_qubit_measurement_error_rate, two_qubit_joint_measurement_error_rate) pour les paramètres qubit avec un jeu d’instructions Majorana. Les schémas QEC ont généralement un seuil de taux d’erreur $p^*$ en dessous duquel la correction d’erreur supprime les erreurs.

Protocole QEC Classe API Python Description
"surface_code" SURFACE_CODE Le code surface basé sur la porte est basé sur arXiv :1208.0928 et arXiv :1009.3686. Le code de surface Majorana est basé sur arXiv :1909.03002 et arXiv :2007.00307.
"floquet_code" FLOQUET_CODE Uniquement pour les qubits Majorana. Le code de la floquet est basé sur arXiv :2202.11829.

Notes

Sauf si une autre valeur est spécifiée, la valeur par défaut du schéma QEC est « surface_code ».

Les paramètres exacts pour chaque schéma QEC prédéfini (y compris un préfacteur croisé $a$, qui peut être extrait numériquement pour les simulations) sont les suivants.

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

Passage de schémas QEC prédéfinis

Il existe deux façons de spécifier des schémas QEC prédéfinis. Vous pouvez sélectionner le nom du modèle QEC pour la classe lors de l’exécution "qecScheme"qsharp.estimatede . Par exemple, pour sélectionner le code de floquet, écrivez :

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

Vous pouvez également passer une liste de paramètres d’estimation à la classe à l’aide EstimatorParams de la QECScheme classe . Par exemple, pour sélectionner le code de floquet, écrivez :

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)

Personnaliser des schémas QEC prédéfinis

Vous pouvez personnaliser des schémas QEC prédéfinis en spécifiant le nom, puis en mettant à jour l’une des autres valeurs. Par exemple, pour augmenter le facteur de pré-croisement dans le code de floquet, écrivez :

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

Notes

Lorsqu’ils ne sont pas spécifiés, les valeurs pour "logicalCycleTime" et par défaut sur "oneQubitMeasurementTime", la valeur par défaut est 0.01"errorCorrectionThreshold" , et la valeur pour "crossingPrefactor" les valeurs par défaut est 0.03"physicalQubitsPerLogicalQubit" .

Personnaliser vos schémas QEC

L’estimateur de ressources peut extraire un schéma QEC personnalisé basé sur la formule ci-dessus en fournissant des valeurs pour le "crossingPrefactor" $a$ et le "errorCorrectionThreshold" $p^*$. En outre, vous devez spécifier le "logicalCycleTime", c’est-à-dire le temps d’exécution d’une seule opération logique, qui dépend de la distance du code et des hypothèses de temps d’opération physique des qubits physiques sous-jacents. Enfin, une deuxième formule calcule le "physicalQubitsPerLogicalQubit", c’est-à-dire le nombre de qubits physiques requis pour encoder un qubit logique en fonction de la distance de code.

Vous pouvez utiliser le code suivant comme modèle pour les schémas QEC :

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

Dans les formules, vous pouvez utiliser les variables one_qubit_gate_time, two_qubit_gate_time, one_qubit_measurement_timeet two_qubit_joint_measurement_time, dont les valeurs sont extraites du champ correspondant des paramètres qubit physiques, ainsi que de la variable eccDistance pour la distance de code calculée pour le qubit logique, en fonction des propriétés physiques du qubit, du seuil de correction d’erreur et du préfacteur de croisement. Variables de temps et eccDistance peuvent être utilisés pour décrire la logicalCycleTime formule. Pour la formule physicalQubitsPerLogicalQubit , seul le eccDistance peut être utilisé.

Budget d’erreur

Le budget d’erreur total $\epsilon$ définit l’erreur globale tolérée pour l’algorithme, c’est-à-dire la probabilité d’échec autorisée de l’algorithme. Sa valeur globale doit être comprise entre 0 et 1, et la valeur par défaut est 0,001, ce qui correspond à 0,1 %. En d’autres termes, l’algorithme est autorisé à échouer un maximum d’une fois dans 1000 exécutions. Ce paramètre est très spécifique à l’application.

Par exemple, si vous exécutez l’algorithme de Shor pour factoriser des entiers, une valeur importante pour le budget d’erreur peut être tolérée, car on peut case activée que les sorties sont bien les facteurs principaux de l’entrée. En revanche, un budget d’erreur plus petit peut être nécessaire pour qu’un algorithme résolve un problème avec une solution, ce qui ne peut pas être vérifié efficacement.

Le budget d’erreur correspond à la somme de trois parties :

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

Si aucun autre paramètre n’est spécifié, le budget d’erreur $\epsilon$ est distribué uniformément et s’applique aux erreurs $\epsilon_{\log}$ pour implémenter des qubits logiques, le budget d’erreur $\epsilon_{\rm dis}$ produit des états T par distillation, et un budget d’erreur $\epsilon_{\rm syn}$ pour synthétiser les portes de rotation avec des angles arbitraires.

Notez que pour la distillation et la synthèse de rotation, les budgets d’erreur respectifs $\epsilon_{\rm dis}$ et $\epsilon_{\rm syn}$ sont répartis de manière uniforme entre tous les états T requis et toutes les portes de rotation requises, respectivement. S’il n’y a pas de portes de rotation dans l’algorithme d’entrée, le budget des erreurs est distribué uniformément aux erreurs logiques et aux erreurs d’état T.

Budget d’erreur de passage

Il existe deux façons de spécifier le budget d’erreur en définissant un nombre compris entre 0 et 1. Vous pouvez passer le budget d’erreur lors de l’exécution qsharp.estimatede . Par exemple, pour sélectionner un budget d’erreur de 1/3, écrivez :

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

Vous pouvez également passer les paramètres de budget d’erreur à la EstimatorParams classe .

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)

En outre, vous pouvez spécifier individuellement chaque composant du budget d’erreur. La somme de toutes les valeurs correspond au budget d’erreur total et doit être comprise entre 0 et 1. Si un algorithme quantique ne contient pas d’états T ni de rotations, les valeurs de t_states et rotations peuvent être respectivement 0.

Le code suivant montre comment spécifier le paramètre de budget d’erreur avec des états T et des rotations :

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

Contraintes

Vous pouvez utiliser la "constraints" classe pour appliquer des contraintes au niveau du composant de fabrique T . En ajustant les contraintes, vous pouvez optimiser les estimations afin de réduire le nombre de qubits ou de réduire le runtime.

Paramètre Type de données Description
logical_depth_factor float Contrôler le temps d’exécution. S’il a une valeur supérieure à 1, le nombre initial de cycles logiques, également appelé profondeur logique, est multiplié par ce nombre. En réduisant logical_depth_factor, vous pouvez augmenter le nombre d’appels de la fabrique T dans un temps donné, ce qui entraîne moins de copies de fabrique T nécessaires pour produire le même nombre d’états T. Lorsque vous réduisez le nombre de copies de fabrique T, le runtime de l’algorithme augmente en conséquence. Le facteur de mise à l’échelle du runtime total peut être plus important, car le taux d’erreur logique requis augmente en raison du nombre supplémentaire de cycles.
max_t_factories entier Nombre maximal de copies de fabrique T. L’estimateur de ressources détermine les ressources nécessaires en sélectionnant le nombre optimal de copies de fabrique T qui réduit le nombre de qubits physiques utilisés, sans tenir compte de la surcharge de temps. Le max_t_factories paramètre limite le nombre maximal de copies et ajuste donc le nombre de cycles logiques en conséquence. Pour plus d’informations, consultez Estimation physique de la fabrique T.
max_duration chaîne de temps Runtime maximal pour l’algorithme. L’estimateur de ressources n’accepte qu’une des max_duration contraintes ou max_physical_qubits à l’heure actuelle, mais pas deux. Si max_duration est spécifié, l’estimateur de ressources tente de trouver la meilleure estimation pour max_physical_qubits parmi les solutions limitées par le nombre maximal spécifié.
max_physical_qubits entier Nombre maximal de qubits physiques pour l’algorithme. L’estimateur de ressources n’accepte qu’une des max_duration contraintes ou max_physical_qubits à l’heure actuelle, mais pas deux. Si max_physical_qubits est spécifié, l’estimateur de ressources tente de trouver la meilleure estimation pour max_duration parmi les solutions limitées par le nombre maximal spécifié.

Le code suivant montre comment spécifier les contraintes pour un algorithme quantique :

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

Notes

Si la valeur fournie à max_duration ou max_physical_qubits est trop petite pour trouver une solution réalisable, l’estimateur de ressources retourne une erreur. Si ni les contraintes ne max_durationmax_physical_qubits sont spécifiées, l’estimateur de ressources vise à trouver une solution avec le temps le plus court.

Conseil

Vous pouvez utiliser max_duration et max_physical_qubits pour influencer l’espace de solution, en trouvant potentiellement des solutions avec un runtime plus long, mais un nombre de qubits plus faible que les solutions sans ces contraintes. Il existe un compromis entre le runtime et le nombre de qubits, et ce compromis peut être géré efficacement pour certains algorithmes, avec des effets variables sur différents algorithmes. Le tableau IV dans [arXiv :2211.07629] illustre l’utilisation effective du compromis entre le nombre de qubits et le runtime pour les algorithmes de dynamique quantique. Pour plus d’informations, consultez l’exemple d’estimation des ressources quantiques avec des contraintes de temps ou de nombre de qubits .

Unités de distillation

Vous pouvez fournir des spécifications pour les algorithmes de distillation des fabriques T avec la DistillationUnitSpecification classe . La spécification peut être prédéfinie ou personnalisée. Vous pouvez spécifier une spécification prédéfinie en sélectionnant le nom de l’unité de distillation : 15-1 RM ou 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)

Dans les deux cas, la notation 15-1 signifie 15 états T d’entrée et 1 état T de sortie. L’unité 15-1 space-efficient de distillation utilise moins de qubits que 15-1 RM mais nécessite plus d’exécution. Pour plus d’informations, consultez La table VI.

Conseil

L’utilisation d’unités de distillation prédéfinies offre de meilleures performances par rapport aux unités personnalisées.

Personnaliser vos unités de distillation

Vous pouvez personnaliser vos propres unités de distillation. Les paramètres exacts pour les unités de distillation sont les suivants.

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

Tous les paramètres numériques sont censés être positifs. spécifie displayName comment l’unité de distillation sera affichée dans les résultats de sortie.

Le code suivant montre comment spécifier les paramètres d’unité de distillation pour un algorithme quantique à l’aide de la DistillationUnitSpecification classe et de la ProtocolSpecificDistillationUnitSpecification classe .

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

Les formules pour failure_probability_formula et output_error_rate_formula sont des formules personnalisées avec des opérations arithmétiques de base, des constantes et seulement trois paramètres :

  • clifford_error_rate, également désigné comme c.
  • readout_error_rate, également désigné comme r.
  • input_error_rate, également désigné comme z.

Consultez les exemples suivants de formules personnalisées utilisant la notation longue et courte. Ces exemples illustrent les formules utilisées par défaut dans l’implémentation standard.

Paramètre Formule longue Formule courte
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 »

Au moins un des paramètres physical_qubit_specification ou logical_qubit_specification doit être fourni. Si seul le premier est fourni, l’unité de distillation peut être appliquée aux qubits physiques. Si seul ce dernier est fourni, l’unité de distillation peut être appliquée aux qubits logiques. Si les deux sont fournis, l’unité de distillation peut être appliquée aux deux types de qubits.

Le paramètre logical_qubit_specification_first_round_override ne peut être fourni que si logical_qubit_specification est spécifié. Si c’est le cas, elle remplace les valeurs de logical_qubit_specification in case si elle est appliquée au premier cycle de distillation. La valeur <protocol specific parameters> requise pour logical_qubit_specification_first_round_override doit suivre le schéma :

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

Estimation de la frontière pareto

Lors de l’estimation des ressources d’un algorithme, il est important de prendre en compte le compromis entre le nombre de qubits physiques et le runtime de l’algorithme. Vous pouvez envisager l’allocation d’autant de qubits physiques que possible pour réduire le runtime de l’algorithme. Toutefois, le nombre de qubits physiques est limité par le nombre de qubits physiques disponibles dans le matériel quantique. Comprendre le compromis entre l’exécution et la mise à l’échelle du système est l’un des aspects les plus importants de l’estimation des ressources.

L’estimation de la frontière de Pareto fournit plusieurs estimations pour le même algorithme, chacune montrant des compromis entre le nombre de qubits et le runtime.

Notes

Si vous exécutez l’estimateur de ressources dans Visual Studio Code à l’aide de l’option Q#: Calculer les estimations des ressources , l’estimation de la frontière pareto est activée par défaut.

Si vous exécutez l’estimateur de ressources dans Python, vous devez spécifier le "estimateType" paramètre en tant que "frontier".

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

Si vous souhaitez visualiser les résultats de l’estimation de la frontière pareto, vous pouvez utiliser la EstimatesOverview fonction . Cette fonction affiche les résultats de l’estimation de la frontière dans un tableau et un diagramme spatio-temporel. Pour plus d’informations, consultez Diagramme de l’espace-temps.

from qsharp_widgets import EstimatesOverview

EstimatesOverview(result)

Notes

Si vous rencontrez un problème lors de l’utilisation de l’estimateur de ressources, case activée la page Résolution des problèmes ou contactez AzureQuantumInfo@microsoft.com.

Étapes suivantes