Azure Quantum QIR profils cibles dans le QDK

L’informatique quantique est encore une technologie émergente. Le matériel quantique ne peut pas exécuter tous les programmes quantiques. Par exemple, seul un matériel peut effectuer des mesures de circuit intermédiaire, ce qui est nécessaire pour exécuter des programmes avec des branches conditionnelles en fonction des résultats de mesure qubit.

Lorsque vous soumettez un programme à exécuter sur Azure Quantum, votre programme est converti au format de représentation intermédiaire quantique (QIR). QIR ne dépend pas du langage de programmation ou du type de matériel quantique sur lequel votre programme s’exécute. Le MicrosoftQuantum Development Kit (QDK) prend en charge plusieurs profils de cible QIR pour différentes capacités matérielles.

Pour plus d’informations sur QIR, consultez Représentation intermédiaire Quantique.

Vue d’ensemble des profils cibles

Azure Quantum et QDK prennent en charge plusieurs profils cibles QIR. Le type de profil cible que vous choisissez détermine les constructions de programmation suivantes que votre programme peut utiliser.

  • Branches conditionnelles avec des instructions if basées sur les résultats des mesures des qubits
  • Opérations arithmétiques sur les nombres à virgule flottante calculés à partir des résultats de mesure qubit
  • Boucles fixes et non liées basées sur les résultats de mesure qubit

Le tableau suivant répertorie tous les QIR profils cibles dans le QDK, ainsi que les structures de programmation prises en charge par ces profils cibles, par ordre du plus restrictif au moins restrictif.

QIR profil cible les branches conditionnelles ; Opérations en virgule flottante Boucles
Base ❌ ❌ ❌
Adaptive RI ✅ ❌ ❌
Adaptive RIF ✅ ✅ ❌
Adaptive ✅ ✅ ✅
Unrestricted ✅ ✅ ✅

Définir des profils cibles dans le QDK

Pour exécuter un programme sur les simulateurs QDK ou une cible Azure Quantum, vous devez définir un QIR profil de cible. Si vous ne définissez pas manuellement un profil cible, il QDK tente de définir automatiquement le profil approprié pour la cible choisie.

lors de l’envoi de programmes à exécuter via le Azure Quantum service, il QDK tente de sélectionner automatiquement le profil approprié pour la cible d’exécution choisie.

Base QIR profil

Le profil cible de base QIR est le profil cible le plus restrictif. Utilisez le profil de base pour des programmes plus simples qui n’utilisent pas de structures de programmation classiques telles que des branches et des boucles. Si votre cible matérielle quantique ne peut pas effectuer de mesures intermédiaires, vous devez probablement utiliser le profil de base.

Les cibles suivantes Azure Quantum peuvent exécuter des programmes qui utilisent le profil de base QIR .

Provider Simulateur QPU
IonQ ionq.simulator ionq.qpu.*
Rigetti rigetti.sim.* rigetti.qpu.*

Pour en savoir plus sur ces Azure Quantum fournisseurs, consultez le fournisseur IonQ et le fournisseur Rigetti.

Définir le profil de base

Pour définir le profil cible de base QIR dans l’extension QDK pour Visual Studio Code (VS Code), choisissez l’une des options suivantes.

  • Si vous configurez un projet Q#, ajoutez la commande suivante au fichier de qsharp.json votre projet.

    {
  "targetProfile": "base"
}

  • Si vous travaillez dans un .qs fichier qui ne fait pas partie d’un projet Q#, définissez le profil cible directement dans votre code Q#. Pour ce faire, ajoutez @EntryPoint(Base) sur la ligne précédant l’opération d’entrée dans votre programme.

    @EntryPoint(Base)
operation Main() : Unit {

...

}

Pour définir le profil cible de base dans le QDK package Python, exécutez le code suivant.

from qdk import init, TargetProfile

init(target_profile=TargetProfile.Base)

Limitations sur les programmes Q# avec profil de base

Le profil cible de base peut exécuter un large éventail de programmes Q#. La contrainte principale est que les programmes Q# ne peuvent pas effectuer de comparaisons logiques avec Result des valeurs de type à partir d’opérations de mesure.

Par exemple, vous ne pouvez pas exécuter l’opération suivante FlipQubitOnZero sur une cible de base, car le programme contient une if instruction qui utilise un résultat de mesure.

    @EntryPoint(Base)
    operation FlipQubitOnZero() : Unit {
        use q = Qubit();
        if M(q) == Zero {
            X(q);
        }
    }

Adaptive RI QIR profil

Le profil cible ri adaptatif peut exécuter un plus large éventail de programmes que le profil de base, mais présente toujours certaines limitations. Les cibles Adaptive RI prennent en charge les programmes qui utilisent des mesures en cours de circuit dans des instructions conditionnelles if. Si votre matériel quantique peut effectuer des mesures intermédiaires et que votre programme utilise des instructions if fondées sur les résultats des mesures, vous devez probablement utiliser le profil RI adaptatif.

Par exemple, le programme Q# suivant peut s’exécuter sur une cible RI adaptative.

@EntryPoint(Adaptive_RI)
operation MeasureQubit(q : Qubit) : Result { 
    return M(q); 
}

operation SetToZero(q : Qubit) : Unit {
     if MeasureQubit(q) == One { X(q); }
}

Les cibles suivantes Azure Quantum peuvent exécuter des programmes qui utilisent le profil de cible RI adaptatif.

Provider Simulateur QPU
Quantinuum quantinuum.sim.h2-1e quantinuum.qpu.h2-1
Quantinuum quantinuum.sim.h2-2e quantinuum.qpu.h2-2

Pour plus d’informations sur Quantinuum dans Azure Quantum, consultez le fournisseur Quantinuum.

