Kom igång med sessioner

Sessioner är en viktig funktion i hybrid kvantberäkning som gör att du kan gruppera flera kvantberäkningsjobb tillsammans. En session är en logisk gruppering av ett eller flera jobb som du skickar till en enda target. Varje session har ett unikt ID kopplat till varje jobb i sessionen. Sessioner är användbara när du vill köra flera kvantberäkningsjobb i följd och köra klassisk kod mellan kvantjobb.

Den här artikeln beskriver arkitekturen för sessioner inom hybridberäkning av kvantberäkning och hur du skapar en ny session i Azure Quantum.

Förutsättningar

För att skapa en session behöver du följande förutsättningar:

Vad är en session?

I sessioner kan du flytta klientberäkningsresursen till molnet för kortare svarstider och möjlighet att köra kvantprogrammet flera gånger med olika parametrar. Du kan logiskt gruppera jobb i en session och du kan prioritera jobb i den sessionen framför icke-sessionsjobb. Qubittillstånd kvarstår inte mellan jobb, men jobb i en session har kortare väntetider. Med kortare kötider kan du köra komplexa algoritmer för att bättre organisera och spåra dina enskilda kvantberäkningsjobb.

Sessioner är användbara för parametriserade kvantalgoritmer, där utdata från ett kvantberäkningsjobb används för att definiera indataparametrar för nästa kvantberäkningsjobb. De vanligaste exemplen på den här typen av algoritm är Variational Quantum Eigensolvers (VQE) och Quantum Approximate Optimization Algorithms (QAOA).

Maskinvara som stöds

Sessioner stöds på alla maskinvaruleverantörer för kvantberäkning. I vissa fall prioriteras jobb som skickas inom en session i kön för den target. Mer information finns i Målbeteende.

Så här skapar du en session

Följ dessa steg för att skapa en session:

Det här exemplet visar hur du skapar en session med Q# infogad kod i en Jupyter-notebook i VS Code.

Kommentar

Sessioner hanteras med Python, även när inline-kod körs Q#.

  1. I VS Codeöppnar du menyn Visa och väljer Kommandopalett.

  2. Ange och välj Skapa: Ny Jupyter Notebook.

  3. Längst upp till höger kommer VS Code att identifiera och visa versionen av Python och den virtuella Python-miljön som valts för anteckningsboken. Om du har flera Python miljöer kan du behöva välja en kernel med hjälp av kernelväljaren längst upp till höger. Om ingen miljö har identifierats, se Jupyter Notebooks i VS Code för konfigurationsinformation.

  4. Kör följande kod i den första cellen i notebook-filen:

    from qdk.azure import Workspace

workspace = Workspace(resource_id="") # add your resource ID

  5. Lägg till en ny cell i anteckningsboken och importera qsharpPython paketet:

    from qdk import qsharp

  6. Välj ditt kvantum target. I det här exemplet target är IonQ-simulatorn.

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

  7. Välj profilens konfigurationertarget, antingen Base, Adaptive_RIeller Unrestricted.

    qsharp.init(target_profile=qsharp.TargetProfile.Base)

    Kommentar

    Adaptive_RI target profiljobb stöds för närvarande på Quantinuum targets. Mer information finns i Integrerad hybridkvantdatoranvändning.

  8. Skriv ditt Q# program. Till exempel genererar följande Q# program en slumpmässig bit. För att illustrera användningen av indataargument tar det här programmet ett heltal, n, och en matris med vinklar, angle, som indata.

    %%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. Sedan skapar du en session. Anta att du vill köra GenerateRandomBit åtgärden tre gånger, så du använder target.submit för att skicka Q# åtgärden med target data och upprepar koden tre gånger – i ett verkligt scenario kanske du vill skicka olika program i stället för samma kod.

    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]

    Viktigt!

    När du skickar argument som parametrar till jobbet formateras argumenten i Q# uttrycket när qsharp.compile anropas. Det innebär att du måste formatera argumenten som Q# objekt. I det här exemplet, eftersom matriser i Python redan skrivs ut som [item0, item1, ...], matchar indataargumenten Q# formateringen. För andra Python datastrukturer kan du behöva mer hantering för att få strängvärdena infogade Q# på ett kompatibelt sätt.

  10. När du har skapat en session kan du använda workspace.list_session_jobs för att hämta en lista över alla jobb i sessionen. Mer information finns i Hantera sessioner.

Målbeteende

Varje kvantmaskinvaruprovider definierar sina egna heuristiker för att bäst hantera prioriteringen av jobb inom en session.

Quantinuum

Om du väljer att skicka jobb inom en session till en Quantinuum target, har din session exklusiv åtkomst till maskinvaran så länge du köar jobb inom en minut efter varandra. Därefter godkänns och hanteras dina jobb med standardlogik för kö och prioritering.

Relaterat innehåll

  • Last updated on