Executar tarefas em uma sessão

• Versões do pacote

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

  qiskit[all]~=2.3.1
  qiskit-ibm-runtime~=0.45.0
  scipy~=1.17.1
  

Use as sessões quando precisar de acesso dedicado e exclusivo à QPU.

Configurar para usar sessões

Antes de iniciar uma sessão, você deve configurar o Qiskit Runtime e inicializá-lo como um serviço:

from qiskit_ibm_runtime import (
    QiskitRuntimeService,
    Session,
    SamplerV2 as Sampler,
    EstimatorV2 as Estimator,
    Executor,
)

service = QiskitRuntimeService()

Abrir uma sessão

Você pode abrir uma sessão de tempo de execução usando o gerenciador de contexto with Session(...) ou inicializando a Session classe. Ao iniciar uma sessão, você deve especificar uma QPU passando um objeto backend . A sessão começa quando seu primeiro trabalho inicia a execução.

Aula de sessão

backend = service.least_busy(operational=True, simulator=False)
session = Session(backend=backend)
estimator = Estimator(mode=session)
sampler = Sampler(mode=session)
executor = Executor(mode=session)
# Close the session because no context manager was used.
session.close()

Gerenciador de contexto

O gerenciador de contexto abre e fecha automaticamente a sessão.

from qiskit_ibm_runtime import (
    Session,
    SamplerV2 as Sampler,
    EstimatorV2 as Estimator,
    Executor,
)

backend = service.least_busy(operational=True, simulator=False)
with Session(backend=backend):
    estimator = Estimator()
    sampler = Sampler()
    executor = Executor()

Duração da sessão

O tempo máximo de vida da sessão (TTL) determina por quanto tempo uma sessão pode ser executada. Você pode definir esse valor com o parâmetro max_time . Isso deve exceder o tempo de execução do trabalho mais longo.

Esse cronômetro começa quando a sessão é iniciada. Quando o valor é atingido, a sessão é encerrada. Todos os trabalhos que estiverem em execução serão concluídos, mas os trabalhos que ainda estiverem na fila falharão.

with Session(backend=backend, max_time="25m"):
  ...

Há também um valor de tempo de vida interativo (TTL interativo) que não pode ser configurado. Se nenhum trabalho de sessão for enfileirado dentro dessa janela, a sessão será temporariamente desativada.

Valores padrão:

Para determinar o TTL máximo ou o TTL interativo de uma sessão, siga as instruções em Determinar detalhes da sessão e procure o valor max_timeou interactive_timeout , respectivamente.

Encerrar uma sessão

Uma sessão termina nas seguintes circunstâncias:

• O valor de tempo limite máximo (TTL) é atingido, resultando no cancelamento de todos os trabalhos na fila.
• A sessão é cancelada manualmente, resultando no cancelamento de todos os trabalhos na fila.
• A sessão é encerrada manualmente. A sessão para de aceitar novos trabalhos, mas continua a executar trabalhos na fila com prioridade.
• Se você usar a Session como um gerenciador de contexto, ou seja, with Session(), a sessão será automaticamente encerrada quando o contexto terminar (o mesmo comportamento do uso de session.close()).

Fechar uma sessão

Uma sessão é fechada automaticamente quando sai do gerenciador de contexto. Quando o gerenciador de contexto de sessão é encerrado, a sessão é colocada no status "Em andamento, não aceitando novos trabalhos". Isso significa que a sessão termina o processamento de todos os trabalhos em execução ou em fila até que o valor máximo de tempo limite seja atingido. Após a conclusão de todos os trabalhos, a sessão é imediatamente encerrada. Isso permite que o agendador execute o próximo trabalho sem esperar pelo tempo limite interativo da sessão, reduzindo assim o tempo médio de enfileiramento do trabalho. Não é possível enviar trabalhos para uma sessão fechada.

with Session(backend=backend) as session:
    estimator = Estimator()
    sampler = Sampler()
    job1 = estimator.run([estimator_pub])
    job2 = sampler.run([sampler_pub])

# The session is no longer accepting jobs but the submitted job will run to completion.
result = job1.result()
result2 = job2.result()

session = Session(backend=backend)

# If using qiskit-ibm-runtime earlier than 0.24.0, change `mode=` to `session=`
estimator = Estimator(mode=session)
sampler = Sampler(mode=session)
job1 = estimator.run([estimator_pub])
job2 = sampler.run([sampler_pub])
print(f"Result1: {job1.result()}")
print(f"Result2: {job2.result()}")

# Manually close the session. Running and queued jobs will run to completion.
session.close()

Output:

Result1: PrimitiveResult([PubResult(data=DataBin(evs=np.ndarray(<shape=(3, 2), dtype=float64>), stds=np.ndarray(<shape=(3, 2), dtype=float64>), ensemble_standard_error=np.ndarray(<shape=(3, 2), dtype=float64>), shape=(3, 2)), metadata={'shots': 4096, 'target_precision': 0.015625, 'circuit_metadata': {}, 'resilience': {}, 'num_randomizations': 32})], metadata={'dynamical_decoupling': {'enable': False, 'sequence_type': 'XX', 'extra_slack_distribution': 'middle', 'scheduling_method': 'alap'}, 'twirling': {'enable_gates': False, 'enable_measure': True, 'num_randomizations': 'auto', 'shots_per_randomization': 'auto', 'interleave_randomizations': True, 'strategy': 'active-accum'}, 'resilience': {'measure_mitigation': True, 'zne_mitigation': False, 'pec_mitigation': False}, 'version': 2})

