Mga compute resource at pamamahala ng resource

Resource model at mga klasikal na resource

Sa seksyong ito, magbibigay tayo ng balangkas para sa pag-iisip tungkol sa mga compute environment na maaaring ilapat sa isang laptop at paakyatin pa hanggang sa mga supercomputer. Sa pagtatapos ng seksyong ito, maiintindihan mo na ang mga pangunahing bahagi ng isang compute environment at kung paano sila magkakaugnay. Lahat ito ay ipinaliwanag ni Iskandar Sitdikov sa sumusunod na video.

Resource model

Ang anumang klasikal na compute environment ay binubuo ng ilang magkakaugnay na resource na nagtutulungan para mapatakbo ang mga application nang mahusay. Kasama sa mga pangunahing resource ang:

• CPU (Central Processing Unit): Ang CPU ang pangunahing processing unit na nagbibigay-kahulugan at nagpapatupad ng mga instruksyon ng programa. Ito ang humahawak ng mga operasyon sa lohika, aritmetika, at kontrol — sa madaling salita, ito ang "utak" ng sistema.

• CPU cache (L1, L2, L3): Ito ang pinakamabilis na memorya sa sistema, na itinayo nang direkta sa loob ng o napakalapit sa CPU core. Iniimbak nito ang maliliit na bahagi ng data at instruksyon na kailangan agad ng CPU. Ang iba't ibang antas (L1, L2, L3) ay nagpapakita ng balanse: ang L1 ang pinakamaliit at pinakamabilis, habang ang L3 ang pinakamalaki at pinakabagal — ngunit mas mabilis pa rin nang ilang order of magnitude kaysa sa RAM.

• RAM (Random Access Memory): Volatile na memorya na nagbibigay ng malaki at pansamantalang storage para sa mga instruksyon ng programa at aktibong ginagamit na data. Tinitiyak nito na mabilis na ma-access ng CPU ang impormasyong kailangan nito habang tumatakbo ang programa nang hindi laging umaasa sa mas mabagal na mga storage device.

• Storage (lokal at network-based): Pinapanatili ng storage ang data at software kahit na patayin na ang sistema, na nagbibigay ng pangmatagalang pananatili para sa malalaking dataset at application. Sa high-performance computing, ang mga solusyon sa storage ay kailangang humawak ng napakaraming siyentipiko o analytical na data nang may bilis at pagiging maaasahan. Kasama sa lokal na storage ang mga solid-state drive (SSD) at hard disk drive (HDD), kung saan mas gusto ang mga SSD dahil sa mas mababang latency at mas mataas na throughput. Para sa malakihang paghawak ng data, ang mga parallel file system, shared network storage, at object-based na sistema ay nagbibigay-daan sa mabilis na pag-access sa maraming compute node, habang ang cloud at archival na storage tier ay sumusuporta sa pangmatagalang panatili at scalability.

• GPU (Graphics Processing Unit): Bagama't ang mga ito ay orihinal na idinisenyo para sa pag-render ng graphics, ang mga modernong GPU ay makapangyarihang parallel processor. Malawak na ginagamit ang mga ito para sa mga gawaing nangangailangan ng maraming sabay-sabay na kalkulasyon tulad ng deep learning, physics simulation, at big data analytics. Mahalagang tandaan na hindi pinapalitan ng mga GPU ang mga CPU; ang mga CPU ang namamahala ng mas mataas na lohika ng programa at ang mga GPU naman ang nagpapabilis ng mga hakbang na highly parallel.

• Mga Koneksyon/Bus: Ito ang mga landas ng komunikasyon na nagdurugtong sa CPU, memorya, storage, at mga peripheral. Pinapagana ng mga bus ang paglipat ng data at koordinasyon sa pagitan ng mga bahagi ng sistema, tinitiyak ang maayos na komunikasyon sa buong compute environment. Sa mga HPC system, ang mga bahagi tulad ng CPU, GPU, at storage device ay konektado sa pamamagitan ng mga high-speed interconnect na nagbibigay-daan sa mabilis na palitan ng data. Ang mga GPU ay karaniwang kumokonekta sa sistema sa pamamagitan ng PCIe, isang standard na interface na may maraming data lane para sa mahusay na komunikasyon. Para sa mas mataas na pagganap, ang NVLink ay nagbibigay ng direkta at high-bandwidth na koneksyon sa pagitan ng mga GPU o sa pagitan ng mga GPU at CPU, binabawasan ang latency at pinapabilis ang mga parallel na workload.

• Filesystem: Inaayos ng filesystem ang data sa mga storage device. Nagbibigay ito ng istruktura para sa pag-imbak, pagkuha, at pamamahala ng mga file, na nagbibigay-daan sa mga programa at mga gumagamit na ma-access ang impormasyon sa isang pare-pareho at lohikal na paraan.

Ang bawat uri ng resource ay may sariling mga unit ng pagsukat na may kaugnayan sa pagganap. Halimbawa, ang mga CPU ay karaniwang sinusukat sa "cores" at "clock speed." Kapag bumibili ng laptop, kasama sa mga espesipikasyon nito ang bilang ng mga core. Ang katulad na konsepto ay naaangkop sa mga computational node sa isang data center, kung saan ang bawat node ay may kaugnay na tiyak na bilang ng mga core. Ang mga compute environment na kinabibilangan ng maramihang uri ng resource (CPU, GPU, at maging QPU) ay tinutukoy bilang heterogeneous computing environment. Ang mga setup na ito ay higit na mahusay na humahawak ng iba't ibang workload sa pamamagitan ng paggamit ng kalakasan ng bawat uri ng processor. Halimbawa, ang mga CPU ay gagamitin para sa mga pangkalahatang gawain at ang mga GPU naman para sa parallel processing. Sa konteksto ng pamamahala at pag-schedule ng resource — lalo na para sa mga heterogeneous computing environment — maaaring kailanganin ang mga karagdagang unit ng pagsukat kasabay ng mga inilarawang dito.

Para sa memorya, ang unit ng pagsukat ay Mega/Giga/Terabyte.

