Sdílet prostřednictvím

Správa relací

  • Článek

V tomto článku se dozvíte, jak spravovat relace. Pomocí relací můžete seskupit jednu nebo více úloh do jedné targetúlohy, což umožňuje efektivně spravovat úlohy. Další informace najdete v tématu Začínáme s relacemi.

Požadavky

  • Účet Azure s aktivním předplatným. Pokud nemáte účet Azure, zaregistrujte se zdarma a zaregistrujte si předplatné s průběžným platbou.

  • Pracovní prostor Azure Quantum. Další informace najdete v tématu Vytvoření pracovního prostoru Azure Quantum.

  • Prostředí Pythonu s nainstalovaným Pythonem a Pipem

  • Balíček Azure Quantum azure-quantum . Pokud chcete použít Qiskit nebo Cirq, musíte balíček nainstalovat azure-quantum se značkami [qiskit] nebo [cirq].

    pip install --upgrade azure-quantum[qiskit]

Poznámka:

Relace se spravují pomocí Pythonu, i když běží Q# vložený kód.

Monitorování relací

Okno Správa úloh v pracovním prostoru Quantum můžete použít k zobrazení všech odeslaných položek nejvyšší úrovně, včetně relací a jednotlivých úloh, které nejsou přidružené k žádné relaci.

  1. V pracovním prostoru Quantum vyberte okno Správa úloh.
  2. Identifikujte úlohy typu Relace. V tomto zobrazení můžete zobrazit jedinečné ID relace ve sloupci ID a sledovat jeho stav. Stavy relace jsou:
    • Čekání: Úlohy v rámci relace se spouštějí.
    • Úspěšné: Relace byla úspěšně ukončena.
    • Časový limit: Pokud během relace po dobu 10 minut není odeslána žádná nová úloha, vyprší časový limit této relace. Další informace naleznete v tématu Vypršení časových limitů relace.
    • Selhání: Pokud úloha v rámci relace selže, skončí tato relace a nahlásí stav Selhání. Další informace najdete v tématu Zásady selhání úlohy v rámci relací.
  3. Kliknutím na název relace zobrazíte další podrobnosti.
  4. Zobrazí se seznam všech úloh v rámci relace a monitoruje jejich stav.

Načítání a výpis relací

Následující tabulka ukazuje příkazy Pythonu pro získání seznamu všech relací a všech úloh pro danou relaci.

Příkaz Popis
workspace.list_sessions() nebo session.list_sessions() Načte seznam všech relací v pracovním prostoru Quantum.
workspace.get_session(sessionId) nebo session.get_session(sessionId) Načtěte relaci s ID sessionId. Každá relace má jedinečné ID.
workspace.list_session_jobs(sessionId) nebo session.list_session_jobs(sessionId) Načte seznam všech úloh v relaci s ID sessionId. Každá relace má jedinečné ID.

Například následující kód definuje funkci, která získá relaci s minimálním počtem úloh. V této relaci se pak zobrazí seznam všech úloh, celkový počet úloh a prvních 10 úloh.

def get_a_session_with_jobs(min_jobs):
    all_sessions = workspace.list_sessions() # list of all sessions
    for session in all_sessions:
        if len(workspace.list_session_jobs(session.id)) >= min_jobs:
            return session

session = get_a_session_with_jobs(min_jobs=3) # Get a Session with at least 3 jobs

session_jobs = workspace.list_session_jobs(session.id) # List of all jobs within Session ID

print(f"Job count: {len(session_jobs)} \n")
print(f"First 10 jobs for session {session.id}:")
for job in session_jobs[0:10]:
    print(f"Id: {job.id}, Name={job.details.name}")

Ruční metody otevírání a zavírání relací

Doporučujeme postupovat podle kroků v části Začínáme s relacemi a vytvořit novou relaci. Relace můžete vytvářet také ručně.

  1. Nejprve vytvořte objekt Session.

    from azure.quantum.job.session import Session, SessionDetails, SessionJobFailurePolicy
import uuid

session = Session(
    workspace=workspace, # required
    id=f"{uuid.uuid1()}", # optional, if not passed will use uuid.uuid1()
    name="", # optional, will be blank if not passed
    provider_id="ionq", # optional, if not passed will try to parse from the target
    target="ionq.simulator", # required
    job_failure_policy=SessionJobFailurePolicy.ABORT # optional, defaults to abort
    )

print(f"Session status: {session.details.status}")

    Poznámka:

    V tomto okamžiku relace existuje pouze v klientovi a vidíte, že je stav Žádný. Pokud chcete zobrazit stav relace, musíte také vytvořit relaci ve službě.

  2. K vytvoření relace ve službě můžete použít workspace.open_session(session) nebo session.open().

  3. Stav a podrobnosti relace můžete aktualizovat pomocí session.refresh()objektu relace nebo získáním nového objektu relace z ID relace.

    same_session = workspace.get_session(session.id) 
