So übermitteln Sie Q# Programme mit Visual Studio Code

Übermitteln von Q# Aufträgen an Azure Quantum

Erfahren Sie, wie Sie VS Code verwenden, um ein Q# Programm auszuführen, zu debuggen und an Azure Quantum zu übermitteln.

Voraussetzungen

Details zur Installation finden Sie unter Einrichten der QDK Erweiterung.

• Ein Azure Quantum Arbeitsbereich in Ihrem Azure Abonnement. Informationen zum Erstellen eines Arbeitsbereichs finden Sie unter Erstellen eines Azure Quantum Arbeitsbereichs.
• Die neueste Version von Visual Studio Code oder VS Code im Web öffnen.
• Die neueste Version der Azure Quantum Development Kit Erweiterung.

Laden eines Q# Beispielprogramms

1. Wählen Sie in VS Code> aus, um die Datei als RandomNum.qs zu speichern.

2. Öffnen Sie RandomNum.qs, geben Sie sample ein, wählen Sie dann in der Optionsliste Zufallsbit-Beispiel aus, und speichern Sie die Datei.

   

Ausführen eines Q#-Programms

1. Um das Programm lokal auf dem integrierten Simulator auszuführen, 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.

2. Wenn Sie Ihr Programm debuggen möchten, bevor Sie es 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äufigkeitshistogramm stellt die Verteilung der Ergebnisse dar, die aus dem mehrmaligen Ausführen eines Quantenprogramms, auch "Schüsse" genannt, gewonnen werden. Jeder Balken im Histogramm entspricht einem möglichen Ergebnis, und seine Höhe repräsentiert die Häufigkeit, mit der dieses Ergebnis beobachtet wird. Das Häufigkeits histogramm hilft dabei, die Wahrscheinlichkeitsverteilung dieser Ergebnisse zu visualisieren.

1. Wählen Sie > aus, und geben Sie Histogramm ein, wodurch der Befehl angezeigt wird. Sie können auch Histogramm aus der Liste der Befehle auswählen, die vor dem Einstiegspunktvorgang stehen. Wählen Sie diese Option aus, um das Q# Histogrammfenster zu öffnen.

   

2. 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.

3. Klicken Sie auf das Symbol für Einstellungen oben links, um Optionen anzuzeigen.

   

4. 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 %.

   

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.

1. Wählen Sie View -> Befehlspalette aus und geben Sie circuit ein, wodurch der QDK: Befehl 'Schaltkreis anzeigen' angezeigt wird. Sie können Schaltkreis auch aus der Liste der Befehle neben der Einstiegspunktoperation auswählen.

   

2. 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.

   

Stellen Sie eine Verbindung zu Azure Quantum her und übermitteln Sie den Auftrag.

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

1. Wählen Sie "Ansicht "> - Befehlspalette aus, und geben Sie folgendes ein QDK: Verbinden mit einem Azure Quantum Arbeitsbereich. Drücken Sie die EINGABETASTE.

2. Wählen Sie "Konto" aus, und folgen Sie Azureden 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 einer Verbindungszeichenfolge.

3. Sobald Sie verbunden sind, erweitern Sie im Explorer-Bereich Quantum Workspaces.

4. Erweitern Sie Ihren Arbeitsbereich und erweitern Sie den Anbieter Rigetti .

   Hinweis

   Wenn ein Problem beim Herstellen einer Verbindung zu Azure Quantum besteht, wird neben dem Arbeitsbereichsnamen ein Warnsymbol angezeigt. Zeigen Sie auf den Arbeitsbereichsnamen, um Fehlerinformationen anzuzeigen.

5. Wählen Sie rigetti.sim.qvm als Ihr target.

   

6. Wählen Sie rechts neben dem target Namen das Wiedergabesymbol aus, um mit der Übermittlung des aktuellen Q# Programms zu beginnen.

   

7. Fügen Sie einen Namen hinzu, um den Auftrag zu identifizieren.

8. Fügen Sie die Anzahl der Shots hinzu, oder die Anzahl der Durchläufe des Programms.

