Aan de slag met Q#-programma's en Visual Studio Code

  • Artikel

In dit artikel vindt u de stappen voor het gebruik van VC Code om Q#-, Jupyter Notebook- of Python-kwantumcomputingtaken te maken en te verzenden naar Azure Quantum met behulp van VS Code.

Q#-taken verzenden naar Azure Quantum

Meer informatie over het gebruik van VS Code om een Q#-programma uit te voeren, fouten op te sporen en te verzenden naar Azure Quantum.

Vereisten

Zie Installing the Modern QDK on VS Code (De moderne QDK installeren op VS Code) voor installatiedetails.

Een Q#-voorbeeldprogramma laden

  1. Selecteer in VS Code Bestand > Nieuw tekstbestand en sla het bestand op als RandomNum.qs.

  2. Open RandomNum.qs en typ sample, selecteer random bit sample in de lijst met opties en sla het bestand op.

    Schermopname van het Q#-bestand in Visual Studio Code met de lijst met codevoorbeelden bij het schrijven van het woordvoorbeeld in het bestand.

Notitie

U kunt ook uw eigen Q#-bestand openen. Als u een ouder Q#-programma uitvoert en er fouten optreden, raadpleegt u Testen en foutopsporing of Uw programma's migreren naar de moderne QDK.

Een Q#-programma uitvoeren

  1. Als u het programma lokaal wilt testen in de ingebouwde simulator, klikt u op Uitvoeren in de onderstaande @EntryPoint()lijst met opdrachten of drukt u op Ctrl+F5. De uitvoer wordt weergegeven in de foutopsporingsconsole.

  2. Als u fouten in uw programma wilt opsporen voordat u het naar Azure Quantum verzendt, klikt u op Fouten opsporen in de onderstaande @EntryPoint()lijst met opdrachten of drukt u op F5. Gebruik de besturingselementen voor foutopsporing bovenaan om over, naar en uit de code te stappen. Zie Testen en foutopsporing voor meer informatie over het opsporen van fouten in Q#- programma's.

    Schermopname van het Q#-bestand in Visual Studio Code waarin wordt weergegeven waar u de codelens kunt vinden met uitvoer- en foutopsporingsopdrachten.

Het frequentie histogram visualiseren

Het frequentie histogram vertegenwoordigt de verdeling van de resultaten die zijn verkregen door het meerdere keren uitvoeren van een kwantumprogramma of 'shots'. Elke balk in het histogram komt overeen met een mogelijk resultaat en de hoogte ervan geeft het aantal keren aan dat het resultaat wordt waargenomen. Het frequentie histogram helpt bij het visualiseren van de waarschijnlijkheidsverdeling van deze resultaten.

  1. Selecteer Beeld -> Opdrachtpalet en typ 'histogram'. De optie Q#: Bestand uitvoeren en histogram weergeven wordt weergegeven. U kunt ook klikken op Histogram in de lijst met opdrachten hieronder @EntryPoint(). Selecteer deze optie om het Q#-histogramvenster te openen.

    Schermopname van het Q#-bestand in Visual Studio Code waarin wordt weergegeven waar u de codelens kunt vinden met de opdracht histogram.

  2. Voer een aantal schoten in om het programma uit te voeren, bijvoorbeeld 100 schoten, en druk op Enter. Het histogram wordt weergegeven in het Q#-histogramvenster.

  3. Klik op het pictogram instellingen linksboven om opties weer te geven.

    Schermopname van het Q#-histogramvenster in Visual Studio Code waarin wordt weergegeven hoe u instellingen kunt weergeven.

  4. Klik op een balk om het percentage van dat resultaat weer te geven. In dit geval zijn er twee mogelijke resultaten, 0 en 1, en het percentage van elk resultaat ligt dicht bij 50%.

    Schermopname van het Q#-histogramvenster in Visual Studio Code.

Tip

U kunt inzoomen op het histogram met behulp van het muiswieltje of een trackpadbeweging. Wanneer u inzoomt, kunt u de grafiek pannen door tijdens het schuiven op Alt te drukken.

Het kwantumcircuit visualiseren

