Informatique hybride intégrée

L’informatique hybride intégrée regroupe les processus classiques et quantiques, ce qui permet au code classique de contrôler l’exécution d’opérations quantiques basées sur des mesures de circuit intermédiaire alors que les qubits physiques restent actifs. À l’aide de techniques de programmation courantes, telles que les conditions imbriquées, les boucles et les appels de fonction, un programme quantique unique peut exécuter des problèmes complexes, ce qui réduit le nombre de captures nécessaires. À l’aide de techniques de réutilisation qubit, des programmes plus volumineux peuvent s’exécuter sur des machines utilisant un plus petit nombre de qubits.

Pour plus d’informations, consultez :

• Granade & Weibe, « Utilisation de marches aléatoires pour l’estimation de phase itérative ».
• Lubinski, et al., « Advancing Hybrid Quantum-Classic Computation with Real-Time Execution »

Prérequis

• Compte Azure avec un abonnement actif. Si vous n’avez pas de compte Azure, inscrivez-vous gratuitement et inscrivez-vous à un abonnement de paiement à l’utilisation.
• Un espace de travail Azure Quantum. Pour plus d’informations, consultez Créer un espace de travail Azure Quantum.
• Si vous souhaitez soumettre Q# des programmes autonomes, vous avez besoin des conditions préalables suivantes :
  • Visual Studio Code avec l’extension Azure Quantum Development Kit installée.
  • Dernière version de l’extension Azure Quantum Development Kit .
• Si vous souhaitez envoyer Python + Q# programmes, vous avez besoin des conditions préalables suivantes :

  • Un environnement Python avec Python et Pip installés.

  • Azure Quantum azure-quantum et qsharp packages.

    pip install --upgrade azure-quantum qsharp
    

Prise en charge de targets

Actuellement, le modèle d’informatique hybride intégré dans Azure Quantum est pris en charge sur Quantinuumtargets.

Envoi de travaux hybrides intégrés

Lors de l’envoi d’un travail hybride intégré, vous devez configurer le target profil en tant que QIR Adaptive RI. Le QIR Adaptive RItarget profil offre la prise en charge des mesures intermédiaires, du flux de contrôle basé sur les mesures, de la réinitialisation qubit et du calcul d’entier classique.

Vous pouvez soumettre des programmes autonomes hybrides Q# intégrés ou Python + Q# programmes à Azure Quantum. Pour configurer le target profil pour les travaux hybrides intégrés, suivez les instructions ci-dessous.

Q# dans Visual Studio Code

Pour configurer le target profil pour les travaux hybrides intégrés dans Visual Studio Code, procédez comme suit :

1. Ouvrez un Q# programme dans Visual Studio Code.
2. Sélectionnez Afficher -> Palette de commandes et tapez Q# : Définir le profil QIR target Azure Quantum. Appuyez sur Entrée.
3. Sélectionnez QIR Adaptive RI.

Une fois que vous avez défini QIR Adaptive RI le target profil, vous pouvez soumettre votre Q# programme en tant que travail hybride intégré à Quantinuum.

1. Sélectionnez Affichage -> Palette de commandes et type Q#: Se connecter à un espace de travail Azure Quantum. Appuyez sur Entrée.
2. Sélectionnez un compte Azure, puis suivez les invites pour vous connecter à votre annuaire, abonnement et espace de travail préférés.
3. Une fois connecté, dans le volet Explorateur , développez Les espaces de travail Quantum.
4. Développez votre espace de travail et développez le fournisseur Quantinuum .
5. Sélectionnez n’importe quel quantinuum disponible target, par exemple quantinuum.sim.h1-1e.
6. Sélectionnez l’icône de lecture à droite du target nom pour commencer à soumettre le programme actuel Q# .
7. Ajoutez un nom pour identifier le travail et le nombre de captures.
8. Appuyez sur Entrée pour envoyer le travail. L’état du travail s’affiche en bas de l’écran.
9. Développez Travaux et survolez votre travail, ce qui affiche les heures et l’état de votre travail.

Q# + Python

1. Lorsque vous utilisez le package Python qsharp , utilisez la qsharp.init fonction et définissez le target_profile paramètre Adaptive_RIsur .

   import qsharp
   
   qsharp.init(target_profile=qsharp.TargetProfile.Adaptive_RI)
   

2. Connectez-vous à votre espace de travail Azure Quantum.

   import azure.quantum
   
   workspace = azure.quantum.Workspace(
       resource_id = "", # add your resource ID
       location = "", # add your location, for example "westus"
   )
   

