Pular para o conteúdo principal

Escolha o modo de execução adequado

Cargas de trabalho em escala utilitária podem levar muitas horas para serem concluídas, por isso é importante que os recursos clássicos e quânticos sejam agendados de forma eficiente para otimizar a execução. Os modos de execução oferecem flexibilidade para equilibrar o custo e o tempo, permitindo usar os recursos de forma ideal para suas cargas de trabalho. Há vários aspectos a considerar ao escolher qual modo de execução utilizar, como o tempo total de execução (tempo máximo de vida, ou TTL) e o intervalo entre jobs (TTL interativo).

Os benefícios de cada um são resumidos abaixo:

  • Batch
    • Todo o lote de jobs é agendado em conjunto e não há tempo adicional de fila para cada um.
    • O processamento clássico dos jobs, como a compilação, é executado em paralelo. Portanto, executar vários jobs em um batch é significativamente mais rápido do que executá-los em série.
    • Geralmente há atraso mínimo entre os jobs, o que pode ajudar a evitar deriva (drift).
    • Se você dividir sua carga de trabalho em vários jobs e executá-los no modo batch, poderá obter resultados de jobs individuais, o que torna o processo mais flexível. Por exemplo, se os resultados de um job não atenderem às suas expectativas, você pode cancelar os jobs restantes. Além disso, se um job falhar, você pode reenviá-lo em vez de reexecutar toda a carga de trabalho.
    • Em geral, é menos caro do que sessões.
  • Session
    • Toda a funcionalidade do modo batch (mas exigindo maior uso; consulte Uso da carga de trabalho para mais detalhes sobre como o uso é calculado).
    • Acesso dedicado e exclusivo à QPU durante a janela ativa da sessão.
    • Útil para cargas de trabalho que não têm todas as entradas prontas no início, para cargas de trabalho iterativas que exigem pós-processamento clássico antes que a próxima possa ser executada, e para experimentos que precisam ser executados o mais próximo possível.
  • Job
    • A forma mais simples de usar ao executar um pequeno experimento.
    • Pode ser executado antes do modo batch.

Recomendações e melhores práticas

Em geral, use o modo batch, a menos que você tenha cargas de trabalho que não tenham todas as entradas prontas no início.

  • Use o modo batch para enviar vários jobs primitivos simultaneamente e reduzir o tempo de processamento.

  • Use o modo session para cargas de trabalho iterativas ou se precisar de acesso dedicado à QPU.

  • Sempre use o modo job para enviar uma única solicitação primitiva.

  • Como sessões geralmente são mais caras, é recomendável usar batch sempre que você não precisar dos benefícios adicionais das sessões.

  • Usuários do Plano Open não podem enviar jobs de sessão.

Para garantir o uso mais eficiente dos modos de execução, as seguintes práticas são recomendadas:

  • Há uma sobrecarga fixa associada à execução de um job. Em geral, se cada um dos seus jobs usa menos de um minuto de tempo de QPU, considere combinar vários em um job maior (isso se aplica a todos os modos de execução). "Tempo de QPU" refere-se ao tempo gasto pelo complexo QPU para processar seu job.

  • Se cada um dos seus jobs consome mais de um minuto de tempo de QPU, ou se combinar jobs não for prático, você ainda pode executar vários jobs em paralelo. Cada job passa por processamento clássico e quântico. Embora uma QPU possa processar apenas um job por vez, até cinco jobs clássicos podem ser processados em paralelo. Você pode aproveitar isso enviando vários jobs no modo de execução batch ou session.

As diretrizes acima são gerais, e você deve ajustar sua carga de trabalho para encontrar a proporção ideal, especialmente ao usar sessões. Por exemplo, se você está usando uma sessão para obter acesso exclusivo a um backend, considere dividir jobs grandes em menores e executá-los em paralelo. Isso pode ser mais econômico porque pode reduzir o tempo de relógio de parede (wall-clock time).

Exemplos

Executar um algoritmo variacional quântico

A execução de um algoritmo variacional quântico geralmente segue este fluxo:

  1. Preparar o ansatz.
  2. Avaliar a função de custo em uma QPU.
  3. Pegar o resultado da etapa anterior e executá-lo por meio de um otimizador clássico.
  4. Ajustar os parâmetros de acordo com a saída de (3) e voltar à etapa (2).

Nesse caso, se você estiver usando o modo job ou batch, cada job gerado pela etapa (2) precisa voltar para a fila. Isso aumenta drasticamente a duração do experimento (wall-clock time) devido ao tempo de fila. Também pode levar mais tempo para convergir devido à deriva do dispositivo (device drift). Ou seja, espera-se que cada iteração produza um resultado melhor, mas a deriva do dispositivo pode piorar os resultados subsequentes.

Além disso, se você usar PEA ou PEC, pode aprender o modelo de ruído uma vez e aplicá-lo a jobs subsequentes ao executar em uma sessão dedicada. Isso geralmente não funciona com o modo batch ou job, porque o modelo de ruído pode ficar desatualizado quando o próximo job sair da fila.

Comparar configurações de mitigação de erros

Para comparar os efeitos dos métodos de mitigação de erros disponíveis, você pode seguir este fluxo:

  1. Construir um Circuit e um observável.
  2. Enviar jobs primitivos que usam diferentes combinações de configurações de mitigação de erros.
  3. Plotar os resultados para observar os efeitos das várias configurações.

Nesse caso, todos os jobs (que são relacionados, mas independentes) estão disponíveis desde o início. Se você usar o modo batch, eles são agendados coletivamente, de modo que você só precisa aguardar que passem pela fila uma única vez. Além disso, como o objetivo é comparar os efeitos de vários métodos de mitigação de erros, é benéfico que sejam executados o mais próximo possível. Portanto, batch seria uma boa escolha. Você poderia executar esses jobs em uma sessão, mas como sessões geralmente são mais caras, é recomendável usar batch sempre que você não precisar da funcionalidade adicional que as sessões oferecem.

Próximos passos