So übermitteln Sie Q#-Programme mit Visual Studio Code

Artikel
07/23/2024

Erfahren Sie, wie Sie Visual Studio Code zum Erstellen und Übermitteln von Q#-Programmen an echte Quantenhardware verwenden. Sie können Quantum Computing-Aufträge als eigenständiges Q#-Programm an Azure Quantum übermitteln, Q# mit Python in einem Q#-Projekt kombinieren und ein Jupyter-Notizbuch ausführen.

Übermitteln von Q#-Aufträgen an Azure Quantum

Erfahren Sie, wie Sie VS Code zum Ausführen, Debuggen und Übermitteln eines Q#-Programms an Azure Quantum verwenden.

Voraussetzungen

Installationsdetails finden Sie unter Installieren des QDK unter VS Code.

Ein Azure Quantum-Arbeitsbereich in Ihrem Azure-Abonnement. Zur Erstellung eines Arbeitsbereichs, siehe bitte Erstellen eines Azure Quantum Arbeitsbereichs.
Die neueste Version von Visual Studio Code oder öffnen Sie VS Code im Web.
Die neueste Version der Azure Quantum Development Kit-Erweiterung.

Laden eines Q#-Beispielprogramms

Wählen Sie in VS Code "Datei > Neue Textdatei" aus, und speichern Sie die Datei als RandomNum.qs.
Öffnen Sie RandomNum.qs , und geben sampleSie es ein, und wählen Sie dann "Random Bit"-Beispiel aus der Liste der Optionen aus, und speichern Sie die Datei.

Hinweis

Sie können auch Ihre eigene Q#-Datei öffnen. Wenn Sie ein älteres Q#-Programm ausführen und Fehler auftreten, lesen Sie "Testen und Debuggen".

Ausführen eines Q#-Programms

Wenn Sie das Programm lokal auf dem integrierten Simulator testen möchten, klicken Sie in der Liste der Befehle neben dem Einstiegspunktvorgang auf "Ausführen ", oder drücken Sie STRG+F5. Die Ausgabe wird in der Debugkonsole angezeigt.
Wenn Sie Ihr Programm debuggen möchten, bevor Sie es an Azure Quantum übermitteln, klicken Sie in der Liste der Befehle neben dem Einstiegspunktvorgang auf "Debuggen ", oder drücken Sie F5. Mit den Debugsteuerelementen am oberen Rand können Sie den Code schrittweise durchlaufen, zur entsprechenden Stelle im Code gelangen und den Code wieder verlassen. Weitere Informationen zum Debuggen von Q#-Programmen finden Sie unter "Testen und Debuggen".

Visualisieren des Häufigkeits histogramms

Das Häufigkeits histogramm stellt die Verteilung von Ergebnissen dar, die aus dem Ausführen eines Quantenprogramms mehrmals oder "Shots" gewonnen wurden. Jeder Balken im Histogramm entspricht einem möglichen Ergebnis, und seine Höhe stellt die Anzahl der Beobachteten dar. Das Häufigkeits histogramm hilft dabei, die Wahrscheinlichkeitsverteilung dieser Ergebnisse zu visualisieren.

Wählen Sie "Ansicht"> aus, und geben Sie "Histogramm" ein, das die Datei "Q#" anzeigen und die Histogrammoption anzeigen soll. Sie können auch in der Liste der Befehle neben dem Einstiegspunktvorgang auf Histogramm klicken. Wählen Sie diese Option aus, um das Q#-Histogrammfenster zu öffnen.
Geben Sie eine Reihe von Aufnahmen ein, um das Programm auszuführen, z. B. 100 Aufnahmen, und drücken Sie die EINGABETASTE. Das Histogramm wird im Q#-Histogrammfenster angezeigt.
Klicken Sie auf das Symbol für die oberen linken Einstellungen, um Optionen anzuzeigen.
Klicken Sie auf eine Leiste, um den Prozentsatz dieses Ergebnisses anzuzeigen. In diesem Fall gibt es zwei mögliche Ergebnisse, 0 und 1, und der Prozentsatz der einzelnen Ergebnisse liegt bei 50 %.

