Migrieren Ihres Q# Codes zum modernen QDK

Das Azure Quantum Development Kit (Modern QDK), das im Januar 2024 veröffentlicht wurde, ist das standardmäßige Q# Development Kit, das in Visual Studio Code und dem Azure Quantum-Portal verwendet wird. Weitere Informationen zu den neuen Features und Verbesserungen finden Sie unter Neuerungen im modernen QDK.

Wenn Sie über programme verfügen, die für das Microsoft Quantum Development Kit (Classic QDK) geschrieben wurden, müssen mindestens einige Elemente für die neuen APIs, Prozesse und Tools geändert werden. Darüber hinaus gibt es Verbesserungen an der Sprachsyntax, um das Q# Programmieren einfacher und flexibler zu machen.

Dieser Artikel führt Sie durch die gängigsten Szenarien, um Ihren Code auf dem neuen QDK zum Laufen zu bringen. S

Veraltetes Visual Studio als Entwicklungsplattform

Das moderne QDK entfernt die Unterstützung für Visual Studio und die zugehörigen .NET-Quantenbibliotheken. Wenn Sie über vorhandene Visual Studio-Projekte verfügen, wird dringend empfohlen, diese mithilfe der Anleitung in diesem Artikel zum modernen QDK zu migrieren. Wenn Sie weiterhin das klassische QDK für Ihre Projekte verwenden möchten, lesen Sie Weiterarbeiten im klassischen QDK.

Importieren von Modulen aus einer Q# Datei

Für Python-Programme, die (*.qs)-Dateien zum Importieren Q# von Funktionen und Vorgängen als Module verwenden Q# , hat sich die Importsyntax geändert.

Um den Vorgang im klassischen QDK aus der Random() Datei source.qszu importieren und auszuführen:

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

Sie würden die Python-Standard-Importsyntax verwenden:

from Sample import Random

print(Random.simulate())

mit der Anforderung, dass sich source.qs und Ihr Python-Programm im selben Ordner befinden.

Um den gleichen Vorgang mit dem modernen QDK zu importieren, definieren Sie ein Q# Projekt, mit dem Sie Ihre Quelldateien und Bibliotheken effizienter und logischer organisieren können. Ausführliche Schritte zum Definieren eines Q# Projekts finden Sie unter Arbeiten mit Q# Projekten.

Nachdem Sie Ihre Projektordner eingerichtet und eine einfache Manifestdatei erstellt haben, verwenden Sie , qsharp.init um auf Ihren Projektstamm zu verweisen und qsharp.eval auf die Quelldateien zuzugreifen und den <Namespace> zu importieren.<>operation_name.

qsharp.init(project_root = '/MyProjectFolder')
print(qsharp.eval("Sample.Random()"))

Wenn der Vorgang oder die Funktion, die Sie importieren, Eingabewerte akzeptiert, können diese auch übergeben werden:

print(qsharp.eval("Sample.Random(4)"))

Ausführen des Programms im lokalen Simulator

Die meisten In-Memory-Simulatoren aus dem klassischen QDK sind veraltet, sodass der Sparsesimulator als lokaler Standardsimulator in VS Code und im Azure Quantum-Portal beibehalten wird.

Veraltete Simulatoren:

• Simulator für den vollständigen Zustand
• Simulator für Rauschen
• Ablaufverfolgungssimulator
• Toffoli-Simulator

So führen Sie den Standard-Sparsesimulator aus:

