Partager via

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 correspondent aux caractéristiques de l’ordinateur que vous ciblez. 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.

Remarque

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

Prérequis

Paramètres Target

L’estimateur de ressources calcule l’estimation des ressources, telles que le nombre de qubits et le temps d’exécution, qui seraient nécessaires pour implémenter un algorithme quantique donné à l’aide d’une technologie 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 :

Conseil

Si vous connaissez déjà des estimations précalculées pour une opération, vous pouvez également les incorporer et optimiser l’exécution de l’estimateur de ressources. Pour plus d’informations, consultez Comment utiliser des estimations connues avec l’estimateur de ressources.

Paramètres 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 exploiter 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 aux futures versions des qubits transmon transmon, ou spin qubits, qui ont généralement des temps d’opération dans le régime nanoseconde. Pour ces qubits, les opérations de contrôle et de mesure sont supposées prendre respectivement 50 ns et 100 ns. Les taux d’erreur de porte à qubit unique et à deux qubits sont supposés être de $10^{-3}$ comme réalistes target, et $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 temps d’opération et les fidélités peuvent correspondre aux futures versions de qubits basées sur les ions, qui ont généralement des temps d’opération dans le régime de microsecondes. Selon des hypothèses typiques pour les qubits d’ion, 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 $10^{-3}$ comme réaliste target et $10^{-4}$ comme optimiste target, tandis que le taux d’erreur pour les portes non-Clifford (T gate) à un seul qubit est de 10^{-6}$. Pour les portes à deux qubits, le taux d’erreur est de $10^{-3}$ en tant que réaliste target et $10^{-4}$ comme optimiste target.
"qubit_maj_ns_e4" , "qubit_maj_ns_e6" MAJ_NS_E4 , MAJ_NS_E6 Les temps d’opération et les fidélités peuvent correspondre aux futures versions améliorées des qubits Majorana. Pour ces qubits, les opérations de contrôle et de mesure sont supposées prendre 100 ns. Pour tenir compte de la protection topologique dans le matériel, les taux d’erreur de mesure conjointe à qubit unique et à deux qubits (taux d’erreur Clifford) sont supposés être de 10 $^{-4}$ comme réalistes target, et $10^{-6}$ comme optimiste target. Les opérations non-Clifford dans cette architecture n’ont pas de protection topologique, le taux d’erreur pour les portes physiques non-Clifford est de 5 %.

Remarque

Sauf si d’autres valeurs sont spécifiées, la valeur par défaut du modèle qubit est "qubit_gate_ns_e3".

Paramètres des paramètres qubit prédéfinis

Pour référence, les paramètres 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 qubit prédéfinis

Il existe deux façons de spécifier par programmation des paramètres qubit prédéfinis. Vous pouvez sélectionner le nom du modèle qubit pour la classe lors de l’exécution qubitParams qsharp.estimate. 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 qubit à la classe à l’aide QubitParamsEstimatorParams de . 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 qubit prédéfinis

Vous pouvez personnaliser les paramètres 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 Qubit pour les qubits basés sur gate

Identificateur Python Type de données Description
name string Nom du modèle qubit
instruction_set « gate_based » Technologie qubit sous-jacente
one_qubit_measurement_time chaîne de temps Durée de l’opération pour la mesure à qubit unique ($t_{\rm meas}$) dans ns
one_qubit_gate_time chaîne de temps Heure de l’opération pour 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 virgule flottante Taux d’erreur pour la mesure à qubit unique
one_qubit_gate_error_rate virgule flottante Taux d’erreur pour la porte Clifford à qubit unique ($p$)
two_qubit_gate_error_rate virgule flottante Taux d’erreur pour la porte à deux qubits Clifford
t_gate_error_rate virgule flottante Taux d’erreur pour préparer l’état non-Clifford à un seul qubit ($p_T$)
idle_error_rate virgule flottante Taux d’erreur correspondant à l’idling

Le code suivant montre comment spécifier des paramètres 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

Remarque

Lorsqu’elles ne sont pas spécifiées, les valeurs pour two_qubit_gate_time et t_gate_time par défaut , one_qubit_gate_timeles valeurs pour two_qubit_gate_error_rate et t_gate_error_rate par défaut one_qubit_gate_error_rate, et la valeur par défaut pour idle_error_rate les valeurs par défaut .one_qubit_measurement_error_rate

