Comment déboguer et tester votre code quantique

Les tests et le débogage sont tout aussi importants dans la programmation quantique que dans la programmation classique. Cet article explique comment déboguer et tester vos programmes quantiques avec Azure Quantum Development Kit (QDK) dans Visual Studio Code (VS Code) et Jupyter Notebook.

Déboguer votre code quantique

Le QDK fournit plusieurs outils pour déboguer votre code. Si vous écrivez Q# ou ouvrez des programmes OpenQASM dans VS Code, vous pouvez utiliser le débogueur VS Code pour définir des points d’arrêt dans vos programmes et analyser votre code. Le QDK fournit également un ensemble de fonctions de vidage que vous pouvez utiliser pour obtenir des informations à différents points de votre programme.

Comment utiliser le débogueur VS Code

Avec l’extension QDK dans VS Code, vous pouvez utiliser le débogueur pour parcourir votre code et dans chaque fonction ou opération, suivre les valeurs des variables locales et suivre les états quantiques des qubits.

L’exemple suivant montre comment utiliser le débogueur avec un programme Q#. Pour obtenir des informations complètes sur les débogueurs VS Code, consultez Débogage sur le site web VS Code.

Dans VS Code, créez et enregistrez un fichier .qs avec le code suivant :

import Std.Arrays.*;
import Std.Convert.*;

operation Main() : Result {
    use qubit = Qubit();
    H(qubit);
    let result = M(qubit);
    Reset(qubit);
    return result;
}

Sur la ligne 6, H(qubit)cliquez à gauche du numéro de ligne pour définir un point d’arrêt. Un cercle rouge apparaît.
Dans la barre latérale principale, choisissez l’icône du débogueur pour ouvrir le volet débogueur, puis sélectionnez Exécuter et Déboguer. La barre de contrôle du débogueur s’affiche.
Appuyez sur F5 pour démarrer le débogueur et passer au point d’arrêt. Dans le menu Variables du volet débogueur : développez la liste déroulante État Quantique pour voir que le qubit a été initialisé dans l’état $\ket{0}$.
Appuyez sur F11 pour passer à l’opération H . Le code source de l’opération H s’affiche. Notez que l’état quantique passe à une superposition à mesure que vous parcourez l’opération H .
Appuyez sur F10 pour passer au-dessus de l’opération M. Notez que l’état quantique est résolu en $\ket{0}$ ou $\ket{1}$ après la mesure. La result variable apparaît également sous Locals.
Appuyez de nouveau sur F10 pour sauter par-dessus l’opération Reset. Notez que l’état quantique est réinitialisé à $\ket{0}$.

Lorsque vous avez terminé d’explorer le débogueur, appuyez sur *Ctrl+ F5 pour quitter le débogueur.

Remarque

Le débogueur VS Code fonctionne uniquement avec les fichiers Q# (.qs) et les fichiers OpenQASM .qasm. Vous ne pouvez pas utiliser le débogueur VS Code sur Q# cellules dans un bloc-notes Jupyter.

Comment déboguer avec les fonctions de vidage de QDK

Le QDK fournit plusieurs Q# et fonctions Python qui enregistrent des informations sur l'état actuel de votre programme lorsque vous appelez ces fonctions. Utilisez les informations provenant de ces fonctions de vidage pour vérifier si votre programme se comporte comme prévu.

La Q#`DumpMachine` fonction

DumpMachine est une Q# fonction qui vous permet d'exporter des informations sur l’état actuel du système qubit sur la console pendant l'exécution de votre programme. DumpMachine n’arrête pas ou n’interrompt pas votre programme pendant l’exécution.

L’exemple suivant appelle DumpMachine à deux points dans un Q# programme et explore la sortie.

Dans VS Code, créez et enregistrez un fichier .qs avec le code suivant :

import Std.Diagnostics.*;

operation Main() : Unit {
    use qubits = Qubit[2];
    X(qubits[1]);
    H(qubits[1]);
    DumpMachine();

    R1Frac(1, 2, qubits[0]);
    R1Frac(1, 3, qubits[1]);
    DumpMachine();

    ResetAll(qubits);
}

Appuyez sur Ctrl+ Maj + Y pour ouvrir la console de débogage.

Appuyez sur Ctrl + F5 pour exécuter votre programme. La sortie DumpMachine suivante s’affiche dans la console de débogage :

