Pumili ng compute profile

Tumatakbo ang mga managed workflow sa mga compute profile. Ang compute profile ay isang nakatakdang kombinasyon ng mga vCPU, memory, at GPU, katulad ng mga resource na hinihiling mo mula sa isang HPC scheduler. Kapag nag-upload ka ng workflow, imamapa mo ang mga size nito, gaya ng S at M, sa mga profile, at pipili ang bawat run ng isa sa mga size na iyon. Tatakbo ang job sa sarili nitong node gamit ang profile na iyon, at pinapanatili nito ang profile hanggang matapos ang job.

Profile	Mga vCPU	Memory (GB)	Mga GPU
8x32	8	32	Wala
16x128	16	128	Wala
48x768	48	768	Wala
128x1500	128	1500	Wala
24x120x1l40s	24	120	1 L40S
20x320x2a100	20	320	2 A100
80x1200x8a100	80	1200	8 A100
160x1792x8h100	160	1792	8 H100

Ang profile ID ay may anyong {cpu}x{memory}, na ang memory ay nasa GB, o {cpu}x{memory}x{count}{gpu} para sa profile na may mga GPU. Halimbawa, ang 24x120x1l40s ay may 24 na vCPU, 120 GB ng memory, at isang NVIDIA L40S GPU.

Tingnan ang mga available na profile

Para makita kung aling mga profile ang available, tawagin ang compute_profiles():

run_workflow_remotely.ipynb

from qiskit_ibm_catalog import ManagedWorkflowClient

client = ManagedWorkflowClient()
print(client.compute_profiles())

8x32            (8 vCPU / 32 GB)
16x128          (16 vCPU / 128 GB)
48x768          (48 vCPU / 768 GB)
128x1500        (128 vCPU / 1500 GB)
24x120x1l40s    (24 vCPU / 120 GB / 1l40s)
20x320x2a100    (20 vCPU / 320 GB / 2a100)
80x1200x8a100   (80 vCPU / 1200 GB / 8a100)
160x1792x8h100  (160 vCPU / 1792 GB / 8h100)

Maghanap ng profile ayon sa mga resource nito

Sa halip na mag-type ng profile ID, maaari mong ilarawan ang mga resource na kailangan ng workflow mo gamit ang compute_profile(), at gamitin ang resulta bilang value sa sizes_map. Ipasa ang cpu at memory sa GB, at ipasa ang gpu para sa GPU profile:

run_workflow_remotely.ipynb

profile = client.compute_profile(cpu=24, memory=120, gpu="1l40s")
print(profile)  # 24x120x1l40s

sizes_map = {"S": "8x32", "L": profile}

Tumatanggap ang sizes_map ng mga profile ID at ng mga profile na ibinabalik ng compute_profile(), at maaari mong paghaluin ang dalawa sa iisang map. Para suriin ang isang profile ID bago mag-upload, ipasa ito sa compute_profile(), halimbawa client.compute_profile("16x128"). Kung walang profile na tumutugma, inililista ng error ang mga available na profile.

Ang compute_profiles() ay nagbabalik ng list, kaya maaari mo rin itong i-filter nang mag-isa. Halimbawa, hinahanap ng sumusunod na code ang mga GPU profile:

run_workflow_remotely.ipynb

gpu_profiles = [p for p in client.compute_profiles() if p.gpu]

Magtakda ng default na compute profile para sa workflow mo

Karamihan ng mga workflow ay nagsisimula sa isang size. Imapa ito sa isang profile gamit ang sizes_map, at gawin itong default gamit ang default_size, kapag ina-upload ang workflow:

run_workflow_remotely.ipynb

from qiskit_ibm_catalog import ManagedWorkflow, ManagedWorkflowClient

client = ManagedWorkflowClient()

my_workflow = client.upload(
    ManagedWorkflow(
        title="my-workflow",
        entrypoint="my_workflow.py",
        working_dir="./source_files/",
        sizes_map={"M": "16x128"},
        default_size="M",
    )
)

Ginagamit ng bawat run ng workflow ang profile na ito, kaya hindi mo kailangang magpasa ng size kapag pinatakbo mo ito:

run_workflow_remotely.ipynb

job = my_workflow.run(circuits=circuits)  # Runs on 16x128

Best practice: itugma ang mga size sa laki ng problema

Ang isang workflow ay lumulutas ng mga partikular na problema, at maaaring mangailangan ito ng iba't ibang compute profile habang lumalaki ang sukat at pagiging kumplikado ng mga problema. Sa isang sizes_map para sa bawat workflow, magagawa mo ang mga sumusunod:

• Bigyan ang malalaking problema ng sapat na compute resource para makumpleto ang pagtakbo.

• Pigilan ang maliliit na problema na gumamit ng mas malaking node kaysa sa kailangan nila.

