Exécuter des tâches dans une session

• Versions de package

  Le code figurant sur cette page a été développé selon les exigences suivantes. Nous recommandons d'utiliser ces versions ou des versions plus récentes.

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

Utilisez les sessions lorsque vous avez besoin d'un accès dédié et exclusif au QPU.

Configurer pour utiliser les sessions

Avant de démarrer une session, vous devez configurer le client Compute d' IBM Quantum, puis l'initialiser en tant que service :

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

service = QiskitRuntimeService()

Ouvrir une session

Vous pouvez ouvrir une session d'exécution en utilisant le gestionnaire de contexte with Session(...) ou en initialisant la classe Session classe. Lorsque vous démarrez une session, vous devez spécifier une QPU en transmettant un objet backend . La session démarre lorsque son premier travail commence à être exécuté.

Classe de session

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()

Gestionnaire de contexte

Le gestionnaire de contexte ouvre et ferme automatiquement la session.

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()

Durée de session

La durée maximale de la session (TTL) détermine la durée d'exécution d'une session. Vous pouvez définir cette valeur à l'aide du paramètre max_time . Cette durée doit être supérieure à la durée d'exécution du travail le plus long.

Cette minuterie démarre au début de la session. Lorsque la valeur est atteinte, la session est fermée. Les tâches en cours d'exécution se terminent, mais celles qui sont encore en file d'attente échouent.

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

Il existe également une valeur TTL interactive (interactive time to live) qui ne peut pas être configurée. Si aucune tâche de session n'est mise en file d'attente dans cette fenêtre, la session est temporairement désactivée.

Valeurs par défaut :

Pour déterminer le TTL maximum ou le TTL interactif d'une session, suivez les instructions de la section Déterminer les détails de la session et recherchez la valeur max_timeou interactive_timeout , respectivement.

Terminer une session

Une session se termine dans les circonstances suivantes :

• La valeur maximale du délai d'attente (TTL) est atteinte, ce qui entraîne l'annulation de tous les travaux en file d'attente.
• La session est annulée manuellement, ce qui entraîne l'annulation de tous les travaux en attente.
• La session est fermée manuellement. La session cesse d'accepter de nouveaux travaux mais continue d'exécuter les travaux en file d'attente avec priorité.
• Si vous utilisez Session comme gestionnaire de contexte, c'est-à-dire with Session(), la session est automatiquement fermée lorsque le contexte se termine (même comportement qu'avec session.close()).

Fermer une session

Une session se ferme automatiquement lorsqu'elle quitte le gestionnaire de contexte. Lorsque le gestionnaire de contexte de session est quitté, la session est placée dans l'état "En cours, n'acceptant pas de nouveaux travaux". Cela signifie que la session termine le traitement de tous les travaux en cours ou en file d'attente jusqu'à ce que la valeur maximale du délai d'attente soit atteinte. Lorsque tous les travaux sont terminés, la session est immédiatement clôturée. Cela permet au planificateur d'exécuter le travail suivant sans attendre le délai d'expiration de la session interactive, ce qui réduit la durée moyenne de la file d'attente des travaux. Il n'est pas possible de soumettre des emplois à une session à huis clos.

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

Vérifier l'état de la session

Vous pouvez interroger le statut d'une session pour comprendre son état actuel en utilisant session.status() ou en consultant la page Workloads.

L'état de la session peut être l'un des suivants :

• Pending: La session n'a pas démarré ou a été désactivée. Le travail de session suivant doit être placé dans la file d'attente comme les autres travaux.
• In progress, accepting new jobs: La session est active et accepte de nouveaux travaux.
• In progress, not accepting new jobs: La session est active mais n'accepte pas de nouveaux travaux. La soumission de travaux à la session est rejetée, mais les travaux en cours de la session sont exécutés jusqu'à leur terme. La session est automatiquement fermée lorsque tous les travaux sont terminés.
• Closed: La valeur maximale du délai d'attente de la session a été atteinte ou la session a été explicitement fermée.

Déterminer les détails de la session

Pour obtenir une vue d'ensemble de la configuration et de l'état d'une session, utilisez la fonction 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}

Modèles d'utilisation

Les sessions sont particulièrement utiles pour les algorithmes qui nécessitent une communication fréquente entre les ressources classiques et quantiques.

Exemple : Exécutez une charge de travail itérative qui utilise l'optimiseur classique SciPy pour minimiser une fonction de coût. Dans ce modèle, SciPy utilise la sortie de la fonction de coût pour calculer sa prochaine entrée.

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()

Exécutez deux algorithmes VQE dans une session à l'aide du threading

Vous pouvez tirer un meilleur parti d'une session en exécutant plusieurs charges de travail simultanément. L'exemple suivant montre comment vous pouvez exécuter simultanément deux algorithmes VQE, chacun utilisant un optimiseur classique différent, à l'intérieur d'une même session. Les étiquettes de travail sont également utilisées pour différencier les travaux de chaque charge de travail.

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()

Etapes suivantes