Result2: PrimitiveResult([SamplerPubResult(data=DataBin(meas=BitArray(<shape=(3, 2), num_shots=4096, num_bits=2>), meas0=BitArray(<shape=(3, 2), num_shots=4096, num_bits=156>), shape=(3, 2)), metadata={'circuit_metadata': {}})], metadata={'execution': {'execution_spans': ExecutionSpans([DoubleSliceSpan(<start='2026-03-15 07:33:44', stop='2026-03-15 07:33:51', size=24576>)])}, 'version': 2})

Verifique o status da sessão

Você pode consultar o status de uma sessão para entender seu estado atual usando session.status() ou visualizando a página Workloads.

O status da sessão pode ser um dos seguintes:

• Pending: A sessão não foi iniciada ou foi desativada. O próximo trabalho de sessão precisa aguardar na fila como os outros trabalhos.
• In progress, accepting new jobs: A sessão está ativa e aceitando novos trabalhos.
• In progress, not accepting new jobs: A sessão está ativa, mas não está aceitando novos trabalhos. O envio de trabalhos para a sessão é rejeitado, mas os trabalhos pendentes da sessão serão executados até a conclusão. A sessão é fechada automaticamente quando todos os trabalhos são concluídos.
• Closed: O valor máximo de tempo limite da sessão foi atingido ou a sessão foi encerrada explicitamente.

Determine os detalhes da sessão

Para obter uma visão geral abrangente da configuração e do status de uma sessão, use o site session.details() method.

from qiskit_ibm_runtime import (
    QiskitRuntimeService,
    Session,
    EstimatorV2 as Estimator,
)

service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

with Session(backend=backend) as session:
    print(session.details())

Output:

{'id': 'a9fd2f9d-6239-4451-a19c-9b45aa6a0618', 'backend_name': 'ibm_torino', 'interactive_timeout': 60, 'max_time': 28800, 'active_timeout': 28800, 'state': 'open', 'accepting_jobs': True, 'last_job_started': None, 'last_job_completed': None, 'started_at': None, 'closed_at': None, 'activated_at': None, 'mode': 'dedicated', 'usage_time': None}

Padrões de uso

As sessões são especialmente úteis para algoritmos que exigem comunicação frequente entre recursos clássicos e quânticos.

Exemplo: Execute uma carga de trabalho iterativa que usa o otimizador clássico SciPy para minimizar uma função de custo. Nesse modelo, o site SciPy usa o resultado da função de custo para calcular seu próximo input.

from scipy.optimize import minimize
from qiskit.circuit.library import efficient_su2


def cost_func(params, ansatz, hamiltonian, estimator):
    # Return estimate of energy from estimator

    energy = sum(
        estimator.run([(ansatz, hamiltonian, params)]).result()[0].data.evs
    )
    return energy


hamiltonian = SparsePauliOp.from_list(
    [("YZ", 0.3980), ("ZI", -0.3980), ("ZZ", -0.0113), ("XX", 0.1810)]
)
su2_ansatz = efficient_su2(hamiltonian.num_qubits)
pm = generate_preset_pass_manager(backend=backend, optimization_level=3)
ansatz = pm.run(su2_ansatz)
mapped_hamiltonian = [
    operator.apply_layout(ansatz.layout) for operator in hamiltonian
]

num_params = ansatz.num_parameters
x0 = 2 * np.pi * np.random.random(num_params)

session = Session(backend=backend)


# If using qiskit-ibm-runtime earlier than 0.24.0, change `mode=` to `session=`
estimator = Estimator(mode=session, options={"default_shots": int(1e4)})
res = minimize(
    cost_func,
    x0,
    args=(ansatz, mapped_hamiltonian, estimator),
    method="cobyla",
    options={"maxiter": 25},
)

# Close the session because no context manager was used.
session.close()

Execute dois algoritmos VQE em uma sessão usando threading

Você pode tirar mais proveito de uma sessão executando várias cargas de trabalho simultaneamente. O exemplo a seguir mostra como é possível executar dois algoritmos VQE, cada um usando um otimizador clássico diferente, simultaneamente em uma única sessão. As tags de trabalho também são usadas para diferenciar os trabalhos de cada carga de trabalho.

from concurrent.futures import ThreadPoolExecutor
from qiskit_ibm_runtime import EstimatorV2 as Estimator


def minimize_thread(estimator, method):
    return minimize(
        cost_func,
        x0,
        args=(ansatz, mapped_hamiltonian, estimator),
        method=method,
        options={"maxiter": 25},
    )


with Session(backend=backend), ThreadPoolExecutor() as executor:
    estimator1 = Estimator()
    estimator2 = Estimator()

    # Use different tags to differentiate the jobs.
    estimator1.options.environment.job_tags = ["cobyla"]
    estimator2.options.environment.job_tags = ["nelder-mead"]

    # Submit the two workloads.
    cobyla_future = executor.submit(minimize_thread, estimator1, "cobyla")
    nelder_mead_future = executor.submit(
        minimize_thread, estimator2, "nelder-mead"
    )

    # Get workload results.
    cobyla_result = cobyla_future.result()
    nelder_mead_result = nelder_mead_future.result()

Próximas etapas