Prise en main des sessions

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

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.

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]
   

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]