Comment installer et exécuter les QDK simulateurs quantiques

Le Microsoft Quantum Development Kit (QDK) inclut un ensemble de simulateurs quantiques auxquels vous pouvez accéder à partir de l’extension Visual Studio Code (VS Code) et du QDKPython package. Ces simulateurs vous permettent de tester la façon dont vos programmes quantiques s’exécutent sur du matériel quantique réel. Cet article explique comment installer les simulateurs et comment exécuter des simulations de base dans Jupyter Notebook et VS Code.

Il QDK comprend quatre simulateurs quantiques :

  • Simulateur de parcimonie
  • Simulateur Clifford
  • Simulateur GPU
  • Simulateur de CPU

Pour plus d’informations sur les QDK simulateurs quantiques, consultez Vue d’ensemble des simulateurs quantiques dans le QDK.

Prerequisites

Pour suivre les étapes décrites dans cet article, vous devez installer les outils suivants :

Installer les simulateurs

Les quatre simulateurs sont disponibles dans le QDKpackage, mais seul le simulateur partiellement alloué est disponible dans l’extensionQDKVS Code.Python

Pour utiliser le simulateur sparse dans l’extension VS Code, installez l’extension QDK pour VS Code.

Pour utiliser les simulateurs quantiques dans Python et Jupyter Notebookinstaller la dernière version duPythonqdkpackage avec les jupyter éléments supplémentaires :

pip install --upgrade "qdk[jupyter]"

L’extra jupyter n’est pas nécessaire pour utiliser les simulateurs, mais installe le qdk.widgets module. Le module widgets vous permet de créer des visualisations à partir de vos résultats de simulation dans Jupyter Notebook.

Exécuter des simulations à l’aide de l’extension QDK pour VS Code

L’extension QDK pour VS Code n’offre que le simulateur sparse. Pour exécuter votre programme sur le simulateur sparse dans VS Code, ouvrez un programme Q# (.qs) ou OpenQASM (.qasm) dans VS Code et exécutez le fichier.

Par exemple, suivez ces étapes pour exécuter l’un des exemples de programmes Q# fournis avec l’extension QDK :

  1. Dans VS Code, ouvrez le menu Fichier et sélectionnez Nouveau fichier texte.
  2. Donnez au fichier un nom qui se termine par l’extension .qs .
  3. Dans le fichier vide, entrez l’exemple. Une liste d’exemples de code inclus s’ouvre.
  4. Choisissez un exemple de code, par exemple Bell Pair sample.
  5. Pour exécuter le programme sur le simulateur sparse, sélectionnez la commande Exécuter dans la lentille de code au-dessus de l’opération Main.

Le VS Code terminal affiche la sortie de la simulation.

Note

Vous pouvez ajouter des modèles de bruit limités aux simulations éparses des programmes Q# dans l’extension QDK . Pour plus d’informations, consultez Ajouter du bruit de Pauli au simulateur creux dans VS Code.

Exécuter des simulations à l’aide du QDKPython package

Le QDKPython package offre les quatre simulateurs. L’appel des simulateurs dépend du simulateur et de l’infrastructure de programmation quantique.

Appeler le simulateur partiellement alloué

Vous pouvez utiliser le simulateur sparse pour les programmes Q#, OpenQASM et Qiskit. Le tableau suivant montre comment appeler le simulateur partiellement alloué à partir du qdk package pour 10 captures dans chaque infrastructure de programmation quantique prise en charge.

Framework de programmation Python API Exemple d’appel
Q# qsharp.run qsharp.run("MyQsharpProgram()", shots=10)
OpenQASM openqasm.run openqasm.run(my_qasm_program, shots=10)
Qiskit qiskit.QSharpBackend QSharpBackend().run(my_qiskit_program, shots=10)

Note

Vous pouvez ajouter des modèles de bruit au simulateur sparse à l’aide du paramètre noise pour les programmes Q# et OpenQASM, mais vous ne pouvez pas ajouter de modèles de bruit pour les programmes Qiskit.

