De kwantumsimulators installeren en uitvoeren QDK

De Microsoft Quantum Development-kit (QDK) bevat een set kwantumsimulators waartoe u toegang hebt vanuit de Visual Studio Code extensie (VS Code) en het QDKPython pakket. Met deze simulatoren kunt u testen hoe uw kwantumprogramma's worden uitgevoerd op echte kwantumhardware. In dit artikel wordt uitgelegd hoe u de simulators installeert en hoe u basissimulaties uitvoert in Jupyter Notebook en VS Code.

De QDK bevat vier kwantumsimulators:

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

Zie QDKvoor meer informatie over de QDK kwantumsimulators.

Prerequisites

Als u de stappen in dit artikel wilt volgen, moet u de volgende hulpprogramma's installeren:

• Een Python-omgeving (versie 3.10 of hoger) met Python en Pip
• De nieuwste versie van Visual Studio Code (VS Code)
• De nieuwste versies van de extensie Python en Jupyter in VS Code

De simulators installeren

Alle vier de simulators zijn beschikbaar in het QDKPython pakket, maar alleen de sparse simulator is beschikbaar in de QDKVS Code extensie.

Als u de sparse-simulator in de VS Code extensie wilt gebruiken, installeert u de QDK extensie voor VS Code.

Als u de kwantumsimulators wilt gebruiken in Python en Jupyter Notebookinstalleert u de nieuwste versie van het qdkPython pakket met de jupyter extra:

pip install --upgrade "qdk[jupyter]"

De jupyter extra is niet vereist om de simulators te gebruiken, maar installeert wel de qdk.widgets module. Met de module widgets kunt u visualisaties maken op basis van uw simulatieresultaten in Jupyter Notebook.

Simulaties uitvoeren met behulp van de QDK extensie voor VS Code

De QDK extensie voor VS Code biedt alleen de sparse simulator. Als u uw programma wilt uitvoeren op de sparsesimulator in VS Code, opent u een Q# (.qs) of OpenQASM-programma (.qasm) in VS Code en voert u het bestand uit.

Voer bijvoorbeeld deze stappen uit om een van de Q#-voorbeeldprogramma's uit te voeren die bij de QDK extensie worden geleverd:

1. Open in VS Code het menu Bestand en selecteer Nieuw tekstbestand.
2. Geef het bestand een naam die eindigt op de .qs extensie.
3. Voer in het lege bestand een voorbeeld in. Er wordt een lijst met opgenomen codevoorbeelden geopend.
4. Kies een codevoorbeeld, bijvoorbeeld Bell Pair-sample.
5. Als u het programma wilt uitvoeren op de sparse simulator, selecteert u de opdracht Uitvoeren in de codelens boven de Main-bewerking.

De VS Code terminal toont de uitvoer van de simulatie.

Simulaties uitvoeren met behulp van het QDKPython pakket

Het QDKPython pakket biedt alle vier simulators. Hoe u de simulatoren aanroept, is afhankelijk van de simulator en het kwantumprogrammeerframework.

De sparse-simulator aanroepen

U kunt de sparse simulator aanroepen voor Q#-, OpenQASM- en Qiskit-programma's. In de volgende tabel ziet u hoe u de sparse-simulator aanroept vanuit het qdk pakket voor 10 opnamen in elk ondersteund kwantumprogrammeerframework.

Volg bijvoorbeeld deze stappen om het Q#-programma Bell pair uit te voeren in een Jupyter notebook in VS Code:

1. Open VS Codehet menu Beeld en selecteer Opdrachtpalet.

2. Voer Creëren: Nieuw Jupyter Notebook in. Er wordt een leeg notitieblokbestand geopend op een nieuw tabblad.

3. Importeer in de eerste cel de qsharp module uit het qdk pakket.

   from qdk import qsharp
   

4. Gebruik in een nieuwe cel de magic-opdracht %%qsharp om de Q#-code te schrijven.

   %%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. Maak een nieuwe cel. Als u het Q#-programma wilt uitvoeren in de sparsesimulator, roept u de run functie aan vanuit de qsharp module en geeft u het aantal opnamen op.

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

De Clifford-simulator aanroepen

U kunt de Clifford-simulator aanroepen voor Q#-, OpenQASM-, Qiskit- en QIR-programma's. In de volgende tabel ziet u hoe u de Clifford-simulator aanroept vanuit het qdk pakket voor 10 opnamen in elk ondersteund kwantumprogrammeerframework.

De volgende Python code maakt bijvoorbeeld een eenvoudig OpenQASM-programma en voert het programma uit op de Clifford-simulator:

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)

De GPU- en CPU-simulatoren aanroepen

U kunt de GPU- en CPU-simulators aanroepen voor Qiskit- en QIR-programma's. In de volgende tabel ziet u hoe u de GPU-simulator aanroept vanuit het qdk pakket voor 10 opnamen in elk van de ondersteunde frameworks voor kwantumprogrammering. Als u de CPU-simulator wilt aanroepen, vervangt u door 'gpu''cpu' de parameters van het simulatortype.

De volgende Python code converteert bijvoorbeeld een eenvoudig OpenQASM-programma naar QIR en voert de QIR uit op de GPU-simulator:

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)