Q#-programma's verzenden met Visual Studio Code

Artikel
07/23/2024

Meer informatie over het gebruik van Visual Studio Code voor het maken en verzenden van Q#-programma's naar echte kwantumhardware. U kunt kwantumcomputingstaken verzenden naar Azure Quantum als een zelfstandig Q#-programma, Q# combineren met Python in een Q#-project en een Jupyter Notebook uitvoeren.

Q#-taken verzenden naar Azure Quantum

Meer informatie over het gebruik van VS Code voor het uitvoeren, opsporen van fouten en het verzenden van een Q#-programma naar Azure Quantum.

Vereisten

Zie QDK installeren in VS Code voor installatiedetails.

Een Azure Quantum-werkruimte in uw Azure-abonnement. Zie Een Azure Quantum-werkruimte maken om een werkruimte te maken.
De nieuwste versie van Visual Studio Code of open VS Code op het web.
De nieuwste versie van de Azure Quantum Development Kit-extensie.

Een Q#-voorbeeldprogramma laden

Selecteer in VS Code Bestand > nieuw tekstbestand en sla het bestand op als RandomNum.qs.
Open RandomNum.qs en typ sample, selecteer vervolgens Random Bit-voorbeeld in de lijst met opties en sla het bestand op.

Notitie

U kunt ook uw eigen Q#-bestand openen. Als u een ouder Q#-programma uitvoert en fouten krijgt, raadpleegt u Testen en foutopsporing.

Een Q#-programma uitvoeren

Als u het programma lokaal wilt testen op de ingebouwde simulator, klikt u op Uitvoeren in de lijst met opdrachten naast de invoerpuntbewerking of drukt u op Ctrl+F5. Uw uitvoer wordt weergegeven in de console voor foutopsporing.
Als u fouten in uw programma wilt opsporen voordat u het naar Azure Quantum verzendt, klikt u op Fouten opsporen in de lijst met opdrachten naast de invoerpuntbewerking of drukt u op F5. Gebruik de besturingselementen voor foutopsporing bovenaan om de code te doorlopen, in en uit te voeren. Zie Testen en foutopsporing voor meer informatie over het opsporen van fouten in Q#-programma's.

Het frequentie histogram visualiseren

Het frequentie histogram vertegenwoordigt de verdeling van 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 geeft het aantal keren aan dat het resultaat wordt waargenomen. Het frequentie histogram helpt bij het visualiseren van de waarschijnlijkheidsverdeling van deze resultaten.

Selecteer Weergave -> Opdrachtpalet en typ 'histogram' dat het Q#-bestand moet openen: Voer het bestand uit en geef de histogramoptie weer. U kunt ook op Histogram klikken in de lijst met opdrachten naast de invoerpuntbewerking. Selecteer deze optie om het Q#-histogramvenster te openen.
Voer een aantal schoten in om het programma uit te voeren, bijvoorbeeld 100 shots en druk op Enter. Het histogram wordt weergegeven in het Q#-histogramvenster.
Klik op het pictogram instellingen linksboven om opties weer te geven.
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 is bijna 50%.

Tip

U kunt het histogram inzoomen met behulp van het muiswiel 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 via het kwantumprogramma, inclusief de poorten en metingen die erop zijn toegepast. Zie Quantum-circuitdiagrammen in Visual Studio Code voor meer informatie.

Selecteer Weergave -> Opdrachtpalet en typ 'circuit' die de Q#- optie moet weergeven. U kunt ook klikken op Circuit in de lijst met opdrachten naast de invoerpuntbewerking.
Het circuit wordt weergegeven in het Q#-circuitvenster. In het circuitdiagram ziet u één qubitregister dat is geïnitialiseerd naar de status |0⟩. Vervolgens wordt een Hadamard-poort, H, toegepast op de qubit, gevolgd door een meetbewerking, die wordt vertegenwoordigd door een metersymbool. Zie Kwantumcircuitconventies voor meer informatie.

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.

