Partager via

Différents types de target profils dans Azure Quantum

Les appareils quantiques sont toujours une technologie émergente et malheureusement, tous ne peuvent pas exécuter chaque programme Q#. Par conséquent, vous devez garder à l’esprit certaines restrictions pendant que vous développez des programmes quantiques. Les target types de profils définissent les fonctionnalités des appareils quantiques que vous target utilisez avec vos programmes Q#. Le Kit de développement Quantum (QDK) a un ensemble de types de profils différents target , qui prennent ensemble en charge toutes les fonctionnalités des appareils quantiques actuels disponibles dans Azure Quantum.

Cet article décrit les différents types de target profils dans Azure Quantum, leurs limitations et comment les configurer dans le QDK.

Profils cibles et leurs limitations

Actuellement, Azure Quantum et QDK gèrent différents target profils, en fonction de leur capacité à exécuter des programmes de représentation intermédiaire quantique (QIR).

  • Unrestricted: Ce profil peut exécuter n’importe quel QIR programme, et ainsi n’importe quel programme Q#, dans les limites de la mémoire pour les simulateurs ou le nombre de qubits pour les ordinateurs quantiques physiques.
  • Base: Ce profil peut exécuter n’importe quel programme Q# qui ne nécessite pas l’utilisation des résultats des mesures qubits pour contrôler le flux du programme. Dans un programme Q# ciblé pour ce type de QPU, les valeurs de type Result ne permettent pas la comparaison d'égalité.
  • Adaptive RI: Ce profil a une capacité limitée à utiliser les résultats des mesures qubit pour contrôler le flux du programme. Dans un programme Q# ciblé pour ce type de QPU, vous pouvez comparer les valeurs de type Result dans les conditions des instructions if au sein des opérations, permettant une mesure en milieu de circuit.
  • Adaptive RIF: Ce profil a les mêmes fonctionnalités que le Adaptive RI profil, mais prend également en charge les opérations à virgule flottante.

Créer et exécuter des programmes pour Unrestrictedtarget profil

Unrestricted target les profils peuvent exécuter tout le programme Q#. Vous pouvez donc écrire du code Q# sans avoir à prendre en compte les restrictions de fonctionnalité. Azure Quantum ne fournit aucun appareil targets réel qui prend en charge ce profil. Toutefois, vous pouvez exécuter Unrestricted des programmes Q# qui ont ce profil sur les simulateurs fournis avec le QDK.

Configurer le Unrestrictedtarget profil

Si vous ne définissez pas manuellement votre QIRtarget profil, le compilateur définit automatiquement le target profil pour vous. Le compilateur choisit le profil le plus restrictif qui permet toujours à votre programme de s’exécuter sur l’appareil target Azure Quantum que vous choisissez.

Pour définir manuellement le QIRtarget profil sur Illimité, 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 target profil directement dans votre code Q#. Pour ce faire, incluez @EntryPoint(Unrestricted) juste avant l’opération de point d’entrée dans votre programme, même si cette opération est la valeur par défaut Main.

  • En Python, appelez la qdk.init méthode pour définir le target profil.

    from qdk import init, TargetProfile

init(target_profile=TargetProfile.Unrestricted)

Créer et exécuter des programmes pour Basetarget profil

Base target les profils peuvent exécuter une grande variété d’applications Q#, avec la contrainte qu’ils ne peuvent pas utiliser de résultats de mesures qubit pour contrôler le flux du programme. Plus précisément, les valeurs de type Result ne prennent pas en charge la comparaison d’égalité.

Par exemple, vous ne pouvez pas exécuter l’opération suivante FlipQubitOnZero sur un Basetarget:

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

L’opération FlipQubitOnZero échoue lorsque vous exécutez ce code sur un Basetarget car l’appareil target ne peut pas utiliser le résultat d’une mesure qubit pour effectuer une logique conditionnelle pendant l’exécution de l’algorithme quantique. Si vous envisagez d’exécuter des algorithmes sur un Basetarget appareil, assurez-vous que votre code ne contient if aucun bloc pour la branche conditionnelle qui s’appuie sur des qubits mesurés pour évaluer une condition logique.

