Eseguire lavori in una sessione

• Versioni del pacchetto

  Il codice presente in questa pagina è stato sviluppato utilizzando i seguenti requisiti. Si consiglia di utilizzare queste versioni o versioni più recenti.

  qiskit[all]~=2.3.1
  qiskit-ibm-runtime~=0.45.0
  scipy~=1.17.1
  

Utilizzate le sessioni quando avete bisogno di un accesso dedicato ed esclusivo alla QPU.

Configurazione per l'utilizzo delle sessioni

Prima di avviare una sessione, è necessario configurare il client Compute di IBM Quantum e inizializzarlo come servizio:

from qiskit_ibm_runtime import (
    QiskitRuntimeService,
    Session,
    SamplerV2 as Sampler,
    EstimatorV2 as Estimator,
    Executor,
)

service = QiskitRuntimeService()

Apri una sessione

È possibile aprire una sessione di runtime utilizzando il gestore di contesto with Session(...) o inizializzando la classe Session classe. Quando si avvia una sessione, è necessario specificare una QPU passando un oggetto backend . La sessione inizia quando inizia l'esecuzione del primo lavoro.

Classe di sessione

backend = service.least_busy(operational=True, simulator=False)
session = Session(backend=backend)
estimator = Estimator(mode=session)
sampler = Sampler(mode=session)
executor = Executor(mode=session)
# Close the session because no context manager was used.
session.close()

Gestore del contesto

Il gestore del contesto apre e chiude automaticamente la sessione.

from qiskit_ibm_runtime import (
    Session,
    SamplerV2 as Sampler,
    EstimatorV2 as Estimator,
    Executor,
)

backend = service.least_busy(operational=True, simulator=False)
with Session(backend=backend):
    estimator = Estimator()
    sampler = Sampler()
    executor = Executor()

Durata delle sessioni

Il tempo massimo di vita della sessione (TTL) determina la durata della sessione. È possibile impostare questo valore con il parametro max_time . Questo dovrebbe superare il tempo di esecuzione del lavoro più lungo.

Questo timer si avvia all'avvio della sessione. Quando il valore viene raggiunto, la sessione viene chiusa. I lavori in corso vengono terminati, mentre quelli ancora in coda non vengono eseguiti.

with Session(backend=backend, max_time="25m"):
  ...

Esiste anche un valore di time to live interattivo (interactive TTL) che non può essere configurato. Se non vengono accodati lavori di sessione entro tale finestra, la sessione viene temporaneamente disattivata.

Valori predefiniti:

Per determinare il TTL massimo o interattivo di una sessione, seguire le istruzioni in Determinare i dettagli della sessione e cercare il valore max_timeo interactive_timeout , rispettivamente.

Termina una sessione

Una sessione termina nelle seguenti circostanze:

• Il raggiungimento del valore massimo di timeout (TTL) comporta l'annullamento di tutti i lavori in coda.
• La sessione viene annullata manualmente, con conseguente cancellazione di tutti i lavori in coda.
• La sessione viene chiusa manualmente. La sessione smette di accettare nuovi lavori, ma continua a eseguire i lavori in coda con priorità.
• Se si usa Session come gestore del contesto, cioè with Session(), la sessione viene chiusa automaticamente quando il contesto termina (lo stesso comportamento di session.close()).

Chiudi una sessione

Una sessione si chiude automaticamente quando si esce dal gestore del contesto. Quando si esce dal gestore del contesto di sessione, la sessione viene posta nello stato "In corso, non accetta nuovi lavori". Ciò significa che la sessione termina l'elaborazione di tutti i lavori in corso o in coda fino al raggiungimento del valore massimo di timeout. Al termine di tutti i lavori, la sessione viene immediatamente chiusa. Ciò consente allo scheduler di eseguire il lavoro successivo senza attendere il timeout interattivo della sessione, riducendo così il tempo medio di accodamento dei lavori. Non è possibile presentare lavori in una sessione chiusa.

with Session(backend=backend) as session:
    estimator = Estimator()
    sampler = Sampler()
    job1 = estimator.run([estimator_pub])
    job2 = sampler.run([sampler_pub])

# The session is no longer accepting jobs but the submitted job will run to completion.
result = job1.result()
result2 = job2.result()

session = Session(backend=backend)

# If using qiskit-ibm-runtime earlier than 0.24.0, change `mode=` to `session=`
estimator = Estimator(mode=session)
sampler = Sampler(mode=session)
job1 = estimator.run([estimator_pub])
job2 = sampler.run([sampler_pub])
print(f"Result1: {job1.result()}")
print(f"Result2: {job2.result()}")

# Manually close the session. Running and queued jobs will run to completion.
session.close()

Output:

Result1: PrimitiveResult([PubResult(data=DataBin(evs=np.ndarray(<shape=(3, 2), dtype=float64>), stds=np.ndarray(<shape=(3, 2), dtype=float64>), ensemble_standard_error=np.ndarray(<shape=(3, 2), dtype=float64>), shape=(3, 2)), metadata={'shots': 4096, 'target_precision': 0.015625, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32})], metadata={'dynamical_decoupling': {'enable': False, 'sequence_type': 'XX', 'extra_slack_distribution': 'middle', 'scheduling_method': 'alap'}, 'twirling': {'enable_gates': False, 'enable_measure': True, 'num_randomizations': 'auto', 'shots_per_randomization': 'auto', 'interleave_randomizations': True, 'strategy': 'active-accum'}, 'resilience': {'measure_mitigation': True, 'zne_mitigation': False, 'pec_mitigation': False}, 'version': 2})

