Uw Q# code migreren naar de moderne QDK

De Azure Quantum Development Kit (Modern QDK), uitgebracht in januari 2024, is de standaardontwikkelingskit Q# die wordt gebruikt in Visual Studio Code en de Azure Quantum-portal. Zie Wat is er nieuw in de moderne QDK voor meer informatie over de nieuwe functies en verbeteringen.

Als u bestaande programma's hebt die zijn geschreven voor de Microsoft Quantum Development Kit (klassieke QDK), moeten ten minste enkele elementen worden gewijzigd voor de nieuwe API's, processen en hulpprogramma's. Daarnaast zijn er verbeteringen in de Q# taalsyntaxis om het coderen eenvoudiger en flexibeler te maken.

In dit artikel wordt u begeleid bij de meest voorkomende scenario's om uw code aan de slag te laten gaan met de nieuwe QDK. S

Visual Studio wordt afgeschaft als ontwikkelplatform

De moderne QDK verwijdert de ondersteuning voor Visual Studio en de bijbehorende .NET-kwantumbibliotheken. Als u bestaande Visual Studio-projecten hebt, is het raadzaam deze te migreren naar de moderne QDK met behulp van de richtlijnen in dit artikel. Als u de klassieke QDK wilt blijven gebruiken voor uw projecten, raadpleegt u Doorgaan met werken in de klassieke QDK.

Modules importeren uit een Q# bestand

Voor Python-programma's die (*.qs)-bestanden gebruiken Q# om functies en bewerkingen als modules te importeren Q# , is de importsyntaxis gewijzigd.

Als u in de klassieke QDK de Random() bewerking wilt importeren en uitvoeren vanuit het bestand source.qs:

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

gebruikt u de standaardsyntaxis voor Het importeren van Python:

from Sample import Random

print(Random.simulate())

met de vereiste dat source.qs en uw Python-programma zich in dezelfde map bevinden.

Als u dezelfde bewerking wilt importeren met de moderne QDK, definieert u een Q# project, waarmee u uw bronbestanden en bibliotheken op een efficiëntere en logische manier kunt organiseren. Zie Werken met Q# projecten voor gedetailleerde stappen voor het definiëren Q# van een project.

Nadat u uw projectmappen hebt ingesteld en een eenvoudig manifestbestand hebt gemaakt, gebruikt qsharp.init u om te verwijzen naar de hoofdmap van het project en qsharp.eval om toegang te krijgen tot de bronbestanden en de <naamruimte> te importeren.<>operation_name.

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

Als de bewerking of functie die u importeert invoerwaarden accepteert, kunnen deze ook worden doorgegeven:

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

Uw programma uitvoeren op de lokale simulator

De meeste in-memory simulators van de klassieke QDK zijn afgeschaft, waardoor de sparse-simulator de standaard lokale simulator blijft in VS Code en de Azure Quantum-portal.

Afgeschafte simulators:

• Simulator van volledige status
• Ruissimulator
• Traceringssimulator
• Toffoli-simulator

Ga als volgt te werk om de standaardsparse-simulator uit te voeren:

