Migrer votre Q# code vers le QDK moderne

Le kit de développement Azure Quantum (QDK moderne), publié en janvier 2024, est le kit de développement par défaut Q# utilisé dans Visual Studio Code et le portail Azure Quantum. Pour plus d’informations sur les nouvelles fonctionnalités et améliorations, consultez Nouveautés du QDK moderne.

Si vous avez des programmes existants écrits pour le Kit de développement Microsoft Quantum (QDK classique), au moins certains éléments devront être modifiés pour les nouvelles API, processus et outils. En outre, la syntaxe du Q# langage a été améliorée pour faciliter et rendre le codage plus flexible.

Cet article vous guide à travers les scénarios les plus courants pour que votre code soit opérationnel sur le nouveau QDK. S

Dépréciation de Visual Studio en tant que plateforme de développement

Le QDK moderne supprime la prise en charge de Visual Studio et des bibliothèques quantiques .NET associées. Si vous avez des projets Visual Studio existants, il est vivement recommandé de les migrer vers le QDK moderne en suivant les instructions de cet article. Pour continuer à utiliser le QDK classique pour vos projets, consultez Continuer à travailler dans le QDK classique.

Importation de modules à partir d’un Q# fichier

Pour les programmes Python qui utilisent Q# des fichiers (*.qs) pour importer Q# des fonctions et des opérations en tant que modules, la syntaxe d’importation a changé.

Dans le QDK classique, pour importer et exécuter l’opération Random() à partir du fichier source.qs:

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

vous utiliseriez la syntaxe d’importation Python standard :

from Sample import Random

print(Random.simulate())

avec l’exigence que source.qs et votre programme Python se trouvaient dans le même dossier.

Pour importer la même opération avec le QDK moderne, vous définissez un Q# projet, qui vous permet d’organiser vos fichiers et bibliothèques sources de manière plus efficace et logique. Pour obtenir des étapes détaillées pour définir un Q# projet, consultez Utilisation de Q# projets.

Une fois que vous avez configuré vos dossiers de projet et créé un fichier manifeste simple, utilisez qsharp.init pour pointer vers la racine de votre projet et qsharp.eval accéder aux fichiers sources et importer l’espace <de noms>.<>operation_name.

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

Si l’opération ou la fonction que vous importez prend des valeurs d’entrée, celles-ci peuvent également être transmises :

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

Exécution de votre programme sur le simulateur local

La plupart des simulateurs en mémoire du QDK classique ont été dépréciés, ce qui laisse le simulateur partiellement alloué comme simulateur local par défaut dans VS Code et le portail Azure Quantum.

Simulateurs déconseillés :

• Simulateur d’état complet
• Simulateur de bruit
• Simulateur de trace
• Simulateur Toffoli

Pour exécuter le simulateur éparse par défaut :