Tipp

Sie können das Histogramm mithilfe des Mausrads oder einer Trackpadgeste zoomen. Beim Vergrößern können Sie das Diagramm verschieben, indem Sie beim Scrollen die ALT-TASTE drücken.

Visualisieren des Quantenkreises

Quantenschaltungsdiagramme sind eine visuelle Darstellung von Quantenvorgängen. Sie zeigen den Fluss von Qubits durch das Quantenprogramm, einschließlich der Tore und Messungen, die auf sie angewendet werden. Weitere Informationen finden Sie unter Quantenschaltungsdiagramme in Visual Studio Code.

Wählen Sie "Ansicht"> aus, und geben Sie "Schaltkreis" ein, der die Option "Q#: Schaltkreis anzeigen" anzeigen soll. Sie können auch in der Liste der Befehle neben dem Einstiegspunktvorgang auf " Circuit " klicken.
Der Schaltkreis wird im Q#-Schaltkreisfenster angezeigt. Das Schaltkreisdiagramm zeigt ein Qubit-Register, das in den Zustand |0⟩ initialisiert wird. Anschließend wird ein Hadamard-Tor , H, auf das Qubit angewendet, gefolgt von einem Messvorgang, der durch ein Metersymbol dargestellt wird. Weitere Informationen finden Sie unter Quantum Circuits Conventions.

Herstellen einer Verbindung mit Azure Quantum und Übermitteln eines Auftrags

Sie können Aufträge direkt über VS Code verbinden und übermitteln. In diesem Beispiel übermitteln Sie einen Auftrag an den Rigetti-Simulator.

Wählen Sie "Ansicht" aus– Befehlspalette und geben Sie "Q#" ein: Verbinden mit einem Azure Quantum-Arbeitsbereich>. Drücken Sie die EINGABETASTE.
Wählen Sie Azure-Konto aus, und folgen Sie den Anweisungen, um eine Verbindung mit Ihrem bevorzugten Verzeichnis, Abonnement und Arbeitsbereich herzustellen.

Hinweis

Wenn Sie über eine Verbindungszeichenfolge verfügen, können Sie die Verbindungszeichenfolge auswählen und die Verbindungszeichenfolge einfügen, die Ihrem Azure Quantum-Arbeitsbereich entspricht. Weitere Informationen finden Sie unter Herstellen einer Verbindung mit einem Quantum-Arbeitsbereich mithilfe eines Verbindungszeichenfolge.
Sobald Sie verbunden sind, erweitern Sie im Explorer-Bereich Quantum Workspaces.
Erweitern Sie Ihren Arbeitsbereich, und erweitern Sie den Rigetti-Anbieter .

Hinweis

Wenn beim Herstellen einer Verbindung mit Azure Quantum ein Problem vorliegt, wird neben dem Arbeitsbereichsnamen ein Warnsymbol angezeigt. Zeigen Sie auf den Arbeitsbereichsnamen, um Fehlerinformationen anzuzeigen.
Wählen Sie rigetti.sim.qvm als Ihr target.
Wählen Sie das Wiedergabesymbol rechts neben dem target Namen aus, um mit der Übermittlung des aktuellen Q#-Programms zu beginnen. Wenn Sie ein Popup erhalten, wählen Sie das QIR-Profil target ändern und fortfahren.
Fügen Sie einen Namen hinzu, um den Auftrag zu identifizieren.
Add the number of shots, or number of times that the program is run.
Drücken Sie die EINGABETASTE, um den Auftrag zu senden. Der Auftragsstatus wird unten auf dem Bildschirm angezeigt.
Erweitern Sie Aufträge, und zeigen Sie mit der Maus auf Ihren Auftrag. Dadurch werden die Anzahl und der Status Ihres Auftrags angezeigt.
Wählen Sie zum Anzeigen der Ergebnisse das Cloudsymbol neben dem Auftragsnamen aus, um die Ergebnisse aus dem Arbeitsbereichsspeicher herunterzuladen und in VS Code anzuzeigen.