Kwantumcircuitdiagrammen zijn een visuele weergave van kwantumbewerkingen. Ze tonen de stroom van qubits door het kwantumprogramma, inclusief de poorten en metingen die erop zijn toegepast. Zie Quantum-circuitdiagrammen in Visual Studio Code voor meer informatie.

  1. Selecteer Weergave -> Opdrachtpalet en typ 'circuit' om de optie Q#: Circuit weergeven weer te geven. U kunt ook klikken op Circuit in de lijst met opdrachten hieronder @EntryPoint().

    Schermopname van het Q#-bestand in Visual Studio Code, waarin wordt weergegeven waar u de opdracht voor het codelenscircuit kunt vinden.

  2. Het circuit wordt weergegeven in het Q#-circuitvenster. In het circuitdiagram ziet u één qubitregister dat is geïnitialiseerd met de status |0⟩. Vervolgens wordt een Hadamard-poort, H, toegepast op de qubit, gevolgd door een meetbewerking, die wordt vertegenwoordigd door een metersymbool. Zie Conventies voor kwantumcircuits voor meer informatie.

    Schermopname van het Q#-circuitvenster met het resulterende circuitdiagram voor de willekeurige bitbewerking.

Verbinding maken met Azure Quantum en uw taak verzenden

U kunt rechtstreeks vanuit VS Code verbinding maken en taken verzenden. In dit voorbeeld verzendt u een taak naar de Rigetti-simulator.

  1. Selecteer Weergave -> Opdrachtpalet en typ Q#: Verbinding maken met een Azure Quantum-werkruimte. Druk op Enter.

  2. Selecteer Azure-account en volg de aanwijzingen om verbinding te maken met de map, het abonnement en de werkruimte van uw voorkeur.

    Notitie

    Als u een verbindingsreeks hebt, kunt u Verbindingsreeks selecteren en de verbindingsreeks plakken die overeenkomt met uw Azure Quantum-werkruimte. Zie Verbinding maken met een Quantum-werkruimte met behulp van een verbindingsreeks voor meer informatie.

  3. Zodra u verbinding hebt gemaakt, vouwt u in het deelvenster VerkennerQuantum-werkruimten uit.

  4. Breid uw werkruimte uit en vouw de Rigetti-provider uit.

    Notitie

    Als er een probleem is met het maken van verbinding met Azure Quantum, wordt er een waarschuwingspictogram weergegeven naast de naam van de werkruimte. Beweeg de muisaanwijzer over de naam van de werkruimte om foutinformatie weer te geven.

  5. Selecteer rigetti.sim.qvm als uw target.

    Schermopname van Visual Studio Code waarin wordt getoond hoe u Rigetti-simulator selecteert als target.

  6. Selecteer het afspeelpictogram rechts van de target naam om het huidige Q#-programma in te dienen. Als u een pop-up krijgt, selecteert u Het QIR-profiel target wijzigen en gaat u door.

    Schermopname van Visual Studio Code die laat zien hoe u rigetti-simulator uitvoert als target.

  7. Voeg een naam toe om de taak te identificeren.

  8. Tel het aantal opnamen op of het aantal keren dat het programma wordt uitgevoerd.

  9. Druk op Enter om de taak te verzenden. De taakstatus wordt onder aan het scherm weergegeven.

  10. Vouw Taken uit en beweeg de muisaanwijzer over uw taak, waarmee de tijden en status van uw taak worden weergegeven.

  11. Als u de resultaten wilt weergeven, selecteert u het cloudpictogram naast de taaknaam om de resultaten uit uw werkruimteopslag te downloaden en weer te geven in VS Code.

    Schermopname van Visual Studio Code waarin wordt getoond hoe u de resultaten van uw kwantumtaak kunt downloaden en weergeven.

Jupyter Notebooks-taken verzenden naar Azure Quantum

Meer informatie over het gebruik van VS Code om een Q#-Jupyter Notebook uit te voeren, fouten op te sporen en te verzenden naar Azure Quantum. De stappen in dit artikel zijn ook van toepassing op Jupyter Notebooks op uw lokale Jupyter-server of notebooks in de Azure Quantum-portal.

Vereisten

Zie Installing the Modern QDK on VS Code (De moderne QDK installeren op VS Code) voor installatiedetails.

Uw programma uitvoeren en testen in de lokale simulator

  1. Selecteer in VS Code opdrachtpalet weergeven > en selecteer Creatie: Nieuwe Jupyter Notebook.

  2. In de rechterbovenhoek detecteert VS Code de versie van Python en de virtuele Python-omgeving die voor het notebook is geselecteerd en geeft deze weer. Als u meerdere Python-omgevingen hebt, moet u mogelijk een kernel selecteren met behulp van de kernelkiezer in de rechterbovenhoek. Als er geen omgeving is gedetecteerd, raadpleegt u Jupyter Notebooks in VS Code voor installatie-informatie.

  3. Voer in de eerste cel van het notebook de volgende Python-code uit om de benodigde modules te importeren:

    import qsharp