Scénario	Méthode
Dans un Q# programme dans VS Code	Sélectionnez Exécuter le Q# fichier
Dans une cellule de notebook Python	result=qsharp.eval("EntryPointOperation()") ou result=qsharp.run("EntryPointOperation()", shots=##)
Dans une cellule de %%qsharp notebook	EntryPointOperation()

Mise en production de qubits appliquée

Le QDK moderne applique la condition que les qubits soient à l’état sol ou |0⟩ avant d’être libérés à la fin de leur étendue. Il s’agit d’empêcher la réutilisation des qubits dans un état inattendu lors de l’exécution de programmes sur du matériel quantique.

Par exemple, le code suivant déclenche une erreur d’exécution :

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

et doivent être modifiés pour réinitialiser le qubit avant de retourner la mesure :

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

ou utilisez une opération qui réinitialise le qubit dans le cadre de la prise de la mesure :

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

Configurer le profil de base

Contrairement au simulateur local, les cibles matérielles Azure Quantum ne prennent pas encore en charge toutes les fonctionnalités requises pour exécuter tous les Q# programmes. Si vous envoyez un travail à Azure Quantum, avant de compiler le programme, vous devez définir votre profil cible pour indiquer Q# les fonctionnalités prises en charge par votre matériel cible. Actuellement, seuls les programmes conformes au profil de base QIR peuvent être soumis à Azure Quantum. Notez que pour exécuter du code sur le simulateur local, n’importe quelle configuration de profil peut être utilisée.

VS Code

VS Code affiche le mode profil dans la barre de status en bas pour Q# les fichiers, QIR : Base ou Sans restriction. Le mode sans restriction est particulièrement utile pour exécuter du code sur le simulateur. Si vous envoyez un travail à Azure Quantum et recevez un avertissement indiquant qu’un programme n’est pas défini pour le profil de base, sélectionnez Sans restriction dans la barre de status, puis sélectionnez QIR : Base comme profil.

Jupyter Notebook et Python

Pour définir le profil de base, utilisez la qsharp.init fonction :

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

Notes

• La qsharp.init fonction remplace la commande magique %azure.target-capability .
• Si vous réinitialisez le profil cible, vous devez réexécuter vos Q# cellules ou importations avant de compiler.

Compilation d’un Q# programme à soumettre à Azure Quantum

Avec le QDK moderne, votre programme doit être compilé avant de soumettre le travail à Azure Quantum.

Notes

Pour obtenir des scénarios pas à pas permettant d’envoyer des travaux à Azure Quantum à l’aide Q# de programmes, de programmes Python ou de jupyter Notebooks, consultez Envoyer des travaux à Azure Quantum.

VS Code

Q#les programmes dans VS Code compilent automatiquement votre programme lorsque vous sélectionnez une cible de fournisseur dans votre espace de travail et sélectionnez Envoyer le programme actuelQ#. En cas d’erreurs de compilateur, vous pouvez déboguer le fichier en appuyant sur F5. Pour plus d’informations, consultez Envoyer des travaux à Azure Quantum.

Jupyter Notebook et Python

Pour les programmes Jupyter Notebook et Python qui utilisent la Workspace classe pour se connecter à Azure Quantum, vous devez compiler votre programme, puis l’envoyer à Azure Quantum avec la tâche envoyée.

1. Exécutez le Q# code que vous avez importé ou écrit dans une %%qsharp cellule.

2. Utilisez la qsharp.compile fonction, en passant l’opération ou la Q# fonction à utiliser comme point d’entrée. Par exemple, pour ce Q# programme :

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

   vous transmettez l’opération MyOperation() comme suit :

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

3. Le résultat MyProgram compilé est ensuite passé à Azure Quantum avec la target.submit fonction :

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

Azure CLI

Vous pouvez également utiliser Azure CLI pour vous connecter et envoyer Python et Q# des travaux à Azure Quantum. Pour ce scénario, vous devez enregistrer votre programme compilé sous forme de fichier texte. Pour connaître la procédure pas à pas, consultez Envoyer des travaux à Azure Quantum.

Connexion à Azure Quantum

Pour Q# les programmes dans VS Code, vous pouvez vous connecter à votre espace de travail Azure Quantum et envoyer des travaux dans VS Code.

Pour les programmes Python et Jupyter Notebook, la méthode de connexion par défaut est la azure.quantum.Workspace classe, qui remplace les commandes magiques IQ#%azure dépréciées et le qsharp.azure module. Pour obtenir des exemples de toutes ces commandes, consultez Envoyer des travaux à Azure Quantum.

Commande magique ou API déconseillée	Utilisation
%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 (...) E/S non bloquantes
%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()

Autres commandes magiques déconseillées

Commande magique déconseillée
%check_kata	Déprécié
%chemistry.broombridge	Déprécié
%chemistry.encode	Déprécié
%chemistry.fh.add_terms	Déprécié
%chemistry.fh.load	Déprécié
%chemistry.inputstate.load	Déprécié
%config	Déprécié
%debug	Déprécié
%experimental.build_info	Déprécié
%kata	Déprécié
%lsmagic	Déprécié
%lsopen	Déprécié
%noise_model	Déprécié
%package	Déprécié
%performance	Déprécié
%project	Déprécié
%who	Déprécié
%workspace	Déprécié