Exécutez des simulations quantiques avec le QDKPython package

Le MicrosoftQuantum Development Kit package (QDK) Python inclut des simulateurs quantiques locaux que vous pouvez utiliser pour tester et développer des programmes quantiques. Cet article explique comment installer les simulateurs et exécuter les programmes Q#, OpenQASM, Qiskit et QIR dans Python ou Jupyter Notebook.

Le QDKPython package comprend quatre simulateurs principaux :

  • Simulateur de parcimonie
  • Simulateur de stabilisateur
  • GPU simulateur
  • CPU simulateur

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

Pour exécuter directement les programmes QDK ou QDK dans l’extension pour Visual Studio Code (VS Code), consultez OpenQASM.

Prerequisites

Pour suivre les exemples Jupyter Notebook de cet article, installez ces outils :

Installer les simulateurs

Pour utiliser les simulateurs quantiques dans Python et Jupyter Notebook, installez la dernière version du package qdkPython avec l’extra jupyter :

pip install --upgrade "qdk[jupyter]"

Les simulateurs ne nécessitent pas l’extra jupyter, mais l’extra ajoute le module qdk.widgets pour visualiser les résultats de simulation dans Jupyter Notebook.

Sélectionnez un simulateur en fonction du framework de programmation quantique et de l’API Python que vous utilisez.

Appeler le simulateur de parcimonie

Le simulateur sparse prend en charge les programmes Q#, OpenQASM et Qiskit. Ce tableau montre comment exécuter 10 exécutions avec le package qdk dans chaque framework.

Framework de programmation Python Interface de Programmation d'Applications (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

Le simulateur sparse prend en charge les modèles de bruit via le paramètre noise pour les programmes Q# et OpenQASM, mais pas pour les programmes Qiskit.

Par exemple, procédez comme suit pour exécuter le programme de paire Q# Bell dans un bloc-notes Jupyter dans VS Code :

  1. Dans VS Code, sélectionnez Afficher>Palette de commandes.

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

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

    from qdk import qsharp

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

    %%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 parcimonieux, appelez la fonction run du module qsharp et spécifiez le nombre d’exécutions.

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

Appeler le simulateur de stabilisateur

Le simulateur stabilisateur exécute efficacement les circuits de grande largeur dominés par Clifford. Le branchement stabilisateur prend également en charge un nombre limité d’opérations non-Clifford, telles que les portes $T$ et $T^\dagger$ et les rotations d’angle arbitraire Pauli. Étant donné que le nombre de branches peut croître de manière exponentielle avec le nombre d’opérations non-Clifford, utilisez un simulateur à état complet pour les circuits avec une évolution non-Clifford importante.

Le simulateur de stabilisateur prend en charge les programmes Q#, OpenQASM, Qiskit et QIR. Ce tableau montre comment effectuer 10 exécutions dans chaque framework.

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

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, ce Python code exécute un OpenQASM programme avec une porte non-Clifford $T$ sur le simulateur de stabilisateur :

from qdk.openqasm import run

qasm_code = """
include "stdgates.inc";
qubit[1] q;
bit[1] result;

h q[0];
t q[0];
h q[0];
result = measure q;
"""

run(qasm_code, type="stabilizer", shots=1000)

Note

Les valeurs "stabilizer" et "clifford" sélectionnent toutes deux le simulateur de stabilisateurs. L’API détermine si le paramètre est type ou simulator_type.

La porte $T$ crée des branches de stabilisateur. La mesure finale échantillonne l’interférence entre ces branches.

Appeler les simulateurs CPU et GPU

Les simulateurs GPU et CPU prennent en charge les programmes Qiskit et QIR Ce tableau montre comment exécuter 10 essais sur le simulateur GPU avec le package qdk dans chaque framework. Pour utiliser le CPU simulateur, remplacez gpu par cpu dans le paramètre de type du simulateur.

Framework de programmation Python Interface de Programmation d'Applications (API) Exemple d’appel
Qiskit qiskit.NeutralAtomBackend 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, ce Python code convertit un programme simple OpenQASM en QIR et exécute le QIR sur le simulateur GPU :

from qdk.openqasm import compile
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)
  • Dernière mise à jour :