Prise en main des sessions

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

1. Dans VS Code, ouvrez le menu Affichage et choisissez Palette de commandes.

2. Entrez et sélectionnez Créer : Nouveau Jupyter Notebook.

3. En haut à droite, VS Code détectera et affichera la version de Python ainsi que l'environnement virtuel Python sélectionné pour le notebook. Si vous avez plusieurs Python environnements, 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 Notebookinformations d’installation dans VS Code.

4. Dans la première cellule du notebook, exécutez le code suivant :

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

5. Ajoutez une nouvelle cellule dans le notebook et importez le qsharpPython package :

   from qdk import qsharp
   

6. Choisissez votre quantum target. Dans cet exemple, il s’agit target du simulateur IonQ.

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

7. 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_RI target les travaux de profil sont actuellement pris en charge sur Quantinuum targets. Pour plus d’informations, consultez l’informatique quantique hybride intégrée.

8. É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;
   }
   

9. 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

   Lorsque vous passez des arguments en tant que paramètres à la tâche, les arguments sont mis en forme dans l’expression Q# lorsque qsharp.compile est appelé. Cela signifie que vous devez mettre en forme vos arguments en tant qu’objets Q# . Dans cet exemple, comme les tableaux dans Python sont déjà imprimés selon le format [item0, item1, ...], les arguments d'entrée correspondent à la mise en forme Q#. Pour d'autres Python structures de données, vous devrez peut-être effectuer davantage de traitement pour obtenir les valeurs de chaîne insérées d'une manière compatible avec Q#.

10. 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.

1. Importer des modules supplémentaires à partir de azure-quantum et qiskit.

   from qdk.qiskit import QuantumCircuit
   from qdk.azure import Workspace
   from azure.quantum.qiskit import AzureQuantumProvider
   

2. Créez un provider objet avec vos informations d’espace de travail Quantum.

   workspace = Workspace(
               resource_id = "", # add your resource ID
               location = "") # add your location
   
   provider = AzureQuantumProvider(workspace)
   

3. É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()
   

4. Créez une instance back-end avec le quantum target de votre choix. Dans cet exemple, définissez votre target au simulateur IonQ.

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

5. Créez une session. Supposons que vous souhaitez exécuter votre circuit quantique trois fois, de sorte que vous utilisez backend.run pour soumettre le Qiskit circuit, 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]
   

1. É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. 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. Choisissez votre quantum target. Dans cet exemple, il s’agit target du simulateur IonQ.

   Remarque

   Cirq les circuits peuvent uniquement utiliser IonQ ou Quantinuum targets.

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

4. Créez une session. Supposons que vous souhaitez exécuter votre circuit quantique trois fois, de sorte que vous utilisez target.submit pour soumettre le Cirq circuit, 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]