9. Drücken Sie die EINGABETASTE, um den Auftrag zu senden. Der Auftragsstatus wird unten auf dem Bildschirm angezeigt.

10. Erweitern Sie Aufträge, und fahren Sie mit der Maus über Ihren Auftrag, um die Zeiten und den Status Ihres Auftrags anzuzeigen.

11. Um die Ergebnisse anzuzeigen, wählen Sie das Cloudsymbol neben dem Auftragsnamen aus, um die Ergebnisse aus Ihrem Arbeitsbereichsspeicher herunterzuladen und in VS Codeanzuzeigen.

    

Senden von Aufträgen an Azure Quantum von Jupyter Notebook

Erfahren Sie, wie Sie VS Code ausführen, debuggen und Q#Jupyter Notebook an Azure Quantum übermitteln können.

Voraussetzungen

Details zur Installation finden Sie unter Einrichten der QDK Erweiterung.

• Ein Azure Quantum Arbeitsbereich in Ihrem Azure Abonnement. Informationen zum Erstellen eines Arbeitsbereichs finden Sie unter Erstellen eines Azure Quantum Arbeitsbereichs.

• Eine Python-Umgebung mit installiertem Python und Pip.

• VS Code mit den Erweiterungen Azure Quantum Development Kit, Python und Jupyter installiert.

• Die qdkPython Bibliothek mit den azure und jupyter Extras sowie dem ipykernel Paket.

  python -m pip install --upgrade "qdk[azure,jupyter]" ipykernel
  

Ausführen und Testen Des Programms im lokalen Simulator

1. In VS Code wählen Sie "Befehlspalette anzeigen>" und "Erstellen: Neu" Jupyter Notebook aus.

2. Oben rechts erkennt und zeigt VS Code die Version von Python und die virtuelle Python Umgebung an, die für das Notizbuch ausgewählt wurden. 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, sehen Sie unter Jupyter NotebookVS Code nach weiteren Informationen zur Einrichtung.

3. Führen Sie in der ersten Zelle des Notizbuchs den folgenden Python Code aus, um die erforderlichen Module zu importieren:

   from qdk import qsharp
   import qdk.azure
   

   • Das qdk.qsharp Modul aktiviert den %%qsharp-Magiebefehl, mit dem Sie Q# Code direkt in eine Zelle eingeben können.
   • Das qdk.azure Modul bietet Konnektivität zu Ihrem Azure Quantum Arbeitsbereich.

   Hinweis

   Wenn der JupyterPython Kernel ipykernel nicht erkannt wird, werden Sie aufgefordert, VS Code ihn zu installieren.

4. 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 sich die Notizbuchzelle von Typ %%qsharp zu Typ Python ändert, sobald Sie den Zauberbefehl Q# eingeben.

   %%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();
           results += [r];
       }
       return results
   }
   

5. Zum Testen des Vorgangs können Sie die eval Methode verwenden, die alle Q# zuvor im Notizbuch definierten Vorgänge aufrufen kann:

   qsharp.eval("RandomNBits(4)")
   

   [Zero, One, One, Zero]
   

6. Verwenden Sie die run Methode, um Ihr Programm auf den lokalen Simulator auszuführen. Geben Sie die shots an, also die Anzahl der Programmausführungen, 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 qdk.widgets Moduls visualisieren. Dieses Modul stellt ein Widget bereit, das ein Quantenkreisdiagramm als SVG-Bild rendert. Weitere Informationen finden Sie unter Quantenschaltungsdiagramme mit Jupyter Notebook.

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

from qdk.qsharp import circuit
from qdk.widgets import Circuit

Circuit(circuit("RandomNBits(4)"))

Weitere Informationen finden Sie unter Quantum Circuits Conventions.

Kompilieren Sie Ihren Auftrag mit dem Basisprofil