print(f"Session: {session.details} \n")
print(f"Session: {same_session.details} \n")

  4. Relaci můžete zavřít s session.close() nebo workspace.close_session(session).

  5. K připojení relace k target, můžete použít target.latest_session.

  6. Můžete počkat na dokončení relace:

    session_jobs = session.list_jobs()
[session_job.id for session_job in session_jobs]

import time
while (session.details.status != "Succeeded" and session.details.status != "Failed" and session.details.status != "TimedOut"):
  session.refresh()
  time.sleep(5)

Předávání argumentů v Q#

Pokud vaše Q# operace přebírá vstupní argumenty, předávají se tyto argumenty během odeslání úlohy, což je kód Pythonu. To znamená, že při formátování argumentů jako Q# objektů musíte být opatrní.

Při předávání argumentů jako parametrů do úlohy jsou při volání qsharp.compileformátovány jako Q# kód, takže hodnoty z Pythonu musí být formátovány do řetězce jako platné Q# syntaxe.

Zvažte následující Q# program, který jako vstup přebírá celé číslo na pole úhlů angle.

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;
}

Operaci chcete spustit GenerateRandomBits třikrát s n=2 různými úhly a různými úhly. Pomocí následujícího kódu Pythonu můžete odeslat tři úlohy s různými úhly.

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]

V tomto příkladu jsou pole v Pythonu již vytištěna jako [item0, item1, ...], vstupní argumenty odpovídají Q# formátování. U jiných datových struktur Pythonu možná budete potřebovat více zpracování, abyste získali řetězcové hodnoty vložené do Q# kompatibilního způsobu. Například Q# řazená kolekce členů musí být v závorkách s hodnotami oddělenými čárkami.

Vypršení časových limitů relace

Relace vyprší, pokud se během relace po dobu 10 minut neposílají žádná nová úloha. Relace hlásí stav časového limitu. Chcete-li se této situaci vyhnout, přidejte with blok using backend.open_session(name="Name"), takže relace close() je vyvolána službou na konci bloku kódu.

Poznámka:

Pokud v programu dojde k chybám nebo chybám, může odeslání nové úlohy po dokončení předchozí úlohy v relaci trvat déle než 10 minut.

Následující fragmenty kódu ukazují příklad vypršení časového limitu relace po 10 minutách, protože se neposílají žádné nové úlohy. Aby se tomu zabránilo, další fragment kódu ukazuje, jak pomocí with bloku vytvořit relaci.

#Example of a session that times out 

session = backend.open_session(name="Qiskit circuit session") # Session times out because only contains one job
backend.run(circuit=circuit, shots=100, job_name="Job 1")

#Example of a session that includes a with block to avoid timeout

with backend.open_session(name="Qiskit circuit session") as session:  # Use a with block to submit multiple jobs within a 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()

Zásady selhání úloh v rámci relací

Výchozí zásada relace, když úloha selže, je ukončit tuto relaci. Pokud odešlete další úlohu ve stejné relaci, služba ji odmítne a relace hlásí stav Selhání. Všechny probíhající úlohy se zruší.

Toto chování však může být změněno zadáním zásady job_failure_policy=SessionJobFailurePolicy.CONTINUEselhání úlohy namísto výchozího SessionJobFailurePolicy.ABORTnastavení při vytváření relace. Pokud je CONTINUEzásada selhání úlohy, služba nadále přijímá úlohy. Relace v tomto případě hlásí stav Selhání , které se po zavření relace změní na Neúspěšné .

Pokud relace nikdy není uzavřená a vyprší časový limit, stav je Časový limit , i když úlohy selhaly.

Například následující program vytvoří relaci se třemi úlohami. První úloha selže, protože určuje "garbage" jako vstupní data. Aby se zabránilo ukončení relace v tomto okamžiku, program ukazuje, jak přidat job_failure_policy=SessionJobFailurePolicy.CONTINUE při vytváření relace.

#Example of a session that does not close but reports Failure(s) when a jobs fails

with target.open_session(name="JobFailurePolicy Continue", job_failure_policy=SessionJobFailurePolicy.CONTINUE) as session:
    target.submit(input_data="garbage", name="Job 1") #Input data is missing, this job fails
    target.submit(input_data=quil_program, name="Job 2") #Subsequent jobs are accepted because of CONTINUE policy
    target.submit(input_data=quil_program, name="Job 3")

Související obsah