Para sa mga graphics card at iba pang accelerator, ang unit ng pagsukat ay depende sa konteksto. Bagama't ang tunay nilang kakayahan sa computing ay sinusukat ng mga detalyadong sukatan — bilang ng mga processing core, sukat ng memorya, at bandwidth ng memorya — sa mga mataas na antas na talakayan ng mga cluster resource o job scheduling, ang mga GPU at katulad na accelerator ay maaaring bilangin sa antas ng device sa pamamagitan ng bilang ng buong device na naatasan (halimbawa, tatlong GPU).

Ang network/connectivity/bus ay mahalagang aspeto ng anumang compute infrastructure dahil tinutukoy nito kung gaano kabilis ang paglipat ng data sa pagitan ng mga compute component. Mula sa CPU hanggang sa cache ng CPU, sa RAM, sa mga PCI card, sa mga device na konektado sa network — lahat ito ay komunikasyon at napakahalaga na magkaroon ng tumpak na mental na modelo nito para sa pagdidisenyo ng mga highly optimized na algorithm para sa HPC.

Pag-scale ng mga klasikal na resource

Ang High-Performance Computing (HPC) ay kinabibilangan ng pag-scale ng mga klasikal na resource na ito upang makamit ang mas mabilis na oras ng pagpoproseso o mapataas ang data na maaaring hawakan nang sabay-sabay (halimbawa, upang mapataas ang laki ng mga solution space na maaaring hanapin). Magagawa ito sa pamamagitan ng:

• Vertical scaling: Pagpapalakas ng kapangyarihan ng mga indibidwal na resource, tulad ng paggamit ng mas makapangyarihang CPU o pagdaragdag ng mas maraming memorya sa loob ng isang pisikal na node, kung saan ang isang node ay isang yunit ng isang compute cluster na naglalaman ng maraming computing resource sa loob nito.

• Horizontal scaling: Pagdaragdag ng mas maraming resource, tulad ng maramihang CPU o GPU, upang magtulungan sa isang node o, mas karaniwan, sa maraming node, na nagbibigay-daan sa distributed computation.

Ang ilan sa mga konsepto ng scaling mula sa seksyong ito ay naaangkop sa susunod na seksyon tungkol sa mga quantum computing resource. Ang ilang iba pang aspeto ng mga quantum resource ay susukatin sa mga bagong paraan.

Suriin ang iyong pag-unawa

Gamitin ang mga paglalarawang nasa itaas upang mahinuha ang ilang mga kalamangan at kahinaan ng iba't ibang diskarte sa scaling: vertical at horizontal?

Sagot:

Maaaring maraming tamang sagot. Ang vertical scaling ay kadalasang mas simple, lalo na kung mayroon kang mga predictable na workload na mangangailangan ng nakapirming halaga ng mga resource. Ngunit ang vertical scaling ay maaaring mas mahal na i-upgrade, dahil ang pangunahing yunit ng computing ay hindi kasingdaling hatiin tulad ng sa horizontal scaling. Ang horizontal scaling ay mas kumplikado na pamahalaan at minsan ay mayroong mga kahirapan o latency na may kaugnayan sa mga koneksyon sa pagitan ng mga node. Ngunit ito ay mas angkop sa iba't ibang kinakailangan sa resource at modular kapag kinakailangan ang mga pag-upgrade.

Bagong uri ng resource: QPU (Quantum Processing Unit)

Sa seksyong ito, magpapakilala tayo ng bagong uri ng resource — isang quantum resource — at tuklasin ang kahulugan nito, mga unit ng pagsukat, at koneksyon sa klasikal na imprastraktura.

Kahulugan ng QPU

• Quantum processing unit (QPU): Kasama sa QPU ang lahat ng hardware na responsable sa pagtanggap ng isang executable na quantum instruction set, o isang quantum circuit, at pagbabalik ng tumpak na sagot.

Ibig sabihin, kasama sa QPU ang isa o higit pang quantum chip (hal. Heron), ang maraming karagdagang bahagi sa dilution refrigerator tulad ng mga quantum amplifier, ang control electronics, at ang klasikal na computing na kailangan para sa mga gawaing tulad ng pagpapanatili ng mga instruksyon at waveform sa memorya, pag-iipon ng mga resulta, at hinaharap na error correction decoding. Bagama't kailangan ang dilution refrigerator upang maisakatuparan ang mga gawaing ito, ibinubukod natin ang dilution refrigerator mula sa kahulugang ito upang payagan ang kaso ng maraming QPU sa parehong refrigerator.

• Quantum computer: Ang isang quantum computer ay binubuo ng QPU kasama ang klasikal na computing na nagho-host ng runtime environment.

• Runtime environment: Ang kombinasyon ng hardware at software na nagbibigay-daan sa pagpapatakbo ng isang programa.

Mga layer sa mga quantum circuit

Sa parehong klasikal at quantum computing, ang mga proseso ay maaaring isagawa nang sunud-sunod o sabay-sabay. Dahil ang mga qubit ay may mayamang state space kumpara sa mga klasikal na bit, minsan ay makatuwiran na maramihang single-qubit gate ang isagawa sa isang qubit nang sunud-sunod (tulad ng isang R_x gate na sinusundan ng isang R_z gate). Dahil ang entanglement sa pagitan ng mga qubit ay kritikal sa quantum computing, karaniwan ding nagkakaroon ng isang set ng mga entangling gate na kumikilos sa maraming qubit ang isang quantum circuit. Ang mga ito at iba pang mga salik ay nagpapalagi ng pagkilala sa mga prosesong maaaring isagawa nang sabay-sabay sa antas ng mga indibidwal na operasyon ng gate sa isang quantum circuit. Sa klasikal na computing, posible rin ang bit-level parallelism ngunit mas bihirang isaalang-alang sa antas ng gate; mas karaniwan na sumangguni sa mga parallel at sequential na proseso sa isang mas malaking antas.