3. Définissez le target paramètre sur quantinuum target que vous souhaitez utiliser. Par exemple, pour utiliser :quantinuum.sim.h1-1etarget

   target = workspace.get_targets("quantinuum.sim.h1-1e")
   

Vous pouvez combiner plusieurs travaux hybrides intégrés au sein d’une session à l’aide de la target.open_session fonction. Pour plus d’informations, consultez Prise en main des sessions.

Remarque

Bien que les sessions soient disponibles pour tous les fournisseurs de matériel informatique quantique, notez que Adaptive_RItarget les travaux de profil sont actuellement pris en charge uniquement sur Quantinuum targets.

Fonctionnalités prises en charge

Le tableau suivant répertorie les fonctionnalités prises en charge pour l’informatique hybride intégrée avec Quantinuum dans Azure Quantum.

Fonctionnalité prise en charge	Notes
Valeurs Dynamics	Bools et entiers dont la valeur dépend d’un résultat de mesure
Boucles	Boucles à limite classique uniquement
Flux de contrôle arbitraire	Utilisation du branchement if/else
Mesure du circuit moyen	Utilise des ressources d’inscription classiques
Réutilisation du Qubit	Pris en charge
Calcul classique en temps réel	Arithmétique d’entier signé 64 bits Utilise des ressources d’inscription classiques

Le QDK fournit targetdes commentaires spécifiques lorsque Q# les fonctionnalités de langage ne sont pas prises en charge pour l’élément sélectionné target. Si votre Q# programme contient des fonctionnalités non prises en charge lors de l’exécution de travaux hybrides intégrés, vous recevez un message d’erreur au moment du design. Pour plus d’informations, consultez la page wiki QIR.

Remarque

Vous devez sélectionner le profil approprié pour obtenir les commentaires appropriés QIR Adaptive RItarget lors de l’utilisation Q# de fonctionnalités qui ne prennent target pas en charge.

Copiez le code suivant dans un Q# fichier et ajoutez les extraits de code suivants pour afficher les fonctionnalités prises en charge en action.

namespace HybridIntegrated {
    open Microsoft.Quantum.Measurement;
    open Microsoft.Quantum.Math;
    open Microsoft.Quantum.Convert;

    @EntryPoint()
    operation Main() : Result {
        use (q0, q1) = (Qubit(), Qubit());
        H(q0);
        let r0 = MResetZ(q0);

        // Copy here the code snippets below to see the supported features 
        // in action.
        // Supported features include dynamic values, classically-bounded loops, 
        // arbitrary control flow, and mid-circuit measurement.

        r0
    }

}

Quantinuum prend en charge les bools et entiers dynamiques, ce qui signifie des bools et des entiers qui dépendent des résultats de mesure. Notez qu’il r0 s’agit d’un Result type qui peut être utilisé pour générer des valeurs de bool et d’entier dynamiques.

        let dynamicBool = r0 != Zero; 
        let dynamicBool = ResultAsBool(r0); 
        let dynamicInt = dynamicBool ? 0 | 1; 

Quantinuum prend en charge les bools et entiers dynamiques. Toutefois, il ne prend pas en charge les valeurs dynamiques pour d’autres types de données, tels que double. Copiez le code suivant pour voir les commentaires sur les limitations des valeurs dynamiques.

        let dynamicDouble = r0 == One ? 1. | 0.; // cannot use a dynamic double value
        let dynamicInt = r0 == One ? 1 | 0;
        let dynamicDouble = IntAsDouble(dynamicInt); // cannot use a dynamic double value
        let dynamicRoot = Sqrt(dynamicDouble); // cannot use a dynamic double value

Même si les valeurs dynamiques ne sont pas prises en charge pour certains types de données, ces types de données peuvent toujours être utilisés avec des valeurs statiques.

    let staticRoot = Sqrt(4.0);
    let staticBigInt = IntAsBigInt(2);

Même les valeurs dynamiques prises en charge ne peuvent pas être utilisées dans certaines situations. Par exemple, Quantinuum ne prend pas en charge les tableaux dynamiques, autrement dit, les tableaux dont la taille dépend d’un résultat de mesure. Quantinuum ne prend pas en charge les boucles délimitées dynamiquement non plus. Copiez le code suivant pour voir les limitations des valeurs dynamiques.

        let dynamicInt = r0 == Zero ? 2 | 4;
        let dynamicallySizedArray = [0, size = dynamicInt]; // cannot use a dynamically-sized array
        let staticallySizedArray = [0, size = 10];
        // Loops with a dynamic condition are not supported by Quantinuum.
        for _ in 0..dynamicInt {
            Rx(PI(), q1);
        }
        
        // Loops with a static condition are supported.
        let staticInt = 3;
        for _ in 0..staticInt {  
            Rx(PI(), q1);  
        }

