Erste Schritte mit Q#-Programmen und Visual Studio Code

In diesem Artikel finden Sie die Schritte zum Verwenden von VC Code zum Erstellen und Übermitteln von Q#-, Jupyter Notebook- oder Python-Quantencomputingaufträgen an Azure Quantum mithilfe von VS 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

Installationsdetails finden Sie unter Installieren des modernen QDK in VS Code.

Laden eines Q#-Beispielprogramms

  1. Wählen Sie in VS Code Datei > Neue Textdatei aus, und speichern Sie die Datei als RandomNum.qs.

  2. Öffnen Sie RandomNum.qs , und geben Sie sampleein, und wählen Sie dann Zufälliges Bitbeispiel aus der Liste der Optionen aus, und speichern Sie die Datei.

    Screenshot der Q#-Datei in Visual Studio Code mit der Liste der Codebeispiele beim Schreiben des Wortbeispiels in 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 oder Migrieren Ihrer Programme zum modernen QDK.

Ausführen eines Q#-Programms

  1. Um die lokale Ausführung Des Programms im integrierten Simulator zu testen, klicken Sie in der Liste der Befehle unten @EntryPoint()auf Ausführen, oder drücken Sie STRG+F5. Ihre Ausgabe wird in der Debugkonsole angezeigt.

  2. Klicken Sie zum Debuggen Ihres Programms vor der Übermittlung an Azure Quantum in der Liste der Befehle unten @EntryPoint()auf Debuggen, oder drücken Sie F5. Verwenden Sie die Debugsteuerelemente oben, um den Code zu, in und aus dem Code zu wechseln. Weitere Informationen zum Debuggen von Q#-Programmen finden Sie unter Testen und Debuggen.

    Screenshot der Q#-Datei in Visual Studio Code, die zeigt, wo die Codelinse mit Ausführungs- und Debugbefehlen zu finden ist.

Zeichnen des Häufigkeitshistogramms

Das Häufigkeitshistogramm stellt die Verteilung der Ergebnisse dar, die beim mehrfachen Ausführen eines Quantenprogramms oder "Shots" erzielt werden. Jeder Balken im Histogramm entspricht einem möglichen Ergebnis, und seine Höhe stellt die Anzahl der Beobachteten dar. Das Häufigkeitshistogramm hilft dabei, die Wahrscheinlichkeitsverteilung dieser Ergebnisse zu visualisieren.

  1. Wählen Sie Ansicht –> Befehlspalette aus , und geben Sie "Histogramm" ein, das die Option Q#: Datei ausführen und Histogramm anzeigen anzeigen soll. Sie können auch in der Liste der Befehle unten @EntryPoint()auf Histogramm klicken. Wählen Sie diese Option aus, um das Q#-Histogrammfenster zu öffnen.

    Screenshot der Q#-Datei in Visual Studio Code, die zeigt, wo das Codeobjektiv mit dem Befehl Histogramm zu finden ist.

  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 oben links auf das Einstellungssymbol , um Optionen anzuzeigen.

    Screenshot des Q#-Histogrammfensters in Visual Studio Code, das zeigt, wie Einstellungen angezeigt werden.

  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 jedes Ergebnisses liegt bei fast 50%.

    Screenshot des Q#-Histogrammfensters in Visual Studio Code

Tipp

Sie können das Histogramm mithilfe des Mauslaufrads oder einer Trackpad-Geste vergrößern. Wenn Sie verkleinert sind, können Sie das Diagramm verschieben, indem Sie beim Scrollen "ALT" drücken.

Herstellen einer Verbindung mit Azure Quantum und Übermitteln Ihres Auftrags

