Installieren und Ausführen der QDK Quantensimulatoren

Die Microsoft Quantum Development Kit (QDK) enthält eine Reihe von Quantensimulatoren, auf die Sie über die Erweiterung Visual Studio Code (VS Code) und die Bibliothek QDKPython zugreifen können. Mit diesen Simulatoren können Sie testen, wie Ihre Quantenprogramme auf realer Quantenhardware ausgeführt werden. In diesem Artikel wird erläutert, wie Sie die Simulatoren installieren und grundlegende Simulationen in Jupyter Notebook und VS Code ausführen.

Dazu QDK gehören vier Quantensimulatoren:

  • Sparse-Simulator
  • Clifford-Simulator
  • GPU-Simulator
  • CPU-Simulator

Weitere Informationen zu den QDK Quantensimulatoren finden Sie in der QDKÜbersicht über Quantensimulatoren.

Voraussetzungen

Um die Schritte in diesem Artikel auszuführen, müssen Sie die folgenden Tools installieren:

Installieren der Simulatoren

Alle vier Simulatoren sind in der Bibliothek QDKPython verfügbar, aber nur der Sparsesimulator ist in der Erweiterung QDKVS Code verfügbar.

Um den Sparse-Simulator in der Erweiterung VS Code zu verwenden, installieren Sie die Erweiterung QDK für VS Code.

Um die Quantensimulatoren in Python und Jupyter Notebook zu verwenden, installieren Sie die neueste Version der qdkPython-Bibliothek mit der zusätzlichen jupyter:

pip install --upgrade "qdk[jupyter]"

Das jupyter Zusatz ist nicht erforderlich, um die Simulatoren zu nutzen, installiert allerdings das qdk.widgets Modul. Mit dem modul widgets können Sie Visualisierungen aus Ihren Simulationsergebnissen in Jupyter Notebook erstellen.

Ausführen von Simulationen mit der QDK Erweiterung für VS Code

Die QDK Erweiterung für VS Code bietet nur den spärlichen Simulator. Um Ihr Programm im Sparse-Simulator in VS Code auszuführen, öffnen Sie ein Q#- (.qs) oder OpenQASM-Programm (.qasm) in VS Code und führen Sie die Datei aus.

Führen Sie beispielsweise die folgenden Schritte aus, um eines der Q#-Beispielprogramme auszuführen, die mit der QDK Erweiterung enthalten sind:

  1. VS CodeÖffnen Sie im Menü "Datei" das Menü "Datei", und wählen Sie "Neue Textdatei" aus.
  2. Geben Sie der Datei einen Namen, der mit der .qs Erweiterung endet.
  3. Geben Sie in der leeren Datei Beispiel ein. Eine Liste der enthaltenen Codebeispiele wird geöffnet.
  4. Wählen Sie ein Codebeispiel aus, z. B. ein Bell Pair-Beispiel.
  5. Um das Programm im Sparse-Simulator auszuführen, wählen Sie den Befehl Ausführen aus der CodeLens oberhalb des Main-Vorgangs aus.

VS Code Das Terminal zeigt die Ausgabe der Simulation an.

Note

Sie können eingeschränkte Rauschmodelle zu geringen Simulationen von Q#-Programmen in der QDK Erweiterung hinzufügen. Weitere Informationen finden Sie unter Hinzufügen von Pauli-Rauschen zum sparsamen Simulator in VS Code.

Ausführen von Simulationen mithilfe der Bibliothek QDKPython

Die Bibliothek QDKPython bietet alle vier Simulatoren. Wie man die Simulatoren aufruft, hängt vom Simulator und vom Quantenprogrammierungsframework ab.

Rufen Sie den Sparse-Simulator auf

Sie können den sparse Simulator für Q#-, OpenQASM- und Qiskit-Programme aufrufen. In der folgenden Tabelle wird gezeigt, wie Sie den sparse Simulator aus der qdk Bibliothek für 10 Aufnahmen in jedem unterstützten Quantenprogrammierungsframework aufrufen.

Programmier-Framework Python API Beispielanruf
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

Sie können dem sparsamen Simulator Rauschmodelle mit dem noise Parameter für Q#- und OpenQASM-Programme hinzufügen, aber Sie können keine Rauschmodelle für Qiskit-Programme hinzufügen.

Führen Sie beispielsweise die folgenden Schritte aus, um das Q#-Programm „Bell-Paar“ in einem Jupyter-Notebook in VS Code auszuführen:

  1. Öffnen Sie in VS Code das Menü Ansicht und wählen Sie Befehlspalette aus.

  2. Geben Sie "Erstellen: Neu" Jupyter Notebookein. Eine leere Notizbuchdatei wird auf einer neuen Registerkarte geöffnet.

  3. Importieren Sie in der ersten Zelle das qsharp Modul aus der qdk Bibliothek.

    from qdk import qsharp

  4. Verwenden Sie in einer neuen Zelle den %%qsharp magischen Befehl, um den Q#-Code zu schreiben.

    %%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. Erstellen einer neuen Zelle. Rufen Sie die Funktion run aus dem qsharp-Modul auf, um das Q#-Programm auf dem Sparse-Simulator auszuführen, und geben Sie die Anzahl der Ausführungen an.

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

Clifford-Simulator aufrufen

Sie können den Clifford Simulator für Q#-, OpenQASM-, Qiskit- und QIR-Programme aufrufen. In der folgenden Tabelle wird gezeigt, wie Sie den Clifford-Simulator aus der qdk Bibliothek für 10 Aufnahmen in jedem unterstützten Quantenprogrammierungsframework aufrufen.

Programmier-Framework Python API Beispielanruf
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

Die APIs NeutralAtomDevice und NeutralAtomBackend sind speziell für Simulationen auf Quantencomputern mit neutralen Atomen gedacht. Weitere Informationen finden Sie unter Übersicht über den Neutralatom-Gerätesimulator.

Beispielsweise erstellt der folgende Python Code ein einfaches OpenQASM-Programm und führt das Programm auf dem Clifford-Simulator aus:

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)

Aufrufen der GPU- und CPU-Simulatoren

Sie können die GPU- und CPU-Simulatoren für Qiskit- und QIR-Programme aufrufen. In der folgenden Tabelle wird gezeigt, wie Sie den GPU-Simulator aus der qdk Bibliothek für 10 Aufnahmen in jedem der unterstützten Quantenprogrammierframeworks aufrufen. Um den CPU-Simulator aufzurufen, ersetzen Sie in den Simulatortyp-Parametern 'gpu' durch 'cpu'.

Programmier-Framework Python API Beispielanruf
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)

Der folgende Python Code konvertiert beispielsweise ein einfaches OpenQASM-Programm in QIR und führt das QIR im GPU-Simulator aus:

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