Sa quantum computing, tinutukoy ang isang "layer" ng mga gate na maaaring lahat ay isagawa nang sabay-sabay. Sa maraming aplikasyon, kapaki-pakinabang na magsagawa ng isang set ng mga rotation sa lahat ng qubit at pagkatapos ay mga entangling gate sa pagitan ng mga pares ng qubit. Sa mga kontekstong ito, tinutukoy ang isang "rotation layer" (isang layer ng mga gate tulad ng R_x, R_y, at/o R_z) at isang "entangling layer" (tulad ng isa na may mga CNOT gate). Ang bilang ng mga layer sa isang circuit ang "circuit depth," isang mahalagang sukatan dahil ang mas malalim na circuit ay nangangahulugang mas maraming layer ng nag-iipon na ingay at mga error.

Maaaring mahirap tukuyin nang biswal ang mga gate layer kapag ang mga layer ay hindi nakahanay gamit ang mga barrier. Sa Qiskit, ang isang barrier ay nagsisilbing isang instruksyon sa mga quantum circuit na gumaganap bilang isang visual na separator at isang hadlang sa panahon ng compilation. Parehong sa pagguhit ng circuit at pagpapatupad nito, walang gate ang ilililipat sa kabila ng barrier. Maaaring ito ay mahalaga sa mga konteksto tulad ng dynamical decoupling, kung saan sadyang isinasagawa ang mga gate na nagpapasimple sa isang identity upang sugpuin ang ilang mga uri ng error. Para sa higit pa sa dynamical decoupling, tingnan ang gabay na ito. Para sa visual na epekto ng mga barrier, ihambing ang dalawang larawang ito ng parehong circuit, ang una ay walang mga barrier at ang pangalawa ay may mga barrier upang pilitin ang pagkakahanay ng mga layer.

Ang mga ito ay parehong circuit at may parehong bilang ng mga layer. Ngunit sa pangalawa, ang pagkakahanay ay nagpapadali sa pagkita na ang circuit ay may:

• Dalawang rotation layer: isa sa paligid ng Y axis ng $\pi/5$, isa sa paligid ng Z axis ng $\pi/4$.
• Tatlong entangling layer. Tandaan na maaaring tawaging "layer" ang bawat CNOT sa sarili nito, dahil ang mga CNOT ay hindi maaaring muling ayusin upang maging parallel nang hindi binabago ang lohikal na operasyon.
• Dalawang karagdagang rotation layer: isa sa paligid ng Y axis ng $\pi/3$, isa sa paligid ng Z axis ng $\pi/2$.
• Dalawang karagdagang entangling layer. Tandaan na sa pagkakataong ito ang unang layer ay bahagyang mas na-parallelize kaysa sa unang set ng mga entangling layer.

Ang depth ng bawat circuit ay 9.

Mga unit ng pagsukat

Sa quantum computing, ang mga kakayahan ng isang quantum system ay karaniwang sinusuri gamit ang tatlong pangunahing sukatan ng pagganap: scale, quality, at speed. Ang mga sukatan na ito ay hindi lamang naglalarawan ng computational na potensyal ng isang quantum device, kundi nagbibigay-impormasyon din sa kung paano pinamamahalaan at ina-schedule ang mga resource sa mga praktikal na aplikasyon.

• Ang scale ay tumutukoy sa bilang ng mga quantum bit (qubit) sa sistema, na kumakatawan kung gaano karaming quantum na impormasyon ang kaya ng device na hawakan. Sa pamamahala ng resource, ito ay direktang nakakaapekto sa circuit width — ang bilang ng mga qubit na kailangan upang mapatakbo ang isang partikular na quantum na gawain. Ang isang quantum unit ay dapat may sapat na qubit upang suportahan ang itinalagang gawain.

• Inilalarawan ng quality kung gaano katumpak na isinasagawa ang mga quantum na operasyon. Madalas itong sinusukat sa pamamagitan ng layer fidelity, na sumusukat ng katumpak ng pagpapatupad ng isang buong layer ng mga quantum gate sa lahat ng qubit. Mula sa pananaw ng pag-schedule, ang mas mataas na fidelity ay nagpapahintulot sa mas malalim na mga circuit na maisakatuparan nang maaasahan, na nakakaapekto sa pangangailangan para sa error mitigation o paghahati ng gawain.

• Ang speed ay sinusukat ng CLOPS (Circuit Layer Operations Per Second), na nagpapakita kung gaano karaming layer ng mga quantum na operasyon ang kaya ng sistema na isagawa bawat segundo. Nakakaapekto ito sa throughput at latency sa pagpapatupad ng gawain, at tumutulong na matukoy kung gaano kabilis makukumpleto ng isang quantum unit ang isang partikular na workload. Ang bilis na ito ay partikular na mahalaga sa isang quantum computer, dahil ang mga qubit ay naghihirap mula sa ingay at mga error nang mas malaki kaysa sa kanilang mga klasikal na katapat. Ang oras kung saan maaari nilang mapanatili ang kanilang quantum na impormasyon sa isang kapaki-pakinabang na paraan ay inilalarawan ng coherence time, karaniwang nasa 200–300 $\mu\text{s}$ para sa mga Heron r3 processor.

Mga pagkakaiba sa pagitan ng quantum at klasikal na sukatan

Maaari mong isipin ang CLOPS bilang isang maluwag na quantum na katumbas ng FLOPS, ngunit may ilang pangunahing pagkakaiba. Sinusukat ng CLOPS ang bilis ng pagpapatupad ng isang quantum processor ng mga quantum circuit, partikular na mga layer ng mga operasyon sa loob ng mga circuit, kasama ang parehong quantum at kinakailangang klasikal na computing na kasangkot sa pagpapatakbo ng mga circuit. Ito ay binuo ng IBM Quantum bilang isang holistic na sukatan ng bilis ng pagpapatupad ng isang quantum computer, na sumasaklaw sa oras ng quantum execution at real-time classical processing na kailangan para sa mga pag-update ng circuit, hindi tulad ng FLOPS na purong sumusukat ng kapasidad sa floating-point arithmetic sa mga klasikal na processor.

