{ "cells": [ { "cell_type": "markdown", "id": "b9fd7c5e-f3b8-4f0d-8632-821d601af52c", "metadata": {}, "source": [ "---\n", "title: \"Exécuter des tâches dans une session\"\n", "description: \"Comment exécuter une tâche de calcul quantique dans une session du service de calcul « IBM Quantum ».\"\n", "---\n", "\n", "\n", "\n", "# Exécuter des tâches dans une session\n", "\n" ] }, { "cell_type": "markdown", "id": "817c70e7-29dd-4f70-85ad-6487d7c4b010", "metadata": { "tags": [ "version-info" ] }, "source": [ "{/*\n", " DO NOT EDIT THIS CELL!!!\n", " This cell's content is generated automatically by a script. Anything you add\n", " here will be removed next time the notebook is run. To add new content, create\n", " a new cell before or after this one.\n", " */}\n", "\n", "\n", " \n", " Le code figurant sur cette page a été développé selon les exigences suivantes.\n", " Nous recommandons d'utiliser ces versions ou des versions plus récentes.\n", "\n", " ```\n", " qiskit[all]~=2.3.1\n", " qiskit-ibm-runtime~=0.45.0\n", " scipy~=1.17.1\n", " ```\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "be06e0ee-e593-4fe7-aa98-4f6e0dcbaa9f", "metadata": {}, "source": [ "\n", " Les utilisateurs du plan ouvert ne peuvent pas soumettre de travaux de session. Les charges de travail doivent être exécutées en [mode travail](/docs/guides/execution-modes#job-mode) ou [en mode batch](/docs/guides/execution-modes#batch-mode).\n", "\n", "\n", "Utilisez les sessions lorsque vous avez besoin d'un accès dédié et exclusif au QPU.\n", "\n", "\n", "\n", "## Configurer pour utiliser les sessions\n", "\n", "Avant de démarrer une session, vous devez [configurer le client Compute d' IBM Quantum](/docs/guides/install-qiskit-runtime), puis l'initialiser en tant que service :\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "117d0471-1f98-489c-906f-8aab836cd877", "metadata": {}, "outputs": [], "source": [ "from qiskit_ibm_runtime import (\n", " QiskitRuntimeService,\n", " Session,\n", " SamplerV2 as Sampler,\n", " EstimatorV2 as Estimator,\n", " Executor,\n", ")\n", "\n", "service = QiskitRuntimeService()" ] }, { "cell_type": "markdown", "id": "1e1cd9a3-7f36-4f42-8924-7f4dac202788", "metadata": {}, "source": [ "\n", "\n", "## Ouvrir une session\n", "\n", "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é.\n", "\n", "\n", " Si vous ouvrez une session mais que vous n'y soumettez aucun travail pendant 30 minutes, la session se ferme automatiquement.\n", "\n", "\n", "**Classe de session**\n", "\n", "\n", " Le bloc de code suivant renverra une erreur pour les utilisateurs du plan ouvert car il utilise des sessions. Les charges de travail sur le plan ouvert ne peuvent être exécutées qu'en [mode travail](/docs/guides/execution-modes#job-mode) ou [en mode batch.](/docs/guides/execution-modes#batch-mode)\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "2694bd4c-2011-4671-9625-3e7e941dd381", "metadata": {}, "outputs": [], "source": [ "backend = service.least_busy(operational=True, simulator=False)\n", "session = Session(backend=backend)\n", "estimator = Estimator(mode=session)\n", "sampler = Sampler(mode=session)\n", "executor = Executor(mode=session)\n", "# Close the session because no context manager was used.\n", "session.close()" ] }, { "cell_type": "markdown", "id": "e0460f64-f5a8-4663-834a-a4c15c9ad82b", "metadata": {}, "source": [ "**Gestionnaire de contexte**\n", "\n", "Le gestionnaire de contexte ouvre et ferme automatiquement la session.\n", "\n", "\n", " Le bloc de code suivant renverra une erreur pour les utilisateurs du plan ouvert car il utilise des sessions. Les charges de travail sur le plan ouvert ne peuvent être exécutées qu'en [mode travail](/docs/guides/execution-modes#job-mode) ou [en mode batch.](/docs/guides/execution-modes#batch-mode)\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "192e5e57-2f9d-4f8e-b3e7-1dd31907e8a6", "metadata": {}, "outputs": [], "source": [ "from qiskit_ibm_runtime import (\n", " Session,\n", " SamplerV2 as Sampler,\n", " EstimatorV2 as Estimator,\n", " Executor,\n", ")\n", "\n", "backend = service.least_busy(operational=True, simulator=False)\n", "with Session(backend=backend):\n", " estimator = Estimator()\n", " sampler = Sampler()\n", " executor = Executor()" ] }, { "cell_type": "markdown", "id": "e4219769-6348-4d0c-8e13-830177a4e7b8", "metadata": {}, "source": [ "\n", "\n", "\n", "\n", "## Durée de session\n", "\n", "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.\n", "\n", "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.\n", "\n", "\n", " Le bloc de code suivant renverra une erreur pour les utilisateurs du plan ouvert car il utilise des sessions. Les charges de travail sur le plan ouvert ne peuvent être exécutées qu'en [mode travail](/docs/guides/execution-modes#job-mode) ou [en mode batch.](/docs/guides/execution-modes#batch-mode)\n", "\n", "\n", "```python\n", "with Session(backend=backend, max_time=\"25m\"):\n", " ...\n", "```\n", "\n", "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.\n", "\n", "Valeurs par défaut :\n", "\n", "| Type d'instance (Open ou Premium Plan) | TTL interactif | Durée de vie maximale |\n", "| --------------------------------------------------------------------------------------------------- | -------------- | --------------------- |\n", "| Forfait Premium | 60 sec\\* | 8 h\\* |\n", "| *\\* Certaines instances du plan Premium peuvent être configurées pour avoir une valeur différente.* | | |\n", "\n", "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](#session-details) et recherchez la valeur `max_time`ou `interactive_timeout` , respectivement.\n", "\n", "\n", "\n", "\n", "\n", "## Terminer une session\n", "\n", "Une session se termine dans les circonstances suivantes :\n", "\n", "* 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.\n", "* La session est annulée manuellement, ce qui entraîne l'annulation de tous les travaux en attente.\n", "* 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é.\n", "* 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()`).\n", "\n", "\n", "\n", "\n", "\n", "### Fermer une session\n", "\n", "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.\n", "\n", "\n", " Le bloc de code suivant renverra une erreur pour les utilisateurs du plan ouvert car il utilise des sessions. Les charges de travail sur le plan ouvert ne peuvent être exécutées qu'en [mode travail](/docs/guides/execution-modes#job-mode) ou [en mode batch.](/docs/guides/execution-modes#batch-mode)\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "c6646bed-3064-488f-b2ff-da9ba793775a", "metadata": {}, "outputs": [], "source": [ "with Session(backend=backend) as session:\n", " estimator = Estimator()\n", " sampler = Sampler()\n", " job1 = estimator.run([estimator_pub])\n", " job2 = sampler.run([sampler_pub])\n", "\n", "# The session is no longer accepting jobs but the submitted job will run to completion.\n", "result = job1.result()\n", "result2 = job2.result()" ] }, { "cell_type": "markdown", "id": "20eb23f3-fc34-4f38-8ad7-85278ff4c823", "metadata": {}, "source": [ "\n", " Si vous n'utilisez pas de gestionnaire de contexte, fermez manuellement la session afin d'éviter tout coût indésirable. Vous pouvez fermer une session dès que vous avez fini de lui soumettre des travaux. Lorsqu'une session est fermée à l'aide de `session.close()`, elle n'accepte plus de nouveaux travaux, mais les travaux déjà soumis continueront à être exécutés jusqu'à leur terme et leurs résultats pourront être récupérés.\n", "\n", "\n", "\n", " Le bloc de code suivant renverra une erreur pour les utilisateurs du plan ouvert car il utilise des sessions. Les charges de travail sur le plan ouvert ne peuvent être exécutées qu'en [mode travail](/docs/guides/execution-modes#job-mode) ou [en mode batch.](/docs/guides/execution-modes#batch-mode)\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "861cf6b3-9695-41eb-9d3d-d5293880ca75", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Result1: PrimitiveResult([PubResult(data=DataBin(evs=np.ndarray(), stds=np.ndarray(), ensemble_standard_error=np.ndarray(), 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})\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Result2: PrimitiveResult([SamplerPubResult(data=DataBin(meas=BitArray(), meas0=BitArray(), shape=(3, 2)), metadata={'circuit_metadata': {}})], metadata={'execution': {'execution_spans': ExecutionSpans([DoubleSliceSpan()])}, 'version': 2})\n" ] } ], "source": [ "session = Session(backend=backend)\n", "\n", "# If using qiskit-ibm-runtime earlier than 0.24.0, change `mode=` to `session=`\n", "estimator = Estimator(mode=session)\n", "sampler = Sampler(mode=session)\n", "job1 = estimator.run([estimator_pub])\n", "job2 = sampler.run([sampler_pub])\n", "print(f\"Result1: {job1.result()}\")\n", "print(f\"Result2: {job2.result()}\")\n", "\n", "# Manually close the session. Running and queued jobs will run to completion.\n", "session.close()" ] }, { "cell_type": "markdown", "id": "aad804ed-027f-49c3-9f7d-8851a4f3de3a", "metadata": {}, "source": [ "\n", "\n", "\n", "\n", "## Vérifier l'état de la session\n", "\n", "Vous pouvez interroger le statut d'une session pour comprendre son état actuel en utilisant `session.status()` ou en consultant la page [Workloads](/workloads).\n", "\n", "L'état de la session peut être l'un des suivants :\n", "\n", "* `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.\n", "* `In progress, accepting new jobs`: La session est active et accepte de nouveaux travaux.\n", "* `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.\n", "* `Closed`: La valeur maximale du délai d'attente de la session a été atteinte ou la session a été explicitement fermée.\n", "\n", "\n", "\n", "\n", "\n", "## Déterminer les détails de la session\n", "\n", "Pour obtenir une vue d'ensemble de la configuration et de l'état d'une session, utilisez la fonction `session.details() method`.\n", "\n", "\n", " Le bloc de code suivant renverra une erreur pour les utilisateurs du plan ouvert car il utilise des sessions. Les charges de travail sur le plan ouvert ne peuvent être exécutées qu'en [mode travail](/docs/guides/execution-modes#job-mode) ou [en mode batch.](/docs/guides/execution-modes#batch-mode)\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "82a2599e-3e32-4e01-9a36-b77a56af7647", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'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}\n" ] } ], "source": [ "from qiskit_ibm_runtime import (\n", " QiskitRuntimeService,\n", " Session,\n", " EstimatorV2 as Estimator,\n", ")\n", "\n", "service = QiskitRuntimeService()\n", "backend = service.least_busy(operational=True, simulator=False)\n", "\n", "with Session(backend=backend) as session:\n", " print(session.details())" ] }, { "cell_type": "markdown", "id": "7db97311-25cb-4b81-9dba-494264c554c6", "metadata": {}, "source": [ "\n", "\n", "## Modèles d'utilisation\n", "\n", "Les sessions sont particulièrement utiles pour les algorithmes qui nécessitent une communication fréquente entre les ressources classiques et quantiques.\n", "\n", "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.\n", "\n", "\n", " Le bloc de code suivant renverra une erreur pour les utilisateurs du plan ouvert car il utilise des sessions. Les charges de travail sur le plan ouvert ne peuvent être exécutées qu'en [mode travail](/docs/guides/execution-modes#job-mode) ou [en mode batch.](/docs/guides/execution-modes#batch-mode)\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "77cc7c96-e8c0-4970-b05e-361ddf74d707", "metadata": {}, "outputs": [], "source": [ "from scipy.optimize import minimize\n", "from qiskit.circuit.library import efficient_su2\n", "\n", "\n", "def cost_func(params, ansatz, hamiltonian, estimator):\n", " # Return estimate of energy from estimator\n", "\n", " energy = sum(\n", " estimator.run([(ansatz, hamiltonian, params)]).result()[0].data.evs\n", " )\n", " return energy\n", "\n", "\n", "hamiltonian = SparsePauliOp.from_list(\n", " [(\"YZ\", 0.3980), (\"ZI\", -0.3980), (\"ZZ\", -0.0113), (\"XX\", 0.1810)]\n", ")\n", "su2_ansatz = efficient_su2(hamiltonian.num_qubits)\n", "pm = generate_preset_pass_manager(backend=backend, optimization_level=3)\n", "ansatz = pm.run(su2_ansatz)\n", "mapped_hamiltonian = [\n", " operator.apply_layout(ansatz.layout) for operator in hamiltonian\n", "]\n", "\n", "num_params = ansatz.num_parameters\n", "x0 = 2 * np.pi * np.random.random(num_params)\n", "\n", "session = Session(backend=backend)\n", "\n", "\n", "# If using qiskit-ibm-runtime earlier than 0.24.0, change `mode=` to `session=`\n", "estimator = Estimator(mode=session, options={\"default_shots\": int(1e4)})\n", "res = minimize(\n", " cost_func,\n", " x0,\n", " args=(ansatz, mapped_hamiltonian, estimator),\n", " method=\"cobyla\",\n", " options={\"maxiter\": 25},\n", ")\n", "\n", "# Close the session because no context manager was used.\n", "session.close()" ] }, { "cell_type": "markdown", "id": "8c03c721-f040-4066-a9d2-f2dd39777789", "metadata": {}, "source": [ "\n", "\n", "\n", "\n", "## Exécutez deux algorithmes VQE dans une session à l'aide du threading\n", "\n", "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.\n", "\n", "\n", " Le bloc de code suivant renverra une erreur pour les utilisateurs du plan ouvert car il utilise des sessions. Les charges de travail sur le plan ouvert ne peuvent être exécutées qu'en [mode travail](/docs/guides/execution-modes#job-mode) ou [en mode batch.](/docs/guides/execution-modes#batch-mode)\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "e83f7d60-13f0-4df1-9766-6fa67c970362", "metadata": {}, "outputs": [], "source": [ "from concurrent.futures import ThreadPoolExecutor\n", "from qiskit_ibm_runtime import EstimatorV2 as Estimator\n", "\n", "\n", "def minimize_thread(estimator, method):\n", " return minimize(\n", " cost_func,\n", " x0,\n", " args=(ansatz, mapped_hamiltonian, estimator),\n", " method=method,\n", " options={\"maxiter\": 25},\n", " )\n", "\n", "\n", "with Session(backend=backend), ThreadPoolExecutor() as executor:\n", " estimator1 = Estimator()\n", " estimator2 = Estimator()\n", "\n", " # Use different tags to differentiate the jobs.\n", " estimator1.options.environment.job_tags = [\"cobyla\"]\n", " estimator2.options.environment.job_tags = [\"nelder-mead\"]\n", "\n", " # Submit the two workloads.\n", " cobyla_future = executor.submit(minimize_thread, estimator1, \"cobyla\")\n", " nelder_mead_future = executor.submit(\n", " minimize_thread, estimator2, \"nelder-mead\"\n", " )\n", "\n", " # Get workload results.\n", " cobyla_result = cobyla_future.result()\n", " nelder_mead_result = nelder_mead_future.result()" ] }, { "cell_type": "markdown", "id": "0194fb4b-0917-45d7-aeb1-9fdff38cc5c5", "metadata": {}, "source": [ "\n", "\n", "## Etapes suivantes\n", "\n", "\n", " * Essayez un exemple dans le tutoriel sur l ['algorithme d'optimisation approximative quantique (QAOA)](/docs/tutorials/quantum-approximate-optimization-algorithm).\n", " * Consultez la référence de l' [API Session](/docs/api/qiskit-ibm-runtime/session).\n", " * Comprendre les [limites des](/docs/guides/job-limits) tâches lors de l'envoi d'une tâche à une QPU IBM®.\n", " * Consultez [la FAQ sur les modes d'exécution](/docs/guides/execution-modes-faq).\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "id": "a1b8767d", "source": "© IBM Corp., 2017-2026" } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3" } }, "nbformat": 4, "nbformat_minor": 4 }