Verwenden Sie die integrierten Quantum-Arbeitsbereiche , um Aufträge direkt aus VS Code herzustellen und zu übermitteln. In diesem Beispiel übermitteln Sie einen Auftrag an den Rigetti-Simulator.

  1. Erweitern Sie im Bereich ExplorerQuantenarbeitsbereiche.

    Screenshot von Visual Studio Code, der zeigt, wie der Bereich Quantum-Arbeitsbereich erweitert wird.

  2. Wählen Sie Vorhandenen Arbeitsbereich hinzufügen aus, und folgen Sie den Anweisungen, um eine Verbindung mit Ihrem bevorzugten Verzeichnis, Abonnement und Arbeitsbereich herzustellen.

  3. Wenn Sie verbunden sind, erweitern Sie Ihren Arbeitsbereich, und erweitern Sie den Rigetti-Anbieter .

  4. Wählen Sie rigetti.sim.qvm als Ihre targetaus.

    Screenshot von Visual Studio Code: Auswählen des Rigetti-Simulators als target.

  5. Wählen Sie rechts neben dem Namen das target Wiedergabesymbol aus, um mit der Übermittlung des aktuellen Q#-Programms zu beginnen. Wenn Sie ein Popup erhalten, wählen Sie Ändern des QIR-Profils target aus, und fahren Sie fort.

    Screenshot von Visual Studio Code: Ausführen des Rigetti-Simulators als target.

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

  7. Fügen Sie die Anzahl der Aufnahmen oder die Häufigkeit der Ausführung des Programms hinzu.

  8. Drücken Sie die EINGABETASTE , um den Auftrag zu übermitteln. Der Auftrag status wird unten auf dem Bildschirm angezeigt.

  9. Erweitern Sie Aufträge, und zeigen Sie auf Ihren Auftrag, der die Zeiten und status Ihres Auftrags anzeigt.

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

    Screenshot von Visual Studio Code, der zeigt, wie Sie die Ergebnisse Ihres Quantenauftrags herunterladen und anzeigen.

Übermitteln von Jupyter Notebooks-Aufträgen an Azure Quantum

Erfahren Sie, wie Sie VS Code verwenden, um eine Q#-Jupyter Notebook an Azure Quantum auszuführen, zu debuggen und zu übermitteln. Die Schritte in diesem Artikel gelten auch für Jupyter Notebooks auf Ihrem lokalen Jupyter-Server oder Notebooks im Azure Quantum-Portal.

Voraussetzungen

Installationsdetails finden Sie unter Installieren des modernen QDK in VS Code.

Ausführen und Testen des Programms im lokalen Simulator

  1. Wählen Sie in VS Code Befehlspalette anzeigen > aus, und wählen Sie Erstellen: Neuer Jupyter Notebook aus.

  2. Rechts oben erkennt VS Code die Python-Version und die virtuelle Python-Umgebung, die für das Notebook ausgewählt wurde. Wenn Sie über mehrere Python-Umgebungen verfügen, müssen Sie möglicherweise einen Kernel mithilfe der Kernelauswahl oben rechts auswählen. Wenn keine Umgebung erkannt wurde, finden Sie Setupinformationen unter Jupyter Notebooks in VS Code .

  3. Führen Sie in der ersten Zelle des Notebooks aus.

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

    Hinweis

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

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

    %%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. Zum Testen des Vorgangs können Sie die eval -Methode verwenden, die einen beliebigen Q#-Vorgang aufrufen kann, der zuvor im Notebook definiert wurde:

    qsharp.eval("RandomNBits(4)")
    
    [Zero, One, One, Zero]
    
  6. Verwenden Sie die run -Methode, um Ihr Programm im lokalen Simulator auszuführen. Geben Sie die shots- oder die Anzahl der Ausführungsarten für das Programm an, 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]]
    

Kompilieren Ihres Auftrags mithilfe des Basisprofils

Wenn Sie Programme im lokalen Quantensimulator ausführen, können Sie jeden Typ von Q#-Programm ü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 so festlegen, dass Q# darüber informiert wird, 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#-Interpreter neu und kompilieren Ihr Programm mit dem Basisprofil:

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

    qsharp.init(target_profile=qsharp.TargetProfile.Base)
    
  2. Da Sie den Interpreter neu initialisiert haben, müssen Sie Ihren 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
    }
    
  3. Verwenden Sie als Nächstes die compile -Methode, um den Vorgang oder die Funktion anzugeben, die der Einstiegspunkt für Ihr 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 Ihres Auftrags