Selecteer Weergave -> Opdrachtpalet en typ Q#: Verbinding maken met een Azure Quantum-werkruimte. Druk op Enter.
Selecteer het Azure-account en volg de aanwijzingen om verbinding te maken met uw voorkeursmap, abonnement en werkruimte.

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.
Zodra u verbinding hebt, vouwt u in het deelvenster Explorer kwantumwerkruimten uit.
Vouw 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.
Selecteer rigetti.sim.qvm als uw target.
Selecteer het afspeelpictogram rechts van de target naam om het huidige Q#-programma te verzenden. Als u een pop-up krijgt, selecteert u Het QIR-profiel target wijzigen en gaat u door.
Voeg een naam toe om de taak te identificeren.
Voeg het aantal shots of het aantal keren toe dat het programma wordt uitgevoerd.
Druk op Enter om de taak in te dienen. De taakstatus wordt onderaan het scherm weergegeven.
Vouw Taken uit en beweeg de muisaanwijzer over uw taak, waarin de tijden en status van uw taak worden weergegeven.
Als u de resultaten wilt weergeven, selecteert u het cloudpictogram naast de taaknaam om de resultaten van uw werkruimteopslag te downloaden en weer te geven in VS Code.

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 azure Quantum Portal.

Vereisten

Zie QDK installeren in VS Code voor installatiedetails.

Een Azure Quantum-werkruimte in uw Azure-abonnement. Zie Een Azure Quantum-werkruimte maken om een werkruimte te maken.
Een Python-omgeving waarop Python en Pip zijn geïnstalleerd.
VS Code waarop de Azure Quantum Development Kit, Python en Jupyter-extensies zijn geïnstalleerd.
De Azure Quantum qsharp- qsharp-widgetsen azure-quantum pakketten en het ipykernel pakket.
```
python -m pip install --upgrade qsharp qsharp-widgets azure-quantum ipykernel
```

Uw programma uitvoeren en testen in de lokale simulator

Selecteer in VS Code het opdrachtenpalet Weergeven > en selecteer Maken: Nieuw Jupyter Notebook.
In de rechterbovenhoek detecteert en geeft VS Code de versie van Python en de virtuele Python-omgeving weer die is geselecteerd voor het notebook. 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 informatie over de installatie.
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.

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 %%qsharptypt, het type notebookcel wordt gewijzigd 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
}

Als u uw bewerking wilt testen, kunt u de eval methode gebruiken waarmee een Q#-bewerking kan worden aangeroepen die eerder in het notebook is gedefinieerd:
```
qsharp.eval("RandomNBits(4)")
```
```
[Zero, One, One, Zero]
```

Gebruik de run methode om uw programma uit te voeren naar de lokale simulator. Geef het shots, of het aantal 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 biedt 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 waarin wordt getoond hoe u het circuit voor een Q#-bewerking kunt visualiseren.

Zie Kwantumcircuitconventies voor meer informatie.

Uw taak compileren met behulp van het basisprofiel

Wanneer u programma's uitvoert in de lokale kwantumsimulator, kunt u elk type Q#-programma verzenden. 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 zo instellen dat Q# weet welke mogelijkheden uw target hardware ondersteunt. Dat is momenteel het basisprofiel. Zie Profieltypen in Azure Quantum voor meer informatie.

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

Gebruik de init methode om het profiel in te stellen:

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

