Prise en main des sessions

Les sessions sont une fonctionnalité clé de l’informatique quantique hybride qui vous permet de regrouper plusieurs travaux d’informatique quantique ensemble.

Cet article explique l’architecture des sessions dans l’informatique quantique hybride et explique comment créer une session.

Prérequis

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

• Un 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.

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

• Package Azure Quantum azure-quantum . Si vous souhaitez utiliser Qiskit ou Cirq, vous devez installer le azure-quantum package avec les balises [qiskit] ou [cirq].

  pip install --upgrade azure-quantum[qiskit] 
  

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.

Dans les sessions, la ressource de calcul du client 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-session. Bien que les états qubits ne soient pas persistants entre les travaux, une session permet des temps de file d’attente plus courts pour les travaux et des problèmes d’exécution plus longs.

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 des algorithmes quantiques paramétrables où la sortie d’un travail de calcul 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 informatique quantique. Dans certains cas, les travaux envoyés au sein d’une session sont hiérarchisés dans la file d’attente de ce target. Pour plus d’informations, consultez Target comportement.

Guide pratique pour créer une session

Pour créer une session, procédez comme suit :

Q# + Python

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

Remarque

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

1. Dans VS Code, sélectionnez Affichage > Palette de commandes, puis sélectionnez Créer : Notebook Jupyter.

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 obtenir des informations de configuration.

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 du target profil, soit Base, Adaptive_RIsoit Unrestricted.

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

   Remarque

   Adaptive_RItarget les travaux de profil sont actuellement pris en charge sur Quantinuum targets. Pour plus d’informations, consultez l’informatique quantique hybride intégrée.

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

   %%qsharp
   import Std.Measurement.*;
   import Std.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 souhaitez exécuter GenerateRandomBit l’opération trois fois, de sorte que vous utilisez target.submit pour 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 soumettre différents programmes 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.compile. Cela signifie que vous devez être prudent pour mettre en forme vos arguments en tant qu’objets Q# . Dans cet exemple, étant donné que les tableaux en 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 devrez peut-être gérer davantage pour obtenir les valeurs de chaîne insérées de manière Q# 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 Comment gérer les sessions.

Qiskit

1. Tout d’abord, vous devez importer des modules supplémentaires à partir de azure-quantum et qiskit. Ensuite, créez un provider objet avec vos informations d’espace de travail Quantum.

   from qiskit import QuantumCircuit
   from azure.quantum import Workspace
   from azure.quantum.qiskit import AzureQuantumProvider
   
   workspace = Workspace(
               resource_id = "", # add your resource ID
               location = "") # add your location
   
   provider = AzureQuantumProvider(workspace)
   

2. Écrivez votre circuit quantique. Par exemple, le circuit suivant génère un bit aléatoire.

   circuit = QuantumCircuit(2, 2)
   circuit.name = "GenerateRandomBit"
   circuit.h(0)
   circuit.cx(0,1)
   circuit.measure([0,1], [0,1])
   circuit.draw()
   

3. Ensuite, créez une instance back-end avec le quantum target de votre choix. Dans cet exemple, définissez le simulateur IonQ en tant que target.

   backend = provider.get_backend("ionq.simulator")
   

4. Ensuite, créez une session. Supposons que vous souhaitiez exécuter votre circuit quantique trois fois, de sorte que vous utilisez backend.run pour soumettre le circuit Qiskit, et que vous répétez le code trois fois - dans un scénario réel, vous pouvez soumettre différents programmes au lieu du même code. 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 Comment gérer les sessions.

   with backend.open_session(name="Qiskit Session") as session:
       job1 = backend.run(circuit=circuit, shots=100, job_name="Job 1") # First job submission
       job1.wait_for_final_state()
       job2 = backend.run(circuit=circuit, shots=100, job_name="Job 2") # Second job submission
       job2.wait_for_final_state()
       job3 = backend.run(circuit=circuit, shots=100, job_name="Job 3") # Third job submission
       job3.wait_for_final_state()
   
   session_jobs = session.list_jobs()
   [session_job.details.name for session_job in session_jobs]
   

Cirq

1. Tout d’abord, écrivez votre circuit quantique. Par exemple, le circuit suivant génère un bit aléatoire.

   import cirq
   
   q0 = cirq.LineQubit(0)
   q1 = cirq.LineQubit(1)
   circuit = cirq.Circuit(
       cirq.H(q0),  # H gate
       cirq.CNOT(q0, q1),
       cirq.measure(q0, key='q0'),
       cirq.measure(q1, key='q1')
   )
   print(circuit)
   

2. Ensuite, créez un service objet avec vos informations d’espace de travail Quantum.

   from azure.quantum.cirq import AzureQuantumService
   
   service = AzureQuantumService(
               resource_id = "", # add your resource ID
               location = "") # add your location
   

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

   Remarque

   Les circuits Cirq peuvent uniquement utiliser IonQ ou Quantinuum targets.

   target = service.get_target("ionq.simulator")
   

4. Ensuite, vous créez une session. Supposons que vous souhaitiez exécuter votre circuit quantique trois fois, de sorte que vous utilisez target.submit pour soumettre le circuit Cirq, et que vous répétez le code trois fois - dans un scénario réel, vous pouvez soumettre différents programmes au lieu du même code.. 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 Comment gérer les sessions.

   with target.open_session(name="Cirq Session") as session:
       target.submit(program=circuit, name="Job 1", repetitions=100) # First job submission
       target.submit(program=circuit, name="Job 2", repetitions=100) # Second job submission
       target.submit(program=circuit, name="Job 3", repetitions=100) # Third job submission
   
   session_jobs = session.list_jobs()
   [session_job.details.name for session_job in session_jobs]
   

Comportement de Target

Chaque fournisseur de matériel quantique définit leurs propres heuristiques pour mieux gérer 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 tant que vous filez d’attente les travaux dans un délai d’une minute entre eux. 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

• Comment gérer vos sessions
• Exécuter l’informatique quantique hybride