Monitorar ou cancelar um job

Este guia explica como monitorar o status do job, visualizar informações de uso e cancelar jobs. Você pode acessar essas informações tanto pela IBM Quantum® Platform quanto programaticamente usando o Qiskit.

Versões dos pacotes

O código nesta página foi desenvolvido usando os seguintes requisitos. Recomendamos usar essas versões ou mais recentes.

qiskit-ibm-runtime~=0.46.1

Monitorar um job

Use estes métodos para verificar o status dos seus jobs enviados, recuperar resultados e visualizar detalhes relacionados ao job e sua execução.

Monitorar um job com Qiskit
Monitorar um job no IBM Quantum Platform

A instância do job fornece vários métodos para monitoramento:

Método	Descrição
`job.status()`	Verifica o status atual do job
`job.job_id()`	Obtém o identificador exclusivo do job
`job.result()`	Recupera os resultados do job (chamada bloqueante até a conclusão)
`job.wait_for_final_state()`	Bloqueia até que o job atinja um estado terminal

Por que um job permanece "In progress"

Você pode notar que um job (usando job mode ou batch mode) que você espera que leve apenas alguns segundos permanece no status In progress (chamado RUNNING no Qiskit) por muito mais tempo. Isso é normal e não significa que o job está consumindo todo esse tempo como uso. Isso acontece por causa de como os jobs são agendados em uma QPU:

Todo job requer pré-processamento clássico antes de poder ser executado na QPU. Um job passa para In progress (RUNNING) assim que esse processamento clássico começa — não quando ele começa a ser executado na QPU.
A maior parte desse processamento clássico é executada em paralelo, então vários jobs podem estar In progress ao mesmo tempo.
No entanto, apenas um job por vez pode ser executado na QPU. Quando vários jobs terminam seu processamento clássico e estão prontos para executar, eles precisam esperar sua vez para a QPU. Isso é conhecido como contenção de QPU. Quando a contenção é alta, um job pode permanecer In progress perceptivelmente mais tempo do que os poucos segundos de tempo de QPU que ele realmente precisa.
A contenção também pode ocorrer quando uma tarefa de manutenção do sistema, como calibração, está sendo executada na QPU. Seu job permanece In progress até que a tarefa de manutenção seja concluída e a QPU fique disponível.

Por causa disso, o tempo real decorrido que um job passa In progress não é o mesmo que seu uso. Tanto o uso estimado quanto o tempo máximo de execução são baseados apenas no tempo em que a QPU está bloqueada para executar seu job e, portanto, excluem o processamento clássico multithread descrito acima. Um tempo longo em In progress não aumenta seu uso ou custo relatado.

Session mode é diferente

O comportamento anterior se aplica ao job mode e ao batch mode. No session mode, durante a janela ativa da sessão, o usuário tem acesso exclusivo ao backend e nenhum outro job pode ser executado, incluindo jobs de calibração. Portanto, qualquer contenção de QPU acontece apenas entre seus próprios jobs de sessão. Além disso, como a capacidade da QPU é reservada durante a duração da sessão, o uso da sessão é medido como o tempo decorrido enquanto a sessão permanece ativa, independentemente de os jobs estarem sendo executados ativamente. Consulte Uso da carga de trabalho para mais informações.

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"qiskit_ibm_runtime": "qiskit-ibm-runtime"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

# Retrieve a job by ID
job = service.job("<job_id>")

# Get job ID (useful for saving for later retrieval)
print(f"Job ID: {job.job_id()}")

# Check current status
print(f"Status: {job.status()}")

# Wait for job to complete (blocking call)
job.wait_for_final_state()
print("Job completed")

# Get results
results = job.result()
print(results)

Ver o uso restante

Acompanhe quanto da cota de uso do seu plano resta.

Verificar o uso com Qiskit
View usage on IBM Quantum Platform

Use o método service.usage() para obter informações de uso da sua instância ativa atual.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

# Get usage information for the current active instance
usage = service.usage()
print(usage)

Ver métricas do job

Obtenha uma visão geral dos seus envios de jobs, incluindo métricas de cargas de trabalho de batch e sessão.

Obter métricas do job com Qiskit
Ver métricas do job no IBM Quantum Platform

Use o método service.jobs() com filtros para recuperar informações sobre seus jobs enviados, como quantos foram enviados, quais são seus status e quando foram criados. O exemplo a seguir recupera todos os jobs enviados nos últimos sete dias e calcula o uso total desses jobs.

from datetime import datetime, timedelta
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

