Utilização da carga de trabalho

O uso representa o consumo do serviço de Unidade de Processamento de Carga ( Qiskit Runtime ) e é determinado pelo tempo durante o qual uma QPU fica reservada para executar cargas de trabalho.

• O uso da sessão é medido como o tempo decorrido enquanto a sessão permanece ativa, pois a capacidade da QPU é reservada durante toda a duração da sessão, independentemente de as cargas de trabalho estarem em execução ativa. Consulte “Duração da sessão” para obter mais informações sobre as transições de status da sessão.
• O uso em lote é medido como o tempo acumulado durante o qual a QPU fica bloqueada para executar todas as tarefas do lote.
• A utilização de uma única tarefa é medida como o tempo em que a QPU fica bloqueada para executar a tarefa.

Observe que trabalhos com falha ou cancelados contam para o seu uso em determinadas circunstâncias. Consulte a seção Trabalhos com falha e cancelados para obter detalhes.

Para usuários do plano Pay-As-You-Go, consulte “Gerenciar custos” para obter detalhes sobre como definir um limite de custos.

Utilização para trabalhos com falha e cancelados

Quando um trabalho falha ou é cancelado, o uso relatado é o seguinte:

• Modo de tarefa ou em lote: Se a falha ou o cancelamento ocorreu devido a um erro do sistema, o uso relatado é zero. Para tarefas que falharam devido a erro do usuário ou quando um usuário cancelou uma tarefa, o uso relatado corresponde a todo o consumo ocorrido até aquele momento, incluindo a sobrecarga incorrida para preparar a QPU para a execução da tarefa.

• Modo de sessão: O uso relatado é o tempo real em que a sessão está ativa, independentemente do número de tarefas que falham ou são canceladas.

Consultar o uso real de uma carga de trabalho

Após a conclusão de uma carga de trabalho, há várias maneiras de visualizar seu uso real:

• Executar batch.usage() ou session.usage() em qiskit-ibm-runtime 0.30 ou posterior. Se estiver usando uma versão mais antiga de qiskit-ibm-runtime (>= 0.23 e < 0.30 ), o uso ainda poderá ser encontrado em session.details()["usage_time"] e batch.details()["usage_time"].
• Uso GET /sessions/{id} para ver o uso de um lote ou sessão específica.
• Uso GET /jobs/{id} para ver o uso de um único trabalho.

Ver uso da instância

Você pode visualizar o uso de uma instância na página Instâncias ou, para quem tiver a devida autoridade, na página Analytics. Observe que as páginas podem mostrar números de uso diferentes porque calculam o uso de forma diferente.

A página Instâncias mostra o uso em tempo real dos últimos 28 dias (contínuo), até a hora atual no dia atual. O uso da página do Analytics é recalculado a cada hora e inclui os últimos 28 dias completos, ou seja, mostra o uso das 00:00 horas de 28 dias atrás até hoje, no topo da hora.

Estime o uso antes de enviar um trabalho

Embora a obtenção de uma estimativa local precisa seja complicada devido às operações extras realizadas para supressão e atenuação de erros, você pode usar essa fórmula de linha de base para obter uma aproximação do uso estimado:

<per sub-job overhead> + (rep_delay + <circuit length>) * <num executions>

• <per sub-job overhead> é uma sobrecarga de aproximadamente 2s por subtrabalho. Isso inclui operações como o carregamento da carga útil nos componentes eletrônicos de controle. Seu trabalho primitivo pode ser dividido em vários subtrabalhos se for muito grande para o mecanismo de execução processar tudo de uma vez.
• rep_delay é uma opção personalizável pelo usuário, e o padrão é dado por backend.default_rep_delay, que é de 250 microssegundos na maioria dos back-ends do IBM Quantum. Observe que a redução de rep_delay diminui o tempo total de execução da QPU, mas às custas do aumento da taxa de erro de preparação do estado; consulte o guia de execução da taxa de repetição dinâmica para obter mais informações.
• <circuit length> é o comprimento total da instrução. Cada instrução leva um tempo diferente na QPU, portanto, o comprimento total varia de circuito para circuito. Uma medição, por exemplo, pode levar 56 vezes mais tempo do que uma porta x . backend.target[<instruction>][<qubit>].duration pode ser usado para encontrar a duração exata de cada instrução. O comprimento típico de um circuito está provavelmente entre 50 e 100 microssegundos. Se estiver usando técnicas de supressão ou atenuação de erros com os primitivos, instruções extras poderão ser inseridas no seu circuito, o que aumentaria o comprimento total do circuito.
  Note

  A opção experimental scheduler_timing retorna o tempo total do circuito, mas esse NÃO é o tempo usado para faturamento.

• <num executions> é o número total de circuitos multiplicado pelo número de disparos, sendo que os circuitos são aqueles gerados após a transmissão dos elementos d PUB.
  • Se você estiver usando técnicas de mitigação de erros com os primitivos, circuitos extras podem ser executados como parte do processo de mitigação, o que aumentaria o número total de execuções. Além disso, técnicas avançadas de mitigação de erros, como PEA e PEC, apresentam uma sobrecarga muito maior, pois exigem circuitos em funcionamento para o aprendizado de ruído.
  • O estimador agrupa observáveis comutáveis por qubit, o que reduz o número de execuções.

Se você não estiver usando nenhuma técnica avançada de mitigação de erros ou personalizada rep_delay, pode usar 2+0.00035*<num executions> como uma fórmula rápida.

Estimar o uso localmente com o Qiskit

Este exemplo de código demonstra como usar o Qiskit para calcular o tempo de circuito:

# Schedule the circuit to get more accurate timing
pm = generate_preset_pass_manager(
    target=backend.target,
    optimization_level=0,
    scheduling_method="alap"
)

scheduled_circuits = pm.run(isa_circuits)

init_duration = backend.target["reset"][(0,)].duration
rep_delay = sampler.options.execution.rep_delay or backend.default_rep_delay

circuit_duration = 0

for circuit in scheduled_circuits:
    # Estimate circuit length
    circuit_duration += circuit.estimate_duration(backend.target)

    # Add INIT time
    if sampler.options.execution.init_qubits:
        circuit_duration += init_duration

    # Add rep_delay
    circuit_duration += rep_delay

total_time = 2 + (circuit_duration*shots)
print(f"Total estimated usage is {math.ceil(total_time)} seconds")

Próximas etapas