Nagbibigay ang CLOPS ng isang nasusukat na sukatan ng pagganap na maaaring i-benchmark sa kasalukuyang hardware. Ginamit ng IBM Quantum ang CLOPS upang ma-benchmark ang iba't ibang quantum processor at ang mga halaga ay matatagpuan sa pahina ng Compute resources sa IBM Quantum Platform. Ang mga halaga ng CLOPS ay depende sa mga kakayahan ng hardware, bilis ng gate, bilis ng klasikal na processing, at integrasyon ng mga ito.

Ang bilang ng qubit ay isang nakapirming bilang para sa isang partikular na QPU. Ang CLOPS at quality ay nakasalalay sa regular na calibration at maintenance at maaaring bahagyang magbago sa paglipas ng panahon, kahit para sa isang QPU.

Magkasama, ang mga sukatan na ito ay gumagabay sa kung paano inilalaan at ina-schedule ang mga quantum system. Sa maraming kaso, ang buong quantum system ay tinatrato bilang isang yunit. Ngunit kapag ang isang gawain ay nalampas ang kapasidad ng isang yunit — uman man sa bilang ng qubit, circuit depth, o bilis ng pagpapatupad — ang mga pamamaraan tulad ng circuit cutting/knitting ay maaaring gamitin. Ang circuit cutting ang proseso ng paghahati ng malalaking quantum na gawain sa mas maliliit at napapamahalaang sub-gawain na maaaring ipamahagi sa maraming quantum chip, na nagbibigay-daan sa scalable quantum computation sa kabila ng mga limitasyon ng hardware. Ang circuit knitting naman ang prosesong sumusunod sa circuit cutting — ang klasikal na post-processing na hakbang na "nag-ti-knit" o pinagsasama ang mga resulta mula sa mas maliliit na subcircuit.

Ang mga quantum computer ay walang tradisyonal na memorya, sa kahulugang patuloy na nada-address na storage tulad ng RAM o GPU memory. Ang mga klasikal na computing resource ay may mga discrete na bit na nakaimbak sa memorya, na nagbibigay-daan sa data na ma-save, makuha, at magamit muli sa panahon ng computation. Gumagamit ang mga quantum resource ng mga qubit na hindi nag-iimbak ng memorya sa klasikal na kahulugan. Sa halip, ang mga qubit ay umiiral sa mga quantum state na kumakatawan sa mga superposition ng 0 at 1 nang sabay-sabay, na nagbibigay-daan sa exponential parallelism sa state space. Gayunpaman, ang mga estado ng qubit ay marupok at hindi maaaring i-clone o mabasa nang deterministiko sa mga intermediate na hakbang nang hindi binabasag ang quantum state, kaya ang memorya-tulad na pag-uugali sa panahon ng computation ay hindi umiiral. Ang mga qubit ay dapat mapanatili sa isang coherent na estado sa buong pagpapatupad, at ang "memorya" ay esensyal na ang quantum state mismo. Ang klasikal na memorya ay maaari lamang gamitin kasabay ng isang quantum processor, hindi bilang panloob na quantum memory. Mayroon itong mahahalagang implikasyon: ang mga klasikal na compute resource ay maaaring gamitin muli at mag-imbak ng mga intermediate na resulta nang malaya; ang mga quantum resource ay hindi makakapaggawa nito nang walang mga pagsukat na nagagambala sa computation.

Koneksyon sa klasikal na imprastraktura

Ang mga QPU ay maaaring ikonekta sa klasikal na imprastraktura sa pamamagitan ng mga network at iba't ibang application programming interface (API) na nagbibigay-daan sa mga software developer na makipag-ugnayan sa mga QPU nang programatically. Ang mga API na ito ay karaniwang nakatago sa likod ng mga software development kit (SDK) at library (tulad ng Qiskit) at inilalantad sa mga computational scientist sa anyo ng mga programming abstraction (tulad ng Qiskit Primitives, na tatalakayin natin sa Kabanata 3: mga programming model).

Ito ay kapaki-pakinabang na iguhit ang pagkakaiba sa pagitan ng matapit at maluwag na integrasyon ng quantum at klasikal na resource. Sa kasalukuyan, ang mga QPU ay hindi nasa parehong node ng mga klasikal na compute resource. Sa katunayan, ang mga QPU ay kasalukuyang hindi konektado sa pamamagitan ng PCIe, kundi sa pamamagitan ng network. Maaari itong magbago sa hinaharap, ngunit mayroong mga hamon sa engineering na may kaugnayan sa mga kondisyong pangkapaligiran na pinakamainam para sa mga QPU at mga klasikal na compute resource.

Pag-scale ng mga quantum resource

Ang pag-scale ng mga quantum resource ay maaari ring ikategorya sa vertical at horizontal.

• Ang vertical scaling ay ang pagdaragdag ng bilang ng mga qubit bawat chip o pagpapabuti ng fidelity ng mga device.
• Ang horizontal scaling ay ang pagkonekta ng mga chip gamit ang mga coupler o sa pamamagitan ng klasikal na interconnect.

Suriin ang iyong pag-unawa

Ano ang mga quantum na katumbas ng klasikal na (a) mga bit ng impormasyon, at (b) bilis ng processor?

Sagot:

(a) Mga quantum bit o qubit — mga yunit ng impormasyon na hindi tulad ng kanilang mga klasikal na katapat (na maaari lamang umabot sa estado 0 o 1), ay maaaring nasa superposition ng 0 at 1 nang sabay-sabay.

(b) Circuit layer operations per second o CLOPS — bilang ng mga sequential na operasyon na kayang isagawa ng QPU bawat segundo, kasama ang ilang pakikipag-ugnayan sa mga klasikal na computing resource, tulad ng sa pag-load ng mga parameter mula sa circuit.

Pamamahala ng resource

Parehong ang mga HPC at quantum na resource ay parehong mahalaga at kumplikado; dapat silang pamahalaan nang maingat. Sa seksyong ito, ipapaliwanag natin kung paano pamahalaan ang mga resource para sa mga programa ng gumagamit. Ang pamamahala ng resource sa compute infrastructure ay tumutukoy sa proseso ng (1) pagpaplano, (2) paglalaan, at (3) pagkontrol/pamamahala ng paggamit ng mga computing resource tulad ng mga CPU, memorya, storage, at bandwidth ng network upang matiyak ang mahusay at epektibong paggamit ng resource.

