Installera och köra QDK kvantsimulatorerna

Microsoft Quantum Development Kit (QDK) innehåller en uppsättning kvantsimulatorer som du kan komma åt från Visual Studio Code (VS Code) tillägget och QDKPython paketet. Med de här simulatorerna kan du testa hur dina kvantprogram körs på verklig kvantmaskinvara. Den här artikeln beskriver hur du installerar simulatorerna och hur du kör grundläggande simuleringar i Jupyter Notebook och VS Code.

Innehåller QDK fyra kvantsimulatorer:

  • Sparse-simulator
  • Clifford-simulator
  • GPU-simulator
  • CPU-simulator

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

Förutsättningar

Om du vill följa stegen i den här artikeln måste du installera följande verktyg:

Installera simulatorerna

Alla fyra simulatorerna är tillgängliga i QDKPython paketet, men endast den glesa simulatorn är tillgänglig i QDKVS Code tillägget.

Om du vill använda sparse-simulatorn i tillägget VS Code, installerar du tillägget QDK för VS Code.

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

pip install --upgrade "qdk[jupyter]"

Tillägget jupyter krävs inte för att använda simulatorerna, men installerar modulen qdk.widgets . Med modulen widgets kan du skapa visualiseringar från simuleringen i Jupyter Notebook.

Köra simuleringar med tillägget QDK för VS Code

Tillägget QDK för VS Code erbjuder endast den glesa simulatorn. Om du vill köra programmet på den glesa simulatorn i VS Codeöppnar du ett Q#-program (.qs) eller OpenQASM () i.qasmVS Code och kör filen.

Följ till exempel de här stegen för att köra ett av Q#-exempelprogrammen som medföljer QDK tillägget:

  1. I VS Codeöppnar du menyn Arkiv och väljer Ny textfil.
  2. Ge filen ett namn som slutar med .qs tillägget.
  3. I den tomma filen skriver du sample. En lista över inkluderade kodexempel öppnas.
  4. Välj ett kodexempel, till exempel Bell Pair-exempel.
  5. Om du vill köra programmet på den glesa simulatorn väljer du kommandot Kör från kodlinsen ovanför main-åtgärden .

Terminalen VS Code visar utdata från simuleringen.

Note

Du kan lägga till begränsade brusmodeller till glesa simuleringar av Q#-program i QDK tillägget. Mer information finns i Lägga till Pauli-brus i sparse-simulatorn i VS Code.

Köra simuleringar med hjälp av QDKPython paketet

Paketet QDKPython erbjuder alla fyra simulatorerna. Hur du anropar simulatorerna beror på simulatorn och kvantprogrammeringsramverket.

Kalla på den glesa simulatorn

Du kan anropa sparse-simulatorn för Q#-, OpenQASM- och Qiskit-program. I följande tabell visas hur du anropar den glesa simulatorn från qdk paketet för 10 bilder i varje kvantprogrammeringsramverk som stöds.

Programmeringsramverk Python API 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

Du kan lägga till brusmodeller i den glesa simulatorn med parametern noise för Q#- och OpenQASM-program, men du kan inte lägga till brusmodeller för Qiskit-program.

Följ till exempel de här stegen för att köra Q#-programmet Bell pair i en Jupyter-notebook i VS Code:

  1. I VS Codeöppnar du menyn Visa och väljer Kommandopalett.

  2. Ange Skapa: 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 run du funktionen från modulen qsharp och anger antalet skott.

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

Anropa Clifford-simulatorn

Du kan anropa Clifford-simulatorn för Q#-, OpenQASM-, Qiskit- och QIR-program. Följande tabell visar hur du anropar Clifford-simulatorn från qdk paketet för 10 bilder i varje kvantprogrammeringsramverk som stöds.

Programmeringsramverk Python API Exempelanrop
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

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

Följande Python-kod skapar till exempel ett enkelt OpenQASM-program och kör programmet på Clifford-simulatorn:

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)

Anropa GPU- och CPU-simulatorerna

Du kan anropa GPU- och CPU-simulatorerna för Qiskit- och QIR-program. I följande tabell visas hur du anropar GPU-simulatorn från qdk paketet för 10 bilder i vart och ett av de kvantprogrammeringsramverk som stöds. Om du vill anropa CPU-simulatorn ersätter du 'gpu' med 'cpu' för parametrarna för simulatorns typ.

Programmeringsramverk Python API Exempelanrop
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)

Följande Python-kod konverterar till exempel ett enkelt OpenQASM-program till QIR och kör QIR på GPU-simulatorn:

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