Szenario	Methode
In einem Q# Programm in VS Code	Wählen Sie Datei ausführen Q# aus.
In einer Python-Notebookzelle	result=qsharp.eval("EntryPointOperation()") oder result=qsharp.run("EntryPointOperation()", shots=##)
In einer %%qsharp Notebookzelle	EntryPointOperation()

Erzwungene Qubit-Freigabe

Das moderne QDK erzwingt die Anforderung, dass sich Qubits im Zustand "Boden" oder "|0⟩ befinden, bevor sie am Ende ihres Gültigkeitsbereichs freigegeben werden. Dadurch soll verhindert werden, dass Qubits möglicherweise in einem unerwarteten Zustand wiederverwendet werden, wenn Programme auf Quantenhardware ausgeführt werden.

Der folgende Code löst beispielsweise einen Laufzeitfehler aus:

operation MyOperation() : Result {
    use q = Qubit();
        X(q);
        return M(q);
}

und müssen geändert werden, um entweder das Qubit zurückzusetzen, bevor die Messung zurückgegeben wird:

operation MyOperation() : Result {
    use q = Qubit();
        X(q);
        let r = M(q);
        Reset(q);
        return r;
}

oder verwenden Sie einen Vorgang, der das Qubit im Rahmen der Messung zurücksetzt:

open Microsoft.Quantum.Measurement;
operation MyOperation() : Result {
    use q = Qubit();
    X(q);
    return MResetZ(q);
}

Konfigurieren des Basisprofils

Im Gegensatz zum lokalen Simulator unterstützen Azure Quantum-Hardwareziele noch nicht die vollständigen Funktionen, die zum Ausführen aller Q# Programme erforderlich sind. Wenn Sie einen Auftrag an Azure Quantum übermitteln, müssen Sie vor dem Kompilieren des Programms Ihr Zielprofil festlegen, um zu ermitteln Q# , welche Funktionen Ihre Zielhardware unterstützt. Derzeit können nur Programme, die mit dem QIR-Basisprofil kompatibel sind, an Azure Quantum übermittelt werden. Beachten Sie, dass für die Ausführung von Code im lokalen Simulator jede Profilkonfiguration verwendet werden kann.

VS-Code

VS Code zeigt den Profilmodus in der status leiste unten für Q# Dateien an, entweder QIR: Base oder Unrestricted. Der uneingeschränkte Modus ist am nützlichsten für die Ausführung von Code im Simulator. Wenn Sie einen Auftrag an Azure Quantum übermitteln und eine Warnung erhalten, dass ein Programm nicht für das Basisprofil festgelegt ist, wählen Sie uneingeschränkt in der status leiste und dann QIR: Base als Profil aus.

Jupyter Notebook und Python

Verwenden Sie qsharp.init die -Funktion, um das Basisprofil festzulegen:

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

Hinweis

• Die qsharp.init Funktion ersetzt den Magic-Befehl %azure.target-capability .
• Wenn Sie das Zielprofil zurücksetzen, müssen Sie Ihre Q# Zellen oder Importe erneut ausführen, bevor Sie kompilieren.

Kompilieren eines Q# Programms zum Übermitteln an Azure Quantum

Mit dem modernen QDK muss Ihr Programm kompiliert werden, bevor der Auftrag an Azure Quantum übermittelt wird.

Hinweis

Schritt-für-Schritt-Szenarien zum Übermitteln von Aufträgen an Azure Quantum mithilfe von Q# Programmen, Python-Programmen oder Jupyter Notebooks finden Sie unter Übermitteln von Aufträgen an Azure Quantum.

VS-Code

Q# Programme in VS Code kompilieren Ihr Programm automatisch, wenn Sie ein Anbieterziel in Ihrem Arbeitsbereich auswählen und aktuelles Q# Programm übermitteln auswählen. Wenn Compilerfehler auftreten, können Sie die Datei debuggen, indem Sie F5 drücken. Weitere Informationen finden Sie unter Übermitteln von Aufträgen an Azure Quantum.

Jupyter Notebook und Python

Für Jupyter Notebook- und Python-Programme, die die -Klasse zum Herstellen einer Workspace Verbindung mit Azure Quantum verwenden, müssen Sie Ihr Programm kompilieren und es dann mit der Auftragserreichung an Azure Quantum senden.

1. Führen Sie den Code aus, den Q# Sie importiert oder in eine %%qsharp Zelle geschrieben haben.

2. Verwenden Sie die qsharp.compile -Funktion, und übergeben Sie den Vorgang oder die Q# Funktion, die als Einstiegspunkt verwendet werden soll. Für dieses Q# Programm beispielsweise:

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

   Sie würden den MyOperation() Vorgang wie folgt übergeben:

   MyProgram = qsharp.compile("MyOperation()")
   

3. Das kompilierte Ergebnis MyProgram wird dann mit der target.submit -Funktion an Azure Quantum übergeben:

   job = target.submit(MyProgram, "job name", ...)
   

Azure CLI

Sie können auch die Azure CLI verwenden, um Python und Aufträge an Azure Quantum zu verbinden und Q# zu übermitteln. In diesem Szenario müssen Sie Ihr kompiliertes Programm als Textdatei speichern. Eine schritt-für-Schritt-Prozedur finden Sie unter Übermitteln von Aufträgen an Azure Quantum.

Herstellen einer Verbindung mit Azure Quantum

Für Q# Programme in VS Code können Sie eine Verbindung mit Ihrem Azure Quantum-Arbeitsbereich herstellen und Aufträge in VS Code übermitteln.

Bei Python- und Jupyter Notebook-Programmen ist die Standardverbindungsmethode die azure.quantum.Workspace -Klasse, die die veralteten I-Magic-BefehleQ#%azure und das qsharp.azure Modul ersetzt. Beispiele für all diese Befehle finden Sie unter Übermitteln von Aufträgen an Azure Quantum.

Veralteter Magic-Befehl oder -API	Zweck
%azure.connect qsharp.azure.connect()	wksp = azure.quantum.Workspace( resource_id=""", location="")
%azure.target qsharp.azure.target()	target = wksp.get_targets("<target_name>")
%azure.execute qsharp.azure.execute()	job = target.submit(...) Nicht blockierende E/A
%azure.submit qsharp.azure.submit()	job = target.submit(<QirInputData>, <jobName>, input_params={"count: <##>"})
%azure.jobs qsharp.azure.jobs()	wksp.list_jobs()
%azure.output qsharp.azure.output()	job.get_results()
%azure. status qsharp.azure. status()	job.details. status
%azure.quotas	wksp.get_quotas()

Andere veraltete Magic-Befehle

Veralteter Magic-Befehl
%check_kata	Als veraltet markiert
%chemistry.broombridge	Als veraltet markiert
%chemistry.encode	Als veraltet markiert
%chemistry.fh.add_terms	Als veraltet markiert
%chemistry.fh.load	Als veraltet markiert
%chemistry.inputstate.load	Als veraltet markiert
%config	Als veraltet markiert
%debug	Als veraltet markiert
%experimental.build_info	Als veraltet markiert
%kata	Als veraltet markiert
%lsmagic	Als veraltet markiert
%lsopen	Als veraltet markiert
%noise_model	Als veraltet markiert
%package	Als veraltet markiert
%performance	Als veraltet markiert
%project	Als veraltet markiert
%wer	Als veraltet markiert
%workspace	Als veraltet markiert