# Retrieve all jobs in the last 7 days
seven_days_ago = datetime.now() - timedelta(days=7)
jobs = service.jobs(limit=None, created_after=seven_days_ago)

# To retrieve all jobs in a Session or Batch, use the session_id filter
# jobs = service.jobs(session_id="<session id>")

total_usage = 0
for job in jobs:
    total_usage += job.usage()

print(f"{len(jobs)} jobs were submitted in the last 7 days.")
print(f"Total usage was {total_usage} seconds")

Recuperar os resultados de um job posteriormente

Você pode salvar IDs de jobs e recuperar resultados mais tarde, mesmo após fechar sua sessão.

Retrieve results with Qiskit
Recuperar resultados no IBM Quantum Platform

Se você salvou o ID do job quando o enviou, use service.job(<job_id>) para recuperá-lo mais tarde. Se você não tiver o ID do job, ou se quiser recuperar vários jobs de uma vez (incluindo jobs de QPUs desativadas), use service.jobs() em vez disso, com filtros opcionais.

Consulte a documentação da API QiskitRuntimeService.jobs para filtros disponíveis.

Este exemplo demonstra a recuperação de resultados recentes executados em um backend específico.

Recuperar propriedades do backend

Recuperar propriedades do backend com Qiskit
Recuperar propriedades do backend no IBM Quantum Platform

Você pode usar job.properties() para recuperar propriedades do backend, incluindo taxas de erro, no momento da execução do job.

Este exemplo demonstra como recuperar propriedades do backend que eram atuais no momento em que um job foi executado, incluindo tempos de $T_1$ / $T_2$ e taxas de erro para um qubit específico (0).

Pacotes de provedor descontinuados

service.jobs() também retorna jobs executados a partir do pacote descontinuado qiskit-ibm-provider. Jobs enviados pelo pacote mais antigo (também descontinuado) qiskit-ibmq-provider não estão mais disponíveis.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

# Uncomment the next line to retrieve a specific job by ID
# job = service.job("<job_id>")

# Optionally retrieve multiple jobs with filters
# Use `limit` to retrieve a specific number of jobs. The default `limit` is 10.
my_backend = "<your-backend>"
recent_jobs = service.jobs(backend_name=my_backend, limit=10)

print(f"Retrieved {len(recent_jobs)} recent jobs from {my_backend}\n")

# Get results from all jobs
for job in recent_jobs:
    print(f"Job ID: {job.job_id()}")
    print(f"Status: {job.status()}")

    # Retrieve results if the job is complete
    if str(job.status()) == "DONE":
        try:
            results = job.result()
            print(f"Results: {results}")
        except Exception as e:
            print(f"Error retrieving results: {e}")
    else:
        print("Results: Not available (job still running or failed)")
    print()

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

# Retrieve a specific job by ID
job = service.job("<job_id>")

print(f"Job ID: {job.job_id()}")
print(f"Backend: {job.backend}\n")

# Fetch backend properties at the time of job execution
properties = job.properties()

if properties:
    print("Backend Properties at Job Execution Time:")
    print("=" * 60)

    # Get T1 (relaxation time) for qubit 0
    t1 = properties.t1(0)
    print(f"Qubit 0 T1 (relaxation time): {t1}")

    # Get T2 (dephasing time) for qubit 0
    t2 = properties.t2(0)
    print(f"Qubit 0 T2 (dephasing time): {t2}")

    # Get readout error for qubit 0
    readout_error = properties.readout_error(0)
    print(f"Qubit 0 readout error: {readout_error}")

    # Get all properties for a specific qubit
    print("All properties for qubit 0:")
    qubit_props = properties.qubit_property(0)
    for prop_name, prop_value in qubit_props.items():
        print(f"  {prop_name}: {prop_value}")
else:
    print("No properties available for this job")

Cancelar um job

Cancele um job que está na fila ou em execução. Depois que um job é cancelado, ele não pode ser retomado.

Cancelar com Qiskit
Cancelar no IBM Quantum Platform

Use o método job.cancel() para cancelar um job programaticamente.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

# Retrieve the job
job = service.job("<job_id>")

# Cancel the job
job.cancel()

print(f"Job {job.job_id()} has been canceled")

Próximos passos

Recomendações

Revise a referência da API QiskitRuntimeService para métodos adicionais de gerenciamento de jobs.
Explore os modos de execução para entender os tipos de carga de trabalho batch e sessão.

Monitorar um job​

Por que um job permanece "In progress"​

Session mode é diferente​

Ver o uso restante​

Ver métricas do job​

Recuperar os resultados de um job posteriormente​

Recuperar propriedades do backend​

Cancelar um job​

Próximos passos​