Übermitteln von Aufträgen für Jupyter-Notizbücher an Azure Quantum

Erfahren Sie, wie Sie VS Code zum Ausführen, Debuggen und Übermitteln eines Q#-Jupyter-Notizbuchs an Azure Quantum verwenden. Die Schritte in diesem Artikel gelten auch für Jupyter-Notizbücher auf Ihrem lokalen Jupyter-Server oder -Notizbücher im Azure Quantum-Portal.

Voraussetzungen

Installationsdetails finden Sie unter Installieren des QDK unter VS Code.

Ein Azure Quantum-Arbeitsbereich in Ihrem Azure-Abonnement. Zur Erstellung eines Arbeitsbereichs, siehe bitte Erstellen eines Azure Quantum Arbeitsbereichs.
Eine Python-Umgebung mit installiertem Python und Pip.
VS Code mit installierten Azure Quantum Development Kit-, Python- und Jupyter-Erweiterungen .
Azure Quantum qsharp, qsharp-widgetsund azure-quantum Pakete, und das ipykernel Paket.
```
python -m pip install --upgrade qsharp qsharp-widgets azure-quantum ipykernel
```

Ausführen und Testen Des Programms im lokalen Simulator

Wählen Sie in VS Code die Optionen Ansicht > Befehlspalette und dann Erstellen aus: Verwenden von Jupyter Notebook.
In der oberen rechten Ecke erkennt und zeigt VS Code die Version von Python und die virtuelle Python-Umgebung an, die für das Notizbuch ausgewählt wurde. Wenn Sie über mehrere Python-Umgebungen verfügen, müssen Sie möglicherweise einen Kernel mit der Kernelauswahl oben rechts auswählen. Wenn keine Umgebung erkannt wurde, finden Sie Informationen zum Einrichten unter Jupyter-Notizbücher in VS Code .
Führen Sie in der ersten Zelle des Notizbuchs den folgenden Python-Code aus, um die erforderlichen Module zu importieren:
```
import qsharp
import azure.quantum
```
- Das qsharp Modul aktiviert den %%qsharp magischen Befehl, mit dem Sie Q#-Code direkt in eine Zelle eingeben können.
- Das azure-quantum Modul bietet Konnektivität zu Ihrem Azure Quantum-Arbeitsbereich.
Hinweis

Wenn der Jupyter Python-Kernel ipykernel nicht erkannt wird, werden Sie von VS Code aufgefordert, ihn zu installieren.

Fügen Sie eine weitere Zelle hinzu, und geben Sie diesen Q#-Code ein, der eine vom Benutzer angegebene Anzahl zufälliger Bits zurückgibt:

Hinweis

Beachten Sie, dass die Notizbuchzelle, sobald Sie den Zauberbefehl %%qsharpeingeben, den Typ von Python in Q# ändert.

%%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
}

Zum Testen des Vorgangs können Sie die Methode verwenden, mit der eval alle zuvor im Notizbuch definierten Q#-Vorgänge aufgerufen werden können:
```
qsharp.eval("RandomNBits(4)")
```
```
[Zero, One, One, Zero]
```

Verwenden Sie die run Methode, um Ihr Programm auf den lokalen Simulator auszuführen. Geben Sie das shotsProgramm oder die Häufigkeit an, mit der das Programm ausgeführt werden soll, und der Simulator gibt die Ergebnisse als Python-Liste zurück.

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

Visualisieren des Quantenkreises

Sie können Quantenschaltungen mithilfe des qsharp-widgets Pakets visualisieren. Dieses Paket stellt ein Widget bereit, das ein Quantenschaltungsdiagramm als SVG-Bild rendert. Weitere Informationen finden Sie unter Quantenschaltungsdiagramme mit Jupyter-Notizbüchern.