Configurer le Basetarget profil

Pour définir manuellement le profil de QIRtarget sur Base, 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 target profil directement dans votre code Q#. Pour ce faire, incluez @EntryPoint(Base) juste avant l’opération de point d’entrée dans votre programme, même si cette opération est la valeur par défaut Main.

  • En Python, appelez la qdk.init méthode pour définir le target profil.

    from qdk import init, TargetProfile

init(target_profile=TargetProfile.Base)

Pris en charge targets pour le profil Basetarget

Pour l’instant, Azure Quantum fournit l’accès aux éléments suivants Basetargets:

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

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

Créer et exécuter des programmes pour Adaptive RItarget profil

Adaptive RI target les profils peuvent exécuter une plus grande variété d’applications Q# que des Base profils, mais ont toujours certaines limitations. Contrairement aux Basetarget Profils, Adaptive RItargets prend en charge les mesures en milieu de circuit.

Avec les mesures de milieu de circuit, vous pouvez mesurer sélectivement des qubits à n’importe quel point du programme quantique, pas seulement à la fin. Vous pouvez ensuite utiliser les résultats de mesure pour d’autres opérations dans votre programme, comme le branchement conditionnel avec if des blocs. Les qubits que vous mesurez le circuit intermédiaire s’réduisent à un état classique (zéro ou un), mais les qubits non mesurés restent dans leur état quantique.

Lorsque vous mesurez un qubit en Q#, une valeur de type Result est retournée. Si vous souhaitez utiliser ce résultat dans une instruction conditionnelle, vous devez comparer directement dans l’instruction conditionnelle. Les blocs conditionnels correspondants ne peuvent pas contenir d’instructions return ou set.

Par exemple, le code Q# suivant est autorisé dans un Adaptive RItarget:

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

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

Configurer le Adaptive RItarget profil

Pour définir manuellement le profil de QIRtarget sur Adaptive RI, 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 target profil directement dans votre code Q#. Pour ce faire, incluez @EntryPoint(Adaptive_RI) juste avant l’opération de point d’entrée dans votre programme, même si cette opération est la valeur par défaut Main.

  • En Python, appelez la qdk.init méthode pour définir le target profil.

    from qdk import init, TargetProfile

init(target_profile=TargetProfile.Adaptive_RI)

Pris en charge targets pour le profil Adaptive RItarget

Pour l’instant, Quantinuum est le seul fournisseur dans Azure Quantum qui a Adaptive RItargets.

  • Émulateurs:quantinuum.sim.h2-1e et quantinuum.sim.h2-2e
  • QPU :quantinuum.qpu.h2-1 et quantinuum.qpu.h2-2

Pour plus d’informations sur les offres de Quantinuum dans Azure Quantum, consultez Les émulateurs Quantinuum.

Créer et exécuter des programmes pour Adaptive RIFtarget profil

Adaptive RIF target profils possèdent toutes les capacités des profils Adaptive RI, mais prennent également en charge les programmes Q# comportant des calculs en virgule flottante.

Par exemple, le code Q# suivant est autorisé dans un Adaptive RIFtarget:

@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;
}

Configurer le Adaptive RIFtarget profil

Pour définir manuellement le profil de QIRtarget sur Adaptive RIF, 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 target profil directement dans votre code Q#. Pour ce faire, incluez @EntryPoint(Adaptive_RIF) juste avant l’opération de point d’entrée dans votre programme, même si cette opération est la valeur par défaut Main.

  • En Python, appelez la qdk.init méthode pour définir le target profil.

    from qdk import init, TargetProfile

init(target_profile=TargetProfile.Adaptive_RIF)

Pris en charge targets pour le profil Adaptive RIFtarget

Pour l’instant, Azure Quantum n’a pasAdaptive RIFtargets. Toutefois, vous pouvez exécuter des programmes sur Adaptive RIFtargets le simulateur local dans le QDK.

  • Last updated on