Pagpaplano — pagsasalang-isip ng resource

Ang anumang programa ay kumukonsyumo ng mga resource, at ang pagsasalang-isip ng mga kinakailangang resource ay mahalaga para sa mahusay na pamamahala ng resource. Kasama dito ang pagsasalang-isip ng halaga ng CPU, memorya, at iba pang resource na kailangan upang mapatupad ang isang programa. Ang parehong bagay ay maaaring sabihin para sa mga quantum resource. Gayunpaman, ang mga quantum resource ay umiiral sa isang ganap na naiibang antas. Ang IBM Quantum® Heron r3 quantum processor ay may 156 na qubit, kumpara sa maraming bilyun-bilyong klasikal na bit sa isang karaniwang laptop. Ang oras at gastos ay mga konsiderasyon din. Sa kasalukuyan, ang IBM Quantum ay may libreng plano, ang Open Plan, na nagbibigay-daan sa mga gumagamit na tuklasin ang quantum computing gamit ang 10 minuto ng oras ng QPU bawat buwan. Ang ilang organisasyon sa pananaliksik ay nangangailangan ng napakaraming oras ng QPU kaya mayroon silang nakatuong IBM quantum computer sa lugar.

Ang isang hakbang sa pagsasalang-isip ng resource na natatangi sa quantum computing ay ang circuit depth. Tulad ng nabanggit kanina, ang bawat quantum gate at bawat oras ng pagkaantala sa pagitan ng mga operasyon ay may kasamang ingay at isang tiyak na posibilidad ng isang error. Habang mas malalim ang quantum circuit, mas malaki ang ingay. Mayroong dalawang subtlety dito: ang mga two-qubit gate ay may mas mataas na error rate kaysa sa mga single-qubit gate, kaya madalas maaaring balewalain ang single-qubit depth. Higit pa rito, hindi lahat ng qubit sa isang quantum chip ay direktang konektado. Minsan ang impormasyon ay kailangang i-swap mula sa qubit patungo sa qubit upang maisagawa ang mga kinakailangang entanglement at ang prosesong ito ng pag-swap ay nangangailangan ng mga two-qubit gate. Ang pag-swap na iyon ay pinamamahalaan sa isang prosesong tinatawag na "transpilation," isang kumplikadong proseso na nagsisilbi rin ng iba pang layunin; ito ay tinalakay nang mas detalyado sa susunod na aralin. Ang kaugnay na limitasyon ng dami ay ang transpiled two-qubit depth. Ang eksaktong maximum depth kung saan maaaring makuha ang mga high-fidelity na resulta ay depende sa circuit. Ngunit sa pamamagitan ng paggamit ng mga modernong pamamaraan ng error mitigation, maaaring makakuha ng mga high-fidelity na resulta na may transpiled two-qubit depth na 80 o higit pa.

Paglalaan — pag-schedule

Ang pag-schedule ay ang proseso ng paglalaan ng mga resource sa mga programa at pamamahala ng kanilang pagpapatupad. Kasama dito ang:

• Job submission: Ang proseso kung saan nagpapadala ang isang gumagamit ng kahilingan (job) sa HPC system, na tinutukoy kung anong computational na trabaho at mga resource ang kailangan para sa pagpapatupad.
• Resource allocation: Ang pagtatalaga ng mga available na resource ng HPC system (tulad ng mga node, CPU, memorya) sa isang isinumiteng job batay sa mga kinakailangan nito.
• Job execution: Ang aktwal na pagpapatakbo ng mga computational na gawain na tinukoy ng job sa mga inilalaang HPC resource.

Mayroong mga katumbas ng lahat ng mga prosesong ito para sa mga quantum computer.

• Ang mga job ay isinusumite ng gumagamit, gamit ang Qiskit Runtime, at karaniwang gumagamit ng Qiskit Runtime primitive, tulad ng Sampler, Estimator, o iba pa.
• Pumipili ang gumagamit mula sa isang listahan ng mga backend na maa-access nila. Ang kumpletong listahan ng mga available na backend ay makikita sa pahina ng Compute resources sa IBM Quantum Platform. Karaniwan na gamitin lang ang pinaka-abalang quantum computer. Ngunit may mga kaso kung saan maaaring mahalaga na gumamit ng isang tiyak na isa dahil sa mga konsiderasyon sa layout ng device, pag-uulit ng mga nakaraang kalkulasyon, at iba pa.
• Ang pagpapatupad ng mga quantum job ay katulad ng kaso ng HPC. Bagama't ang ilang mga pagkakaiba ay nabalangkas na, ilang ay sulit na ulitin dito. Ang mga QPU sa kasalukuyan ay karaniwang hindi matatagpuan sa parehong node ng mga klasikal na compute resource ngunit konektado sa pamamagitan ng isang network. Maaari itong may mga implikasyon sa pag-schedule. Higit pa rito, ang mga quantum computer ay maaaring may malaking oras ng queue, at ang mga oras ng queue na ito ay nagbabago-bago, na nagpapahirap sa tumpak na kontrol ng timing. Ang sitwasyong ito ay maaaring naiiba para sa mga nakatuong sistema; nakasalalay iyon sa panloob na administrasyon ng quantum computer.

Pagkontrol/Pamamahala — workload management

Ang workload management, na kilala rin bilang orchestration, ay ang proseso ng pamamahala ng maraming programa at ng kanilang mga kinakailangan sa resource. Kasama dito ang:

• Resource provisioning: Ang proseso ng paghahanda at pagpapaging available ng mga HPC resource para gamitin ng mga job, kasama ang hardware at software setup. Tulad ng makikita natin sa ibang pagkakataon, ang mga QPU ay mga computing resource na maaaring i-provision nang katulad ng mga klasikal na HPC resource, na may mga caveat mula sa nakaraang seksyon.
• Job scheduling: Ang aktibidad ng scheduler software sa pagpapasya kung aling mga job ang tatakbo, kailan, at sa aling mga resource, na pinamamahalaan ang mga priyoridad at queue upang mahusay na magamit ang HPC system. Bagama't naaangkop ang malawak na pahayag na ito sa mga quantum resource, maaaring may mas kaunting kontrol sa timing kaysa sa ibang mga resource.

