Informatique quantique interactive : sessions

  • Article

Cet article explique l’architecture de l’informatique quantique interactive, également appelée sessions, et comment créer une session.

Dans ce modèle d’informatique quantique hybride, la ressource de calcul cliente peut être déplacée vers le cloud, ce qui entraîne une latence inférieure et la possibilité de répéter l’exécution du circuit quantique avec différents paramètres. Les travaux peuvent être regroupés logiquement en une session, et les travaux de cette session peuvent être hiérarchisés par rapport aux travaux non de session. Bien que les états qubits ne persistent pas entre les travaux, une session permet des temps de file d’attente plus courts pour les travaux et des problèmes plus longs.

Informatique quantique interactive

Prérequis

Pour créer une session, vous avez besoin des prérequis suivants :

Qu’est-ce qu’une session ?

Une session est un regroupement logique d’un ou plusieurs travaux soumis à un seul target. Chaque session a un ID unique attaché à chaque travail de cette session.

Les sessions vous permettent d’organiser plusieurs travaux d’informatique quantique avec la possibilité d’exécuter du code classique entre les travaux quantiques. Vous serez en mesure d’exécuter des algorithmes complexes pour mieux organiser et suivre vos travaux d’informatique quantique individuels.

Un scénario utilisateur clé dans lequel vous souhaiterez peut-être combiner des travaux dans une session est les algorithmes quantiques paramétrés où la sortie d’un travail d’informatique quantique informe les paramètres du travail d’informatique quantique suivant. Les exemples les plus courants de ce type d’algorithme sont Variational Quantum Eigensolvers (VQE) et Quantum Approximate Optimization Algorithms (QAOA).

Matériel pris en charge

Les sessions sont prises en charge sur tous les fournisseurs de matériel d’informatique quantique, actuellement IonQ, Quantinuum et Rigetti. Dans certains cas, les travaux envoyés au sein d’une session sont classés par ordre de priorité dans la file d’attente de ce target. Pour plus d’informations, consultez Comportement cible.

Bien démarrer avec les sessions

Les sessions sont gérées avec Python et peuvent être créées pour tous les programmes quantiques QIR, y compris Q#les programmes Qiskit et Cirq.

Cet exemple montre comment créer une session avec Q# du code inline à l’aide d’un Jupyter Notebook dans Visual Studio Code. Vous pouvez également créer des sessions à l’aide d’un programme Python qui appelle un programme adjacent Q# .

Notes

Les sessions sont gérées avec Python, même lors de l’exécution de Q# code inline.

  1. Dans VS Code, sélectionnez Afficher > la palette de commandes, puis Créer : nouveau Jupyter Notebook.

  2. En haut à droite, VS Code détecte et affiche la version de Python et l’environnement Python virtuel sélectionné pour le notebook. Si vous avez plusieurs environnements Python, vous devrez peut-être sélectionner un noyau à l’aide du sélecteur de noyau en haut à droite. Si aucun environnement n’a été détecté, consultez Jupyter Notebooks dans VS Code pour plus d’informations sur l’installation.

  3. Dans la première cellule du notebook, exécutez

    import azure.quantum

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

  4. Cliquez sur + Code pour ajouter une nouvelle cellule dans le notebook et importer qsharp le Kit de développement logiciel (SDK) Python.

    import qsharp

  5. Sélectionnez le quantum target de votre choix. Dans cet exemple, vous utilisez le simulateur IonQ en tant que target.

    target = workspace.get_targets("ionq.simulator")

  6. Sélectionnez les configurations de votre target profil ou BaseUnrestricted.

    qsharp.init(target_profile=qsharp.TargetProfile.Base) # or qsharp.TargetProfile.Unrestricted

  7. Écrivez votre Q# programme. Par exemple, le programme suivant Q# génère un bit aléatoire. Pour illustrer l’utilisation d’arguments d’entrée, ce programme prend un entier , net un tableau d’angles , angle, comme entrée.

    %%qsharp