Basis | Amplitude      | Probability | Phase
-----------------------------------------------
 |00⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
 |01⟩ | −0.7071+0.0000𝑖 |    50.0000% |  -3.1416

Basis | Amplitude      | Probability | Phase
-----------------------------------------------
 |00⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
 |01⟩ | −0.6533−0.2706𝑖 |    50.0000% |  -2.7489

La sortie de DumpMachine montre comment l’état des systèmes de qubits change après chaque ensemble de portes.

Remarque

La sortie de DumpMachine utilise l'ordre des octets big-endian.

La fonction Python `dump_machine`

La dump_machine fonction est une fonction du qsharp package Python. Cette fonction retourne le nombre actuel de qubits alloués et un dictionnaire qui contient les amplitudes d’état éparses du système qubit.

L’exemple suivant exécute le même programme que l’exemple précédent DumpMachine , mais dans un notebook Jupyter au lieu d’un .qs fichier.

Dans VS Code, appuyez sur Ctrl + Maj + P pour ouvrir la palette de commandes.
Entrez Créer : Nouveau bloc-notes Jupyter , puis appuyez sur Entrée. Un nouvel onglet Jupyter Notebook s’ouvre.
Dans la première cellule, copiez et exécutez le code suivant :
```
from qdk import qsharp 
```
Créez une cellule de code, puis copiez et exécutez le code suivant Q# :
```
%%qsharp

use qubits = Qubit[2];
X(qubits[0]);
H(qubits[1]);
```

Créez une nouvelle cellule de code. Copiez et exécutez le code Python suivant pour afficher l’état qubit à ce stade du programme :

dump = qsharp.dump_machine()
dump

La dump_machine fonction affiche la sortie suivante :

Basis State
(|𝜓₁…𝜓ₙ⟩)  Amplitude       Measurement Probability  Phase
|10⟩       0.7071+0.0000𝑖   50.0000%                 ↑  0.0000
|11⟩       0.7071+0.0000𝑖   50.0000%                 ↑  0.0000

Créez une cellule de code, puis copiez et exécutez le code suivant Q# :
```
%%qsharp

R1Frac(1, 2, qubits[0]);
R1Frac(1, 3, qubits[1]);
```

Créez une nouvelle cellule de code. Copiez et exécutez le code Python suivant pour afficher l’état qubit à ce stade du programme :

dump = qsharp.dump_machine()
dump

La dump_machine fonction affiche la sortie suivante :

Basis State
(|𝜓₁…𝜓ₙ⟩)  Amplitude      Measurement Probability  Phase
|10⟩       0.5000+0.5000𝑖  50.0000%                 ↗  0.7854
|11⟩       0.2706+0.6533𝑖  50.0000%                 ↗  1.1781

Pour imprimer une version dump_machine abrégée, créez une cellule et exécutez le code Python suivant :
```
print(dump)
```
Pour obtenir le nombre total de qubits dans le système, créez une cellule de code et exécutez le code Python suivant :
```
dump.qubit_count
```
Vous pouvez accéder aux amplitudes des états qubits individuels qui ont une amplitude différente de zéro. Par exemple, créez une cellule de code et exécutez le code Python suivant pour obtenir les amplitudes individuelles des états $\ket{10}$ et $\ket{11}$ :
```
print(dump[2])
print(dump[3])
```

La fonction `dump_operation`

La dump_operation fonction est une fonction du qsharp.utils package Python. Cette fonction prend deux entrées : une opération ou une définition d’opération Q# en tant que chaîne et le nombre de qubits utilisés dans l’opération. La sortie de dump_operation est une liste imbriquée qui représente la matrice carrée de nombres complexes correspondant à l'opération quantique donnée. Les valeurs de matrice sont dans la base de calcul, et chaque sous-liste représente une ligne de la matrice.

L’exemple suivant utilise dump_operation pour afficher des informations pour un système de 1 qubit et 2 qubits.

Dans VS Code, appuyez sur Ctrl + Maj + P pour ouvrir la palette de commandes.
Entrez Créer : Nouveau bloc-notes Jupyter , puis appuyez sur Entrée. Un nouvel onglet Jupyter Notebook s’ouvre.

Dans la première cellule, copiez et exécutez le code suivant :