Quantinuum prend en charge le flux de contrôle, y compris if/else la branchement, à l’aide de conditions statiques et dynamiques. La branchement sur des conditions dynamiques est également appelé branchement basé sur les résultats de mesure.

        let dynamicInt = r0 == Zero ? 0 | 1; 
        if dynamicInt > 0 {
            X(q1);
        }
        let staticInt = 1;
        if staticInt > 5 {
            Y(q1);
        } else {
            Z(q1);
        }

Quantinuum prend en charge les boucles avec des conditions classiques et y compris if des expressions.

        for idx in 0..3 {
            if idx % 2 == 0 {
                Rx(ArcSin(1.), q0);
                Rz(IntAsDouble(idx) * PI(), q1)
            } else {
                Ry(ArcCos(-1.), q1);
                Rz(IntAsDouble(idx) * PI(), q1)
            }
        }

Quantinuum prend en charge la mesure du circuit moyen, c’est-à-dire la branche en fonction des résultats de mesure.

        if r0 == One {
            X(q1);
        }
        let r1 = MResetZ(q1);
        if r0 != r1 {
            let angle = PI() + PI() + PI()* Sin(PI()/2.0);
            Rxx(angle, q0, q1);
        } else {
            Rxx(PI() + PI() + 2.0 * PI() * Sin(PI()/2.0), q1, q0);
        }

Estimation du coût d’un travail hybride intégré

Vous pouvez estimer le coût d’exécution d’un travail hybride intégré sur le matériel Quantinuum en l’exécutant d’abord sur un émulateur.

Après une exécution réussie sur l’émulateur :

1. Dans votre espace de travail Azure Quantum, sélectionnez Gestion des travaux.
2. Sélectionnez le travail que vous avez envoyé.
3. Dans la fenêtre contextuelle Détails du travail, sélectionnez Estimation du coût pour afficher le nombre de crédits d’émulateur de quantinuum (eHQCs) utilisés. Ce nombre se traduit directement par le nombre de HQC (crédits quantiques Quantinuum) nécessaires pour exécuter le travail sur le matériel Quantinuum.

Remarque

Quantinuum désinscrit l’ensemble du circuit et calcule le coût sur tous les chemins de code, qu’ils soient exécutés de manière conditionnelle ou non.

Exemples hybrides intégrés

Vous trouverez les exemples suivants dans le Q# référentiel d’exemples de code. Ils illustrent l’ensemble de fonctionnalités actuel pour l’informatique hybride intégrée.

Code de répétition à trois qubits

Cet exemple montre comment créer un code de répétition à trois qubits qui peut être utilisé pour détecter et corriger les erreurs de retournement de bits.

Il tire parti des fonctionnalités de calcul hybride intégrées pour compter le nombre de fois où la correction des erreurs a été effectuée alors que l’état d’un registre qubit logique est cohérent.

Vous trouverez l’exemple de code ici.

Estimation de la phase itérative

Cet exemple* programme illustre une estimation de phase itérative dans Q#. Il utilise l’estimation de phase itérative pour calculer un produit interne entre deux vecteurs 2 dimensionnels encodés sur un target qubit et un qubit ancilla. Un qubit de contrôle supplémentaire est également initialisé, qui est le seul qubit utilisé pour la mesure.

Le circuit commence par encoder la paire de vecteurs sur le target qubit et le qubit ancilla. Il applique ensuite un opérateur Oracle à l’ensemble du registre, contrôlé sur le qubit de contrôle, qui est configuré dans l’état $\ket +$. L’opérateur Oracle contrôlé génère une phase sur l’état $\ket 1$ du qubit de contrôle. Cela peut ensuite être lu en appliquant une porte H au qubit de contrôle pour rendre la phase observable lors de la mesure.

Vous trouverez l’exemple de code ici.

*Cet exemple de code a été écrit par des membres de l’équipe KPMG Quantum en Australie et fait partie d’une licence MIT. Il vise à illustrer des fonctionnalités étendues de boucles délimitées, des appels de fonction classiques au moment de QIR Adaptive RItargets l’exécution, des instructions conditionnelles imbriquées si des instructions, des mesures de circuit intermédiaire et une réutilisation de qubit.

Contenu connexe

• Informatique hybride distribuée.
• Informatique quantique interactive : sessions