Nachdem Sie Ihr Programm nun in das richtige Format kompiliert haben, erstellen Sie ein -Objekt, um eine azure.quantum.Workspace 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 von der Übersichtsseite Ihres Arbeitsbereichs im Azure-Portal kopiert werden.

  1. Geben Sie in einer neuen Zelle Ihre Ressourcen-ID und Ihren Speicherort aus Ihrem Azure Quantum-Arbeitsbereich ein:

    MyWorkspace = azure.quantum.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 aus rigetti.sim.qvmtarget:

    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()
    
    {'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. Auf alle Eigenschaften des Auftrags kann in job.detailszugegriffen 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
    

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

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

Voraussetzungen

Installationsdetails finden Sie unter Installieren des modernen QDK in VS Code.

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 beliebige Funktionen aus Ihrem Python-Code aufrufen können. Dies ist besonders hilfreich, wenn Sie ein Programm starten müssen, das Eingabeparameter akzeptiert.

  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 von zufälligen Bits zurückgibt, und speichern Sie die Datei in Ihrem Projekt als source.qs.

    Hinweis

    Beachten Sie, dass dieser Q#-Code keine Funktion wie ein Q#-Programm hat @EntryPoint (siehe Übermitteln von Q#-Aufträgen an Azure Quantum), aber im Gegensatz zu einem Jupyter Notebook einen Namespace erfordert (siehe Übermitteln von Jupyter Notebook Aufträgen an 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. Öffnen Sie im selben Ordner eine andere Datei, und speichern Sie sie als randomNum.py.

  4. Fügen Sie den folgenden Code hinzu, um die qsharp Module und azure.quantum zu importieren.

    import qsharp
    import azure.quantum
    
  5. Fügen Sie als Nächstes Code hinzu, um den Stammordner des Q#-Projekts zu definieren, und führen Sie den target Vorgang im lokalen Simulator durch. Der Vorgang wird nach <Namespace> aufgerufen.<operation_name( )> und in diesem Fall übergeben Sie die Anzahl der zurückzugebenden zufälligen Bits.

    qsharp.init(project_root = '/MyProjectRootFolder')
    print(qsharp.eval("Sample.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 randomNum.pySie in die vorherige print-Anweisung durch Folgendes:

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

Kompilieren Ihres Auftrags mithilfe des Basisprofils

Wenn Sie Programme im lokalen Quantensimulator ausführen, können Sie jeden Typ von Q#-Programmen ü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.

Hinweis

Für nur Q#-Programme in VS Code legt VS Code das Basisprofil automatisch fest.

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

    qsharp.init(target_profile=qsharp.TargetProfile.Base)
    
  2. Verwenden Sie dann die compile -Methode, um den Vorgang oder die Funktion anzugeben, die der Einstiegspunkt in Ihr Programm ist. Das kompilierte Programm kann dann an beliebige Quantenhardware übermittelt werden:

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

Herstellen einer Verbindung mit Azure Quantum und Übermitteln Ihres Auftrags

Sie können eine Verbindung mit Azure Quantum herstellen und Ihren Auftrag mithilfe eines von Python erstellten Workspace Objekts übermitteln oder Ihren Auftrag mithilfe der Azure CLI verbinden und übermitteln. Bei Verwendung der Azure CLI müssen Sie das kompilierte Programm als Textdatei speichern und diese Datei mithilfe eines CLI-Befehls übermitteln.

Nachdem Sie Ihr Programm nun in das richtige Format kompiliert haben, erstellen Sie ein -Objekt, um eine azure.quantum.Workspace 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 von der Übersichtsseite Ihres Arbeitsbereichs im Azure-Portal kopiert werden.

  1. Fügen Sie den folgenden Code zu hinzu randomNum.py, und geben Sie Ihre Ressourcen-ID und Ihren Standort aus Ihrem Azure Quantum-Arbeitsbereich ein:

    workspace = azure.quantum.Workspace(
        resource_id = "MyResourceID",
        location = "MyLocation"
    )
    
  2. 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)
    
  3. Wählen Sie aus rigetti.sim.qvmtarget:

    MyTarget = workspace.get_targets("rigetti.sim.qvm")
    
  4. 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)
    
  5. So extrahieren Sie nur die Werte und zeigen sie an:

    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. Auf alle Eigenschaften des Auftrags kann in job.detailszugegriffen 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': '0fc396d2-97dd-11ee-9958-6ca1004ff31f', 'name': 'MyPythonJob', 'provider_id': 'rigetti'...}
    Job name: MyPythonJob
    Job status: Succeeded
    Job ID: fc396d2-97dd-11ee-9958-6ca1004ff31f
    

Nächste Schritte