Partager via

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

Cet article explique comment personnaliser les paramètres target de l'estimateur de ressources Azure Quantum pour qu'ils correspondent aux caractéristiques de la machine 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 cibles

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 :

  • Un modèle de qubit physique, qui définit les propriétés des qubits physiques sous-jacents.
  • Schéma QEC (Quantum Error Correction), qui est le schéma de correction d’erreur quantique supposé.
  • Un budget d’erreur, qui est l’erreur globale autorisée, c’est-à-dire, le nombre de fois où le programme est autorisé à échouer.
  • Contraintes au niveau du composant, qui sont le nombre de cycles logiques et le nombre de copies de la fabrique T.
  • Unités de distillation pour spécifier les algorithmes de distillation des usines T.
  • Estimation de la frontière de Pareto pour exécuter plusieurs estimations du nombre de qubits et du temps d'exécution pour le même algorithme.

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 de qubits transmon supraconducteurs, ou de qubits de spin, qui ont généralement des temps d'opération dans le régime nanoseconde. Pour ces qubits, les opérations de porte 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 target réaliste, et $10^{-4}$ comme target optimiste pour un système mis à l’échelle.
"qubit_gate_us_e3" , "qubit_gate_us_e4" GATE_US_E3 , GATE_US_E4 Les temps de fonctionnement et les fidélités peuvent correspondre aux futures versions de qubits basées sur les ions, qui ont généralement des temps de fonctionnement dans l'ordre de la microseconde. 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 (porte T) à un seul qubit est de $10^{{-6}}$. Pour les portes à deux qubits, le taux d'erreur est de $10^{{-3}}$ comme une estimation réaliste target et de $10^{{-4}}$ comme une estimation 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 porte 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 pour un seul qubit et pour deux qubits (taux d’erreur Clifford) sont supposés être de $10^{-4}$ comme target réaliste et de $10^{-6}$ comme target optimiste. 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 une autre valeur est spécifiée, la valeur par défaut pour le 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 qubitParams lors de l'exécution de qsharp.estimate. Par exemple, pour sélectionner le paramètre "qubit_maj_ns_e6" qubit, écrivez :

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

Vous pouvez également passer les paramètres qubit à la classe EstimatorParams en utilisant QubitParams. 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 des qubits basés sur des portes

Identificateur Python Type de données Description
name chaîne Nom du modèle qubit
instruction_set "gate_based" Technologie qubit sous-jacente
one_qubit_measurement_time chaîne d’heure Durée de l’opération pour la mesure à qubit unique ($t_{\rm meas}$) dans ns
one_qubit_gate_time chaîne temporelle Durée de l'opération pour le porte à qubit unique ($t_{\rm gate}$) en ns
two_qubit_gate_time chaîne horaire Temps d'opération de la porte à deux qubits en ns
t_gate_time chaîne horaire 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 à qubit unique
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 à deux qubits Clifford
t_gate_error_rate flotter Taux d’erreur pour préparer l’état non Clifford d’un seul qubit ($p_T$)
idle_error_rate flotter Taux d’erreur correspondant au ralenti

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_time, les valeurs pour two_qubit_gate_error_rate et t_gate_error_rate par défaut à one_qubit_gate_error_rate, et la valeur pour idle_error_rate par défaut à one_qubit_measurement_error_rate.

Paramètres Qubit pour les qubits Majorana

Identificateur Python Type de données Description
name chaîne Nom du modèle qubit
instruction_set "majorana" Technologie qubit sous-jacente
one_qubit_measurement_time chaîne d’heure Durée de l’opération pour la mesure à qubit unique ($t_{\rm meas}$) dans ns
two-qubit_joint_measurement_time chaîne d’heure Durée de l'opération de mesure des deux qubits en ns
t_gate_time chaîne temporelle Durée d’opération de la porte non-Clifford à qubit unique en nanosecondes
one_qubit_measurement_error_rate float Taux d’erreur pour la mesure à qubit unique
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 seul qubit ($p_T$)
idle_error_rate float Taux d’erreur correspondant à l'arrêt au ralenti

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

Lorsque les valeurs ne sont pas spécifiées, celles pour two_qubitJointMeasurementTime et t_gate_time prennent par défaut one_qubit_measurement_time, celles pour two_qubit_joint_measurement_error_rate et t_gate_error_rate prennent par défaut one_qubit_measurement_error_rate, et la valeur pour idle_error_rate prend 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, readout, et au 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)

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.

Importante

