Aan de slag met sessies

Sessies zijn een belangrijke functie van hybride kwantumcomputing waarmee u meerdere kwantumcomputingtaken kunt groeperen.

In dit artikel wordt de architectuur van sessies in hybride kwantumcomputing uitgelegd en wordt uitgelegd hoe u een nieuwe sessie maakt.

Vereisten

Als u een sessie wilt maken, hebt u de volgende vereisten nodig:

• Een Azure-account met een actief abonnement. Als u geen Azure-account hebt, registreert u zich gratis en registreert u zich voor een abonnement op basis van betalen per gebruik.

• Een Azure Quantum-werkruimte. Zie Een Azure Quantum-werkruimte maken voor meer informatie.

• Een Python-omgeving waarop Python en Pip zijn geïnstalleerd.

• Het Azure Quantum-pakket azure-quantum . Als u Qiskit of Cirq wilt gebruiken, moet u het azure-quantum pakket installeren met de tags [qiskit] of [cirq].

  pip install --upgrade azure-quantum[qiskit] 
  

Wat is een sessie?

Een sessie is een logische groepering van een of meer taken die worden verzonden naar één target. Elke sessie heeft een unieke id gekoppeld aan elke taak in die sessie.

In sessies kan de rekenresource van de client naar de cloud worden verplaatst, wat resulteert in een lagere latentie en de mogelijkheid om de uitvoering van het kwantumcircuit met verschillende parameters te herhalen. Taken kunnen logisch worden gegroepeerd in één sessie en de taken in die sessie kunnen worden gerangschikt op niet-sessietaken. Hoewel de qubitstatussen niet tussen taken behouden blijven, maakt een sessie kortere wachtrijtijden mogelijk voor taken en langdurige problemen.

Met sessies kunt u meerdere kwantumcomputingstaken organiseren met de mogelijkheid om klassieke code tussen kwantumtaken uit te voeren. U kunt complexe algoritmen uitvoeren om uw afzonderlijke kwantumcomputingtaken beter te ordenen en bij te houden.

Een belangrijk gebruikersscenario waarin u taken in een sessie kunt combineren, zijn geparameteriseerde kwantumalgoritmen waarbij de uitvoer van een kwantumcomputingtaak de parameters van de volgende kwantumcomputingtaak informeert. De meest voorkomende voorbeelden van dit type algoritme zijn Variational Quantum Eigensolvers (VQE) en Quantum Approximate Optimization Algorithms (QAOA).

Ondersteunde hardware

Sessies worden ondersteund op alle kwantumcomputinghardwareproviders. In sommige gevallen worden taken die binnen een sessie worden verzonden, prioriteit gegeven in de wachtrij van die target. Zie het gedrag voor meer informatie.Target

Een sessie maken

Voer de volgende stappen uit om een sessie te maken:

Q# + Python

In dit voorbeeld ziet u hoe u een sessie met Q# inlinecode maakt met behulp van een Jupyter Notebook in Visual Studio Code. U kunt ook sessies maken met behulp van een Python-programma dat een aangrenzend Q# programma aanroept.

Notitie

Sessies worden beheerd met Python, zelfs wanneer inlinecode wordt uitgevoerd Q# .

1. Selecteer in VS Code het opdrachtenpalet Weergeven > en selecteer Maken: Nieuw Jupyter Notebook.

2. In de rechterbovenhoek detecteert en geeft VS Code de versie van Python en de virtuele Python-omgeving weer die is geselecteerd voor het notebook. Als u meerdere Python-omgevingen hebt, moet u mogelijk een kernel selecteren met behulp van de kernelkiezer in de rechterbovenhoek. Als er geen omgeving is gedetecteerd, raadpleegt u Jupyter Notebooks in VS Code voor informatie over de installatie.

3. Voer in de eerste cel van het notebook de opdracht uit

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

4. Klik op + Code om een nieuwe cel toe te voegen in het notebook en Python SDK te importeren qsharp .

   import qsharp
   

5. Selecteer het kwantum target van uw keuze. In dit voorbeeld gebruikt u de IonQ-simulator als target.

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

