{ "cells": [ { "cell_type": "markdown", "id": "810fe365-8557-46b0-97e7-324b08a1c6e2", "metadata": {}, "source": [ "---\n", "title: \"Surveiller ou annuler une tâche\"\n", "description: \"Comment suivre ou annuler une tâche envoyée à IBM Quantum Platform\"\n", "---\n", "\n", "\n", "\n", "# Surveiller ou annuler une tâche\n", "\n", "Ce guide explique comment suivre l'état des tâches, consulter les informations d'utilisation et annuler des tâches. Vous pouvez accéder à ces informations soit via IBM Quantum® Platform, soit par programmation à l'aide de Qiskit.\n", "\n" ] }, { "cell_type": "markdown", "id": "866ed6ab-a597-402e-876a-8315ac5ed9e6", "metadata": { "tags": [ "version-info" ] }, "source": [ "\n" ] }, { "cell_type": "markdown", "id": "bb84ab8e-6db9-45d6-bb59-2f06f38d9965", "metadata": {}, "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 présenté sur cette page a été développé en respectant les exigences suivantes.\n", " Nous vous recommandons d'utiliser ces versions ou des versions plus récentes.\n", "\n", " ```\n", " qiskit-ibm-runtime~=0.46.1\n", " ```\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "view-status", "metadata": {}, "source": [ "\n", "\n", "## Surveiller une tâche\n", "\n", "Utilisez ces méthodes pour vérifier l'état des tâches que vous avez soumises, récupérer les résultats et consulter les détails relatifs à la tâche et à son exécution.\n", "\n", "\n", " \n", " L'instance de tâche propose plusieurs méthodes de surveillance :\n", "\n", " | Méthode | Description |\n", " | ---------------------------- | ----------------------------------------------------------------------------------- |\n", " | `job.status()` | Vérifier l'état actuel de la mission |\n", " | `job.job_id()` | Récupérer l'identifiant unique de la mission |\n", " | `job.result()` | Récupérer les résultats d'un travail (appel bloquant jusqu'à la fin de l'opération) |\n", " | `job.wait_for_final_state()` | Bloquer jusqu’à ce que la tâche atteigne un état final |\n", "\n", " \n", " \n", "\n", " \n", " Accédez à la [page « Workloads »](/workloads) et consultez la colonne « Statut ». Votre statut professionnel correspond à l'une des options suivantes :\n", "\n", " * **En attente** : la tâche attend d'être exécutée sur un QPU\n", " * **En cours** : la tâche est actuellement en cours d'exécution\n", " * **Terminé** : la tâche s'est achevée avec succès\n", " * **Échec** : une erreur s'est produite lors de l'exécution de la tâche\n", " * **Annulé** : l'utilisateur a annulé la tâche\n", "\n", " Cliquez sur le nom de la tâche ou sur la ligne correspondante pour ouvrir la vue détaillée, où vous pourrez consulter des informations telles que les résultats et les éventuels messages d'erreur.\n", " \n", "\n", "\n", "\n", "\n", "### Pourquoi une tâche reste-t-elle « En cours »?\n", "\n", "Vous remarquerez peut-être qu'une tâche (en mode « job » ou en mode « batch ») qui, selon vos prévisions, ne devrait prendre que quelques secondes, reste dans l'état «\\*\\* En cours\\*\\* » (appelé `RUNNING` dans Qiskit) pendant bien plus longtemps. C'est normal, et cela ne signifie pas que la tâche occupe tout ce temps en termes d'utilisation. Cela s'explique par la manière dont les tâches sont planifiées sur une QPU :\n", "\n", "* Chaque tâche nécessite un prétraitement classique avant de pouvoir être exécutée sur le QPU. Une tâche passe à l'état « **En cours** » (`RUNNING`) dès que ce traitement classique commence — et non pas lorsqu'elle commence à s'exécuter sur le QPU.\n", "* La plupart de ces traitements classiques s'exécutent en parallèle, ce qui permet de **mener** plusieurs tâches de front.\n", "* Cependant, un seul travail à la fois peut s'exécuter sur le QPU. Lorsque plusieurs tâches ont terminé leur traitement classique et sont prêtes à être exécutées, elles doivent attendre leur tour pour accéder au QPU. C'est ce qu'on appelle *un conflit de QPU*. Lorsque la contention est élevée, une tâche peut rester **« En cours »** nettement plus longtemps que les quelques secondes de temps QPU dont elle a réellement besoin.\n", "* Des conflits peuvent également survenir lorsqu'une tâche de maintenance du système, telle qu'un étalonnage, est en cours d'exécution sur le QPU. Votre tâche reste **en cours** jusqu'à ce que la tâche de maintenance soit terminée et que le QPU soit à nouveau disponible.\n", "\n", "C'est pourquoi la durée réelle (en temps réel) pendant laquelle une tâche est **en cours d'exécution** ne correspond pas à son temps d'utilisation. Tant l' [estimation de la durée d'utilisation](/docs/guides/estimate-job-run-time) que la [durée d'exécution maximale](/docs/guides/max-execution-time) sont calculées uniquement en fonction du temps pendant lequel le QPU est réservé à l'exécution de votre tâche; elles n'incluent donc pas le traitement classique multithread décrit ci-dessus. Une durée prolongée **de l'état « En cours »** n'entraîne pas d'augmentation de votre consommation déclarée ni de vos coûts.\n", "\n", "\n", "\n", "#### Le mode « session » est différent\n", "\n", "Le comportement décrit ci-dessus s'applique aussi bien au [mode « job »](/docs/guides/execution-modes#job-mode) qu'au [mode « batch](/docs/guides/execution-modes#batch-mode) ». En [mode session](/docs/guides/execution-modes#session-mode), tant que la fenêtre de session est active, l'utilisateur dispose d'un accès exclusif au backend et aucune autre tâche ne peut s'exécuter, y compris les tâches d'étalonnage. Par conséquent, tout conflit d'accès à la QPU ne se produit qu'entre les tâches de votre propre session. De plus, la capacité de la QPU étant réservée pour toute la durée de la session, l'utilisation de la session est mesurée en fonction du temps écoulé tant que la session reste active, que les tâches soient en cours d'exécution ou non. Pour plus d'informations, consultez la section « [Utilisation de la charge de travail](/docs/guides/estimate-job-run-time#usage) ».\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "ee0318b6-0bfd-4f0b-b980-4e233a2d5d7b", "metadata": { "tags": [ "id-status" ] }, "outputs": [], "source": [ "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", "service = QiskitRuntimeService()\n", "\n", "# Retrieve a job by ID\n", "job = service.job(\"\")\n", "\n", "# Get job ID (useful for saving for later retrieval)\n", "print(f\"Job ID: {job.job_id()}\")\n", "\n", "# Check current status\n", "print(f\"Status: {job.status()}\")\n", "\n", "# Wait for job to complete (blocking call)\n", "job.wait_for_final_state()\n", "print(\"Job completed\")\n", "\n", "# Get results\n", "results = job.result()\n", "print(results)" ] }, { "cell_type": "markdown", "id": "view-usage", "metadata": {}, "source": [ "\n", "\n", "## Afficher l'utilisation restante\n", "\n", "Suivez le solde de votre quota d'utilisation.\n", "\n", "\n", " \n", " Utilisez la méthode `service.usage()` pour obtenir des informations d'utilisation concernant votre instance actuellement active.\n", "\n", " \n", " \n", "\n", " \n", " Accédez à la [page « Instances »](/instances) et sélectionnez l'onglet correspondant au forfait que vous souhaitez consulter. Le temps total utilisé et le temps total restant dans le cadre de votre forfait s'affichent.\n", " \n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "usage-code", "metadata": { "tags": [ "id-usage" ] }, "outputs": [], "source": [ "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", "service = QiskitRuntimeService()\n", "\n", "# Get usage information for the current active instance\n", "usage = service.usage()\n", "print(usage)" ] }, { "cell_type": "markdown", "id": "view-metrics", "metadata": {}, "source": [ "\n", "\n", "## Afficher les indicateurs de performance de l'offre d'emploi\n", "\n", "Obtenez une vue d'ensemble de vos soumissions de tâches, y compris les indicateurs de charge de travail par lot et par session.\n", "\n", "\n", " \n", " Utilisez la méthode [`service.jobs()`](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#jobs) avec des filtres pour récupérer des informations sur les tâches que vous avez soumises, telles que leur nombre, leur statut et leur date de création. L'exemple suivant récupère toutes les tâches soumises au cours des sept derniers jours et calcule la consommation totale générée par ces tâches.\n", "\n", " \n", " \n", "\n", " \n", " Accédez à la [page « Analytics »](/analytics) pour consulter et télécharger des données, telles que celles-ci :\n", "\n", " * Utilisation totale\n", " * Utilisation filtrée par instance, ordinateur quantique et utilisateur\n", " * Nombre de tâches, de lots et de sessions\n", "\n", " **Remarque** : vous ne pouvez accéder à la page « Analytics » que pour les comptes dont vous êtes le propriétaire ou que vous gérez.\n", " \n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "metrics-code", "metadata": { "tags": [ "id-metrics" ] }, "outputs": [], "source": [ "from datetime import datetime, timedelta\n", "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", "service = QiskitRuntimeService()\n", "\n", "# Retrieve all jobs in the last 7 days\n", "seven_days_ago = datetime.now() - timedelta(days=7)\n", "jobs = service.jobs(limit=None, created_after=seven_days_ago)\n", "\n", "# To retrieve all jobs in a Session or Batch, use the session_id filter\n", "# jobs = service.jobs(session_id=\"\")\n", "\n", "total_usage = 0\n", "for job in jobs:\n", " total_usage += job.usage()\n", "\n", "print(f\"{len(jobs)} jobs were submitted in the last 7 days.\")\n", "print(f\"Total usage was {total_usage} seconds\")" ] }, { "cell_type": "markdown", "id": "retrieve-later", "metadata": {}, "source": [ "\n", "\n", "## Récupérer les résultats d'un travail ultérieurement\n", "\n", "Vous pouvez enregistrer les identifiants de tâche et consulter les résultats ultérieurement, même après avoir fermé votre session.\n", "\n", "\n", " \n", " Si vous avez enregistré l'identifiant de la tâche lors de son envoi, utilisez `service.job()` pour le récupérer ultérieurement. Si vous ne disposez pas de l'identifiant de tâche, ou si vous souhaitez récupérer plusieurs tâches à la fois (y compris celles provenant de QPU retirées), utilisez plutôt `service.jobs()` cette commande, avec des filtres facultatifs.\n", "\n", " Consultez la documentation de l'API [`QiskitRuntimeService.jobs`](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#jobs) pour connaître les filtres disponibles.\n", "\n", " Cet exemple montre comment récupérer les résultats récents d'une exécution effectuée sur un backend spécifique.\n", "\n", " \n", " \n", "\n", " \n", " 1. Accédez à la [page « Workloads](/workloads) ».\n", " 2. Utilisez les options de recherche ou de filtrage pour trouver votre offre d'emploi par nom, date ou statut.\n", " 3. Cliquez sur la tâche pour afficher ses résultats et ses détails.\n", " \n", "\n", "\n", "\n", "\n", "## Récupérer les propriétés du backend\n", "\n", "\n", " \n", " Vous pouvez utiliser `job.properties()` pour récupérer les propriétés du backend, notamment les taux d'erreur, au moment de l'exécution de la tâche.\n", "\n", " Cet exemple montre comment récupérer les propriétés du backend telles qu'elles étaient au moment de l'exécution d'un travail, notamment les temps d' $T_1$ / $T_2$ s et les taux d'erreur pour un qubit spécifique (0).\n", "\n", " \n", "\n", " \n", " `service.jobs()` renvoie également les travaux exécutés à partir du paquetage `qiskit-ibm-provider` , qui est obsolète. Les travaux soumis par l'ancien paquetage (également obsolète) `qiskit-ibmq-provider` ne sont plus disponibles.\n", " \n", " \n", "\n", " \n", " Vous pouvez consulter les données d'étalonnage du backend aussi bien au moment de l'exécution d'une tâche qu'au moment de sa création.\n", "\n", " 1. Accéder à la [page « Workloads »](/workloads)\n", " 2. Cliquez sur une charge de travail pour ouvrir sa page « Détails »\n", " 3. Dans la section « Ordinateur quantique », cliquez sur « Afficher l'historique des étalonnages »\n", " 4. Utilisez le menu déroulant pour passer de l'affichage des données « Au début de l'exécution de la tâche » à « À la création de la tâche »\n", " \n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "retrieve-code", "metadata": { "tags": [ "id-retrieve" ] }, "outputs": [], "source": [ "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", "service = QiskitRuntimeService()\n", "\n", "# Uncomment the next line to retrieve a specific job by ID\n", "# job = service.job(\"\")\n", "\n", "# Optionally retrieve multiple jobs with filters\n", "# Use `limit` to retrieve a specific number of jobs. The default `limit` is 10.\n", "my_backend = \"\"\n", "recent_jobs = service.jobs(backend_name=my_backend, limit=10)\n", "\n", "print(f\"Retrieved {len(recent_jobs)} recent jobs from {my_backend}\\n\")\n", "\n", "# Get results from all jobs\n", "for job in recent_jobs:\n", " print(f\"Job ID: {job.job_id()}\")\n", " print(f\"Status: {job.status()}\")\n", "\n", " # Retrieve results if the job is complete\n", " if str(job.status()) == \"DONE\":\n", " try:\n", " results = job.result()\n", " print(f\"Results: {results}\")\n", " except Exception as e:\n", " print(f\"Error retrieving results: {e}\")\n", " else:\n", " print(\"Results: Not available (job still running or failed)\")\n", " print()" ] }, { "cell_type": "code", "execution_count": null, "id": "55afa300-0af7-4f5e-8b32-c32b6ba39621", "metadata": { "tags": [ "id-backend-properties" ] }, "outputs": [], "source": [ "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", "service = QiskitRuntimeService()\n", "\n", "# Retrieve a specific job by ID\n", "job = service.job(\"\")\n", "\n", "print(f\"Job ID: {job.job_id()}\")\n", "print(f\"Backend: {job.backend}\\n\")\n", "\n", "# Fetch backend properties at the time of job execution\n", "properties = job.properties()\n", "\n", "if properties:\n", " print(\"Backend Properties at Job Execution Time:\")\n", " print(\"=\" * 60)\n", "\n", " # Get T1 (relaxation time) for qubit 0\n", " t1 = properties.t1(0)\n", " print(f\"Qubit 0 T1 (relaxation time): {t1}\")\n", "\n", " # Get T2 (dephasing time) for qubit 0\n", " t2 = properties.t2(0)\n", " print(f\"Qubit 0 T2 (dephasing time): {t2}\")\n", "\n", " # Get readout error for qubit 0\n", " readout_error = properties.readout_error(0)\n", " print(f\"Qubit 0 readout error: {readout_error}\")\n", "\n", " # Get all properties for a specific qubit\n", " print(\"All properties for qubit 0:\")\n", " qubit_props = properties.qubit_property(0)\n", " for prop_name, prop_value in qubit_props.items():\n", " print(f\" {prop_name}: {prop_value}\")\n", "else:\n", " print(\"No properties available for this job\")" ] }, { "cell_type": "markdown", "id": "cancel-job", "metadata": {}, "source": [ "\n", "\n", "## Annuler un travail\n", "\n", "Annuler une tâche en attente ou en cours d'exécution. Une fois qu'une tâche a été annulée, elle ne peut plus être reprise.\n", "\n", "\n", " \n", " Utilisez la méthode `job.cancel()` pour annuler une tâche par programmation.\n", "\n", " \n", " \n", "\n", " \n", " 1. **Dans le tableau des charges de travail** : cliquez sur le menu déroulant situé à la fin de la ligne correspondant à la charge de travail que vous souhaitez annuler, puis sélectionnez « **Annuler** ».\n", " 2. **Depuis la page de détails de la tâche** : cliquez sur la tâche pour ouvrir sa page de détails, utilisez le menu déroulant « \\*\\*Actions \\*\\*» situé en haut de la page, puis sélectionnez « **Annuler** ».\n", " \n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "cancel-code", "metadata": { "tags": [ "id-cancel" ] }, "outputs": [], "source": [ "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", "service = QiskitRuntimeService()\n", "\n", "# Retrieve the job\n", "job = service.job(\"\")\n", "\n", "# Cancel the job\n", "job.cancel()\n", "\n", "print(f\"Job {job.job_id()} has been canceled\")" ] }, { "cell_type": "markdown", "id": "next-steps", "metadata": {}, "source": [ "\n", "\n", "## Etapes suivantes\n", "\n", "\n", " * Consultez la documentation [de référence de l'API `QiskitRuntimeService`](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service) pour découvrir d'autres méthodes de gestion des tâches.\n", " * Découvrez [les modes d'exécution](/docs/guides/execution-modes) pour comprendre les types de charges de travail par lots et par session.\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "id": "a1b8767d", "source": "© IBM Corp., 2017-2026" } ], "metadata": { "description": "How to monitor or cancel a job submitted to IBM Quantum Platform", "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" }, "title": "Monitor or cancel a job" }, "nbformat": 4, "nbformat_minor": 4 }