Uso de la carga de trabajo

El uso se refiere al consumo del servicio « Qiskit Runtime » y viene determinado por el tiempo durante el que una QPU está reservada para ejecutar cargas de trabajo.

• El uso de la sesión se mide como el tiempo transcurrido mientras la sesión permanece activa, ya que la capacidad de la QPU se reserva durante toda la duración de la sesión, independientemente de si las cargas de trabajo se están ejecutando activamente. Consulte «Duración de la sesión» para obtener más información sobre las transiciones de estado de la sesión.
• El uso por lotes se mide como el tiempo acumulado durante el cual la QPU permanece bloqueada para ejecutar todos los trabajos del lote.
• El uso de un solo trabajo se mide como el tiempo durante el cual la QPU permanece bloqueada para ejecutar dicho trabajo.

Tenga en cuenta que los trabajos fallidos o cancelados cuentan para su uso en determinadas circunstancias. Consulte la sección Trabajos fallidos y cancelados para obtener más información.

Si utilizas el plan de pago por uso, consulta «Gestionar costes» para obtener más información sobre cómo establecer un límite de gastos.

Uso para trabajos fallidos y cancelados

Cuando un trabajo falla o se cancela, el uso reportado es el siguiente:

• Modo de trabajo o por lotes: si el fallo o la cancelación se debieron a un error del sistema, el consumo registrado es cero. En el caso de los trabajos que hayan fallado debido a un error del usuario o que este haya cancelado, el uso registrado corresponde a todo el consumo que se haya producido hasta ese momento, incluida la sobrecarga generada al preparar la QPU para ejecutar el trabajo.

• Modo de sesión: El uso informado es el tiempo real durante el cual la sesión está activa, independientemente del número de trabajos que fallen o se cancelen.

Consultar el uso real de una carga de trabajo

Una vez finalizada una carga de trabajo, hay varias formas de ver su uso real:

• Ejecute batch.usage() o session.usage() en qiskit-ibm-runtime 0.30 o posterior. Si se utiliza una versión anterior de qiskit-ibm-runtime (>= 0.23 y < 0.30 ), el uso puede encontrarse aún en session.details()["usage_time"] y batch.details()["usage_time"].
• Utilice GET /sessions/{id} para ver el uso de un lote o sesión específicos.
• Utilice GET /jobs/{id} para ver el uso de un solo trabajo.

Ver uso de la instancia

Puede ver el uso de una instancia en la página Instancias o, para aquellos con la autoridad adecuada, en la página Análisis. Tenga en cuenta que las páginas pueden mostrar cifras de uso diferentes porque calculan el uso de forma distinta.

La página Instancias muestra el uso en tiempo real de los últimos 28 días (sucesivos), hasta la hora actual del día en curso. El uso de la página de Analytics se recalcula cada hora e incluye los últimos 28 días completos; es decir, muestra el uso desde las 00:00 de hace 28 días hasta hoy, al principio de la hora.

Calcule el uso antes de enviar un trabajo

Aunque obtener una estimación local precisa es complicado debido a las operaciones adicionales realizadas para la supresión y mitigación de errores, puede utilizar esta fórmula de referencia para obtener una aproximación del uso estimado:

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

• <per sub-job overhead> es una sobrecarga de aproximadamente 2s por subtrabajo. Esto incluye operaciones como la carga de la carga útil en la electrónica de control. Su trabajo primitivo puede dividirse en varios sub-trabajos si es demasiado grande para que el motor de ejecución lo procese todo a la vez.
• rep_delay es una opción personalizable por el usuario, y el valor por defecto viene dado por backend.default_rep_delay, que es de 250 microsegundos en la mayoría de los backends de IBM Quantum. Tenga en cuenta que la reducción de rep_delay disminuye el tiempo total de ejecución de QPU, pero a expensas de un aumento de la tasa de error de preparación de estado; consulte la guía de ejecución de la tasa de repetición dinámica para obtener más información.
• <circuit length> es la longitud total de la instrucción. Cada instrucción requiere un tiempo diferente en la QPU, por lo que la duración total varía de un circuito a otro. Una medición, por ejemplo, puede tardar 56 veces más que una puerta x . backend.target[<instruction>][<qubit>].duration se puede utilizar para encontrar la duración exacta de cada instrucción. Un circuito típico puede durar entre 50 y 100 microsegundos. Si utilizas técnicas de supresión o mitigación de errores con las primitivas, es posible que se inserten instrucciones adicionales en tu circuito, lo que aumentaría la longitud total del circuito.
  Note

  La opción experimental scheduler_timing devuelve el tiempo total del circuito, pero NO es el tiempo utilizado para la facturación.

• <num executions> es el número total de circuitos multiplicado por el número de disparos, donde los circuitos son los generados después de que se transmiten los elementos PUB.
  • Si utiliza técnicas de mitigación de errores con las primitivas, es posible que se ejecuten circuitos adicionales como parte del proceso de mitigación, lo que aumentaría el número total de ejecuciones. Además, las técnicas avanzadas de mitigación de errores, como PEA y PEC, conllevan una sobrecarga mucho mayor, ya que requieren circuitos en funcionamiento para el aprendizaje del ruido.
  • El estimador agrupa observables conmutables por qubit, lo que reduce el número de ejecuciones.

Si no estás utilizando ninguna técnica avanzada de mitigación de errores ni personalizada rep_delay, puedes utilizar 2+0.00035*<num executions> como fórmula rápida.

Calcular el consumo a nivel local con Qiskit

Este ejemplo de código muestra cómo utilizar Qiskit para calcular el tiempo 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óximos pasos