Halimbawa:

Isaalang-alang ang isang kilalang gawain bilang konteksto para sa pag-unawa sa pamamahala ng resource: ang paghahanap ng mga prime factor ng malalaking bilang. Ipagpalagay pa natin na ang algorithm na ginagamit ay umaasa sa brute force na pag-check ng bawat potensyal na divisor. Bagama't ito ay madalas ay hindi ang pinaka-mahusay na paraan, madaling maunawaan kung paano maaaring pamahalaan ang workload.

Pagpaplano — pagsasalang-isip ng resource

• Suriin kung gaano karaming oras ng CPU at memorya ang maaaring kailangan ng prime factorization.
• Planuhin ang parallelization ng iyong gawain — ilang CPU/core ang gagamitin mo?

Paglalaan — pag-schedule

• Sa pagsusumite ng job, ang scheduler ay nagtatalaga ng mga CPU core at memorya sa gawaing prime factorization. Halimbawa, maaari itong maglaan ng lahat ng potensyal na divisor na nagtatapos sa mga digit na 1, 3, 7, 9 sa isa sa apat na core, ayon sa pagkakasunod.
• Job execution: Ang algorithm ng prime factorization ay tumatakbo, nagsasagawa ng mga dibisyon o iba pang mga hakbang sa factorization sa mga inilalaang resource hanggang makumpleto ang gawain.

Pagkontrol/Pamamahala — workload management

• Inioorkestra ng sistema ang pagkakasunod at timing ng mga prime factorization job upang ma-optimize ang throughput.
• Ang pinakamadaling kaso na maiisip ay na ang isa sa mga core ay nakahanap ng target na prime factor. Dapat nitong ihinto ang kalkulasyon sa ibang mga core upang magamit ang mga ito para sa susunod na gawain.

Gumagamit ang mga high-performance computing environment ng espesyal na software upang isagawa ang mga hakbang na ito at pamahalaan ang mga resource. Sa susunod na seksyon, matututunan natin ang tungkol sa isang malawakang pinagtibay na sistema ng software sa pamamahala ng resource: Slurm.

Halimbawa na may mga quantum resource:

Ang isang workflow na magiging paksa ng iba pang mga aralin sa kursong ito ay ang pagtukoy ng mga chemical ground state at enerhiya gamit ang sample-based quantum diagonalization (SQD). Ito ay tinalakay nang mas detalyado sa Aralin 4, at maaari ka ring bisitahin ang kursong ito sa SQD at mga kaugnay na pamamaraan sa IBM Quantum Learning. Ang kailangan lang nating malaman para sa talakayan na ito ay ang workflow ay kinabibilangan ng sumusunod:

• Maghanda ng quantum circuit
• Sukatin ang quantum circuit
• Gamitin ang mga resulta ng pagsukat upang i-project ang problema sa isang kapaki-pakinabang na subspace
• I-diagonalize ang isang mas maliit na projected matrix gamit ang mga klasikal na computing resource
• Pag-ulit, uman man upang matiyak ang self-consistency sa pamamagitan ng mga konsiderasyon tulad ng charge conservation, at posibleng mga pag-ulit ng quantum circuit kung ito ay may mga variational parameter.

Pagpaplano — pagsasalang-isip ng resource

• I-map ang mga electronic orbital sa mga qubit upang matukoy ang bilang ng mga qubit na kailangan mo.
• Pagsamahin ang naka-map na Hamiltonian ng sistema at ang (posibleng variational) na estado sa isang quantum circuit at suriin ang transpiled, two-qubit depth. Tiyaking ito ay makatwirang.
• Suriin ang laki ng subspace na iyong ipo-project; mula dito, suriin kung gaano karaming oras ng CPU at memorya ang maaaring kailangan ng diagonalization.
• Planuhin ang parallelization ng iyong gawain — ilang CPU/core ang gagamitin mo?

Paglalaan — pag-schedule

• Pinipili ng gumagamit ang QPU; ang proseso ng transpilation ay awtomatikong nagma-map ng mga qubit sa iyong abstract quantum circuit sa mga pisikal na qubit sa QPU. Ito ay mahalaga dahil ang abstract circuit ay maaaring mag-assume ng direktang connectivity na hindi umiiral sa chip, bukod sa iba pang dahilan.
• Sa pagsusumite ng job sa pamamagitan ng Qiskit Runtime, ang job ay pumapasok sa queue para sa napiling QPU. Walang kontrol ang gumagamit sa oras ng queue, bagama't maaaring naiiba ito para sa mga nakatuong sistema.
• Naghihintay ang mga klasikal na computing resource para sa mga quantum na resulta.
• Ang isang diagonalization job ay isinusumite sa mga HPC resource; sa pagsusumite ng job, ang scheduler ay nagtatalaga ng mga CPU core at memorya sa gawaing diagonalization.
• Job execution: Ang algorithm ng diagonalization ay tumatakbo, dina-diagonalize ang mas maliit na projected matrix hanggang makumpleto ang gawain.

Pagkontrol/Pamamahala — workload management

• Inioorkestra ng sistema ang pagkakasunod at timing ng mga quantum at klasikal na hakbang sa buong proseso. Halimbawa, kapag na-diagonalize na ang projected matrix at nakuha ang ground state energy, depende sa mga pamantayan ng convergence, ang workflow ay maaaring bumalik sa isang bagong quantum circuit (na may bagong variational parameter).
• Kapag natugunan na ng ground state energy ang mga pamantayan ng convergence, ang kalkulasyon sa lahat ng core ay tumitigil.

