Interactieve kwantumcomputing: sessies

In dit artikel wordt de architectuur van interactieve kwantumcomputing, ook wel sessies genoemd, uitgelegd en wordt uitgelegd hoe u een nieuwe sessie maakt.

In dit model van hybride kwantumcomputing kan de rekenresource van de client worden verplaatst naar de cloud, 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 prioriteit krijgen boven niet-sessietaken. Hoewel de qubitstatussen niet behouden blijven tussen taken, zorgt een sessie voor kortere wachtrijtijden voor taken en langer lopende problemen.

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 meldt u zich aan 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 met Python en Pip 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 zijn verzonden naar één target. Aan elke sessie is een unieke id gekoppeld aan elke taak in die sessie.

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

Een belangrijk gebruikersscenario waarin u taken in een sessie wilt 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 hardwareproviders voor kwantumcomputing, momenteel IonQ, Quantinuum en Rigetti. In sommige gevallen krijgen taken die binnen een sessie zijn ingediend, prioriteit in de wachtrij van die target. Zie Doelgedrag voor meer informatie.

Aan de slag met sessies

Sessies worden beheerd met Python en kunnen worden gemaakt voor alle QIR-kwantumprogramma's, waaronder Q#Qiskit- en Cirq-programma's.

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 opdrachtpalet weergeven > en selecteer Maken: Nieuwe Jupyter Notebook.

2. Rechtsboven detecteert VS Code de versie van Python en de virtuele Python-omgeving die voor het notebook is geselecteerd en geeft deze weer. 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 installatie-informatie.

3. Voer in de eerste cel van het notebook

   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 aan het notebook en Python SDK te importeren qsharp .

   import qsharp
   

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

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

6. Selecteer de configuraties van uw target profiel, of BaseUnrestricted.

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

7. Schrijf uw Q# programma. Het volgende Q# programma genereert bijvoorbeeld een willekeurige bit. Ter illustratie van het gebruik van invoerargumenten gebruikt dit programma een geheel getal, nen een matrix van hoeken, angle, als invoer.

   %%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. 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 kunt u verschillende programma's indienen 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

   Wanneer argumenten als parameters aan de taak worden doorgegeven, worden ze opgemaakt in de Q# expressie bij het aanroepen qsharp.compilevan . Dit betekent dat u voorzichtig moet zijn met het opmaken van uw argumenten als Q# objecten. Omdat in dit voorbeeld 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 de Q# in te voegen.

9. Zodra u een sessie hebt gemaakt, kunt u gebruiken workspace.list_session_jobs om een lijst met alle taken in de sessie op te halen. 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. Het volgende circuit genereert bijvoorbeeld een willekeurige bit.

   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-endexemplaar 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 gebruikt backend.run u om het Qiskit-circuit in te dienen en herhaalt u de code drie keer. In een praktijkscenario kunt u verschillende programma's indienen in plaats van dezelfde code. U kunt gebruiken workspace.list_session_jobs om een lijst met alle taken in de sessie op te halen. 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. Het volgende circuit genereert bijvoorbeeld een willekeurige bit.

   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 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 gebruikt target.submit u om het Cirq-circuit te verzenden en herhaalt u de code drie keer. In een praktijkscenario kunt u verschillende programma's indienen in plaats van dezelfde code. U kunt gebruiken workspace.list_session_jobs om een lijst met alle taken in de sessie op te halen. 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]
   

Bewakingssessies

U kunt de blade Taakbeheer in uw Quantum-werkruimte gebruiken om alle verzonden items op het hoogste niveau weer te geven, inclusief sessies en afzonderlijke taken die niet aan een sessie zijn gekoppeld.

1. Selecteer de blade Taakbeheer in uw Quantum-werkruimte.
2. Identificeer de taken van het type Sessie. In deze weergave ziet u de unieke id van een sessie in kolom-id en controleert u de status ervan. De statussen van een sessie zijn:
   • Wachten: Taken binnen de sessie worden uitgevoerd.
   • Geslaagd: de sessie is beëindigd.
   • Time-out: als er gedurende 10 minuten geen nieuwe taak binnen de sessie wordt verzonden, treedt er een time-out op voor die sessie. Zie Sessietime-outs voor meer informatie.
   • Mislukt: als een taak in een sessie mislukt, wordt die sessie beëindigd en wordt de status Mislukt gerapporteerd. Zie Beleid voor taakfouten binnen sessies voor meer informatie.
3. Klik op de naam van een sessie voor meer informatie.
4. U kunt de lijst met Alle taken in de sessie bekijken en hun status controleren.

Doelgedrag

Elke kwantumhardwareprovider definieert zijn eigen heuristiek om de prioriteitstelling van taken binnen een sessie zo goed mogelijk 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 zet. Daarna worden uw taken geaccepteerd en afgehandeld met de standaardlogica voor wachtrijen en prioriteitstelling.

Gerelateerde inhoud

• Sessies beheren
• Geïntegreerde kwantumcomputing