import azure.quantum
    • De qsharp module activeert de %%qsharp magic-opdracht waarmee u Q#-code rechtstreeks in een cel kunt invoeren.
    • De azure-quantum module biedt connectiviteit met uw Azure Quantum-werkruimte.

    Notitie

    Als de Jupyter Python-kernel ipykernel niet wordt gedetecteerd, wordt u door VS Code gevraagd deze te installeren.

  4. Voeg nog een cel toe en voer deze Q#-code in die een door de gebruiker opgegeven aantal willekeurige bits retourneert:

    Notitie

    U ziet dat zodra u de magic-opdracht typt %%qsharp, de notebookcel het type verandert van Python in Q#.

    %%qsharp

operation Random() : Result {
    use q = Qubit();
    H(q);
    let result = M(q);
    Reset(q);
    return result
}

operation RandomNBits(N: Int): Result[] {
    mutable results = [];
    for i in 0 .. N - 1 {
        let r = Random();
        set results += [r];
    }
    return results
}

  5. Als u uw bewerking wilt testen, kunt u de eval methode gebruiken, waarmee elke Q#-bewerking kan worden aangeroepen die eerder in het notebook is gedefinieerd:

    qsharp.eval("RandomNBits(4)")

    [Zero, One, One, Zero]

  6. Gebruik de methode om uw programma uit te voeren naar de run lokale simulator. Geef het shotsaantal keren op dat het programma moet worden uitgevoerd en de simulator retourneert de resultaten als een Python-lijst.

    qsharp.run("RandomNBits(4)", shots=10)

    [[One, One, One, One],
[Zero, Zero, One, Zero],
[One, Zero, Zero, One],
[Zero, One, Zero, Zero],
[One, Zero, One, One],
[One, Zero, One, Zero],
[One, One, One, Zero],
[One, One, One, One],
[Zero, Zero, Zero, One],
[One, Zero, Zero, One]]

Het kwantumcircuit visualiseren

U kunt kwantumcircuits visualiseren met behulp van het qsharp-widgets pakket. Dit pakket bevat een widget waarmee een kwantumcircuitdiagram wordt weergegeven als een SVG-afbeelding. Zie Quantum-circuitdiagrammen met Jupyter Notebooks voor meer informatie.

Voeg de volgende code toe aan een nieuwe cel om het circuit te visualiseren:

from qsharp_widgets import Circuit

Circuit(qsharp.circuit("RandomNBits(4)"))

Schermopname van Jupyter Notebook die laat zien hoe u het circuit voor een Q#-bewerking kunt visualiseren.

Zie Conventies voor kwantumcircuits voor meer informatie.

Uw taak compileren met behulp van het basisprofiel

Wanneer u programma's uitvoert op de lokale kwantumsimulator, kunt u elk type Q#-programma indienen. Azure Quantum-hardware targets biedt echter nog geen ondersteuning voor de volledige mogelijkheden die nodig zijn om alle Q#-programma's uit te voeren. Als u Q#-programma's wilt compileren en verzenden naar Azure Quantum, moet u uw target profiel instellen om Q# te laten weten welke mogelijkheden uw target hardware ondersteunt. Momenteel is dat het basisprofiel. Zie Profieltypen in Azure Quantum voor meer informatie.

De Q#-interpreter opnieuw initialiseren en uw programma compileren met het basisprofiel:

  1. Gebruik de init methode om het profiel in te stellen:

    qsharp.init(target_profile=qsharp.TargetProfile.Base)

  2. Omdat u de interpreter opnieuw hebt geïnitialiseerd, moet u uw code opnieuw uitvoeren met het nieuwe profiel:

    %%qsharp

operation Random() : Result {
    use q = Qubit();
    H(q);
    let result = M(q);
    Reset(q);
    return result
}

operation RandomNBits(N: Int): Result[] {
    mutable results = [];
    for i in 0 .. N - 1 {
        let r = Random();
        set results += [r];
    }
    return results
}

  3. Gebruik vervolgens de compile methode om de bewerking of functie op te geven die het toegangspunt voor uw programma is. Hiermee compileert u uw code in QIR-indeling, die vervolgens kan worden verzonden naar elke kwantumhardware:

    MyProgram = qsharp.compile("RandomNBits(4)")