Gumagamit ang mga high-performance computing environment ng espesyal na software upang isagawa ang mga hakbang na ito at pamahalaan ang mga resource. Sa susunod na seksyon, matututunan natin ang tungkol sa isang malawakang pinagtibay na sistema ng software sa pamamahala ng resource: Slurm. Mahalagang tandaan na ang Slurm ay walang mga tool para sa lahat ng hakbang na inilarawan sa itaas. Ang Slurm ay hindi nagbibigay ng suporta para sa pagpaplano ng mga job, ni detalyadong workload management tulad ng komunikasyon sa pagitan ng mga bahagi ng workload. Ito ay angkop sa kasalukuyang estado ng quantum computing sa HPC, dahil ang mga QPU ay karaniwang na-access sa pamamagitan ng network.

Suriin ang iyong pag-unawa

Ipagpalagay na sinusubukan mong hanapin sa isang hindi nakaayos na database ang isang elemento na tatawagin nating ang 'target'. Para sa bawat isa sa mga sumusunod na aksyon, sabihin sa kung aling yugto ng pamamahala ng resource ito naaayon: (a) Pagsasalang-isip ng laki ng database at oras na kailangan upang suriin ang bawat elemento (b) Pagtitiyak na ang paghahanap ng target sa isang GPU ay humihinto sa proseso sa ibang mga GPU upang palayain ang mga ito para sa susunod na problema. (c) Paghahati ng search space sa mga rehiyon para sa bawat isa sa iyong (sabihin nating 10) GPU na hahanapin

Sagot:

(a) Pagpaplano (b) Pagkontrol/pamamahala (c) Paglalaan/pag-schedule,

Software: Slurm

Sa seksyong ito, ilalapat natin ang mga konsepto na natutunan sa kabanatang ito para magsanay sa paggamit ng sikat na resource management system na Slurm.

Panimula sa Slurm

Ang Slurm ay isang open-source na resource management system na malawakang ginagamit sa mga high-performance computing environment. Nagbibigay ito ng komprehensibong hanay ng mga tool para sa pamamahala ng resources, pag-schedule ng mga job, at pagmamanman ng performance ng sistema.

Tatalakayin natin ang mga pangunahing kaalaman sa paggamit ng Slurm, kabilang ang:

• Pagsusumite ng job
• Paglalaan ng resources
• Pagmamanman ng job

Dahil talagang mahirap na magbigay ng HPC resources sa bawat estudyante ng kursong ito, dito tayo magiging malikhain — magbibigay kami ng isang repository na may mga Docker image na ginagaya ang isang tunay na HPC cluster na may Slurm, ngunit sa mas maliit na sukat. Makakatulong ito sa atin na magsanay ng mga natutunan sa isang ligtas at muling magagawang kapaligiran.

Tandaan na sa kasalukuyan, lahat ng quantum at classical resources ay inilalaan para sa buong tagal ng isang eksperimento. Sa ngayon, wala pang interleaved na paglalaan ng magkahalong resources. Isang mahalagang paalala: kahit na nagsimula na ang job, hindi direktang kinokontrol ng user ang quantum system tulad ng inaasahan ng mga karanasang gumagamit ng HPC. Ang job ay inilulunsad sa isang arbitrary na x86 node, na nagpapatakbo ng Qiskit Runtime service, at ang runtime service na iyon ay kumokonekta sa isa pang scheduler na wala sa direktang kontrol ng user. Pamilyar ang daloy na ito sa mga HPC user na maaga pang nagsimulang humingi ng eksklusibong access sa mga GPU node (ang orihinal na gamit ng gres).

Mga tagubilin sa pag-install at pangkalahatang-ideya ng setup

Para makapag-practice sa pagsasama ng quantum at HPC resources, kakailanganin mo ng access sa tunay na HPC environment, o kailangan mong gayahin ang isang HPC environment sa iyong lokal na makina. Makikita ang gabay sa lokal na setup gamit ang Docker sa repository na ito. Naka-link doon ang suporta para sa pagse-set up ng IBM Cloud® account at pag-install ng SPANK plugin para sa QRMI. Naroroon din sa repository na iyon ang ilang Python file para subukan ang iyong environment.

Kapag natapos mo na ang pag-install, gamitin natin ang command sa ibaba para tingnan ang compute resources ng Slurm sa iyong terminal. Kung matagumpay ang pag-install, dapat makumpirma mo ang kabuuang tatlong virtual node.

$ sinfo

PARTITION AVAIL TIMELIMIT NODES STATE NODELIST
normal      up 5-00:00:00     2  idle c[1-2]
quantum*    up   infinite     1  idle q1

$ scontrol show node

NodeNAME=q1 Arch=x86_64 CoresPerSocket=1
CPUAlloc=0 CPUTot=1 CPULoad=0.34
AvailableFeatures=(null)
ActiveFeatures=(null)
Gres=qpu:1
NodeAddr=q1 NodeHostName=q1 Version=21.08.6
...

Mayroon tayong dalawang partition o grupo ng node: normal at quantum. Ang normal na partition ay binubuo ng mga node na may access sa classical resources lamang. Ang quantum partition naman ay may access sa quantum resources. Maaari mong makita ang mga detalye ng bawat node sa pamamagitan ng pagpapatakbo ng scontrol show nodes.

Magpatakbo ng simpleng hello world example sa Slurm

Una, patakbuhin natin ang isang simpleng classical na hello world example gamit ang Slurm. Gagamit tayo ng Python para sa mga halimbawa. Likhain natin ang hello_world.py, na simple at madaling maunawaan.

$ vim hello_world.py

import time
time.sleep(10)
print("Hello, World!")
~

Ngayon kailangan nating sabihin sa resource manager kung anong resources ang kailangan natin para patakbuhin ang programang ito. Nagbibigay ang Slurm ng paraan para tukuyin ang lahat ng metadata para sa job sa pamamagitan ng isang submission script, na isang shell script na may mga annotation na espesipiko sa Slurm. Binibigyang-daan ka ng mga annotation na ito na tukuyin ang mga kinakailangan sa resource, mga parameter ng schedule, at iba pa. Likhain natin ang shell script na hello_world.sh para dito.

$ vim hello_world.sh

#SBATCH --job-name=hello-world
#SBATCH --output=hello-world.out
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=1
#SBATCH --partition=normal