Omdat u de interpreter opnieuw hebt geïnitialiseerd, moet u de 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
}

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 uw 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 Azure Portal.

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"
)

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
```

Selecteer het rigetti.sim.qvmtargetvolgende:

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

Gebruik ten slotte de submit methode om uw programma te verzenden met de bijbehorende parameters en de resultaten weer te geven:

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

{'[0, 1, 1, 1]': 0.08,
 '[1, 1, 0, 0]': 0.1,
 '[0, 0, 1, 0]': 0.04,
 '[0, 1, 0, 0]': 0.05,
 '[1, 0, 1, 0]': 0.05,
 '[1, 0, 0, 0]': 0.07,
 '[0, 1, 0, 1]': 0.07,
 '[1, 0, 1, 1]': 0.07,
 '[0, 0, 0, 0]': 0.08,
 '[1, 1, 1, 0]': 0.05,
 '[0, 0, 0, 1]': 0.1,
 '[0, 0, 1, 1]': 0.04,
 '[0, 1, 1, 0]': 0.09,
 '[1, 0, 0, 1]': 0.04,
 '[1, 1, 1, 1]': 0.05,
 '[1, 1, 0, 1]': 0.02}

Alle eigenschappen van de taak zijn toegankelijk in job.detailsbijvoorbeeld:

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

Aanvullende taakdetails

Het azure.quantum Python-pakket bevat aanvullende methoden om gedetailleerdere taakgegevens weer te geven.

job.get_results_histogram(): Deze methode retourneert een woordenlijst met de resultaten en het aantal shots voor elke unieke meting. De resultaten voor de vorige taak zijn bijvoorbeeld

print(job.get_results_histogram())

{   
    '[0, 1, 1, 1]' : {'Outcome' : [0, 1, 1, 1], 'Count' : 8},  
    '[1, 1, 0, 0]' : {'Outcome' : [1, 1, 0, 0], 'Count' : 10},
    '[0, 0, 1, 0]' : {'Outcome' : [0, 0, 1, 0], 'Count' : 4},
    '[0, 1, 0, 0]' : {'Outcome' : [0, 1, 0, 0], 'Count' : 5},
    '[1, 0, 1, 0]' : {'Outcome' : [1, 0, 1, 0], 'Count' : 5},  
    '[1, 0, 0, 0]' : {'Outcome' : [1, 0, 0, 0], 'Count' : 7},
    '[0, 1, 0, 1]' : {'Outcome' : [0, 1, 0, 1], 'Count' : 7},
    '[1, 0, 1, 1]' : {'Outcome' : [1, 0, 1, 1], 'Count' : 7},
    '[0, 0, 0, 0]' : {'Outcome' : [0, 0, 0, 0], 'Count' : 8},  
    '[1, 1, 1, 0]' : {'Outcome' : [1, 1, 1, 0], 'Count' : 5},
    '[0, 0, 0, 1]' : {'Outcome' : [0, 0, 0, 1], 'Count' : 10},
    '[0, 0, 1, 1]' : {'Outcome' : [0, 0, 1, 1], 'Count' : 4},
    '[0, 1, 1, 0]' : {'Outcome' : [0, 1, 1, 0], 'Count' : 9},  
    '[1, 0, 0, 1]' : {'Outcome' : [1, 0, 0, 1], 'Count' : 4},
    '[1, 1, 1, 1]' : {'Outcome' : [1, 1, 1, 1], 'Count' : 5},
    '[1, 1, 0, 1]' : {'Outcome' : [1, 1, 0, 1], 'Count' : 2}
}

job.get_results_shots() : Deze methode retourneert een lijst met elk shotresultaat. De resultaten voor de vorige taak zijn bijvoorbeeld

print(job.get_results_shots())

[ [0, 1, 1, 1], [1, 0, 1, 1], [0, 0, 1, 1], [1, 1, 0, 1], [1, 0, 0, 0], [1, 0, 1, 1], [1, 1, 0, 1], ...]

Python met Q#-taken verzenden naar Azure Quantum

Leer hoe u VS Code gebruikt om een Python-programma te schrijven dat Q#-bewerkingen aanroept, verbinding maakt met Azure met behulp van de Python-opdrachten of Azure CLI en uw taak verzendt.

Vereisten

Zie QDK installeren in VS Code voor installatiedetails.

Een Azure Quantum-werkruimte in uw Azure-abonnement. Zie Een Azure Quantum-werkruimte maken om een werkruimte te maken.
Een Python-omgeving waarop Python en Pip zijn geïnstalleerd.
VS Code waarop de Azure Quantum Development Kit en de Python-extensie zijn geïnstalleerd.
De Azure Quantum qsharp en azure-quantum pakketten.
Azure CLI waarop de nieuwste Azure Quantum-extensie is geïnstalleerd.

Uw Q#-bewerkingen maken en importeren

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

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

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 de map /src in uw project als Source.qs.


    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
}

Open een ander bestand in de hoofdmap van het project (met het qsharp.json bestand) en sla het op als randomNum.py.
Voeg de volgende code toe om de qsharp en azure.quantum modules te importeren.
```
import qsharp
import azure.quantum
```
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 <naamruimte.<>operation_name( )>, en in dit geval geeft u het aantal willekeurige bits door dat moet worden geretourneerd.

Notitie

Omdat er geen naamruimte is opgegeven, Source.qsgebruikt de compiler de bestandsnaam als de standaardnaamruimte - Source.RandomNBits(). Zie Projecten en impliciete naamruimten voor meer informatie.
```
qsharp.init(project_root = '../MyProjectRootFolder')
print(qsharp.eval("Source.RandomNBits(4)"))
```
```
[Zero, One, One, Zero]
```

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

result = qsharp.run("Source.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 in de lokale kwantumsimulator, kunt u elk type Q#-programma verzenden. 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. Op dit moment is dat het Base of Adpative_RI profiel. Zie Profieltypen in Azure Quantum voor meer informatie.

Notitie

Voor alleen Q#-programma's in VS Code wordt het Base profiel automatisch ingesteld.

Gebruik de init methode om het profiel in te stellen:
```
qsharp.init(project_root = '../MyProjectRootFolder', target_profile=qsharp.TargetProfile.Base)
```
Notitie

Omdat u de qsharp-status opnieuw initialiseert, moet u de project_root parameter opnieuw instellen, zodat de compiler weet waar de RandomNBits bewerking moet worden gevonden. Dit kan ook zijn gedaan in stap 5 van de vorige procedure.
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 alle kwantumhardware:
```
MyProgram = qsharp.compile("Source.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 uw taak verbinden en verzenden met behulp van Azure CLI. Als u Azure CLI gebruikt, moet u het gecompileerde programma opslaan als tekstbestand en dat bestand verzenden met behulp van een CLI-opdracht.

Python gebruiken
Met behulp van de Azure CLI

Voeg de volgende code toe aan randomNum.pyhet invullen van uw resource-id en locatie vanuit uw Azure Quantum-werkruimte:
```
workspace = azure.quantum.Workspace(
    resource_id = "MyResourceID",
    location = "MyLocation"
)
```

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

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

Selecteer het rigetti.sim.qvmtargetvolgende:

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

Gebruik ten slotte de submit methode om uw programma te verzenden met de bijbehorende parameters. De taakresultaten worden geretourneerd als een Python-woordenlijst.
```
job = MyTarget.submit(MyProgram, "MyPythonJob", shots=100)
results = job.get_results()
print("\nResults: ", results)
```

Alleen de waarden extraheren en weergeven:

for x in results:
    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

Alle eigenschappen van de taak zijn toegankelijk in job.detailsbijvoorbeeld:

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

Aanvullende taakdetails

Het azure.quantum Python-pakket bevat aanvullende methoden om gedetailleerdere taakgegevens weer te geven.

job.get_results_histogram(): Deze methode retourneert een woordenlijst met de resultaten en het aantal shots voor elke unieke meting. De resultaten voor de vorige taak zijn bijvoorbeeld

results = job.get_results_histogram()
for x in results.items():
    print(x)

{   
    '[0, 0, 0, 0]' : {'Outcome' : [0, 0, 0, 0], 'Count' : 30},  
    '[1, 0, 0, 0]' : {'Outcome' : [1, 0, 0, 0], 'Count' : 10},
    '[1, 1, 1, 1]' : {'Outcome' : [1, 1, 1, 1], 'Count' : 30},
    '[0, 1, 1, 1]' : {'Outcome' : [0, 1, 1, 1], 'Count' : 30}
}

job.get_results_shots() : Deze methode retourneert een lijst met elk shotresultaat. De resultaten voor de vorige taak zijn bijvoorbeeld

print(job.get_results_shots())

[ [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1], [1, 1, 1, 1], [1, 0, 0, 0], [0, 1, 1, 1], [0, 0, 0, 0], ...]

Als u een taak wilt verzenden naar Azure Quantum met de Azure CLI, moet u een fysiek bestand indienen van het programma dat u zojuist hebt gecompileerd.

Voeg toe aan de volgende code aan uw randomNum.py bestand. Hiermee opent u een tekstbestand en schrijft u het gecompileerde programma naar de juiste indeling.
```
file = open("compiled_output.txt", "w")
file.write(MyProgram._ll_str)
file.close()
```
Als u de taak wilt verzenden naar Azure Quantum, meldt u zich aan met de Azure CLI:
```
az login
```
Zorg ervoor dat u de nieuwste versie van de Azure CLI-extensie quantum uitvoert:
```
az extension add --upgrade --name quantum
```
Geef het abonnement op dat u wilt gebruiken op basis van het abonnement dat is gekoppeld aan uw Azure-account. U kunt uw abonnements-id ook vinden in het overzicht van uw werkruimte in Azure Portal.
```
az account set -s <MySubscriptionID>
```
Bekijk uw beschikbare werkruimten met:
```
az quantum workspace list
```
U kunt een quantum workspace set standaardwerkruimte selecteren die u wilt gebruiken om taken weer te geven en te verzenden.
```
az quantum workspace set \
   -g <MyResourceGroup> \
   -w <MyWorkspace> \
   -l <MyLocation> \
   -o table
```
Geef de beschikbare targets in uw werkruimte weer met:
```
az quantum target list -o table
```
Verzend uw taak met behulp van de job submit opdracht.
- --target-id kan elke targetzijn. Gebruik voor dit voorbeeld de rigetti.sim.qvmtarget.
- --job-name kan elke tekenreeks zijn.
- --job-input-format is altijd qir.v1.
- --job-input-file is de naam van het tekstbestand dat u in stap 1 hebt gemaakt.
- --entry-point is altijd ENTRYPOINT__main
```
az quantum job submit \
    --target-id rigetti.sim.qvm \
    --job-name MyQuantumJob \
    --job-input-format qir.v1 \
    --job-input-file compiled_output.txt \
    --entry-point ENTRYPOINT__main
```

Als u de status van de taak wilt controleren, kopieert u de id uit de uitvoer van de laatste stap en gebruikt u de job show opdracht:

az quantum job show --job-id b0012975-744a-4405-970e-3d8dc4afb2c0 -o table

Name      Id                                    Status     Target           Submission time                   Completion time                  
--------  ------------------------------------  ---------  ---------------  --------------------------------  -------------------------------- 
MyQuantumJob  b2f07cc4-b49b-40b0-b63b-9a4885e5fef5  Succeeded  rigetti.sim.qvm  2023-12-11T05:33:23.187773+00:00  2023-12-11T05:33:29.252742+00:00

Gebruik de job output opdracht om de uitvoer van de taak weer te geven:

az quantum job output --job-id b0012975-744a-4405-970e-3d8dc4afb2c0 -o table

Result        Frequency
------------  -----------  ----------------------
[0, 1, 1, 1]  1.00000000   |████████████████████|

Delen via

Q#-programma's verzenden met Visual Studio Code

Q#-taken verzenden naar Azure Quantum

Vereisten

Een Q#-voorbeeldprogramma laden

Een Q#-programma uitvoeren

Het frequentie histogram visualiseren

Het kwantumcircuit visualiseren

Verbinding maken met Azure Quantum en uw taak verzenden

Jupyter Notebooks-taken verzenden naar Azure Quantum

Vereisten

Uw programma uitvoeren en testen in de lokale simulator

Het kwantumcircuit visualiseren

Uw taak compileren met behulp van het basisprofiel

Verbinding maken met Azure Quantum en uw taak verzenden

Aanvullende taakdetails

Python met Q#-taken verzenden naar Azure Quantum

Vereisten

Uw Q#-bewerkingen maken en importeren

Uw taak compileren met behulp van het basisprofiel

Verbinding maken met Azure Quantum en uw taak verzenden

Aanvullende taakdetails

Feedback

Aanvullende resources

Delen via

Q#-programma's verzenden met Visual Studio Code

Q#-taken verzenden naar Azure Quantum

Vereisten

Een Q#-voorbeeldprogramma laden

Een Q#-programma uitvoeren

Het frequentie histogram visualiseren

Het kwantumcircuit visualiseren

Verbinding maken met Azure Quantum en uw taak verzenden

Jupyter Notebooks-taken verzenden naar Azure Quantum

Vereisten

Uw programma uitvoeren en testen in de lokale simulator

Het kwantumcircuit visualiseren

Uw taak compileren met behulp van het basisprofiel

Verbinding maken met Azure Quantum en uw taak verzenden

Aanvullende taakdetails

Python met Q#-taken verzenden naar Azure Quantum

Vereisten

Uw Q#-bewerkingen maken en importeren

Uw taak compileren met behulp van het basisprofiel

Verbinding maken met Azure Quantum en uw taak verzenden

Aanvullende taakdetails

Gerelateerde inhoud

Feedback

Aanvullende resources