open Microsoft.Quantum.Measurement;
open Microsoft.Quantum.Arrays;

operation GenerateRandomBits(n: Int, angle: Double[]) : Result[] {
   use qubits = Qubit[n]; // n parameter as the size of the qubit array
   for q in qubits {
       H(q);
   }
   R(PauliZ, angle[0], qubits[0]); // arrays as entry-points parameters
   R(PauliZ, angle[1], qubits[1]);
   let results = MeasureEachZ(qubits);
   ResetAll(qubits);
   return results;
}

  8. Ensuite, vous créez une session. Supposons que vous souhaitiez exécuter GenerateRandomBit l’opération trois fois. Vous pouvez target.submit donc envoyer l’opération Q# avec les target données et répéter le code trois fois. Dans un scénario réel, vous pouvez envoyer des programmes différents au lieu du même code.

    angle = [0.0, 0.0]
with target.open_session(name="Q# session of three jobs") as session:
    target.submit(input_data=qsharp.compile(f"GenerateRandomBits(2, {angle})"), name="Job 1", shots=100) # First job submission
    angle[0] += 1
    target.submit(input_data=qsharp.compile(f"GenerateRandomBits(2, {angle})"), name="Job 2", shots=100) # Second job submission
    angle[1] += 1
    target.submit(input_data=qsharp.compile(f"GenerateRandomBits(2, {angle})"), name="Job 3", shots=100) # Third job submission

session_jobs = session.list_jobs()
[session_job.details.name for session_job in session_jobs]

    Important

    Lors du passage d’arguments en tant que paramètres au travail, ils sont mis en forme dans l’expression lors de l’appel Q#qsharp.compilede . Cela signifie que vous devez veiller à mettre en forme vos arguments en tant qu’objets Q# . Dans cet exemple, étant donné que les tableaux dans Python sont déjà imprimés en tant que [item0, item1, ...], les arguments d’entrée correspondent à la Q# mise en forme. Pour d’autres structures de données Python, vous aurez peut-être besoin d’une gestion plus grande pour obtenir les valeurs de chaîne insérées dans le Q# de manière compatible.

  9. Une fois que vous avez créé une session, vous pouvez utiliser workspace.list_session_jobs pour récupérer une liste de tous les travaux de la session. Pour plus d’informations, consultez Gestion des sessions.

Sessions d’analyse

Vous pouvez utiliser le panneau Gestion des travaux de votre espace de travail Quantum pour afficher tous les éléments envoyés de niveau supérieur, y compris les sessions et les travaux individuels qui ne sont associés à aucune session.

  1. Sélectionnez le panneau Gestion des travaux dans votre espace de travail Quantum.
  2. Identifiez les travaux de type Session. Dans cette vue, vous pouvez voir l’ID unique d’une session dans l’ID de colonne et surveiller son état. Les états d’une session sont les suivants :
    • En attente : les travaux de la session sont en cours d’exécution.
    • Réussite : la session s’est terminée avec succès.
    • Délai d’attente : si aucune nouvelle tâche n’est envoyée au cours de la session pendant 10 minutes, cette session expire. Pour plus d’informations, consultez Délais d’expiration de session.
    • Échec : si un travail au sein d’une session échoue, cette session se termine et signale un status d’échec. Pour plus d’informations, consultez Stratégie d’échec de travail dans les sessions.
  3. Pour plus d’informations, cliquez sur le nom d’une session.
  4. Vous pouvez voir la liste de Tous les travaux dans la session et surveiller leur status.

Comportement cible

Chaque fournisseur de matériel quantique définit sa propre heuristique pour gérer au mieux la hiérarchisation des travaux au sein d’une session.

Quantinuum

Si vous choisissez d’envoyer des travaux au sein d’une session à un Quantinuum target, votre session aura un accès exclusif au matériel, à condition que vous ayez mis en file d’attente les travaux dans une minute les uns des autres. Après cela, vos travaux seront acceptés et gérés avec la logique de mise en file d’attente et de hiérarchisation standard.

Contenu connexe