Wenn Sie Programme auf dem lokalen Quantensimulator ausführen, können Sie jede Art von Q# Programm übermitteln. Die Azure Quantum Hardware targets unterstützt jedoch noch nicht die vollständigen Fähigkeiten, die zum Ausführen aller Q# Programme erforderlich sind. Um die Programme zu kompilieren und zu übermitteln Q# zu Azure Quantum, müssen Sie Ihr target Profil so festlegen, um anzugeben Q#, 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 und kompilieren Sie Ihr Programm mit dem Basisprofil:

1. Verwenden Sie die init Methode, um das Profil festzulegen:

   from qdk import init, TargetProfile
   
   init(target_profile=TargetProfile.Base)
   

2. 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();
           results += [r];
       }
       return results
   }
   

3. 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:

   from qdk.qsharp import compile
   
   MyProgram = compile("RandomNBits(4)")
   

Stellen Sie eine Verbindung zu Azure Quantum her und übermitteln Sie den Auftrag.

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

1. Füllen Sie in einer neuen Zelle Ihre Ressourcen-ID und Ihren Standort aus Ihrem Azure Quantum Arbeitsbereich aus:

   from qdk.azure import Workspace
   
   MyWorkspace = Workspace(
       resource_id = "MyResourceID",
       location = "MyLocation"
   )
   

2. 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
   

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

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

4. 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}
   

5. Auf alle Eigenschaften des Jobs kann in job.details zugegriffen werden, 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 qdk.azure Modul enthält zusätzliche Methoden zum Anzeigen detaillierterer Auftragsdaten.

• job.get_results_histogram: Diese Methode gibt ein Wörterbuch mit den Ergebnissen und der Shot-Zahl für jede einzelne Messung zurück. Die Ergebnisse für den vorherigen Auftrag wären zum Beispiel

  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ären zum Beispiel

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

Senden Sie Python mit Q# Aufträgen an Azure Quantum

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

Voraussetzungen

Details zur Installation finden Sie unter Einrichten der QDK Erweiterung.

• Ein Azure Quantum Arbeitsbereich in Ihrem Azure Abonnement. Informationen zum Erstellen eines Arbeitsbereichs finden Sie unter Erstellen eines Azure Quantum Arbeitsbereichs.
• Eine Python-Umgebung mit installiertem Python und Pip.
• VS Code mit installierter Azure Quantum Development Kit und Python Erweiterung.
• Die qdkPython Bibliothek mit der azure Erweiterung.
• Azure CLI mit der neuesten installierten Azure Quantum Erweiterung.

Erstellen und Importieren Ihrer Q# Vorgänge

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

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

2. Ö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 /src im Verzeichnis in Ihrem Projekt unter 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();
           results += [r];
       }
       return results
   }
   

3. Öffnen Sie im Projektstammordner (mit der qsharp.json Datei) eine andere Datei, und speichern Sie sie unter randomNum.py.

4. Fügen Sie den folgenden Code hinzu, um die erforderlichen Importe zu laden:

   from qdk import qsharp
   from qdk.azure import Workspace
   

5. Fügen Sie als Nächstes Code hinzu, um den Q# Projektstammordner zu definieren und den target Vorgang im lokalen Simulator auszuführen. 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]
   

6. 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 Sie in randomNum.py den vorherigen Ausdruck 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 Sie Ihren Auftrag mit dem Basisprofil

Wenn Sie Programme auf dem lokalen Quantensimulator ausführen, können Sie jede Art von Q# Programm übermitteln. Die Azure Quantum Hardware targets unterstützt jedoch noch nicht die vollständigen Fähigkeiten, die zum Ausführen aller Q# Programme erforderlich sind. Um Q#-Programme Azure Quantum kompilieren und übermitteln zu können, müssen Sie Ihr target-Profil so festlegen, damit Q# feststellt, welche Funktionen Ihre target-Hardware unterstützt. Derzeit ist das entweder das Base- oder Adpative_RI-Profil. Weitere Informationen finden Sie unter Profiltypen in Azure Quantum.

1. 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.

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

Stellen Sie eine Verbindung zu Azure Quantum her und übermitteln Sie den Auftrag.

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