Exercice – Bien démarrer avec l’estimateur de ressources Azure Quantum

8 minutes

C’est l’heure de s’entraîner avec l’estimateur de ressources Azure Quantum. Dans l’exemple suivant, vous estimez les ressources physiques de l’exemple d’algorithme de Shor.

Installer qsharp et qsharp-widgets

Tout d’abord, installez les derniers packages Azure Quantum qsharp et qsharp-widgets.

python -m pip install --upgrade qsharp qsharp-widgets

Créer l’algorithme quantique

Dans Visual Studio Code, sélectionnez Affichage > Palette de commandes, puis sélectionnez Créer : Notebook Jupyter.
Dans la première cellule du bloc-notes, importez le package qsharp :
```
import qsharp
from qsharp_widgets import EstimateDetails
```

Ajoutez une nouvelle cellule, puis copiez le code suivant :

%%qsharp
/// # Sample
/// Random Bit
///
/// # Description
/// This Q# program generates a random bit by setting a qubit in a superposition
/// of the computational basis states |0〉 and |1〉, and returning the measurement
/// result.

    operation RandomBit() : Result {
        // Qubits are only accesible for the duration of the scope where they
        // are allocated and are automatically released at the end of the scope.
        use qubit = Qubit();

        // Set the qubit in superposition by applying a Hadamard transformation.
        H(qubit);

        // Measure the qubit. There is a 50% probability of measuring either 
        // `Zero` or `One`.
        let result = M(qubit);

        // Reset the qubit so it can be safely released.
        Reset(qubit);
        return result;
    }

Estimer l’algorithme quantique

À présent, estimez les ressources physiques de l’opération RandomBit à l’aide des hypothèses par défaut. Ajoutez une nouvelle cellule, puis copiez le code suivant :
```
result = qsharp.estimate("RandomBit()")
result
```
La fonction qsharp.estimate crée un objet de résultat, qui permet d’afficher un tableau avec le nombre global de ressources physiques. Le premier tableau présente les principales estimations des ressources physiques. L’opération RandomBit nécessite 300 qubits et prend 2 microsecondes pour s’exécuter sur un ordinateur Quantum.

Estimations de ressources physiques Valeur

Runtime 2 microsecondes

rQOPS 3,00 M

Qubits physiques 300

Estimations de ressources physiques	Valeur
Runtime	2 microsecondes
rQOPS	3,00 M
Qubits physiques	300

Vous pouvez examiner les détails des coûts en réduisant les groupes, qui ont plus d’informations. Par exemple, réduisez le groupe Paramètres des qubits logiques pour voir que la distance de code est de 5, et que le nombre de qubits physiques par qubit logique est de 50.

Paramètre des qubits logiques	Valeur
Schéma QEC	surface_code
Distance du code	5
Qubits physiques	50
Durée de cycle logique	2 microsecondes
Taux d’erreur des qubits logiques	3,00E-5
Préfacteur de croisement	0,03
Seuil de correction d’erreurs	0,01
Formule de durée de cycle logique	(4 * `twoQubitGateTime` + 2 * `oneQubitMeasurementTime`) * `codeDistance`
Formule des qubits physiques	2 * `codeDistance` * `codeDistance`

Vous pouvez utiliser le champ jobParams pour accéder à tous les paramètres cibles qui peuvent être passés à l’exécution du travail et voir quelles valeurs par défaut ont été supposées :

result['jobParams']

{'errorBudget': 0.001,
 'qecScheme': {'crossingPrefactor': 0.03,
  'errorCorrectionThreshold': 0.01,
  'logicalCycleTime': '(4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance',
  'name': 'surface_code',
  'physicalQubitsPerLogicalQubit': '2 * codeDistance * codeDistance'},
 'qubitParams': {'instructionSet': 'GateBased',
  'name': 'qubit_gate_ns_e3',
  'oneQubitGateErrorRate': 0.001,
  'oneQubitGateTime': '50 ns',
  'oneQubitMeasurementErrorRate': 0.001,
  'oneQubitMeasurementTime': '100 ns',
  'tGateErrorRate': 0.001,
  'tGateTime': '50 ns',
  'twoQubitGateErrorRate': 0.001,
  'twoQubitGateTime': '50 ns'}}

Vous pouvez voir que l’estimateur de ressources prend le modèle qubit qubit_gate_ns_e3, le code de correction d’erreur surface_code et le budget d’erreur 0,001 comme valeurs par défaut pour l’estimation.

Modifier les valeurs par défaut et estimer l’algorithme

Lorsque vous soumettez une requête d'estimation des ressources pour votre programme, vous pouvez spécifier certains paramètres facultatifs. Voici les paramètres cibles que vous pouvez personnaliser :

errorBudget: l’erreur globale de budget autorisée pour l’algorithme
qecScheme: le schéma de correction des erreurs Quantum (QEC)
qubitParams: les paramètres qubit physiques
constraints: les contraintes au niveau du composant
distillationUnitSpecifications: les spécifications des algorithmes de distillation pour les fabriques T
estimateType: unique ou frontière

Modifier le modèle de qubit

Vous pouvez estimer le coût pour le même algorithme à l’aide du paramètre qubit basé sur Majorana, qubitParams, qubit_maj_ns_e6.

result_maj = qsharp.estimate("RandomBit()", params={
                "qubitParams": {
                    "name": "qubit_maj_ns_e6"
                }})
EstimateDetails(result_maj)

Modifier le schéma de correction des erreurs quantiques

Vous pouvez réexécuter le travail d’estimation des ressources pour le même exemple sur les paramètres qubit basés sur Majorana avec un schéma QEC floqué, qecScheme.

result_maj = qsharp.estimate("RandomBit()", params={
                "qubitParams": {
                    "name": "qubit_maj_ns_e6"
                },
                "qecScheme": {
                    "name": "floquet_code"
                }})
EstimateDetails(result_maj)

Modifier le budget d’erreur

Ensuite, réexécutez le même circuit quantique avec une errorBudget de 10 %.

result_maj = qsharp.estimate("RandomBit()", params={
                "qubitParams": {
                    "name": "qubit_maj_ns_e6"
                },
                "qecScheme": {
                    "name": "floquet_code"
                },
                "errorBudget": 0.1})
EstimateDetails(result_maj)