from qdk import qsharp
from qsharp.utils import dump_operation

Pour afficher les éléments de matrice d’une porte à qubit unique, appelez dump_operation et passez 1 pour le nombre de qubits. Par exemple, copiez et exécutez le code Python suivant dans une nouvelle cellule de code pour obtenir les éléments de matrice d’une porte d’identité et une porte Hadamard :
```
res = dump_operation("qs => ()", 1)
print("Single-qubit identity gate:\n", res)
print()

res = dump_operation("qs => H(qs[0])", 1)
print("Single-qubit Hadamard gate:\n", res)
```
Vous pouvez également appeler la fonction qsharp.eval et ensuite référencer l'opération Q# dans dump_operation pour obtenir le même résultat. Par exemple, créez une cellule de code, puis copiez et exécutez le code Python suivant pour imprimer les éléments de matrice pour une porte Hadamard à qubit unique :
```
qsharp.eval("operation SingleH(qs : Qubit[]) : Unit { H(qs[0]) }")

res = dump_operation("SingleH", 1)
print("Single-qubit Hadamard gate:\n", res)
```
Pour afficher les éléments de matrice d’une porte à deux qubits, appelez dump_operation et passez 2 pour le nombre de qubits. Par exemple, copiez et exécutez le code Python suivant dans une nouvelle cellule de code pour obtenir les éléments de matrice d’une opération Ry contrôlée où le deuxième qubit est le target qubit :
```
qsharp.eval ("operation ControlRy(qs : Qubit[]) : Unit { Controlled Ry([qs[0]], (0.5, qs[1])); }")

res = dump_operation("ControlRy", 2)
print("Controlled Ry rotation gate:\n", res)
```

Pour plus d’exemples de test et de débogage de votre code, dump_operationconsultez les opérations de test à partir des exemples QDK.

Tester votre code quantique

Le QDK fournit plusieurs Q# fonctions et opérations que vous pouvez utiliser pour tester votre code lors de son exécution. Vous pouvez également écrire des tests unitaires pour les programmes Q#.

Expression `fail`

L’expression fail termine immédiatement votre programme. Pour incorporer des tests dans votre code, utilisez les fail expressions à l’intérieur d’instructions conditionnelles.

L’exemple suivant utilise une fail instruction pour tester qu’un tableau qubit contient exactement 3 qubits. Le programme se termine par un message d’erreur lorsque le test ne passe pas.

Dans VS Code, créez et enregistrez un fichier .qs avec le code suivant :

operation Main() : Unit {
    use qs = Qubit[6];
    let n_qubits = Length(qs);

    if n_qubits != 3 {
        fail $"The system should have 3 qubits, not {n_qubits}.";
    }  
}

Appuyez sur Ctrl + F5 pour exécuter le programme. Votre programme échoue et la sortie suivante s’affiche dans la console de débogage :
```
Error: program failed: The system should have 3 qubits, not 6.
```
Modifiez votre code de Qubit[6] à Qubit[3], enregistrez votre fichier, puis appuyez sur Ctrl + F5 pour réexécuter le programme. Le programme s’exécute sans erreur, car le test réussit.

La fonction `Fact`

Vous pouvez également utiliser la Q#Fact fonction à partir de l’espace Std.Diagnostics de noms pour tester votre code. La Fact fonction prend une expression booléenne et une chaîne de message d’erreur. Si l’expression booléenne a la valeur true, le test réussit et votre programme continue à s’exécuter. Si l’expression booléenne est false, Fact met fin à votre programme et affiche le message d’erreur.

Pour effectuer le même test de longueur de tableau dans votre code précédent, mais avec la fonction Fact, procédez comme suit :

Dans VS Code, créez et enregistrez un fichier .qs avec le code suivant :

import Std.Diagnostics.Fact;

operation Main() : Unit {
    use qs = Qubit[6];
    let n_qubits = Length(qs);

    Fact(n_qubits == 3,  $"The system should have 3 qubits, not {n_qubits}.")
}

Appuyez sur Ctrl + F5 pour exécuter le programme. La condition de test dans Fact n’est pas passée et le message d’erreur s’affiche dans la console de débogage.
Modifiez votre code de Qubit[6] à Qubit[3], enregistrez votre fichier, puis appuyez sur Ctrl + F5 pour réexécuter le programme. La condition de test dans Fact réussit et votre programme s’exécute sans erreur.