Fügen Sie einer neuen Zelle den folgenden Code hinzu, um den Schaltkreis zu visualisieren:

from qsharp_widgets import Circuit

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

Screenshot des Jupyter-Notizbuchs, in dem gezeigt wird, wie sie den Schaltkreis für einen Q#-Vorgang visualisieren.

Weitere Informationen finden Sie unter Quantum Circuits Conventions.

Kompilieren Ihres Auftrags mithilfe des Basisprofils

Wenn Sie Programme auf dem lokalen Quantensimulator ausführen, können Sie einen beliebigen Q#-Programmtyp übermitteln. Azure Quantum-Hardware targets unterstützt jedoch noch nicht die vollständigen Funktionen, die zum Ausführen aller Q#-Programme erforderlich sind. Um Q#-Programme zu kompilieren und an Azure Quantum zu übermitteln, müssen Sie Ihr target Profil festlegen, um Q# mitzuteilen, welche Funktionen Ihre target Hardware unterstützt. Derzeit ist dies das Basisprofil. Weitere Informationen finden Sie unter Profiltypen in Azure Quantum.

So initialisieren Sie den Q#-Dolmetscher erneut, und kompilieren Sie Ihr Programm mit dem Basisprofil:

Verwenden Sie die init Methode, um das Profil festzulegen:
```
qsharp.init(target_profile=qsharp.TargetProfile.Base)
```

Da Sie den Dolmetscher neu initialisiert haben, müssen Sie Den Code erneut mit dem neuen Profil ausführen:

%%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
}

Verwenden Sie als Nächstes die compile Methode, um den Vorgang oder die Funktion anzugeben, der der Einstiegspunkt zu Ihrem Programm ist. Dadurch wird Ihr Code in das QIR-Format kompiliert, das dann an jede Quantenhardware übermittelt werden kann:
```
MyProgram = qsharp.compile("RandomNBits(4)")
```

Herstellen einer Verbindung mit Azure Quantum und Übermitteln eines Auftrags

Nachdem Ihr Programm nun in das richtige Format kompiliert wurde, erstellen Sie ein azure.quantum.Workspace Objekt, um eine Verbindung mit Azure Quantum herzustellen. Sie verwenden die Ressourcen-ID Ihres Azure Quantum-Arbeitsbereichs, um eine Verbindung herzustellen. Die Ressourcen-ID und der Speicherort können auf der Übersichtsseite des Arbeitsbereichs im Azure-Portal kopiert werden.

Füllen Sie in einer neuen Zelle Ihre Ressourcen-ID und Ihren Standort aus Ihrem Azure Quantum-Arbeitsbereich aus:
```
MyWorkspace = azure.quantum.Workspace(
    resource_id = "MyResourceID",
    location = "MyLocation"
)
```
Verwenden Sie die get_targets Methode, um die verfügbare Hardware targets in Ihrem Arbeitsbereich anzuzeigen:
```
MyTargets = MyWorkspace.get_targets()
print("This workspace's targets:")
MyTargets
```

Wählen Sie folgendes aus rigetti.sim.qvmtarget:

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

Verwenden Sie schließlich die submit Methode, um Ihr Programm mit seinen Parametern zu übermitteln und die Ergebnisse anzuzeigen:

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}

Auf alle Eigenschaften des Auftrags kann zugegriffen job.detailswerden, z. B.:

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

Weitere Auftragsdetails

Das azure.quantum Python-Paket enthält zusätzliche Methoden zum Anzeigen detaillierterer Auftragsdaten.

job.get_results_histogram(): Diese Methode gibt ein Wörterbuch der Ergebnisse und die Anzahl der Aufnahmen für jede eindeutige Messung zurück. Die Ergebnisse für den vorherigen Auftrag würden z. B.

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() : Diese Methode gibt eine Liste der einzelnen Aufnahmeergebnisse zurück. Die Ergebnisse für den vorherigen Auftrag würden z. B.
```
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], ...]
```

