Paggamit ng workload

Ang usage ay kumakatawan sa pagkonsumo ng serbisyong Qiskit Runtime at tinutukoy ng dami ng oras na naka-lock ang QPU para sa pagpapatupad ng mga workload.

• Ang session usage ay sinusukat bilang elapsed time habang nananatiling aktibo ang session, dahil ang kapasidad ng QPU ay nakalaan para sa buong tagal ng session, anuman ang kung aktibong tumatakbo ang mga workload. Tingnan ang Session length para sa karagdagang impormasyon tungkol sa mga transition ng status ng session.
• Ang batch usage ay sinusukat bilang kabuuang oras na naka-lock ang QPU para ipagawa ang lahat ng job sa batch.
• Ang single job usage ay sinusukat bilang oras na naka-lock ang QPU para ipagawa ang job.

Tandaan na ang mga nabigo o nakanselong job ay maaaring mabilang sa iyong usage sa ilang partikular na sitwasyon — tingnan ang seksyong Failed and canceled jobs para sa mga detalye.

Para sa mga gumagamit ng Pay-As-You-Go Plan, tingnan ang Manage cost para sa mga detalye tungkol sa pagtatakda ng limitasyon sa gastos.

Usage para sa mga nabigo at nakanselong job

Kapag nabigo o nakansela ang isang job, ang iniuulat na usage ay ang sumusunod:

• Job o batch mode: Kung ang pagkabigo o pagkakansela ay nangyari dahil sa isang system error, ang iniuulat na usage ay zero. Para sa mga job na nabigo dahil sa user error o kapag nag-cancel ang isang user ng job, ang iniuulat na usage ay anumang konsumo na naganap hanggang sa puntong iyon.

• Session mode: Ang iniuulat na usage ay ang wall-clock time habang aktibo ang session, anuman ang bilang ng mga job na nabigo o nakansela.

I-query ang aktwal na usage ng isang workload

Pagkatapos makumpleto ang isang workload, may ilang paraan upang makita ang aktwal nitong usage:

• Patakbuhin ang batch.usage() o session.usage() sa qiskit-ibm-runtime 0.30 o mas bago. Kung gumagamit ng mas lumang bersyon ng qiskit-ibm-runtime (>= 0.23 at < 0.30), mahahanap pa rin ang usage sa session.details()["usage_time"] at batch.details()["usage_time"].
• Gamitin ang GET /sessions/{id} para makita ang usage para sa isang partikular na batch o session.
• Gamitin ang GET /jobs/{id} para makita ang usage para sa isang solong job.

Tingnan ang usage ng instance

Maaari mong tingnan ang usage ng isang instance sa pahina ng Instances, o, para sa mga may tamang awtoridad, sa pahina ng Analytics. Tandaan na maaaring magpakita ang mga pahinang ito ng iba't ibang bilang ng usage dahil naiiba ang paraan ng pagkalkula ng bawat isa.

Ipinapakita ng pahina ng Instances ang real-time na usage para sa nakaraang 28 araw (rolling), hanggang sa kasalukuyang oras sa kasalukuyang araw. Ang usage sa pahina ng Analytics ay muling kinakalkula bawat oras at kinabibilangan ng huling 28 buong araw; iyon ay, ipinapakita nito ang usage mula 00:00 ng 28 araw na nakalipas hanggang ngayon, sa simula ng oras.

Tantiyahin ang usage bago mag-submit ng job

Habang ang pagkuha ng tumpak na lokal na pagtatantya ay kumplikado dahil sa mga karagdagang operasyong ginagawa para sa error suppression at mitigation, maaari mong gamitin ang baseline na formula na ito para makakuha ng tinatayang usage:

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

• Ang <per sub-job overhead> ay isang overhead na halos 2s bawat sub-job. Kasama dito ang mga operasyon tulad ng pag-load ng payload sa control electronics. Maaaring hatiin ang iyong primitive job sa maraming sub-job kung ito ay masyadong malaki para iproseso nang lahat sa isang pagkakataon ng execution engine.
• Ang rep_delay ay isang opsyong maaaring i-customize ng gumagamit, at ang default ay ibinibigay ng backend.default_rep_delay, na 250 microseconds sa karamihan ng IBM Quantum backend. Tandaan na ang pagbaba ng rep_delay ay nagpapababa ng kabuuang oras ng pagpapatupad ng QPU, ngunit sa gastos ng mas mataas na error rate sa state preparation; tingnan ang gabay na Dynamic repetition rate execution para sa karagdagang impormasyon.
• Ang <circuit length> ay ang kabuuang haba ng instruction. Bawat instruction ay gumagamit ng iba't ibang tagal ng oras sa QPU, kaya nagbabago ang kabuuang haba mula sa isang circuit patungo sa isa pa. Ang isang measurement, halimbawa, ay maaaring 56 beses na mas matagal kaysa sa isang x gate. Ang backend.target[<instruction>][<qubit>].duration ay maaaring gamitin para mahanap ang eksaktong tagal ng bawat instruction. Ang karaniwang haba ng circuit ay malamang nasa pagitan ng 50-100 microseconds. Kung gumagamit ka ng mga teknik na error suppression o mitigation sa mga primitive, maaaring may mga karagdagang instruction na idinagdag sa iyong circuit, na magpapataas ng kabuuang haba ng circuit.
  tala

  Ang experimental na opsyong scheduler_timing ay nagbabalik ng kabuuang oras ng circuit, ngunit ito ay HINDI ang oras na ginagamit para sa billing.

• Ang <num executions> ay ang kabuuang bilang ng mga circuit na pinarami sa bilang ng mga shot, kung saan ang mga circuit ay ang mga nabuong matapos i-broadcast ang mga PUB element.
  • Kung gumagamit ka ng mga teknik na error mitigation sa mga primitive, maaaring may mga karagdagang circuit na tatakbo bilang bahagi ng proseso ng mitigation, na magpapataas ng kabuuang bilang ng mga execution. Bukod pa rito, ang mga advanced na teknik na error mitigation tulad ng PEA at PEC ay may mas mataas na overhead dahil kailangan nilang magpatakbo ng mga circuit para sa noise learning.
  • Ang Estimator ay naggrugrupo ng mga qubit-wise commuting observable, na nagbabawas ng bilang ng mga execution.

Kung hindi ka gumagamit ng anumang advanced na teknik na error mitigation o custom na rep_delay, maaari mong gamitin ang 2+0.00035*<num executions> bilang mabilis na formula.

Tantiyahin ang usage nang lokal gamit ang Qiskit

Ipinapakita ng halimbawang code na ito kung paano gamitin ang Qiskit para kalkulahin ang oras ng circuit:

# 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")

Mga susunod na hakbang

Mga rekomendasyon

• Suriin ang mga tip na ito: Minimize job run time.
• Itakda ang Maximum execution time.
• Alamin kung paano mag-transpile nang lokal sa seksyong Transpile.
• Subukan ang gabay na Compare transpiler settings.