Écrire des Q# tests unitaires avec l’annotation `@Test()`

Dans Q# les programmes, vous pouvez appliquer l’annotation @Test() à un appelant (fonction ou opération) pour transformer l’appelant en test unitaire. Ces tests d’unités s’affichent dans le menu Test dans VS Code afin que vous puissiez tirer parti de cette fonctionnalité VS Code. Vous pouvez transformer un appelant en test unitaire uniquement lorsque l’appelant ne prend pas de paramètres d’entrée.

L’exemple suivant encapsule le code de test de longueur du tableau dans une opération et transforme cette opération en un test unitaire :

Dans VS Code, créez et enregistrez un fichier .qs avec le code suivant :
```
import Std.Diagnostics.Fact;

@Test()
operation TestCase() : Unit {
    use qs = Qubit[3];
    let n_qubits = Length(qs);

    Fact(n_qubits == 3, $"The system should have 3 qubits, not {n_qubits}.");
}
```
Annotation @Test() sur la ligne avant la définition de l’opération TestCase transforme l’opération en test unitaire VS Code. Une flèche verte apparaît sur la ligne de définition de l’opération.
Choisissez la flèche verte pour exécuter TestCase et rapporter les résultats des tests.
Pour interagir avec vos tests unitaires dans l’Explorateur de tests de VS Code, choisissez l’icône en forme de flacon de test dans la barre latérale principale.
Modifiez votre code à partir de Qubit[3] et Qubit[6] réexécutez le test unitaire pour voir comment les informations de test changent.

Vous pouvez écrire et exécuter Q# des tests unitaires dans VS Code sans opération de point d’entrée dans votre programme.

Remarque

Les appelables du namespace Std.Diagnostics ne sont pas compatibles avec QIR génération. Par conséquent, incluez uniquement des tests unitaires dans le code Q# que vous exécutez sur des simulateurs. Si vous souhaitez générer QIR à partir de votre Q# code, n’incluez pas de tests unitaires dans votre code.

Les opérations `CheckZero` et `CheckAllZero`

Les opérations CheckZero et CheckAllZeroQ# vérifient si l'état actuel d'un qubit ou array de qubits est $\ket{0}$. L’opération CheckZero prend un qubit unique et retourne true uniquement lorsque le qubit est dans l’état $\ket{0}$. Les CheckAllZero opérations prennent un tableau qubit et retournent true uniquement lorsque tous les qubits du tableau sont dans l’état $\ket{0}$. Pour utiliser CheckZero et CheckAllZero, importez-les à partir de l'espace de noms Std.Diagnostics.

L’exemple suivant utilise les deux opérations. Les CheckZero tests que l’opération X retourne le premier qubit de l’état $\ket{0}$ à l’état $\ket{1}$ et l’opération CheckAllZero teste que les deux qubits sont réinitialisés à l’état $\ket{0}$.

Dans VS Code, créez et enregistrez un nouveau .qs fichier avec le code suivant, puis exécutez le programme et examinez la sortie dans la console Debug.

import Std.Diagnostics.*;

operation Main() : Unit {
    use qs = Qubit[2];
    X(qs[0]); 

    if CheckZero(qs[0]) {
        Message("X operation failed");
    }
    else {
        Message("X operation succeeded");
    }

    ResetAll(qs);

    if CheckAllZero(qs) {
        Message("Reset operation succeeded");
    }
    else {
        Message("Reset operation failed");
    }
}

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2025-10-14

Partager via

Comment déboguer et tester votre code quantique

Déboguer votre code quantique

Comment utiliser le débogueur VS Code

Comment déboguer avec les fonctions de vidage de QDK

La Q#DumpMachine fonction

La fonction Python dump_machine

La fonction dump_operation

Tester votre code quantique

Expression fail

La fonction Fact

Écrire des Q# tests unitaires avec l’annotation @Test()

Les opérations CheckZero et CheckAllZero

Commentaires

Ressources supplémentaires

La Q#`DumpMachine` fonction

La fonction Python `dump_machine`

La fonction `dump_operation`

Expression `fail`

La fonction `Fact`

Écrire des Q# tests unitaires avec l’annotation `@Test()`

Les opérations `CheckZero` et `CheckAllZero`