Übermitteln von Python mit Q#-Aufträgen an Azure Quantum

Erfahren Sie, wie Sie VS Code verwenden, um ein Python-Programm zu schreiben, das Q#-Vorgänge aufruft, eine Verbindung mit Azure mithilfe der Python-Befehle oder der Azure CLI herzustellen und Ihren Auftrag zu übermitteln.

Voraussetzungen

Installationsdetails finden Sie unter Installieren des QDK unter VS Code.

Ein Azure Quantum-Arbeitsbereich in Ihrem Azure-Abonnement. Zur Erstellung eines Arbeitsbereichs, siehe bitte Erstellen eines Azure Quantum Arbeitsbereichs.
Eine Python-Umgebung mit installiertem Python und Pip.
VS Code mit installierter Azure Quantum Development Kit - und Python-Erweiterung .
Azure Quantum qsharp und azure-quantum Pakete.
Azure CLI mit der neuesten installierten Azure Quantum-Erweiterung.

Erstellen und Importieren ihrer Q#-Vorgänge

Mit dem qsharp Paket können Sie Ihre Funktionen und Vorgänge in Q#-Dateien speichern und Q#-Projekte erstellen, mit denen Sie sie aus Ihrem Python-Code aufrufen können. Dies ist besonders hilfreich, wenn Sie ein Programm starten müssen, das Eingabeparameter verwendet.

Führen Sie die Schritte zum Erstellen eines Q#-Projekts aus.

Öffnen Sie eine neue Textdatei, fügen Sie den folgenden Q#-Code hinzu, der eine vom Benutzer angegebene Anzahl zufälliger Bits zurückgibt, und speichern Sie die Datei im Verzeichnis "/src " in Ihrem Projekt 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
}

Öffnen Sie im Projektstammordner (mit der qsharp.json Datei) eine andere Datei, und speichern Sie sie unter randomNum.py.
Fügen Sie den folgenden Code hinzu, um die qsharp Module zu azure.quantum importieren.
```
import qsharp
import azure.quantum
```
Fügen Sie als Nächstes Code zum Definieren des Q#-Projektstammordners hinzu, und testen Sie den target Vorgang im lokalen Simulator. Der Vorgang wird vom <Namespace> aufgerufen.<operation_name( )>, und in diesem Fall übergeben Sie die Anzahl der zufälligen Bits, die zurückgegeben werden sollen.

Hinweis

Da kein Namespace angegeben Source.qswurde, verwendet der Compiler den Dateinamen als Standardnamespace - Source.RandomNBits(). Weitere Informationen finden Sie unter Projekte und implizite Namespaces.
```
qsharp.init(project_root = '../MyProjectRootFolder')
print(qsharp.eval("Source.RandomNBits(4)"))
```
```
[Zero, One, One, Zero]
```

Sie können den Vorgang auch mit der run Methode testen, die einen zusätzlichen shots Parameter übergibt, und die Ergebnisse in einer Python-Liste zurückgibt. Ersetzen randomNum.pySie in , die vorherige Druckausweisung durch Folgendes:

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

Kompilieren Ihres Auftrags mithilfe des Basisprofils

Wenn Sie Programme auf dem lokalen Quantensimulator ausführen, können Sie einen beliebigen Q#-Programmtyp übermitteln. Azure Quantum-Hardware targets unterstützt jedoch noch nicht die vollständigen Funktionen, die zum Ausführen aller Q#-Programme erforderlich sind. Um Q#-Programme zu kompilieren und an Azure Quantum zu übermitteln, müssen Sie Ihr target Profil festlegen, um Q# mitzuteilen, welche Funktionen Ihre target Hardware unterstützt. Derzeit ist das entweder das Profil oder Adpative_RI das Base Profil. Weitere Informationen finden Sie unter Profiltypen in Azure Quantum.

Hinweis

