{ "cells": [ { "cell_type": "markdown", "id": "810fe365-8557-46b0-97e7-324b08a1c6e2", "metadata": {}, "source": [ "---\n", "title: \"Monitorare o annullare un lavoro\"\n", "description: \"Come monitorare o annullare un lavoro inviato a IBM Quantum Platform\"\n", "---\n", "\n", "\n", "\n", "# Monitorare o annullare un lavoro\n", "\n", "Questa guida spiega come monitorare lo stato dei lavori, visualizzare le informazioni sull'utilizzo e annullare i lavori. È possibile accedere a queste informazioni sia tramite IBM Quantum® Platform sia a livello di programmazione utilizzando 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", " Il codice presente in questa pagina è stato sviluppato sulla base dei seguenti requisiti.\n", " Si consiglia di utilizzare queste versioni o quelle più recenti.\n", "\n", " ```\n", " qiskit-ibm-runtime~=0.46.1\n", " ```\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "view-status", "metadata": {}, "source": [ "\n", "\n", "## Monitorare un lavoro\n", "\n", "Utilizza questi metodi per verificare lo stato dei lavori inviati, recuperare i risultati e visualizzare i dettagli relativi al lavoro e alla sua esecuzione.\n", "\n", "\n", " \n", " L'istanza di lavoro offre diversi metodi di monitoraggio:\n", "\n", " | Metodo | Descrizione |\n", " | ---------------------------- | ---------------------------------------------------------------------------- |\n", " | `job.status()` | Verifica lo stato attuale del lavoro |\n", " | `job.job_id()` | Ottieni l'identificativo univoco del lavoro |\n", " | `job.result()` | Recupera i risultati del processo (chiamata in attesa fino al completamento) |\n", " | `job.wait_for_final_state()` | Bloccare fino a quando il processo non raggiunge uno stato finale |\n", "\n", " \n", " \n", "\n", " \n", " Accedi alla [pagina](/workloads) \"Workloads\" e controlla la colonna \"Stato\". Il tuo stato lavorativo può essere uno dei seguenti:\n", "\n", " * **In sospeso** : il processo è in attesa di essere eseguito su una QPU\n", " * **In corso** : il processo è attualmente in esecuzione\n", " * **Completato** : lavoro portato a termine con successo\n", " * **Errore** : si è verificato un errore durante l'esecuzione del processo\n", " * **Annullato** : l'utente ha annullato il lavoro\n", "\n", " Fai clic sul nome del processo o sulla riga per aprire la vista dettagliata, dove potrai visualizzare informazioni quali i risultati ed eventuali messaggi di errore.\n", " \n", "\n", "\n", "\n", "\n", "### Perché un'attività rimane \"In corso\"\n", "\n", "Potresti notare che un’operazione (sia in modalità job che in modalità batch) che ti aspetti duri solo pochi secondi rimane nello stato “**In corso** ” (denominato `RUNNING` in Qiskit) per molto più tempo. È normale, e non significa che l'attività stia occupando tutto quel tempo in termini di utilizzo. Ciò accade a causa del modo in cui i processi vengono pianificati su una QPU:\n", "\n", "* Ogni processo richiede una fase di pre-elaborazione standard prima di poter essere eseguito sulla QPU. Un lavoro passa allo stato “**In corso** ” (`RUNNING`) non appena ha inizio questa elaborazione classica — non quando inizia l’esecuzione sulla QPU.\n", "* La maggior parte di queste operazioni di elaborazione classica viene eseguita in parallelo, quindi è possibile che più processi siano **in corso** contemporaneamente.\n", "* Tuttavia, sulla QPU può essere eseguito un solo processo alla volta. Quando diversi processi hanno completato l'elaborazione classica e sono pronti per essere eseguiti, devono attendere il proprio turno per accedere alla QPU. Questo fenomeno è noto come *contesa QPU*. Quando il livello di contesa è elevato, un processo può rimanere **in corso per un tempo** notevolmente più lungo rispetto ai pochi secondi di tempo QPU di cui ha effettivamente bisogno.\n", "* Possono verificarsi situazioni di contesa anche quando sulla QPU è in esecuzione un’attività di manutenzione del sistema, come ad esempio la calibrazione. Il tuo lavoro rimane \" **In corso**\" fino al completamento dell'attività di manutenzione e alla disponibilità della QPU.\n", "\n", "Per questo motivo, il tempo effettivo trascorso da un processo **nello stato “In corso”** non corrisponde al suo tempo di utilizzo. Sia la [stima dei tempi di utilizzo](/docs/guides/estimate-job-run-time) che il [tempo](/docs/guides/max-execution-time) massimo di esecuzione si basano esclusivamente sul tempo in cui la QPU è riservata all'esecuzione del tuo lavoro e, pertanto, escludono l'elaborazione classica multithread descritta sopra. Un tempo **di elaborazione** prolungato non comporta un aumento dell'utilizzo o dei costi riportati.\n", "\n", "\n", "\n", "#### La modalità di sessione è diversa\n", "\n", "Il comportamento descritto in precedenza si applica sia alla [modalità \"job\"](/docs/guides/execution-modes#job-mode) che alla [modalità \"batch\"](/docs/guides/execution-modes#batch-mode). In [modalità sessione](/docs/guides/execution-modes#session-mode), mentre la finestra della sessione è attiva, l'utente ha accesso esclusivo al backend e nessun altro processo può essere eseguito, compresi i processi di calibrazione. Pertanto, eventuali conflitti relativi alla QPU si verificano solo tra i processi della propria sessione. Inoltre, poiché la capacità della QPU viene riservata per tutta la durata della sessione, l'utilizzo della sessione viene misurato in base al tempo trascorso mentre la sessione rimane attiva, indipendentemente dal fatto che i processi siano effettivamente in esecuzione. Per ulteriori informazioni, consultare la sezione \" [Utilizzo del carico di lavoro](/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", "## Visualizza utilizzo residuo\n", "\n", "Tieni traccia di quanto rimane della quota di utilizzo del tuo piano.\n", "\n", "\n", " \n", " Utilizza il metodo `service.usage()` per ottenere informazioni sull'utilizzo dell'istanza attualmente attiva.\n", "\n", " \n", " \n", "\n", " \n", " Accedi alla [pagina](/instances) \"Istanze\" e seleziona la scheda relativa al piano che desideri controllare. Vengono visualizzati il tempo totale utilizzato e il tempo totale rimanente del tuo piano.\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", "## Visualizza le metriche relative alle offerte di lavoro\n", "\n", "Ottieni una panoramica delle tue richieste di elaborazione, comprese le metriche relative al carico di lavoro per batch e per sessione.\n", "\n", "\n", " \n", " Utilizza il metodo [`service.jobs()`](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#jobs) con i filtri per recuperare informazioni sui tuoi lavori inviati, ad esempio quanti ne sono stati inviati, quali sono i loro stati e quando sono stati creati. L'esempio seguente recupera tutti i lavori inviati negli ultimi sette giorni e calcola l'utilizzo totale di tali lavori.\n", "\n", " \n", " \n", "\n", " \n", " Accedi alla [pagina](/analytics) \"Analisi\" per visualizzare e scaricare dati come quelli riportati di seguito:\n", "\n", " * Utilizzo totale\n", " * Utilizzo filtrato per istanza, computer quantistico e utente\n", " * Conteggio dei carichi di lavoro relativi a processi, batch e sessioni\n", "\n", " **Nota** : è possibile accedere alla pagina \"Analytics\" solo per gli account di cui sei titolare o che gestisci.\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", "## Recuperare i risultati del lavoro in un secondo momento\n", "\n", "È possibile salvare gli ID dei lavori e recuperare i risultati in un secondo momento, anche dopo aver chiuso la sessione.\n", "\n", "\n", " \n", " Se hai salvato l'ID del lavoro al momento dell'invio, utilizzalo `service.job()` per recuperarlo in un secondo momento. Se non disponi dell'ID del processo, oppure se desideri recuperare più processi contemporaneamente (compresi quelli provenienti da QPU dismesse), utilizza `service.jobs()` invece questa opzione, con filtri opzionali.\n", "\n", " Consulta la documentazione dell'API [`QiskitRuntimeService.jobs`](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#jobs) per conoscere i filtri disponibili.\n", "\n", " Questo esempio illustra come recuperare i risultati più recenti ottenuti su un backend specifico.\n", "\n", " \n", " \n", "\n", " \n", " 1. Vai alla [pagina \"Workloads\"](/workloads).\n", " 2. Utilizza le opzioni di ricerca o di filtro per trovare il tuo lavoro in base al nome, alla data o allo stato.\n", " 3. Clicca sul lavoro per visualizzarne i risultati e i dettagli.\n", " \n", "\n", "\n", "\n", "\n", "## Recupera le proprietà del backend\n", "\n", "\n", " \n", " È possibile utilizzare `job.properties()` per recuperare le proprietà del backend, compresi i tassi di errore, al momento dell'esecuzione del processo.\n", "\n", " Questo esempio illustra come recuperare le proprietà del backend valide al momento dell'esecuzione di un lavoro, inclusi i tempi di $T_1$ / $T_2$ e i tassi di errore relativi a uno specifico qubit (0).\n", "\n", " \n", "\n", " \n", " `service.jobs()` restituisce anche i lavori eseguiti dal pacchetto deprecato `qiskit-ibm-provider` . I lavori inviati dal vecchio pacchetto (anch'esso deprecato) `qiskit-ibmq-provider` non sono più disponibili.\n", " \n", " \n", "\n", " \n", " È possibile visualizzare i dati di calibrazione del backend sia al momento dell'esecuzione del processo, sia al momento della sua creazione.\n", "\n", " 1. Vai alla [pagina \"Carichi di lavoro\"](/workloads)\n", " 2. Fai clic su un carico di lavoro per aprire la pagina dei dettagli\n", " 3. Nella sezione \"Computer quantistico\", fare clic su \"Visualizza cronologia delle calibrazioni\"\n", " 4. Utilizza il menu a tendina per passare dalla visualizzazione dei dati \"All'avvio dell'esecuzione del processo\" a \"Al momento della creazione del processo\"\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", "## Annulla un lavoro\n", "\n", "Annulla un processo in coda o in esecuzione. Una volta annullato, un lavoro non può essere ripreso.\n", "\n", "\n", " \n", " Utilizzare il metodo `job.cancel()` per annullare un processo a livello di programmazione.\n", "\n", " \n", " \n", "\n", " \n", " 1. **Dalla tabella dei carichi di lavoro** : fare clic sul menu a tendina alla fine della riga corrispondente al carico di lavoro che si desidera annullare, quindi selezionare **Annulla**.\n", " 2. **Dalla pagina dei dettagli del lavoro** : clicca sul carico di lavoro per aprirne la pagina dei dettagli, utilizza il menu a tendina **\"Azioni\"** nella parte superiore e seleziona **\"Annulla\"**.\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", "## Passi successivi\n", "\n", "\n", " * Consulta la documentazione [di riferimento dell'API `QiskitRuntimeService`](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service) per ulteriori metodi di gestione dei lavori.\n", " * Esplora [le modalità di esecuzione](/docs/guides/execution-modes) per comprendere i tipi di carico di lavoro in batch e a sessione.\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 }