Maaari mong ibatay ang mga size sa mga salik na tumutukoy sa paggamit ng memory at CPU ng workflow mo, gaya ng laki ng subspace, bilang ng mga batch, o bilang ng mga qubit.

Tukuyin ang mga size

Maaari kang magmapa ng hanggang apat na size, para sa maliliit (S), katamtaman (M), malalaki (L), at napakalalaking (XL) problema. Halimbawa, nagtatakda ang sumusunod na code ng workflow na may tatlong size:

run_workflow_remotely.ipynb

sizes_map = {"S": "8x32", "M": "16x128", "L": "128x1500"}

my_workflow = client.upload(
    ManagedWorkflow(
        title="my-workflow",
        entrypoint="my_workflow.py",
        working_dir="./source_files/",
        sizes_map=sizes_map,
        default_size="M",
    )
)

Mga patakaran sa size

Ang mga size label ay dapat na S, M, L, o XL, kaya ang isang workflow ay maaaring magtakda ng hanggang apat na size. Tinutugma ng managed workflow ang mga label sa uppercase o lowercase, at iniimbak ang mga ito sa uppercase. Maaaring mapa ang dalawang size sa iisang profile.

Tinatanggihan ng workflow ang unang upload sa mga sumusunod na kaso:

• Ang isang label ay hindi S, M, L, o XL.

• Itinakda mo ang sizes_map nang walang default_size, o ang default_size nang walang sizes_map.

• Ang default_size ay hindi isa sa mga label sa sizes_map.

• Ang isang value sa sizes_map ay hindi available na compute profile.

Baguhin ang mga size sa muling pag-upload

Kapag muli mong in-upload ang workflow gamit ang parehong title, ganito hinahawakan ng managed workflow ang mga size:

• Kung itinakda mo ang sizes_map, pinapalitan ng mga bagong size ang lahat ng naka-store na size.

• Kung hindi mo itinakda ang sizes_map, pinapanatili ng workflow ang mga naka-store na size at ang default.

• Para baguhin lang ang default, itakda ang default_size nang walang sizes_map. Ang value ng default_size ay dapat isa sa mga naka-store na size.

Itakda ang default_size tuwing itinatakda mo ang sizes_map. Hindi nangangailangan ng default_size ang muling pag-upload. Kung hindi kasama sa mga bagong size ang dating default, walang default ang workflow, at pumapalya ang bawat run na walang function_size.

Pumili ng size para sa bawat run

Ipasa ang function_size sa run() para pumili ng isa sa mga size ng workflow para sa job na iyon. Kung hindi mo ito ipapasa, gagamitin ng job ang default na size ng workflow:

run_workflow_remotely.ipynb

print(my_workflow.sizes())  # {'S': '8x32', 'M': '16x128', 'L': '128x1500'}
print(my_workflow.get_default_size())  # 'M'

job = my_workflow.run(function_size="L", circuits=circuits)  # Runs on 128x1500
job = my_workflow.run(circuits=circuits)  # Runs on the default size, M

Ibinabalik ng sizes() at get_default_size() ang mga size na naka-store noong nilo-load mo ang workflow. Para makita ang mga size na nagbago pagkatapos mong i-load ang workflow, i-load itong muli.

Para basahin ang size at compute profile ng job, tawagin ang get_function_size() at get_compute_profile() sa code ng workflow mo:

source_files/my_workflow.py

from qiskit_serverless import get_compute_profile, get_function_size

print(get_function_size())  # 'L'
print(get_compute_profile())  # '128x1500'

Mag-troubleshoot ng mga size

Problema	Sanhi
Pumapalya ang upload na may Invalid size '...'. Valid sizes are: S, M, L, XL.	Ang isang label sa sizes_map ay hindi isa sa apat na sinusuportahang label.
Pumapalya ang upload na may Unknown compute profile '...' for size '...'.	Ang isang value sa sizes_map ay hindi available na profile. Suriin ang ID gamit ang compute_profiles(), o gamitin ang compute_profile() para hanapin ito.
Pumapalya ang compute_profile() na may No compute profile matches ...	Walang profile na may eksaktong mga resource na iyon. Para sa GPU profile, ipasa rin ang gpu. Pumili ng profile mula sa listahan sa error.
Pumapalya ang upload na may 'default_size' is required when 'sizes' is provided.	Itinakda ng unang upload ang sizes_map nang walang default_size.
Pumapalya ang run() na may Unknown function size '...' for this function. Available sizes: ...	Hindi tinutukoy ng workflow ang size na ipinasa mo sa function_size.
Pumapalya ang run() na may This function has no size.	Pinalitan ng muling pag-upload ang mga size at inalis ang default. Mag-upload muli gamit ang default_size, o ipasa ang function_size.