6. Selecteer de configuraties van het target profiel, ofwel Base, Adaptive_RIof Unrestricted.

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

   Notitie

   Adaptive_RItarget profieltaken worden momenteel ondersteund op Quantinuum targets. Zie Geïntegreerde hybride kwantumcomputing voor meer informatie.

7. Schrijf uw Q# programma. Met het volgende Q# programma wordt bijvoorbeeld een willekeurige bit gegenereerd. Om het gebruik van invoerargumenten te illustreren, gebruikt dit programma een geheel getal, nen een matrix met hoeken, angleals invoer.

   %%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. Vervolgens maakt u een sessie. Stel dat u de bewerking drie keer wilt uitvoeren GenerateRandomBit , zodat u target.submit de Q# bewerking met de target gegevens verzendt en u de code drie keer herhaalt. In een praktijkscenario wilt u mogelijk verschillende programma's verzenden in plaats van dezelfde 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]
   

   Belangrijk

   Bij het doorgeven van argumenten als parameters aan de taak, worden ze opgemaakt in de expressie bij het Q# aanroepen qsharp.compile. Dit betekent dat u voorzichtig moet zijn met het opmaken van uw argumenten als Q# objecten. Omdat matrices in Python al zijn afgedrukt als [item0, item1, ...], komen de invoerargumenten overeen met de Q# opmaak. Voor andere Python-gegevensstructuren hebt u mogelijk meer verwerking nodig om de tekenreekswaarden op een compatibele manier in te Q# voegen.

9. Zodra u een sessie hebt gemaakt, kunt u een workspace.list_session_jobs lijst met alle taken in de sessie ophalen. Zie Sessies beheren voor meer informatie.

Qiskit

1. Eerst moet u extra modules importeren uit azure-quantum en qiskit. Maak vervolgens een provider object met de gegevens van uw Quantum-werkruimte.

   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. Schrijf uw kwantumcircuit. Met het volgende circuit wordt bijvoorbeeld een willekeurige bit gegenereerd.

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

3. Maak vervolgens een back-endinstantie met het kwantum target van uw keuze. In dit voorbeeld stelt u IonQ-simulator in als de target.

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

4. Maak vervolgens een sessie. Stel dat u uw kwantumcircuit drie keer wilt uitvoeren, dus u gebruikt backend.run om het Qiskit-circuit in te dienen en u herhaalt de code drie keer. In een praktijkscenario wilt u mogelijk verschillende programma's verzenden in plaats van dezelfde code. U kunt een workspace.list_session_jobs lijst met alle taken in de sessie ophalen. Zie Sessies beheren voor meer informatie.

   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. Schrijf eerst uw kwantumcircuit. Met het volgende circuit wordt bijvoorbeeld een willekeurige bit gegenereerd.

   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. Maak vervolgens een service object met de gegevens van uw Quantum-werkruimte.

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

3. Selecteer het kwantum target van uw keuze. In dit voorbeeld gebruikt u de IonQ-simulator als target.

   Notitie

   Cirq-circuits kunnen alleen IonQ of Quantinuum targetsgebruiken.

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

4. Vervolgens maakt u een sessie. Stel dat u uw kwantumcircuit drie keer wilt uitvoeren, dus u gebruikt target.submit om het Cirq-circuit te verzenden en u herhaalt de code drie keer. In een praktijkscenario wilt u mogelijk verschillende programma's indienen in plaats van dezelfde code. U kunt een workspace.list_session_jobs lijst met alle taken in de sessie ophalen. Zie Sessies beheren voor meer informatie.

   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]
   

Target gedrag

Elke kwantumhardwareprovider definieert hun eigen heuristieken om de prioriteitstelling van taken binnen een sessie het beste te beheren.

Quantinuum

Als u ervoor kiest om taken binnen een sessie naar een Quantinuum targette verzenden, heeft uw sessie exclusieve toegang tot de hardware zolang u taken binnen één minuut van elkaar in de wachtrij plaatst. Daarna worden uw taken geaccepteerd en verwerkt met de standaardlogica voor wachtrijen en prioriteitstelling.

Gerelateerde inhoud

• Uw sessies beheren
• Hybride kwantumcomputing uitvoeren