Kör kvantsimuleringar med QDKPython-paketet

Paketet MicrosoftQuantum Development Kit (QDK) Python innehåller lokala kvantsimulatorer som du kan använda för att testa och utveckla kvantprogram. Den här artikeln beskriver hur du installerar simulatorerna och kör Q#, OpenQASM, Qiskitoch QIR program i Python eller Jupyter Notebook.

Paketet QDKPython innehåller fyra primära simulatorer:

  • Sparse-simulator
  • Stabilisatorsimulator
  • GPU simulator
  • CPU simulator

Mer information om QDK kvantsimulatorerna finns i Översikt över kvantsimulatorer i QDK.

Information om hur du kör Q#- eller QDK-program direkt i tillägget QDK för Visual Studio Code (VS Code) finns i OpenQASM.

Förutsättningar

Om du vill följa de Jupyter Notebook exemplen i den här artikeln installerar du följande verktyg:

Installera simulatorerna

Om du vill använda kvantsimulatorerna i Python och Jupyter Notebook installerar du den senaste versionen av qdkPython paketet med det jupyter extra:

pip install --upgrade "qdk[jupyter]"

Simulatorerna kräver inte extra jupyter, men extra lägger till modulen qdk.widgets för att visualisera simuleringsresultat i Jupyter Notebook.

Välj en simulator baserat på det kvantprogrammeringsramverk och Python API som du använder.

Kalla på den glesa simulatorn

Den sparsamma simulatorn stöder Q#, OpenQASM och Qiskit program. Den här tabellen visar hur du kör 10 körningar med qdk-paketet i varje ramverk.

Programmeringsramverk Python API (applikationsprogrammeringsgränssnitt) Exempelanrop
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

Den sparse simulatorn stöder brusmodeller via parametern noise för Q#- och OpenQASM-program, men inte för Qiskit-program.

Följ till exempel dessa steg för att köra Bell-parprogrammet Q# i en Jupyter-anteckningsbok i VS Code:

  1. I VS Code väljer du Visa>Kommandopaletten.

  2. Skriv in Skapa: En Ny Jupyter Notebook. En tom notebook-fil öppnas på en ny flik.

  3. I den första cellen importerar du modulen qsharp från paketet qdk.

    from qdk import qsharp

  4. I en ny cell använder du det %%qsharp magiska kommandot för att skriva Q# koden.

    %%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. Skapa en ny cell. Om du vill köra Q# programmet på den glesa simulatorn anropar du funktionen run från modulen qsharp och anger antalet skott.

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

Ring stabilisatorsimulatorn

Stabilisatorsimulatorn kör effektivt stora, Clifforddominerade kretsar. Stabilisatorförgrening stöder också ett begränsat antal icke-Clifford-operationer, till exempel $T$- och $T^\dagger$-portar och godtyckliga vinkelrotationer Pauli. Eftersom antalet grenar kan öka exponentiellt med antalet icke-Clifford-operationer bör du använda en fulltillståndssimulator för kretsar med betydande icke-Clifford-utveckling.

Stabilisatorsimulatorn stöder Q#, OpenQASM, Qiskitoch QIR program. Den här tabellen visar hur du kör 10 körningar i varje ramverk.

Programmeringsramverk Python API (applikationsprogrammeringsgränssnitt) Exempelanrop
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)

NeutralAtomDevice API:erna och NeutralAtomBackend är till för simuleringar på neutrala atom-kvantdatorer specifikt. Mer information finns i Översikt över neutral atomenhetssimulator.

Den här Python koden kör till exempel ett OpenQASM program med en icke-Clifford$T$-port på stabilisatorsimulatorn:

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

Båda "stabilizer" och "clifford" väljer stabilisatorsimulatorn. API:et avgör om parametern är type eller simulator_type.

T-porten skapar förgreningar i stabilisatortillstånd. Den slutliga mätningen mäter interferensen mellan dessa grenar.

Anropa GPU- och CPU-simulatorerna

Simulatorerna GPU och CPU stöder programmen Qiskit och QIR. Den här tabellen visar hur du kör 10 skott på GPU simulatorn med qdk paketet i varje ramverk. Om du vill använda CPU simulatorn ersätter du gpu med cpu i parametern simulatortyp.

Programmeringsramverk Python API (applikationsprogrammeringsgränssnitt) Exempelanrop
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)

Den här Python koden konverterar till exempel ett enkelt OpenQASM program till QIR och kör QIR på GPU simulatorn:

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)
  • Uppdaterades senast