Verbinding maken met Azure Quantum en uw taak verzenden

Nu u het programma in de juiste indeling hebt gecompileerd, maakt u een azure.quantum.Workspace -object om verbinding te maken met Azure Quantum. U gebruikt de resource-id van uw Azure Quantum-werkruimte om verbinding te maken. De resource-id en -locatie kunnen worden gekopieerd van de overzichtspagina van uw werkruimte in de Azure Portal.

  1. Vul in een nieuwe cel uw resource-id en locatie in vanuit uw Azure Quantum-werkruimte:

    MyWorkspace = azure.quantum.Workspace(
    resource_id = "MyResourceID",
    location = "MyLocation"
)

  2. Gebruik de get_targets methode om de beschikbare hardware targets in uw werkruimte te bekijken:

    MyTargets = MyWorkspace.get_targets()
print("This workspace's targets:")
MyTargets

  3. Selecteer de rigetti.sim.qvmtargetoptie :

    MyTarget = MyWorkspace.get_targets("rigetti.sim.qvm")

  4. Gebruik ten slotte de submit methode om uw programma met de bijbehorende parameters in te dienen en de resultaten weer te geven:

    job = MyTarget.submit(MyProgram, "MyQuantumJob", shots=100)
job.get_results()

    {'Histogram': ['[0, 0, 0, 0]',
  0.3,
  '[1, 0, 0, 0]',
  0.1,
  '[1, 1, 1, 1]',
  0.3,
  '[0, 1, 1, 1]',
  0.3]}

  5. Alle eigenschappen van de taak zijn toegankelijk in job.details, bijvoorbeeld:

    print(job.details)
print("\nJob name:", job.details.name)
print("Job status:", job.details.status)
print("Job ID:", job.details.id)

    {'additional_properties': {'isCancelling': False}, 'id': '0150202e-9638-11ee-be2f-b16153380354', 'name': 'MyQuantumJob', 'provider_id': 'rigetti'...}
Job name: MyQuantumJob
Job status: Succeeded
Job ID: 0150202e-9638-11ee-be2f-b16153380354

Python met Q#-taken verzenden naar Azure Quantum

Meer informatie over het gebruik van VS Code om een Python-programma te schrijven dat Q#-bewerkingen aanroept, verbinding te maken met Azure met behulp van de Python-opdrachten of Azure CLI en uw taak te verzenden.

Vereisten

Zie Installing the Modern QDK on VS Code (De moderne QDK installeren op VS Code) voor installatiedetails.

uw Q#-bewerkingen Creatie en importeren

Met het qsharp pakket kunt u uw functies en bewerkingen opslaan in Q#-bestanden en Q#-projecten maken waarmee u deze vanuit uw Python-code kunt aanroepen. Dit is vooral handig wanneer u een programma moet starten dat invoerparameters gebruikt.

  1. Volg de stappen om een Q#-project te maken.

  2. Open een nieuw tekstbestand, voeg de volgende Q#-code toe die een door de gebruiker opgegeven aantal willekeurige bits retourneert en sla het bestand op in uw project als source.qs.

    Notitie

    Houd er rekening mee dat deze Q#-code geen functie heeft @EntryPoint zoals een Q#-programma (zie Q#-taken indienen bij Azure Quantum), maar er is wel een naamruimte vereist, in tegenstelling tot een Jupyter Notebook (zie Jupyter Notebook taken verzenden naar Azure Quantum).

    namespace Sample {

  operation Random() : Result {
        use q = Qubit();
        H(q);
        let result = M(q);
        Reset(q);
        return result
  }

  operation RandomNBits(N: Int): Result[] {
        mutable results = [];
        for i in 0 .. N - 1 {
           let r = Random();
           set results += [r];
        }
        return results
  }
}

  3. Open in dezelfde map een ander bestand en sla het op als randomNum.py.

  4. Voeg de volgende code toe om de qsharp modules en azure.quantum te importeren.

    import qsharp
import azure.quantum

  5. Voeg vervolgens code toe om de hoofdmap van het Q#-project te definiëren en test de target bewerking uit te voeren op de lokale simulator. De bewerking wordt aangeroepen door de< naamruimte>.<operation_name( )> en in dit geval geeft u het aantal willekeurige bits door dat moet worden geretourneerd.

    qsharp.init(project_root = '/MyProjectRootFolder')