Définir le profil RI adaptatif

Pour définir le profil cible ri QIR adaptatif dans l’extension QDK pour VS Code, choisissez l’une des options suivantes.

  • Si vous configurez un projet Q#, ajoutez la commande suivante au fichier de qsharp.json votre projet :

    {
  "targetProfile": "adaptive_ri"
}

  • Si vous travaillez dans un .qs fichier qui ne fait pas partie d’un projet Q#, définissez le profil cible directement dans votre code Q#. Pour ce faire, ajoutez @EntryPoint(Adaptive_RI) sur la ligne précédant l’opération d’entrée dans votre programme.

    @EntryPoint(Adaptive_RI)
operation Main() : Unit {

...

}

Pour définir le profil cible ri adaptatif dans le QDK package Python, exécutez le code suivant.

from qdk import init, TargetProfile

init(target_profile=TargetProfile.Adaptive_RI)

Adaptive RIF QIR profil

Le profil cible RIF adaptatif a les mêmes fonctionnalités que le profil ri adaptatif, mais prend également en charge les programmes qui contiennent des opérations arithmétiques à virgule flottante. Si votre matériel quantique peut effectuer des mesures en cours de circuit et que votre programme utilise des instructions if ainsi que des nombres à virgule flottante calculés à partir des résultats des mesures, vous devez probablement utiliser le profil RIF adaptatif.

Par exemple, le programme Q# suivant peut s’exécuter sur une cible RIF adaptative.

@EntryPoint(Adaptive_RIF)
operation DynamicFloat() : Double {
    use q = Qubit();
    H(q);
    mutable f = 0.0;
    if M(q) == One {
        f = 0.5;
    }
    Reset(q);
    return f;
}

Azure Quantum n'a pas de cibles RIF adaptatives pour l'instant, mais vous pouvez exécuter des programmes pour les cibles RIF adaptatives sur les simulateurs locaux QDK . Pour plus d’informations sur les simulateurs dans le QDK, consultez Vue d’ensemble des simulateurs quantiques dans le QDK.

Définir le profil RIF adaptatif

Pour définir le profil cible RIF QIR adaptatif dans l’extension QDK pour VS Code, choisissez l’une des options suivantes.

  • Si vous configurez un projet Q#, ajoutez la commande suivante au fichier de qsharp.json votre projet :

    {
  "targetProfile": "adaptive_rif"
}

  • Si vous travaillez dans un .qs fichier qui ne fait pas partie d’un projet Q#, définissez le profil cible directement dans votre code Q#. Pour ce faire, ajoutez @EntryPoint(Adaptive_RIF) sur la ligne précédant l’opération d’entrée dans votre programme.

    @EntryPoint(Adaptive_RIF)
operation Main() : Unit {

...

}

Pour définir le profil cible RIF adaptatif dans le QDK package Python, exécutez le code suivant.

from qdk import init, TargetProfile

init(target_profile=TargetProfile.Adaptive_RIF)

Adaptive QIR profil

Le profil cible adaptatif a les mêmes fonctionnalités que le profil RIF adaptatif, mais prend également en charge les programmes qui utilisent des boucles basées sur les résultats de mesure. Adaptive les programmes peuvent utiliser des boucles avec un nombre défini d’itérations, ainsi que des boucles « répéter jusqu’au succès » (RUS).

Azure Quantum n'a pas de cibles adaptatives pour l'instant, mais vous pouvez exécuter des programmes pour des cibles adaptatives sur les simulateurs locaux QDK . Pour plus d’informations sur les simulateurs dans le QDK, consultez Vue d’ensemble des simulateurs quantiques dans le QDK.

Définir le profil adaptatif

Pour définir le profil cible adaptatif QIR dans l’extension QDK pour VS Code, choisissez l’une des options suivantes.

  • Si vous configurez un projet Q#, ajoutez la commande suivante au fichier de qsharp.json votre projet :

    {
  "targetProfile": "adaptive"
}

  • Si vous travaillez dans un .qs fichier qui ne fait pas partie d’un projet Q#, définissez le profil cible directement dans votre code Q#. Pour ce faire, ajoutez @EntryPoint(Adaptive) sur la ligne précédant l’opération d’entrée dans votre programme.

    @EntryPoint(Adaptive)
operation Main() : Unit {

...

}

Pour définir le profil cible adaptatif dans le QDK package Python, exécutez le code suivant.

from qdk import init, TargetProfile

init(target_profile=TargetProfile.Adaptive)

Unrestricted QIR profil

Le profil cible illimité peut exécuter tous les programmes quantiques. Aucune cible quantique actuelle ne prend en charge le mode non restreint QIR, mais vous pouvez utiliser le profil non restreint pour exécuter des programmes complexes sur les simulateurs QDK pour le développement quantique.

Définir le profil illimité

Pour définir le profil cible illimité QIR dans l’extension QDK pour VS Code, choisissez l’une des options suivantes.

  • Si vous configurez un projet Q#, ajoutez la commande suivante au fichier de qsharp.json votre projet :

    {
  "targetProfile": "unrestricted"
}

  • Si vous travaillez dans un .qs fichier qui ne fait pas partie d’un projet Q#, définissez le profil cible directement dans votre code Q#. Pour ce faire, ajoutez @EntryPoint(Unrestricted) sur la ligne précédant l’opération d’entrée dans votre programme.

    @EntryPoint(Unrestricted)
operation Main() : Unit {

...

}

Pour définir le profil cible illimité dans le QDK package Python, exécutez le code suivant.

from qdk import init, TargetProfile

init(target_profile=TargetProfile.Unrestricted)
  • Last updated on