Für Q#-Programme in VS Code legt VS Code das Base Profil automatisch fest.

Verwenden Sie die init Methode, um das Profil festzulegen:
```
qsharp.init(project_root = '../MyProjectRootFolder', target_profile=qsharp.TargetProfile.Base)
```
Hinweis

Da Sie den qsharp-Zustand erneut initialisieren, müssen Sie den project_root Parameter erneut festlegen, damit der Compiler weiß, wo der RandomNBits Vorgang gefunden werden soll. Dies könnte auch in Schritt 5 des vorherigen Verfahrens geschehen sein.
Verwenden Sie dann die compile Methode, um den Vorgang oder die Funktion anzugeben, der der Einstiegspunkt für Ihr Programm ist. Das kompilierte Programm kann dann an jede Quantenhardware übermittelt werden:
```
MyProgram = qsharp.compile("Source.RandomNBits(4)")
```

Herstellen einer Verbindung mit Azure Quantum und Übermitteln eines Auftrags

Sie können eine Verbindung mit Azure Quantum herstellen und Ihren Auftrag mithilfe eines python-erstellten Workspace Objekts übermitteln oder Ihren Auftrag mithilfe der Azure CLI verbinden und übermitteln. Wenn Sie Azure CLI verwenden, müssen Sie das kompilierte Programm als Textdatei speichern und diese Datei mit einem CLI-Befehl übermitteln.

Verwenden von Python
Verwenden der Azure-Befehlszeilenschnittstelle

Fügen Sie den folgenden Code hinzu randomNum.py, um Ihre Ressourcen-ID und Ihren Standort aus Ihrem Azure Quantum-Arbeitsbereich auszufüllen:
```
workspace = azure.quantum.Workspace(
    resource_id = "MyResourceID",
    location = "MyLocation"
)
```
Verwenden Sie die get_targets Methode, um die verfügbare Hardware targets in Ihrem Arbeitsbereich anzuzeigen:
```
MyTargets = workspace.get_targets()
print("This workspace's targets:")
for x in MyTargets:
    print(x)
```

Wählen Sie folgendes aus rigetti.sim.qvmtarget:

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

Verwenden Sie schließlich die submit Methode, um Ihr Programm mit seinen Parametern zu übermitteln. Die Auftragsergebnisse werden als Python-Wörterbuch zurückgegeben.
```
job = MyTarget.submit(MyProgram, "MyPythonJob", shots=100)
results = job.get_results()
print("\nResults: ", results)
```

So extrahieren Sie nur die Werte, und zeigen Sie sie an:

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

Auf alle Eigenschaften des Auftrags kann zugegriffen job.detailswerden, z. B.:

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

Weitere Auftragsdetails

Das azure.quantum Python-Paket enthält zusätzliche Methoden zum Anzeigen detaillierterer Auftragsdaten.

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() : Diese Methode gibt eine Liste der einzelnen Aufnahmeergebnisse zurück. Die Ergebnisse für den vorherigen Auftrag würden z. B.
```
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], ...]
```

Um einen Auftrag an Azure Quantum mit der Azure CLI zu übermitteln, müssen Sie eine physische Datei des soeben kompilierten Programms übermitteln.