Scenario	Methode
In een Q# programma in VS Code	Selecteer Bestand uitvoeren Q#
In een Python-notebookcel	result=qsharp.eval("EntryPointOperation()") of result=qsharp.run("EntryPointOperation()", shots=##)
In een %%qsharp notebookcel	EntryPointOperation()

Afgedwongen qubitrelease

De moderne QDK dwingt de vereiste af dat qubits zich in de status grond of |0⟩ bevinden voordat ze aan het einde van hun bereik worden vrijgegeven. Dit is om te voorkomen dat qubits mogelijk opnieuw worden gebruikt in een onverwachte status bij het uitvoeren van programma's op kwantumhardware.

Met de volgende code wordt bijvoorbeeld een runtimefout geactiveerd:

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

en moet worden gewijzigd om de qubit opnieuw in te stellen voordat de meting wordt geretourneerd:

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

of gebruik een bewerking waarmee de qubit opnieuw wordt ingesteld als onderdeel van het uitvoeren van de meting:

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

Het basisprofiel configureren

In tegenstelling tot de lokale simulator bieden Azure Quantum-hardwaredoelen nog geen ondersteuning voor de volledige mogelijkheden die nodig zijn om alle Q# programma's uit te voeren. Als u een taak naar Azure Quantum verzendt, moet u voordat u het programma compileert, uw doelprofiel instellen om te bepalen Q# welke mogelijkheden uw doelhardware ondersteunt. Op dit moment kunnen alleen programma's die voldoen aan het QIR-basisprofiel worden ingediend bij Azure Quantum. Houd er rekening mee dat voor het uitvoeren van code op de lokale simulator elke profielconfiguratie kan worden gebruikt.

VS-code

VS Code geeft de profielmodus weer in de statusbalk onderaan voor Q# bestanden, QIR: Basis of Onbeperkt. De onbeperkte modus is het handigst voor het uitvoeren van code op de simulator. Als u een taak naar Azure Quantum verzendt en een waarschuwing krijgt dat er geen programma is ingesteld voor het basisprofiel, selecteert u Onbeperkt in de statusbalk en selecteert u QIR: Base als profiel.

Jupyter-notebooks en Python

Als u het basisprofiel wilt instellen, gebruikt u de qsharp.init functie:

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

Notitie

• De qsharp.init functie vervangt de magic-opdracht %azure.target-capability .
• Als u het doelprofiel opnieuw instelt, moet u de Q# cellen of importbewerkingen opnieuw uitvoeren voordat u compileert.

Een programma compileren Q# om te verzenden naar Azure Quantum

Met de moderne QDK moet uw programma worden gecompileerd voordat u de taak naar Azure Quantum verzendt.

Notitie

Zie Taken verzenden naar Azure Quantum voor stapsgewijze scenario's voor het verzenden van taken naar Azure Quantum met behulp van Q# programma's, Python-programma's of Jupyter Notebooks.

VS-code

Q# programma's in VS Code compileren uw programma automatisch wanneer u een providerdoel selecteert in uw werkruimte en Huidig Q# programma verzenden selecteert. Als er compilerfouten zijn, kunt u fouten in het bestand opsporen door op F5 te drukken. Zie Taken verzenden naar Azure Quantum voor meer informatie.

Jupyter-notebooks en Python

Voor Jupyter Notebook- en Python-programma's die de Workspace klasse gebruiken om verbinding te maken met Azure Quantum, moet u uw programma compileren en het vervolgens naar Azure Quantum verzenden met de inzender van de taak.

1. Voer de Q# code uit die u hebt geïmporteerd of geschreven in een %%qsharp cel.

2. Gebruik de qsharp.compile functie, waarbij u de Q# bewerking of functie doorgeeft die als invoerpunt moet worden gebruikt. Bijvoorbeeld voor dit Q# programma:

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

   U geeft de MyOperation() bewerking door als:

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

3. Het gecompileerde resultaat MyProgram wordt vervolgens doorgegeven aan Azure Quantum met de target.submit functie :

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

Azure CLI

U kunt ook de Azure CLI gebruiken om Python en taken te verbinden en Q# te verzenden naar Azure Quantum. Voor dit scenario moet u het gecompileerde programma opslaan als een tekstbestand. Zie Taken verzenden naar Azure Quantum voor de stapsgewijze procedure.

Verbinding maken met Azure Quantum

Voor Q# programma's in VS Code kunt u verbinding maken met uw Azure Quantum-werkruimte en taken indienen binnen VS Code.

Voor Python- en Jupyter Notebook-programma's is de standaardverbindingsmethode de azure.quantum.Workspace klasse, die de afgeschafte I-magic-opdrachtenQ#%azure en de qsharp.azure module vervangt. Zie Taken verzenden naar Azure Quantum voor voorbeelden van al deze opdrachten.

Afgeschafte magic-opdracht of API	Gebruik
%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(...) Niet-blokkerende I/O
%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 afgeschafte magic-opdrachten

Afgeschafte magic-opdracht
%check_kata	Afgeschaft
%chemistry.broombridge	Afgeschaft
%chemistry.encode	Afgeschaft
%chemistry.fh.add_terms	Afgeschaft
%chemistry.fh.load	Afgeschaft
%chemistry.inputstate.load	Afgeschaft
%config	Afgeschaft
%foutopsporing	Afgeschaft
%experimental.build_info	Afgeschaft
%kata	Afgeschaft
%lsmagic	Afgeschaft
%lsopen	Afgeschaft
%noise_model	Afgeschaft
%package	Afgeschaft
%prestaties	Afgeschaft
%project	Afgeschaft
%wie	Afgeschaft
%werkruimte	Afgeschaft