Toutes les valeurs qui ne sont pas spécifiées prennent une valeur par défaut. Par exemple, spécifier "qubit": {"oneQubitGateTime":"200 ns"} modélise un qubit basé sur une porte dans lequel le temps de la porte à deux qubits ainsi que le temps de la porte à 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), ms, et 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. Ces taux d’erreur targets 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 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 = ad^k\left(\frac{p}{p^*}\right)^{\frac{d+1}{2}} $$

où $a$ est un facteur de croisement, $d$ est la distance du code, $k$ est une puissance de coefficient de distance (généralement définie sur 0), $p$ est le taux d’erreur physique et $p^*$ est le seuil de correction d’erreur quantique. Le préfacteur de croisement $a$ peut être extrait 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 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 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.

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 une 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,
        "distanceCoefficientPower": 0,
        "logicalCycleTime": "(4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance",
        "physicalQubitsPerLogicalQubit": "2 * codeDistance * codeDistance"
    }
}

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

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

Tranmission 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 "qecScheme" lors de l’exécution 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 EstimatorParams en utilisant la classe QECScheme. 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 préfacteur de croisement dans le code Floquet, écrivez :

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

Remarque

Lorsqu'elles ne sont pas spécifiées, les valeurs de "logicalCycleTime" et "physicalQubitsPerLogicalQubit" prennent par défaut la valeur de "oneQubitMeasurementTime", la valeur de "errorCorrectionThreshold" prend par défaut 0.01, et la valeur de "crossingPrefactor" prend par défaut 0.03.

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 les "crossingPrefactor" $a$, les distanceCoefficientPower $k$ et les "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 de 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>,
                        "distanceCoefficientPower": <integer>,
                        "logicalCycleTime": <formula string>,
                        "physicalQubitsPerLogicalQubit": <formula string>
                    }
                })

À l’intérieur des formules, vous pouvez utiliser les variables one_qubit_gate_time, two_qubit_gate_time, one_qubit_measurement_time et two_qubit_joint_measurement_time, dont les valeurs sont extraites du champ correspondant des paramètres de qubit physique, ainsi que la variable eccDistance pour la distance de code calculée pour le qubit logique, basée sur les propriétés physiques du qubit, le seuil de correction d’erreur et le préfacteur de croisement. Les variables de temps et eccDistance peuvent être utilisées pour décrire la formule logicalCycleTime. Pour la formule physicalQubitsPerLogicalQubit, seules les eccDistance peuvent être utilisées.

Erreur budgetaire

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.

Transmission du 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 de 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 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 est le budget d’erreur total et doit être comprise entre 0 et 1. Si un algorithme quantique ne contient pas d'états T ou de rotations T, alors 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 classe "constraints" pour appliquer des contraintes au niveau du composant T factory. 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 flotter 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 l'usine T dans un temps donné, ce qui entraîne la nécessité de moins de copies de l'usine T pour produire le même nombre d’états T. Lorsque vous réduisez le nombre de copies de la fabrique T, le temps d’exécution de l’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 la 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 paramètre max_t_factories 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 d’heure Runtime maximal pour l’algorithme. L'estimateur de ressources n'accepte qu'une seule des contraintes max_duration ou max_physical_qubits à la fois, mais pas deux. S'il 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 seule contrainte parmi max_duration ou max_physical_qubits à la fois, 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 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 à max_duration ou max_physical_qubits est trop petite pour trouver une solution réalisable, l'estimateur de ressources retourne une erreur. Si aucune contrainte max_duration ni max_physical_qubits n'est spécifiée, l'estimateur de ressources vise à trouver une solution avec le délai le plus court.

Conseil

Vous pouvez utiliser max_duration et max_physical_qubits pour influencer l’espace de solution et potentiellement trouver des solutions avec un temps d'exécution plus long, mais un nombre de qubits plus petit 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. Le tableau IV dans [arXiv :2211.07629] illustre l’utilisation efficace du compromis entre le nombre de qubits et le temps d'exécution pour les algorithmes de dynamique quantique. Pour plus d’informations, consultez l’exemple d’estimation des ressources quantique 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 classe DistillationUnitSpecification. 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 temps d'exécution. Pour plus d’informations, consultez 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. Le displayName spécifie comment l’unité de distillation s'affichera dans les résultats de sortie.

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

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 désigné sous le nom de r.
  • input_error_rate, également désigné sous le nom de 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 * taux_d'erreur_d'entrée + 356,0 * taux_d'erreur_de_Clifford » « 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 le 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, il remplace les valeurs de logical_qubit_specification en 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 paramètre "estimateType" comme étant "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 fonction EstimatesOverview. 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 schéma 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 de dépannage ou contactez AzureQuantumInfo@microsoft.com.

Étapes suivantes