Par exemple, suivez ces étapes pour exécuter le programme Q# de paire Bell dans un Jupyter bloc-notes dans VS Code:

  1. Dans VS Code, ouvrez le menu Affichage et sélectionnez Palette de commandes.

  2. Entrez Créer : Nouveau Jupyter Notebook. Un fichier de notebook vide s’ouvre dans un nouvel onglet.

  3. Dans la première cellule, importez le qsharp module à partir du qdk package.

    from qdk import qsharp

  4. Dans une nouvelle cellule, utilisez la %%qsharp commande magique pour écrire le code Q#.

    %%qsharp

operation Main() : (Result, Result) {
    use (q1, q2) = (Qubit(), Qubit());
    PrepareBellPair(q1, q2);
    (MResetZ(q1), MResetZ(q2))
}

operation PrepareBellPair(q1 : Qubit, q2 : Qubit) : Unit {
    H(q1);
    CNOT(q1, q2);
}

  5. Créez une cellule. Pour exécuter le programme Q# sur le simulateur creux, appelez la fonction run du module qsharp et spécifiez le nombre d’exécutions.

    qsharp.run("Main()", shots=10)

Appeler le simulateur Clifford

Vous pouvez appeler le simulateur Clifford pour les programmes Q#, OpenQASM, Qiskit et QIR. Le tableau suivant montre comment appeler le simulateur Clifford à partir du qdk package pour 10 captures dans chaque infrastructure de programmation quantique prise en charge.

Framework de programmation Python API Exemple d’appel
Q# qsharp.run qsharp.run("MyQsharpProgram()", type='clifford', shots=10)
OpenQASM openqasm.run openqasm.run(my_qasm_program, type='clifford', shots=10)
Qiskit simulation.NeutralAtomBackend simulation.NeutralAtomBackend().run(my_qiskit_program, simulator_type='clifford', shots=10)
QIR simulation.NeutralAtomDevice simulation.NeutralAtomDevice().simulate(my_qir, type='clifford', shots=10)
QIR simulation.run_qir simulation.run_qir(my_qir, type='clifford', shots=10)

Note

Les API NeutralAtomDevice et NeutralAtomBackend sont spécifiquement destinées aux simulations sur des ordinateurs quantiques à atomes neutres. Pour plus d’informations, consultez vue d’ensemble du simulateur d’appareil atom neutre.

Par exemple, le code Python suivant crée un programme OpenQASM simple et exécute le programme sur le simulateur Clifford :

from qdk.openqasm import run

qasm_code = """
    include "stdgates.inc";
    qubit[2] q;
    reset q;
    h q[0];
    cx q[0], q[1];
    bit c = measure q[1];
    """

run(qasm_code, type='clifford', shots=10)

Appeler les simulateurs GPU et CPU

Vous pouvez utiliser les simulateurs GPU et CPU pour les programmes Qiskit et QIR. Le tableau suivant montre comment appeler le simulateur GPU à partir du qdk package pour 10 captures dans chacune des infrastructures de programmation quantique prises en charge. Pour appeler le simulateur de processeur, remplacez 'gpu' par 'cpu' dans les paramètres de type du simulateur.

Framework de programmation Python API Exemple d’appel
Qiskit simulation.NeutralAtomBackend simulation.NeutralAtomBackend().run(my_qiskit_program, simulator_type='gpu', shots=10)
QIR simulation.NeutralAtomDevice simulation.NeutralAtomDevice().simulate(my_qir, type='gpu', shots=10)
QIR simulation.run_qir simulation.run_qir(my_qir, type='gpu', shots=10)

Par exemple, le code Python suivant convertit un programme OpenQASM simple en QIR et exécute le QIR sur le simulateur GPU :

from qdk.openqasm import compile#, ProgramType
from qdk.simulation import run_qir

qasm_code = """
    include "stdgates.inc";
    qubit[2] q;
    reset q;
    h q[0];
    cx q[0], q[1];
    bit c = measure q[1];
    """

qir = compile(qasm_code)
run_qir(qir, type='gpu', shots=10)
  • Last updated on