Paramètres Qubit pour les qubits Majorana

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

Un modèle minimal pour l’ensemble d’instructions basées 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

Remarque

Lorsqu’elles ne sont pas spécifiées, les valeurs pour two_qubitJointMeasurementTime et t_gate_time par défaut , one_qubit_measurement_timeles valeurs pour two_qubit_joint_measurement_error_rate et t_gate_error_rate par défaut one_qubit_measurement_error_rate, et la valeur par défaut pour idle_error_rate les valeurs par défaut .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 <double> des nombres ou des paires de nombres. Par exemple :

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

Remarque

Si vous spécifiez une valeur numérique unique pour les taux d’erreur à qubit unique et à deux qubits dans la mesure Majorana qubit, 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élise un qubit basé sur une porte dans laquelle le temps de la porte à deux qubits et l’heure de la porte d’un qubit sont 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, où 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 des taux d’erreur faibles. Ce taux targets d’erreur dépasse généralement les fonctionnalité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 forment 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 préserve les informations quantiques mieux que les qubits physiques sous-jacents.

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

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

où $a$ est un facteur de passage, $d$ est la distance du code, $p$ est le taux d’erreur physique et $p^*$ est le seuil de correction d’erreur quantique. La $a$ de croisement peut être extraite numériquement pour les simulations.

La distance de code $d$ est un paramètre qui contrôle le nombre d’erreurs qui peuvent être corrigées. Ainsi, la distance de code définit 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 de code. L’objectif d’un schéma QEC est de trouver la distance de code minimale qui peut atteindre le jeu de taux d’erreur requis pour une application particulière.

Le taux d’erreur physique $p$ est extrait des paramètres qubits en tant que taux d’erreur du pire cas de toute opération physique de Clifford effectuée sur 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 la 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.

L’estimateur de ressources Azure Quantum prend en charge deux schémas QEC prédéfinis : un code surface et un code de floquet.

Protocole QEC Classe d’API Python Description
« surface_code » SURFACE_CODE Le code de 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 floquet est basé sur arXiv :2202.11829.

Remarque

Sauf si d’autres valeurs sont spécifiées, la valeur par défaut du schéma QEC est « surface_code ».

Paramètres des schémas QEC prédéfinis

Les paramètres exacts pour chaque schéma QEC prédéfini 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.estimate. Par exemple, pour sélectionner le code de floquet, écrivez :

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

Vous pouvez également transmettre 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 passage en préfacteur dans le code de floquet, écrivez :

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

Remarque

Lorsqu’elles ne sont pas spécifiées, les valeurs par "logicalCycleTime" défaut et "physicalQubitsPerLogicalQubit" la valeur par défaut "oneQubitMeasurementTime", la valeur par "errorCorrectionThreshold" défaut et la valeur par "crossingPrefactor" défaut sur 0.03.0.01

Personnaliser vos schémas QEC

L’estimateur de ressource 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"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"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>
                    }
                })

À l’intérieur des formules, vous pouvez utiliser les variables , , et two_qubit_joint_measurement_time, dont les valeurs sont extraites du champ correspondant des paramètres physiques du qubit, ainsi que 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 one_qubit_measurement_timepassage. two_qubit_gate_timeone_qubit_gate_time Les variables de temps et eccDistance peuvent être utilisées pour décrire la logicalCycleTime formule. Pour la formule, vous ne pouvez utiliser que la eccDistance formulephysicalQubitsPerLogicalQubit.

Budget d’erreur

Le budget d’erreur total $\epsilon$ définit l’erreur globale tolérée pour l’algorithme, autrement dit 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 au maximum une fois dans 1 000 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 vous pouvez vérifier que les sorties sont en effet les principaux facteurs 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} $$

Les erreurs logiques $\epsilon_{\log}$ sont l’erreur d’implémentation de qubits logiques, l’erreur d’état T $\epsilon_{\rm dis}$ est l’erreur de production d’états T via la fragmentation, et l’erreur de porte de rotation $\epsilon_{\rm syn}$ est l’erreur de synthèse des portes de rotation avec des angles arbitraires.