Result2: PrimitiveResult([SamplerPubResult(data=DataBin(meas=BitArray(<shape=(3, 2), num_shots=4096, num_bits=2>), meas0=BitArray(<shape=(3, 2), num_shots=4096, num_bits=156>), shape=(3, 2)), metadata={'circuit_metadata': {}})], metadata={'execution': {'execution_spans': ExecutionSpans([DoubleSliceSpan(<start='2026-03-15 07:33:44', stop='2026-03-15 07:33:51', size=24576>)])}, 'version': 2})

Controlla lo stato della sessione

È possibile interrogare lo stato di una sessione per comprenderne lo stato attuale utilizzando session.status() o visualizzando la pagina dei carichi di lavoro.

Lo stato della sessione può essere uno dei seguenti:

• Pending: La sessione non è stata avviata o è stata disattivata. Il lavoro di sessione successivo deve attendere in coda come gli altri lavori.
• In progress, accepting new jobs: La sessione è attiva e accetta nuovi lavori.
• In progress, not accepting new jobs: La sessione è attiva ma non accetta nuovi lavori. L'invio di lavori alla sessione viene rifiutato, ma i lavori di sessione in sospeso vengono eseguiti fino al completamento. La sessione viene chiusa automaticamente al termine di tutti i lavori.
• Closed: Il valore massimo di timeout della sessione è stato raggiunto o la sessione è stata chiusa esplicitamente.

Determinare i dettagli della sessione

Per una panoramica completa della configurazione e dello stato di una sessione, utilizzare il sito session.details() method.

from qiskit_ibm_runtime import (
    QiskitRuntimeService,
    Session,
    EstimatorV2 as Estimator,
)

service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

with Session(backend=backend) as session:
    print(session.details())

Output:

{'id': 'a9fd2f9d-6239-4451-a19c-9b45aa6a0618', 'backend_name': 'ibm_torino', 'interactive_timeout': 60, 'max_time': 28800, 'active_timeout': 28800, 'state': 'open', 'accepting_jobs': True, 'last_job_started': None, 'last_job_completed': None, 'started_at': None, 'closed_at': None, 'activated_at': None, 'mode': 'dedicated', 'usage_time': None}

Modelli di utilizzo

Le sessioni sono particolarmente utili per gli algoritmi che richiedono una comunicazione frequente tra risorse classiche e quantistiche.

Esempio: Eseguire un carico di lavoro iterativo che utilizza il classico ottimizzatore SciPy per minimizzare una funzione di costo. In questo modello, SciPy utilizza l'output della funzione di costo per calcolare il suo prossimo input.

from scipy.optimize import minimize
from qiskit.circuit.library import efficient_su2


def cost_func(params, ansatz, hamiltonian, estimator):
    # Return estimate of energy from estimator

    energy = sum(
        estimator.run([(ansatz, hamiltonian, params)]).result()[0].data.evs
    )
    return energy


hamiltonian = SparsePauliOp.from_list(
    [("YZ", 0.3980), ("ZI", -0.3980), ("ZZ", -0.0113), ("XX", 0.1810)]
)
su2_ansatz = efficient_su2(hamiltonian.num_qubits)
pm = generate_preset_pass_manager(backend=backend, optimization_level=3)
ansatz = pm.run(su2_ansatz)
mapped_hamiltonian = [
    operator.apply_layout(ansatz.layout) for operator in hamiltonian
]

num_params = ansatz.num_parameters
x0 = 2 * np.pi * np.random.random(num_params)

session = Session(backend=backend)


# If using qiskit-ibm-runtime earlier than 0.24.0, change `mode=` to `session=`
estimator = Estimator(mode=session, options={"default_shots": int(1e4)})
res = minimize(
    cost_func,
    x0,
    args=(ansatz, mapped_hamiltonian, estimator),
    method="cobyla",
    options={"maxiter": 25},
)

# Close the session because no context manager was used.
session.close()

Esegui due algoritmi VQE in una sessione utilizzando il threading

È possibile ottenere di più da una sessione eseguendo più carichi di lavoro contemporaneamente. L'esempio seguente mostra come sia possibile eseguire contemporaneamente due algoritmi VQE, ciascuno dei quali utilizza un diverso ottimizzatore classico, all'interno di una singola sessione. I tag dei lavori vengono utilizzati anche per differenziare i lavori da ciascun carico di lavoro.

from concurrent.futures import ThreadPoolExecutor
from qiskit_ibm_runtime import EstimatorV2 as Estimator


def minimize_thread(estimator, method):
    return minimize(
        cost_func,
        x0,
        args=(ansatz, mapped_hamiltonian, estimator),
        method=method,
        options={"maxiter": 25},
    )


with Session(backend=backend), ThreadPoolExecutor() as executor:
    estimator1 = Estimator()
    estimator2 = Estimator()

    # Use different tags to differentiate the jobs.
    estimator1.options.environment.job_tags = ["cobyla"]
    estimator2.options.environment.job_tags = ["nelder-mead"]

    # Submit the two workloads.
    cobyla_future = executor.submit(minimize_thread, estimator1, "cobyla")
    nelder_mead_future = executor.submit(
        minimize_thread, estimator2, "nelder-mead"
    )

    # Get workload results.
    cobyla_result = cobyla_future.result()
    nelder_mead_result = nelder_mead_future.result()

Passi successivi