Fügen Sie ihrer Datei den folgenden Code hinzu randomNum.py . Dadurch wird eine Textdatei geöffnet und das kompilierte Programm in das richtige Format geschrieben.
```
file = open("compiled_output.txt", "w")
file.write(MyProgram._ll_str)
file.close()
```
Um den Auftrag an Azure Quantum zu übermitteln, melden Sie sich mit der Azure CLI an:
```
az login
```
Stellen Sie sicher, dass Sie die neueste Version der Azure CLI-Erweiterung quantum ausführen:
```
az extension add --upgrade --name quantum
```
Geben Sie das Abonnement an, das Sie aus den Abonnements ihres Azure-Kontos verwenden möchten. Sie finden Ihre Abonnement-ID auch in der Übersicht Ihres Arbeitsbereichs im Azure-Portal.
```
az account set -s <MySubscriptionID>
```
Zeigen Sie Ihre verfügbaren Arbeitsbereiche mit:
```
az quantum workspace list
```
Mit dem Befehl quantum workspace set können Sie einen Standardarbeitsbereich auswählen, den Sie zum Auflisten und Übermitteln von Aufträgen verwenden möchten.
```
az quantum workspace set \
   -g <MyResourceGroup> \
   -w <MyWorkspace> \
   -l <MyLocation> \
   -o table
```
Anzeigen der verfügbaren In targets Ihrem Arbeitsbereich mit:
```
az quantum target list -o table
```
Übermitteln Sie Ihren Auftrag mit dem job submit Befehl.
- --target-id kann beliebig targetsein. Verwenden Sie in diesem Beispiel die Datei rigetti.sim.qvmtarget.
- --job-name kann eine beliebige Zeichenfolge sein.
- --job-input-format ist immer qir.v1.
- --job-input-file ist der Name der Textdatei, die Sie in Schritt 1 erstellt haben.
- --entry-point ist immer 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
```

Um den Status des Auftrags zu überprüfen, kopieren Sie die ID aus der Ausgabe des letzten Schritts, und verwenden Sie den job show Befehl:

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

Verwenden Sie den job output Befehl, um die Ausgabe des Auftrags anzuzeigen:

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

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

Freigeben über

So übermitteln Sie Q#-Programme mit Visual Studio Code

Übermitteln von Q#-Aufträgen an Azure Quantum

Voraussetzungen

Laden eines Q#-Beispielprogramms

Ausführen eines Q#-Programms

Visualisieren des Häufigkeits histogramms

Visualisieren des Quantenkreises

Herstellen einer Verbindung mit Azure Quantum und Übermitteln eines Auftrags

Übermitteln von Aufträgen für Jupyter-Notizbücher an Azure Quantum

Voraussetzungen

Ausführen und Testen Des Programms im lokalen Simulator

Visualisieren des Quantenkreises

Kompilieren Ihres Auftrags mithilfe des Basisprofils

Herstellen einer Verbindung mit Azure Quantum und Übermitteln eines Auftrags

Weitere Auftragsdetails

Übermitteln von Python mit Q#-Aufträgen an Azure Quantum

Voraussetzungen

Erstellen und Importieren ihrer Q#-Vorgänge

Kompilieren Ihres Auftrags mithilfe des Basisprofils

Herstellen einer Verbindung mit Azure Quantum und Übermitteln eines Auftrags

Weitere Auftragsdetails

Feedback

Zusätzliche Ressourcen

Freigeben über

So übermitteln Sie Q#-Programme mit Visual Studio Code

Übermitteln von Q#-Aufträgen an Azure Quantum

Voraussetzungen

Laden eines Q#-Beispielprogramms

Ausführen eines Q#-Programms

Visualisieren des Häufigkeits histogramms

Visualisieren des Quantenkreises

Herstellen einer Verbindung mit Azure Quantum und Übermitteln eines Auftrags

Übermitteln von Aufträgen für Jupyter-Notizbücher an Azure Quantum

Voraussetzungen

Ausführen und Testen Des Programms im lokalen Simulator

Visualisieren des Quantenkreises

Kompilieren Ihres Auftrags mithilfe des Basisprofils

Herstellen einer Verbindung mit Azure Quantum und Übermitteln eines Auftrags

Weitere Auftragsdetails

Übermitteln von Python mit Q#-Aufträgen an Azure Quantum

Voraussetzungen

Erstellen und Importieren ihrer Q#-Vorgänge

Kompilieren Ihres Auftrags mithilfe des Basisprofils

Herstellen einer Verbindung mit Azure Quantum und Übermitteln eines Auftrags

Weitere Auftragsdetails

Zugehöriger Inhalt

Feedback

Zusätzliche Ressourcen