Remarque

Sauf si d’autres valeurs sont spécifiées, le budget d’erreur $\epsilon$ est uniformément distribué entre l’erreur logique, l’erreur d’état T et l’erreur de porte de rotation.

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

Passage d’un budget d’erreur

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

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

Vous pouvez également transmettre 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 est le budget d’erreur total et doit être comprise entre 0 et 1. Si un algorithme quantique ne contient pas d’états ou de rotations T, les valeurs et t_states 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 virgule flottante Contrôlez 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 d’algorithme augmente en conséquence. Le facteur de mise à l’échelle du runtime total peut être plus grand, 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 requises 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 temporelle. 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 L’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 ou plusieurs max_duration max_physical_qubits contraintes au moment de l’exécution, mais pas deux. S’il max_duration est spécifié, l’estimateur de ressources tente de trouver la meilleure estimation pour max_physical_qubits 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 ou plusieurs max_duration max_physical_qubits contraintes au moment de l’exécution, mais pas deux. S’il max_physical_qubits est spécifié, l’estimateur de ressources tente de trouver la meilleure estimation pour max_duration les solutions limitées par le nombre maximal spécifié.

Le code suivant montre comment spécifier les contraintes d’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

Remarque

Si la valeur fournie ou max_duration max_physical_qubits est trop petite pour trouver une solution réalisable, l’estimateur de ressources retourne une erreur. Si aucune contrainte n’est max_duration max_physical_qubits spécifiée, l’estimateur de ressources vise à trouver une solution avec le plus court délai.

Conseil

Vous pouvez utiliser max_duration et max_physical_qubits influencer l’espace de solution, potentiellement trouver des solutions avec un runtime plus long, mais un plus petit nombre de qubits par rapport aux 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. La table IV dans [arXiv :2211.07629] illustre l’utilisation efficace du compromis entre le nombre de qubits et le runtime pour les algorithmes de dynamique quantique. Pour plus d’informations, consultez l’estimation des ressources Quantum avec l’exemple de contraintes de temps ou de nombre de contraintes 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 représente 15 états T d’entrée et 1 état T de sortie. L’unité de distillation 15-1 space-efficient utilise moins de qubits que 15-1 RM mais nécessite plus de runtime. Pour plus d’informations, consultez le Tableau VI.

Conseil

L’utilisation d’unités de distillation prédéfinies offre de meilleures performances en comparaison avec celles personnalisées.

Personnaliser vos unités de distillation

Vous pouvez personnaliser vos propres unités de distillation. Les paramètres exacts des 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 la façon dont 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 classe et de laProtocolSpecificDistillationUnitSpecification classe.DistillationUnitSpecification

from qsharp.estimator import EstimatorParams, DistillationUnitSpecification, ProtocolSpecificDistillationUnitSpecification

params = EstimatorParams()
unit = DistillationUnitSpecification()
unit.display_name = "T"
unit.failure_probability_formula = "c"
unit.output_error_rate_formula = "r"
unit.num_input_ts = 1
unit.num_output_ts = 2

physical_qubit_specification = ProtocolSpecificDistillationUnitSpecification()
physical_qubit_specification.num_unit_qubits = 1
physical_qubit_specification.duration_in_qubit_cycle_time = 2
unit.physical_qubit_specification = physical_qubit_specification

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 indiqué comme c.
  • readout_error_rate, également indiqué comme r.
  • input_error_rate, également indiqué comme z.

Consultez les exemples suivants de formules personnalisées utilisant une 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 l’ancien est fourni, l’unité de distillation peut être appliquée à des 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 s’il logical_qubit_specification est spécifié. Si c’est le cas, il remplace les valeurs en logical_qubit_specification cas d’application au premier tour de la 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 d’allouer 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 Pareto fournit plusieurs estimations pour le même algorithme, chacune affichant des compromis entre le nombre de qubits et le runtime.

Remarque

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 en 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 des frontières dans la table et un diagramme espace-temps. Pour plus d’informations, consultez le diagramme espace-temps.

from qsharp_widgets import EstimatesOverview

EstimatesOverview(result)

Remarque

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

Étapes suivantes