Monitorar ou cancelar um trabalho

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

• Versões do pacote

  O código desta página foi desenvolvido com base nos seguintes requisitos. Recomendamos o uso dessas versões ou versões mais recentes.

  qiskit-ibm-runtime~=0.46.1
  

Monitorar uma tarefa

Utilize esses métodos para verificar o status dos trabalhos enviados, obter os resultados e visualizar detalhes relacionados ao trabalho e à sua execução.

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)

Por que um trabalho permanece no status “Em andamento”

Você pode perceber que uma tarefa (seja no modo de tarefa ou no modo em lote) que você esperava que levasse apenas alguns segundos permanece no status “Em andamento ” (denominado RUNNING no Qiskit) por muito mais tempo. Isso é normal e não significa que o trabalho esteja consumindo todo esse tempo como uso. Isso ocorre devido à forma como os trabalhos são agendados em uma QPU:

• Toda tarefa requer um pré-processamento clássico antes de poder ser executada na QPU. Um trabalho passa para o estado “Em andamento (RUNNING)” assim que esse processamento clássico começa — e não quando começa a ser executado na QPU.
• A maior parte desse processamento clássico é executada em paralelo, de modo que vários trabalhos podem estar em andamento ao mesmo tempo.
• No entanto, apenas uma tarefa por vez pode ser executada na QPU. Quando vários trabalhos concluem seu processamento clássico e estão prontos para serem executados, eles precisam aguardar sua vez para acessar a QPU. Isso é conhecido como contenção da QPU. Quando o nível de contenção é alto, um trabalho pode permanecer no estado “Em andamento” por um tempo visivelmente maior do que os poucos segundos de tempo de QPU de que realmente precisa.
• Também pode ocorrer conflito quando uma tarefa de manutenção do sistema, como a calibração, está sendo executada na QPU. Seu trabalho permanecerá no status “Em andamento” até que a tarefa de manutenção seja concluída e a QPU fique disponível.

Por isso, o tempo real decorrido que uma tarefa passa na fase “Em andamento” não é o mesmo que seu tempo de uso. Tanto a estimativa de uso quanto o tempo máximo de execução se baseiam exclusivamente no tempo em que a QPU fica reservada para executar seu trabalho e, portanto, excluem o processamento clássico multithread descrito acima. Um longo período no status “Em andamento” não aumenta o uso ou o custo registrado.

O modo de sessão é diferente

O comportamento descrito acima se aplica ao modo de tarefa e ao modo em lote. No modo de sessão, enquanto a janela da sessão estiver ativa, o usuário tem acesso exclusivo ao backend e nenhum outro trabalho pode ser executado, incluindo trabalhos de calibração. Portanto, qualquer conflito de QPU ocorre apenas entre os trabalhos da sua própria sessão. Além disso, como a capacidade da QPU é reservada durante toda a sessão, o uso da sessão é medido como o tempo decorrido enquanto a sessão permanece ativa, independentemente de os trabalhos estarem em execução ativa. Consulte “Utilização da carga de trabalho” para obter mais informações.

Ver uso restante

Acompanhe quanto ainda resta da cota de uso do seu plano.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

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

Visualizar métricas do trabalho

Obtenha uma visão geral dos seus envios de tarefas, incluindo métricas de carga de trabalho por lote e por sessão.

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 do trabalho posteriormente

Você pode salvar os IDs das tarefas e recuperar os resultados mais tarde, mesmo depois de encerrar sua sessão.

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

Recuperar propriedades do backend

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 uma Tarefa

Cancelar um trabalho que está na fila ou em execução. Uma vez que um trabalho seja cancelado, ele não pode ser retomado.

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óximas etapas