srun hello_world.py
~

Suriin natin ang submission file at tingnan kung ano ang nangyayari dito.

Ang mga #SBATCH directive ay mga espesipikong annotation para sabihin kung ano ang mga kinakailangan natin para sa pagpapatakbo ng program. Dito maaari mong tukuyin ang dami ng resources — ang bilang ng mga node, bilang ng mga task bawat node, bilang ng mga task at CPU bawat node at task — at iba pang mga opsyon tulad ng pangalan ng output file. Ang kumpletong listahan ng mga opsyon ay makikita sa dokumentasyon ng Slurm.

Ngayon ay panahon na para patakbuhin ang ating Slurm job. Ang sbatch ay isang command na tumatanggap ng submission file at naglalagay ng job sa pila para sa pagpapatakbo sa Slurm.

$ sbatch hello_world.sh

Submitted batch job 63

Tingnan natin ang status ng ating program gamit ang command na squeue.

$ squeue

#             JOBID PARTITION     NAME         USER ST       TIME  NODES NODELIST(REASON)
#                 1 main          hello_world  root R        0:01      1 c1

Kapag natapos na ang job, maaari nating suriin ang resulta sa pamamagitan ng pagtingin sa output file.

$ cat hello_world_logs.txt
Hello, World!

Subukan ang iyong pag-unawa

Batay sa Slurm shell script sa ibaba, ano ang (a) pangalan ng job, (b) pangalan ng Python file, at (c) pangalan ng output file? (d) Panghuli, maaari bang gumamit ito ng quantum resources o hindi?

vim hello_learner.sh

#SBATCH --job-name=hello-learner
#SBATCH --output=hello-learner.out
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=1
#SBATCH --partition=quantum

srun hello_learner_qm.py

Sagot:

(a) hello-learner (b) hello-learner_qm.py (c) hello-learner.out (d) Oo, maaari. Gumagamit ito ng quantum partition.

Magpatakbo ng simpleng Qiskit hello world example sa Slurm

Susunod, subukan nating gamitin pati ang quantum resources. Gumawa at patakbuhin natin ang isang simpleng "Hello, Qiskit" na program na gumagamit ng quantum resources.

$ vim hello_qiskit.py

# hello_qiskit.py
from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import EstimatorV2 as Estimator

# Create a new circuit with two qubits
qc = QuantumCircuit(2)

# Add a Hadamard gate to qubit 0
qc.h(0)

# Perform a controlled-X gate on qubit 1, controlled by qubit 0
qc.cx(0, 1)

observables_labels = ["IZ", "IX", "ZI", "XI", "ZZ", "XX"]
observables = [SparsePauliOp(label) for label in observables_labels]

# switch to QRMI service
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

backend = service.backend("...")

# Convert to an ISA circuit and layout-mapped observables.
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_circuit = pm.run(qc)

# Construct the Estimator instance.

estimator = Estimator(mode=backend)
estimator.options.resilience_level = 1
estimator.options.default_shots = 5000

mapped_observables = [
    observable.apply_layout(isa_circuit.layout) for observable in observables
]

# One pub, with one circuit to run against five different observables.
job = estimator.run([(isa_circuit, mapped_observables)])

job_result = job.result()

pub_result = job.result()[0]

print("Result", pub_result)

Dito gagamitin natin ang quantum resource management interface (QRMI), isang Slurm SPANK plugin para sa suporta ng quantum resources at jobs na pinagsamang binuo ng IBM, Pasqal, The Hartree Center, at RPI. Gumawa tayo ng simpleng pauli-2-design circuit na may mga random na paunang halaga at isang simpleng observable, at patakbuhin natin ito gamit ang Estimator para makuha ang expectation value. Para patakbuhin ito, kakailanganin nating muli ng submission script na hello_qiskit.sh, na may quantum resources bilang isang kinakailangan.

$ vim hello_qiskit.sh

#SBATCH --job-name=hello-qiskit
#SBATCH --output=hello_qiskit.out
#SBATCH --nodes=1
#SBATCH --ntasks-per-nodes=1
#SBATCH --cpus-per-task=1
#SBATCH --partition=quantum
#SBATCH --gres=qpu:1

srun python /data/ch2/hello_qiskit/hello_qiskit.py
~

Suriin natin ang submission file at tingnan kung ano ang nangyayari doon. Mayroon tayong isang bagong opsyon, ang gres. Ang gres ay isang opsyon ng Slurm para tukuyin ang mga karagdagang computational resources. Sa kasong ito, ang bagong resource na ito ay ang ating quantum resource. Dahil tinukoy natin ang mga resources at ang partition ng ating cluster kung saan available ang quantum resources, gagamitin ng ating mga Qiskit primitive ang mga inilalaang resources na ito para isagawa ang quantum payload.

Ngayon ay panahon na para patakbuhin ang ating Slurm job.

$ sbatch hello_qiskit.sh

Pagkatapos, tingnan natin ang status ng ating program gamit ang command na squeue.

$ squeue
#             JOBID PARTITION     NAME         USER ST       TIME  NODES NODELIST(REASON)
#                 1 main          hello_qiskit  root R        0:01      1 q1

Maaari nating suriin ang mga log at resulta kapag natapos na ang job.

$ cat hello_qiskit.out | grep Exp
Expectation Value: 0.8372900070983516

Buod

Sa ngayon, natutunan na natin kung ano ang mga computational resources at paano gamitin ang mga ito para magpatakbo ng mga programa sa mga heterogeneous na kapaligiran. Nakagawa at nakapagpatakbo na rin tayo ng dalawang simpleng programa na 'Hello World': isa para sa classical resource at isa pa para sa quantum resource, at natutunan natin kung paano lumikha ng mga shell script para magsumite ng mga task at tingnan ang mga resulta.

Sa susunod na aralin, bubuo tayo sa kaalaman na ito tungkol sa kontrol ng resources para ilapat ang mga programming model sa mga resources na nakuha natin sa panahon ng pagpapatakbo ng job.

Lahat ng code at script na ginamit sa kabanatang ito ay makukuha mo sa aming GitHub repository.