print(qsharp.eval("Sample.RandomNBits(4)"))

    [Zero, One, One, Zero]

  6. U kunt de bewerking ook testen met de run methode, die een extra shots parameter doorgeeft en de resultaten retourneert in een Python-lijst. Vervang in randomNum.pyde vorige afdrukinstructie door het volgende:

    result = qsharp.run("Sample.RandomNBits(4)", shots=10)
for x in result:
    print(x)

    [[One, One, One, One],
[Zero, Zero, One, Zero],
[One, Zero, Zero, One],
[Zero, One, Zero, Zero],
[One, Zero, One, One],
[One, Zero, One, Zero],
[One, One, One, Zero],
[One, One, One, One],
[Zero, Zero, Zero, One],
[One, Zero, Zero, One]]

Uw taak compileren met behulp van het basisprofiel

Wanneer u programma's uitvoert op de lokale kwantumsimulator, kunt u elk type Q#-programma indienen. Azure Quantum-hardware targets biedt echter nog geen ondersteuning voor de volledige mogelijkheden die nodig zijn om alle Q#-programma's uit te voeren. Als u Q#-programma's wilt compileren en verzenden naar Azure Quantum, moet u uw target profiel instellen om Q# te laten weten welke mogelijkheden uw target hardware ondersteunt. Momenteel is dat het basisprofiel. Zie Profieltypen in Azure Quantum voor meer informatie.

Notitie

Voor alleen Q#-programma's in VS Code stelt VS Code het basisprofiel automatisch in.

  1. Gebruik de init methode om het profiel in te stellen:

    qsharp.init(target_profile=qsharp.TargetProfile.Base)

  2. Gebruik vervolgens de compile methode om de bewerking of functie op te geven die het toegangspunt voor uw programma is. Het gecompileerde programma kan vervolgens worden verzonden naar elke kwantumhardware:

    MyProgram = qsharp.compile("Sample.RandomNBits(4)")

Verbinding maken met Azure Quantum en uw taak verzenden

U kunt verbinding maken met Azure Quantum en uw taak verzenden met behulp van een door Python gemaakt Workspace object, of verbinding maken en uw taak verzenden met behulp van Azure CLI. Als u Azure CLI gebruikt, moet u het gecompileerde programma opslaan als een tekstbestand en het bestand verzenden met behulp van een CLI-opdracht.

Nu u het programma in de juiste indeling hebt gecompileerd, maakt u een azure.quantum.Workspace -object om verbinding te maken met Azure Quantum. U gebruikt de resource-id van uw Azure Quantum-werkruimte om verbinding te maken. De resource-id en -locatie kunnen worden gekopieerd van de overzichtspagina van uw werkruimte in de Azure Portal.

  1. Voeg de volgende code toe aan randomNum.pyen vul uw resource-id en locatie in vanuit uw Azure Quantum-werkruimte:

    workspace = azure.quantum.Workspace(
    resource_id = "MyResourceID",
    location = "MyLocation"
)

  2. Gebruik de get_targets methode om de beschikbare hardware targets in uw werkruimte weer te geven:

    MyTargets = workspace.get_targets()
print("This workspace's targets:")
for x in MyTargets:
    print(x)

  3. Selecteer de rigetti.sim.qvmtargetoptie :

    MyTarget = workspace.get_targets("rigetti.sim.qvm")

  4. Gebruik ten slotte de submit methode om uw programma met de bijbehorende parameters te verzenden. De taakresultaten worden geretourneerd als een Python-woordenlijst.

    job = MyTarget.submit(MyProgram, "MyPythonJob", shots=100)
results = job.get_results()
print("\nResults: ", results)

  5. Alleen de waarden extraheren en weergeven:

    resultList = results.get("Histogram")
for x in resultList:
    print(x)

    [0, 0, 0, 0]
0.3
[1, 0, 0, 0]
0.1
[1, 1, 1, 1]
0.3
[0, 1, 1, 1]
0.3

  6. Alle eigenschappen van de taak zijn toegankelijk in job.details, bijvoorbeeld:

    print(job.details)
print("\nJob name:", job.details.name)
print("Job status:", job.details.status)
print("Job ID:", job.details.id)

    {'additional_properties': {'isCancelling': False}, 'id': '0fc396d2-97dd-11ee-9958-6ca1004ff31f', 'name': 'MyPythonJob', 'provider_id': 'rigetti'...}
Job name: MyPythonJob
Job status: Succeeded
Job ID: fc396d2-97dd-11ee-9958-6ca1004ff31f

Volgende stappen