ทรัพยากรการประมวลผลและการจัดการทรัพยากร

โมเดลทรัพยากรและทรัพยากรคลาสสิก

ในส่วนนี้ เราจะให้กรอบการทำงานสำหรับการคิดเกี่ยวกับสภาพแวดล้อมการประมวลผลที่สามารถนำไปใช้กับทั้งแล็ปท็อปและขยายขนาดขึ้นไปถึงซูเปอร์คอมพิวเตอร์ เมื่อสิ้นสุดส่วนนี้ คุณจะเข้าใจองค์ประกอบพื้นฐานของสภาพแวดล้อมการประมวลผลและความสัมพันธ์ระหว่างกัน ทั้งหมดนี้อธิบายโดย Iskandar Sitdikov ในวิดีโอต่อไปนี้

โมเดลทรัพยากร

สภาพแวดล้อมการประมวลผลคลาสสิกใดๆ ถูกสร้างขึ้นจากทรัพยากรที่เชื่อมโยงกันหลายอย่างที่ทำงานร่วมกันเพื่อรันแอปพลิเคชันอย่างมีประสิทธิภาพ ทรัพยากรหลักโดยทั่วไปรวมถึง:

• CPU (Central Processing Unit): CPU คือหน่วยประมวลผลหลักที่ตีความและดำเนินการตามคำสั่งโปรแกรม มันจัดการการดำเนินการด้านตรรกศาสตร์ เลขคณิต และการควบคุม ทำหน้าที่เป็น "สมอง" ของระบบโดยพื้นฐาน

• CPU cache (L1, L2, L3): นี่คือที่เก็บข้อมูลที่เร็วที่สุดในระบบ สร้างขึ้นโดยตรงภายในหรือใกล้มากกับ CPU core มันเก็บข้อมูลและคำสั่งส่วนเล็กๆ ที่ CPU ต้องการทันที ระดับที่แตกต่างกัน (L1, L2, L3) แทนการแลกเปลี่ยน: L1 มีขนาดเล็กที่สุดและเร็วที่สุด ในขณะที่ L3 ใหญ่ที่สุดและช้าที่สุด แต่ยังคงเร็วกว่า RAM หลายเท่า

• RAM (Random Access Memory): หน่วยความจำชั่วคราวที่ให้ที่เก็บข้อมูลชั่วคราวขนาดใหญ่สำหรับคำสั่งโปรแกรมและข้อมูลที่กำลังใช้งาน มันทำให้ CPU สามารถเข้าถึงข้อมูลที่ต้องการได้อย่างรวดเร็วระหว่างการดำเนินการโดยไม่ต้องพึ่งพาอุปกรณ์จัดเก็บข้อมูลที่ช้ากว่าอย่างต่อเนื่อง

• Storage (ในเครื่องและผ่านเครือข่าย): Storage เก็บข้อมูลและซอฟต์แวร์แม้เมื่อระบบปิดอยู่ ให้ที่เก็บข้อมูลระยะยาวสำหรับชุดข้อมูลขนาดใหญ่และแอปพลิเคชัน ใน HPC โซลูชัน storage ต้องจัดการข้อมูลทางวิทยาศาสตร์หรือการวิเคราะห์จำนวนมากทั้งด้วยความเร็วและความน่าเชื่อถือ Local storage รวมถึง solid-state drive (SSD) และ hard disk drive (HDD) โดย SSD ได้รับการนิยมเพราะ latency ต่ำและ throughput สูงกว่า สำหรับการจัดการข้อมูลขนาดใหญ่ ระบบไฟล์แบบขนาน network storage ที่แชร์กัน และระบบแบบ object-based ช่วยให้เข้าถึงข้อมูลได้อย่างรวดเร็วจาก compute node จำนวนมาก ในขณะที่ cloud storage และ archival storage รองรับการเก็บข้อมูลระยะยาวและการขยายขนาด

• GPU (Graphics Processing Unit): แม้ว่าจะออกแบบมาเพื่อการ rendering graphics เป็นหลัก แต่ GPU สมัยใหม่คือ parallel processor ที่ทรงพลัง พวกมันถูกใช้อย่างแพร่หลายสำหรับงานที่ต้องการการคำนวณพร้อมกันจำนวนมาก เช่น deep learning, physics simulation และ big data analytics สิ่งสำคัญคือต้องสังเกตว่า GPU ไม่ได้แทนที่ CPU แต่ CPU กำกับตรรกะโปรแกรมระดับสูง และ GPU เร่งขั้นตอนที่มีการขนานสูง

• Connections/Busses: เหล่านี้คือเส้นทางการสื่อสารที่เชื่อม CPU หน่วยความจำ storage และอุปกรณ์ต่อพ่วง Bus ช่วยให้การถ่ายโอนข้อมูลและการประสานงานระหว่างส่วนต่างๆ ของระบบ ทำให้การสื่อสารในสภาพแวดล้อมการประมวลผลราบรื่น ใน HPC ส่วนประกอบต่างๆ เช่น CPU, GPU และอุปกรณ์ storage เชื่อมต่อกันด้วย high-speed interconnect ที่ช่วยให้แลกเปลี่ยนข้อมูลได้อย่างรวดเร็ว GPU มักเชื่อมต่อกับระบบผ่าน PCIe ซึ่งเป็น interface มาตรฐานที่มี data lane หลายตัวเพื่อการสื่อสารที่มีประสิทธิภาพ สำหรับประสิทธิภาพที่สูงขึ้น NVLink ให้ลิงก์ bandwidth สูงโดยตรงระหว่าง GPU หรือระหว่าง GPU และ CPU ลด latency และเร่ง parallel workload

• Filesystem: Filesystem จัดระเบียบข้อมูลบนอุปกรณ์ storage ให้โครงสร้างสำหรับการเก็บ เรียกค้น และจัดการไฟล์ ทำให้โปรแกรมและผู้ใช้สามารถเข้าถึงข้อมูลได้ในลักษณะที่สอดคล้องกันและเป็นตรรกะ

ทรัพยากรแต่ละประเภทมีหน่วยวัดประสิทธิภาพของตัวเอง ตัวอย่างเช่น CPU มักวัดด้วย "core" และ "clock speed" เมื่อซื้อแล็ปท็อป ข้อกำหนดมักรวมถึงจำนวน core แนวคิดที่คล้ายกันนี้ใช้กับ computational node ใน data center ซึ่งแต่ละ node เชื่อมโยงกับจำนวน core เฉพาะ สภาพแวดล้อมการประมวลผลที่รวมทรัพยากรหลายประเภท (CPU, GPU รวมถึง QPU) เรียกว่า heterogeneous computing environment การตั้งค่าเหล่านี้จัดการ workload ที่หลากหลายได้อย่างมีประสิทธิภาพมากขึ้นโดยใช้จุดแข็งของ processor แต่ละประเภท ตัวอย่างเช่น CPU จะใช้สำหรับงานทั่วไปและ GPU สำหรับการประมวลผลแบบขนาน ในบริบทของการจัดการทรัพยากรและการจัดตารางเวลา — โดยเฉพาะสำหรับสภาพแวดล้อมการประมวลผลแบบ heterogeneous — อาจต้องการหน่วยวัดเพิ่มเติมนอกเหนือจากที่อธิบายไว้ที่นี่

สำหรับหน่วยความจำ หน่วยวัดจะเป็น Mega/Giga/Terabytes

สำหรับ graphics card และ accelerator อื่นๆ หน่วยวัดขึ้นอยู่กับบริบท แม้ว่าความสามารถการประมวลผลที่แท้จริงจะวัดด้วยตัวชี้วัดละเอียด — จำนวน processing core ขนาดหน่วยความจำ และ memory bandwidth แต่ในการอภิปรายระดับสูงเกี่ยวกับทรัพยากร cluster หรือการจัดตารางงาน GPU และ accelerator ที่คล้ายกันสามารถวัดในระดับ device โดยจำนวน whole device ที่กำหนด (เช่น สาม GPU)

Network/connectivity/busses เป็นแง่มุมสำคัญของโครงสร้างพื้นฐานการประมวลผลใดๆ เนื่องจากกำหนดความเร็วในการถ่ายโอนข้อมูลระหว่างส่วนประกอบการประมวลผล ตั้งแต่ LPU ไปถึง cache ของ CPU ไปถึง RAM ไปถึง PCI card ไปถึงอุปกรณ์ที่เชื่อมต่อกับเครือข่าย ทั้งหมดนี้คือการสื่อสาร และมีความสำคัญอย่างยิ่งที่จะมีโมเดลทางความคิดที่ถูกต้องเกี่ยวกับมันเพื่อออกแบบอัลกอริทึมที่ถูก optimize สำหรับ HPC

การขยายขนาดทรัพยากรคลาสสิก

HPC เกี่ยวข้องกับการขยายขนาดทรัพยากรคลาสสิกเหล่านี้เพื่อให้เวลาประมวลผลเร็วขึ้นหรือเพิ่มข้อมูลที่สามารถจัดการได้พร้อมกัน (เช่น เพื่อเพิ่มขนาดของ solution space ที่สามารถค้นหาได้) ซึ่งทำได้โดย:

• การขยายแนวดิ่ง (Vertical scaling): เพิ่มพลังของทรัพยากรแต่ละรายการ เช่น ใช้ CPU ที่ทรงพลังกว่าหรือเพิ่มหน่วยความจำภายใน physical node หนึ่ง ซึ่ง node คือหน่วยของ compute cluster ที่รวมทรัพยากรการประมวลผลหลายอย่างไว้ภายใน

• การขยายแนวนอน (Horizontal scaling): เพิ่มทรัพยากร เช่น CPU หรือ GPU หลายตัว เพื่อทำงานร่วมกันใน node เดียว หรือโดยทั่วไปมากกว่าคือบน node หลายตัว ทำให้เกิด distributed computation

แนวคิดการขยายขนาดบางอย่างจากส่วนนี้จะนำไปใช้กับส่วนถัดไปเกี่ยวกับทรัพยากรควอนตัม แง่มุมอื่นๆ ของทรัพยากรควอนตัมจะถูกวัดในแบบใหม่

ทดสอบความเข้าใจ

ใช้คำอธิบายข้างต้นเพื่ออนุมานข้อดีและข้อเสียบางอย่างของแนวทางการขยายขนาดที่แตกต่างกัน: แนวดิ่งและแนวนอน

คำตอบ:

อาจมีคำตอบที่ถูกต้องหลายอย่าง การขยายแนวดิ่งมักง่ายกว่า โดยเฉพาะหากคุณมี workload ที่คาดเดาได้ซึ่งต้องการทรัพยากรคงที่ แต่การขยายแนวดิ่งอาจมีราคาแพงกว่าในการอัปเกรด เนื่องจากหน่วยการประมวลผลพื้นฐานไม่สามารถแยกออกได้ง่ายเหมือนกับการขยายแนวนอน การขยายแนวนอนมีความซับซ้อนในการจัดการมากกว่าและบางครั้งมีความยากลำบากหรือ latency ที่เกี่ยวข้องกับการเชื่อมต่อระหว่าง node แต่มันปรับตัวได้มากกว่าต่อความต้องการทรัพยากรที่หลากหลายและเป็นแบบ modular เมื่อต้องการอัปเกรด

ทรัพยากรประเภทใหม่: QPU (Quantum Processing Unit)

ในส่วนนี้ เราจะแนะนำทรัพยากรประเภทใหม่ — ทรัพยากรควอนตัม — และสำรวจนิยาม หน่วยวัด และการเชื่อมต่อกับโครงสร้างพื้นฐานคลาสสิก

นิยามของ QPU

• Quantum processing unit (QPU): QPU รวมถึงฮาร์ดแวร์ทั้งหมดที่รับผิดชอบในการรับ executable quantum instruction set หรือ quantum circuit และส่งคืนคำตอบที่แม่นยำ

นั่นหมายความว่า QPU รวมถึง quantum chip หนึ่งตัวหรือมากกว่า (เช่น Heron) ส่วนประกอบเพิ่มเติมหลายอย่างใน dilution refrigerator เช่น quantum amplifier, control electronics และการประมวลผลคลาสสิกที่ต้องการสำหรับงานต่างๆ เช่น การเก็บคำสั่งและ waveform ในหน่วยความจำ การสะสมผลลัพธ์ และการถอดรหัส error correction ในอนาคต แม้ว่า dilution refrigerator จะต้องการสำหรับงานเหล่านี้ แต่เราไม่รวม dilution refrigerator ในนิยามนี้เพื่อให้รองรับกรณีที่มี QPU หลายตัวใน refrigerator เดียวกัน

• คอมพิวเตอร์ควอนตัม: คอมพิวเตอร์ควอนตัมประกอบด้วย QPU บวกกับการประมวลผลคลาสสิกที่ host runtime environment

• Runtime environment: การรวมกันของฮาร์ดแวร์และซอฟต์แวร์ที่ทำให้เป็นไปได้ที่จะรันโปรแกรม

Layer ใน quantum circuit

ทั้งในการประมวลผลคลาสสิกและควอนตัม process อาจดำเนินการตามลำดับหรือแบบขนาน เนื่องจาก qubit มี state space ที่สมบูรณ์กว่า classical bit บางครั้งก็เหมาะสมที่จะดำเนินการ single-qubit gate หลายตัวบน qubit ตามลำดับ (เช่น R_x gate ตามด้วย R_z gate) เนื่องจาก entanglement ระหว่าง qubit มีความสำคัญต่อควอนตัมคอมพิวติ้ง จึงเป็นเรื่องปกติที่ quantum circuit จะมีชุดของ entangling gate ที่ดำเนินการข้าม qubit จำนวนมาก ปัจจัยเหล่านี้และปัจจัยอื่นๆ ทำให้เป็นเรื่องปกติที่จะระบุ process ที่สามารถดำเนินการแบบขนานในระดับของ gate operation แต่ละตัวใน quantum circuit ใน classical computing bit-level parallelism ก็เป็นไปได้เช่นกันแต่พิจารณากันน้อยกว่าในระดับ gate มักอ้างถึง parallel และ sequential process ในระดับที่ใหญ่กว่า

ในควอนตัมคอมพิวติ้ง หนึ่งอ้างถึง "layer" ของ gate ที่สามารถดำเนินการพร้อมกันได้ ในการประยุกต์ใช้หลายอย่าง มักเป็นประโยชน์ที่จะดำเนินการชุดของการหมุนบน qubit ทั้งหมดแล้วตามด้วย entangling gate ระหว่างคู่ qubit ในบริบทเหล่านี้ หนึ่งอ้างถึง "rotation layer" (layer ของ gate อย่าง R_x, R_y และ/หรือ R_z) และ "entangling layer" (เช่น ที่มี CNOT gate) จำนวน layer ใน circuit คือ "circuit depth" ซึ่งเป็นหน่วยวัดสำคัญเนื่องจาก depth ที่มากขึ้นหมายถึง layer ของ noise และข้อผิดพลาดที่สะสมมากขึ้น

อาจเป็นเรื่องยากที่จะระบุ gate layer ด้วยสายตาเมื่อ layer ไม่ได้ถูกจัดเรียงโดยใช้ barrier ใน Qiskit barrier ทำหน้าที่เป็นคำสั่งใน quantum circuit ที่ทำหน้าที่เป็น visual separator และข้อจำกัดระหว่างการ compile ทั้งในการวาด circuit และการดำเนินการ gate จะไม่ถูกย้ายข้าม barrier สิ่งนี้อาจมีความสำคัญในบริบทอย่าง dynamical decoupling ซึ่งหนึ่งจงใจนำ gate ที่ simplify ไปเป็น identity เพื่อกด error type บางอย่าง สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ dynamical decoupling ดูคู่มือนี้ สำหรับผลทางภาพของ barrier เปรียบเทียบสองภาพของ circuit เดียวกัน ภาพแรกไม่มี barrier และภาพที่สองมี barrier เพื่อบังคับการจัดเรียง layer

นี่คือ circuit เดียวกันและมีจำนวน layer เท่ากัน แต่ในแบบที่สอง การจัดเรียงทำให้เห็นได้ง่ายว่า circuit มี:

• Rotation layer สองตัว: หนึ่งรอบแกน Y โดย $\pi/5$ หนึ่งรอบแกน Z โดย $\pi/4$
• Entangling layer สามตัว สังเกตว่าหนึ่งสามารถเรียก CNOT แต่ละตัวว่า "layer" ของตัวเอง เนื่องจาก CNOT ไม่สามารถจัดลำดับใหม่ให้ขนานกันได้โดยไม่เปลี่ยนการดำเนินการทางตรรกะ
• Rotation layer อีกสองตัว: หนึ่งรอบแกน Y โดย $\pi/3$ หนึ่งรอบแกน Z โดย $\pi/2$
• Entangling layer อีกสองตัว สังเกตว่าคราวนี้ layer แรกถูก parallelize มากกว่าชุดแรกของ entangling layer เล็กน้อย

Depth ของ circuit แต่ละอันคือ 9

หน่วยวัด

ในควอนตัมคอมพิวติ้ง ความสามารถของระบบควอนตัมมักได้รับการประเมินโดยใช้ตัวชี้วัดประสิทธิภาพหลักสามตัว: scale, quality และ speed ตัวชี้วัดเหล่านี้ไม่เพียงแต่อธิบายศักยภาพการประมวลผลของอุปกรณ์ควอนตัม แต่ยังแจ้งวิธีการจัดการและจัดตารางทรัพยากรในการประยุกต์ใช้จริง

• Scale หมายถึงจำนวน quantum bit (qubit) ในระบบ แทนจำนวนข้อมูลควอนตัมที่อุปกรณ์สามารถรองรับได้ ในการจัดการทรัพยากร สิ่งนี้ส่งผลโดยตรงต่อความกว้างของ circuit — จำนวน qubit ที่ต้องการสำหรับงานควอนตัมที่กำหนด หน่วยควอนตัมต้องมี qubit เพียงพอเพื่อรองรับงานที่กำหนด

• Quality อธิบายความแม่นยำของการดำเนินการควอนตัม มักถูกวัดด้วย layer fidelity ซึ่งวัดความแม่นยำของการดำเนินการ quantum gate layer เต็มรูปแบบข้าม qubit ทั้งหมด จากมุมมองการจัดตารางเวลา fidelity ที่สูงขึ้นช่วยให้ดำเนินการ circuit ที่ลึกขึ้นได้อย่างน่าเชื่อถือ ส่งผลต่อความต้องการ error mitigation หรือการแยกงาน

• Speed วัดด้วย CLOPS (Circuit Layer Operations Per Second) ซึ่งบ่งบอกว่าระบบสามารถดำเนินการ quantum operation layer ได้กี่ layer ต่อวินาที สิ่งนี้ส่งผลต่อ throughput และ latency ในการดำเนินงาน และช่วยกำหนดว่าหน่วยควอนตัมสามารถทำ workload ที่กำหนดได้เร็วแค่ไหน ความเร็วนี้มีความสำคัญเป็นพิเศษบนคอมพิวเตอร์ควอนตัม เนื่องจาก qubit มีสัญญาณรบกวนและข้อผิดพลาดในระดับที่มากกว่า classical counterpart ระยะเวลาที่ qubit สามารถรักษาข้อมูลควอนตัมในแบบที่มีประโยชน์ได้อธิบายด้วย coherence time โดยทั่วไปอยู่ในระดับ 200-300 $\mu\text{s}$ สำหรับ Heron r3 processor

ความแตกต่างระหว่างตัวชี้วัดควอนตัมและคลาสสิก

คุณอาจคิดว่า CLOPS เป็น analog ควอนตัมแบบหลวมๆ ของ FLOPS แต่มีความแตกต่างบางอย่าง CLOPS วัดความเร็วที่ quantum processor สามารถดำเนินการ quantum circuit ได้ โดยเฉพาะ layer ของการดำเนินการภายใน circuit รวมถึงทั้งการประมวลผลควอนตัมและคลาสสิกที่จำเป็นสำหรับการรัน circuit มันถูกพัฒนาโดย IBM Quantum เป็นตัววัดความเร็วการดำเนินการของคอมพิวเตอร์ควอนตัมแบบองค์รวม ครอบคลุมเวลาดำเนินการควอนตัมและการประมวลผลคลาสสิก real-time ที่จำเป็นสำหรับการอัปเดต circuit ต่างจาก FLOPS ที่วัดความสามารถ floating-point arithmetic ของ classical processor ล้วนๆ

CLOPS ให้ตัวชี้วัดประสิทธิภาพที่วัดได้ซึ่งสามารถ benchmark บนฮาร์ดแวร์ที่มีอยู่ IBM Quantum ใช้ CLOPS เพื่อ benchmark quantum processor ต่างๆ และค่าต่างๆ สามารถพบได้บนหน้า Compute resources บน IBM Quantum Platform ค่า CLOPS ขึ้นอยู่กับความสามารถของฮาร์ดแวร์ ความเร็วของ gate ความเร็วการประมวลผลคลาสสิก และการบูรณาการของสิ่งเหล่านั้น

จำนวน qubit เป็นตัวเลขคงที่สำหรับ QPU ที่กำหนด CLOPS และ quality ขึ้นอยู่กับการสอบเทียบและการบำรุงรักษาอย่างสม่ำเสมอและอาจแปรปรวนเล็กน้อยตามเวลา แม้แต่สำหรับ QPU เดียว

ร่วมกัน ตัวชี้วัดเหล่านี้แนะนำวิธีการจัดสรรและจัดตารางระบบควอนตัม ในหลายกรณี ระบบควอนตัมทั้งหมดถูกถือเป็นหน่วยเดียว อย่างไรก็ตาม เมื่องานเกินความสามารถของหน่วยเดียว — ไม่ว่าจะในแง่ของจำนวน qubit, circuit depth หรือความเร็วการดำเนินการ — เทคนิคอย่าง circuit cutting/knitting สามารถใช้ได้ Circuit cutting คือกระบวนการแบ่งงานควอนตัมขนาดใหญ่ออกเป็นงานย่อยที่จัดการได้ที่สามารถกระจายไปยัง quantum chip หลายตัว ช่วยให้การประมวลผลควอนตัมแบบขยายขนาดได้แม้จะมีข้อจำกัดด้านฮาร์ดแวร์ Circuit knitting หมายถึงกระบวนการที่มาหลังจาก circuit cutting — ขั้นตอน classical post-processing ที่ "knit" หรือรวมผลลัพธ์จาก subcircuit ขนาดเล็กกลับเข้าด้วยกัน

คอมพิวเตอร์ควอนตัมไม่มีหน่วยความจำแบบดั้งเดิม ในแง่ของที่เก็บข้อมูลถาวรที่ระบุตำแหน่งได้อย่าง RAM หรือ GPU memory ทรัพยากรการประมวลผลคลาสสิกมี discrete bit ที่เก็บไว้ในหน่วยความจำ ช่วยให้สามารถบันทึก ดึงข้อมูล และนำมาใช้ซ้ำระหว่างการประมวลผล ทรัพยากรควอนตัมใช้ qubit ซึ่งไม่เก็บหน่วยความจำในแบบคลาสสิก แต่ qubit มีอยู่ในสถานะควอนตัมที่แทน superposition ของ 0 และ 1 พร้อมกัน ทำให้เกิด parallelism แบบ exponential ใน state space อย่างไรก็ตาม สถานะ qubit เปราะบางและไม่สามารถ clone หรืออ่านอย่างแน่ชัดในขั้นตอนกลางโดยไม่ collapse สถานะควอนตัม ดังนั้นพฤติกรรมคล้ายหน่วยความจำถาวรระหว่างการประมวลผลจึงไม่มีอยู่ qubit ต้องรักษา coherent state ตลอดการดำเนินการ และ "หน่วยความจำ" โดยพื้นฐานคือสถานะควอนตัมเอง หน่วยความจำคลาสสิกสามารถใช้ควบคู่กับ quantum processor ได้เท่านั้น ไม่ใช่เป็น quantum memory ภายใน นี่มีผลสำคัญ: ทรัพยากรการประมวลผลคลาสสิกสามารถนำผลลัพธ์ระหว่างกลางกลับมาใช้และเก็บได้อย่างอิสระ แต่ทรัพยากรควอนตัมไม่สามารถทำสิ่งนี้ได้โดยไม่มีการวัดที่จะรบกวนการประมวลผล

การเชื่อมต่อกับโครงสร้างพื้นฐานคลาสสิก

QPU สามารถเชื่อมต่อกับโครงสร้างพื้นฐานคลาสสิกผ่านเครือข่ายและ application programming interface (API) ต่างๆ ที่ช่วยให้นักพัฒนาซอฟต์แวร์สามารถโต้ตอบกับ QPU ได้ด้วยโปรแกรม API เหล่านี้มักถูกซ่อนอยู่เบื้องหลัง software development kit (SDK) และไลบรารี (เช่น Qiskit) และเปิดเผยให้นักวิทยาศาสตร์การประมวลผลในรูปแบบของ programming abstraction (เช่น Qiskit Primitives ที่เราจะพูดถึงในบทที่ 3: โมเดลการเขียนโปรแกรม)

ควรแยกความแตกต่างระหว่างการบูรณาการแบบ tight และ loose ของทรัพยากรควอนตัมและคลาสสิก ปัจจุบัน QPU ไม่ได้อยู่บน node เดียวกับทรัพยากรการประมวลผลคลาสสิก ในความเป็นจริง QPU ยังไม่ได้เชื่อมต่อผ่าน PCIe แต่ผ่านเครือข่าย สิ่งนี้อาจเปลี่ยนแปลงในอนาคต แต่มีความท้าทายทางวิศวกรรมที่เกี่ยวข้องกับสภาพแวดล้อมที่เหมาะสมสำหรับ QPU และทรัพยากรการประมวลผลคลาสสิก

การขยายขนาดทรัพยากรควอนตัม

การขยายขนาดทรัพยากรควอนตัมยังสามารถแบ่งเป็นแนวดิ่งและแนวนอน

• การขยายแนวดิ่งจะเป็นการเพิ่มจำนวน qubit ต่อ chip หรือปรับปรุง fidelity ของอุปกรณ์
• การขยายแนวนอนจะเป็นการเชื่อมต่อ chip ด้วย coupler หรือด้วย classical interconnect

ทดสอบความเข้าใจ

อะไรคือ analog ควอนตัมของ (a) bit ของข้อมูลแบบคลาสสิก และ (b) ความเร็วของ processor?

คำตอบ:

(a) Quantum bit หรือ qubit — หน่วยของข้อมูลซึ่งต่างจาก classical counterpart (ที่สามารถรับสถานะ 0 หรือ 1 เท่านั้น) สามารถอยู่ใน superposition ของ 0 และ 1 พร้อมกันได้

(b) Circuit layer operations per second หรือ CLOPS — จำนวนการดำเนินการตามลำดับที่ QPU สามารถดำเนินการได้ต่อวินาที รวมถึง interface บางอย่างกับทรัพยากรการประมวลผลคลาสสิก เช่น การโหลด parameter จาก circuit

การจัดการทรัพยากร

ทั้งทรัพยากร HPC และควอนตัมมีความล้ำค่าและซับซ้อน ต้องได้รับการจัดการอย่างรอบคอบ ในส่วนนี้ เราจะอธิบายวิธีการจัดการทรัพยากรสำหรับโปรแกรมของผู้ใช้ การจัดการทรัพยากรในโครงสร้างพื้นฐานการประมวลผลหมายถึงกระบวนการของ (1) การวางแผน (2) การจัดสรร และ (3) การควบคุม/การจัดการการใช้ทรัพยากรการประมวลผล เช่น CPU หน่วยความจำ storage และ network bandwidth เพื่อให้แน่ใจว่ามีการใช้ทรัพยากรอย่างมีประสิทธิภาพ

การวางแผน — การประมาณทรัพยากร

โปรแกรมใดๆ ใช้ทรัพยากร และการประมาณทรัพยากรที่ต้องการเป็นสิ่งสำคัญสำหรับการจัดการทรัพยากรอย่างมีประสิทธิภาพ ซึ่งรวมถึงการประมาณจำนวน CPU หน่วยความจำ และทรัพยากรอื่นๆ ที่จำเป็นในการดำเนินโปรแกรม เช่นเดียวกันนี้สามารถพูดได้สำหรับทรัพยากรควอนตัม อย่างไรก็ตาม ทรัพยากรควอนตัมมีอยู่ในขนาดที่แตกต่างอย่างสิ้นเชิง IBM Quantum® Heron r3 quantum processor มี 156 qubit เทียบกับ classical bit หลายพันล้านตัวบนแล็ปท็อปทั่วไป เวลาและค่าใช้จ่ายก็เป็นข้อพิจารณาด้วย ปัจจุบัน IBM Quantum มีแผนฟรี Open Plan ที่ให้ผู้ใช้สำรวจควอนตัมคอมพิวติ้งโดยใช้เวลา QPU 10 นาทีต่อเดือน องค์กรวิจัยบางแห่งต้องการเวลา QPU มากจนมีคอมพิวเตอร์ควอนตัม IBM เฉพาะในสถานที่

ขั้นตอนหนึ่งในการประมาณทรัพยากรที่ไม่ซ้ำกันกับควอนตัมคอมพิวติ้งคือ circuit depth ดังที่กล่าวไว้ก่อนหน้า quantum gate แต่ละตัวและช่วงเวลาหน่วงระหว่างการดำเนินการมาพร้อมกับ noise และความน่าจะเป็นของข้อผิดพลาด quantum circuit ที่ลึกขึ้น noise ก็ยิ่งมากขึ้น มีความละเอียดอ่อนสองประการในเรื่องนี้: two-qubit gate มีอัตราข้อผิดพลาดสูงกว่า single-qubit gate มาก ดังนั้นมักสามารถละเว้น single-qubit depth ได้ นอกจากนี้ qubit ทั้งหมดบน quantum chip ยังไม่ได้เชื่อมต่อกันโดยตรง บางครั้งข้อมูลต้องถูกสลับจาก qubit ไปยัง qubit เพื่อดำเนินการ entanglement ที่ต้องการ และกระบวนการสลับนี้เองก็ต้องการ two-qubit gate การสลับนั้นถูกจัดการในกระบวนการที่เรียกว่า "transpilation" ซึ่งเป็นกระบวนการที่ซับซ้อนที่ทำหน้าที่อื่นด้วย สิ่งนี้จะถูกอภิปรายในรายละเอียดเพิ่มเติมในบทเรียนถัดไป ปริมาณที่จำกัดที่เกี่ยวข้องจึงเป็น transpiled two-qubit depth สูงสุดที่แน่นอนที่จะได้ผลลัพธ์ fidelity สูงขึ้นอยู่กับ circuit แต่โดยใช้เทคนิค error mitigation สมัยใหม่ สามารถได้ผลลัพธ์ fidelity สูงด้วย transpiled two-qubit depth ที่ 80 ขึ้นไป

การจัดสรร — การจัดตารางเวลา

การจัดตารางเวลาคือกระบวนการจัดสรรทรัพยากรให้กับโปรแกรมและจัดการการดำเนินการ ซึ่งเกี่ยวข้องกับ:

• การ submit งาน: กระบวนการที่ผู้ใช้ส่งคำขอ (งาน) ไปยังระบบ HPC ระบุว่าต้องการงานการประมวลผลและทรัพยากรใดสำหรับการดำเนินการ
• การจัดสรรทรัพยากร: การกำหนดทรัพยากรระบบ HPC ที่มีอยู่ (เช่น node, CPU, หน่วยความจำ) ให้กับงานที่ submit ตามความต้องการ
• การดำเนินงาน: การรันงานการประมวลผลที่กำหนดโดยงานบนทรัพยากร HPC ที่ถูกจัดสรร

มี analog ของกระบวนการทั้งหมดเหล่านี้สำหรับคอมพิวเตอร์ควอนตัม

• งานถูก submit โดยผู้ใช้ โดยใช้ Qiskit Runtime และโดยทั่วไปใช้ Qiskit Runtime primitive อย่าง Sampler, Estimator หรืออื่นๆ
• ผู้ใช้เลือกจากรายการ Backend ที่พวกเขาสามารถเข้าถึงได้ รายการ Backend ที่มีอยู่ทั้งหมดสามารถดูได้บนหน้า Compute resources บน IBM Quantum Platform มักจะง่ายที่สุดที่จะใช้คอมพิวเตอร์ควอนตัมที่มีคิวน้อยที่สุด แต่มีกรณีที่อาจสำคัญที่จะใช้เครื่องเฉพาะเนื่องจากการพิจารณา device layout การทำซ้ำการคำนวณก่อนหน้า และอื่นๆ
• การดำเนินการงานควอนตัมคล้ายกับกรณี HPC แม้ว่าความแตกต่างบางอย่างได้ถูกระบุไว้แล้ว แต่บางส่วนก็ควรทบทวนที่นี่ QPU ปัจจุบันไม่ได้อยู่บน node เดียวกับทรัพยากรการประมวลผลคลาสสิกโดยทั่วไปแต่เชื่อมต่อผ่านเครือข่าย สิ่งนี้อาจมีผลต่อการจัดตารางเวลา นอกจากนี้ คอมพิวเตอร์ควอนตัมอาจมีเวลาคิวที่มีนัยสำคัญ และเวลาคิวเหล่านี้แปรปรวน ทำให้การควบคุมเวลาอย่างแม่นยำเป็นเรื่องยาก สถานการณ์นี้อาจแตกต่างสำหรับระบบ dedicated ซึ่งขึ้นอยู่กับการบริหารภายในของคอมพิวเตอร์ควอนตัม

การควบคุม/การจัดการ — การจัดการ workload

การจัดการ workload หรือที่เรียกว่า orchestration คือกระบวนการจัดการโปรแกรมหลายตัวและความต้องการทรัพยากร ซึ่งเกี่ยวข้องกับ:

• Resource provisioning: กระบวนการเตรียมและทำให้ทรัพยากร HPC พร้อมใช้งานสำหรับงาน รวมถึงการตั้งค่าฮาร์ดแวร์และซอฟต์แวร์ ดังที่เราจะเห็นในภายหลัง QPU คือทรัพยากรการประมวลผลที่สามารถ provision ได้เช่นเดียวกับทรัพยากร HPC แบบคลาสสิก พร้อมข้อจำกัดจากส่วนก่อนหน้า
• Job scheduling: กิจกรรมของซอฟต์แวร์ scheduler ในการตัดสินใจว่างานใดรัน เมื่อใด และบนทรัพยากรใด จัดการลำดับความสำคัญและคิวเพื่อใช้ระบบ HPC อย่างมีประสิทธิภาพ แม้ว่าคำกล่าวกว้างๆ นี้จะใช้กับทรัพยากรควอนตัม แต่อาจมีการควบคุมเวลาน้อยกว่าทรัพยากรอื่นๆ

ตัวอย่าง:

พิจารณางานที่รู้จักกันดีเป็นบริบทสำหรับการเข้าใจการจัดการทรัพยากร: การหาตัวประกอบจำนวนเฉพาะของตัวเลขขนาดใหญ่ ให้สมมติเพิ่มเติมว่าอัลกอริทึมที่ใช้อาศัยการตรวจสอบทุก divisor ที่เป็นไปได้แบบ brute force แม้ว่านี่จะไม่ใช่วิธีที่มีประสิทธิภาพที่สุดเสมอไป แต่ก็เข้าใจง่ายว่า workload อาจถูกจัดการอย่างไร

การวางแผน — การประมาณทรัพยากร

• ประมาณว่าการ factorize จำนวนเฉพาะต้องการเวลา CPU และหน่วยความจำเท่าใด
• วางแผนการ parallelize งานของคุณ — คุณจะใช้ CPU/core กี่ตัว?

การจัดสรร — การจัดตารางเวลา

• เมื่อ submit งาน scheduler จัดสรร CPU core และหน่วยความจำให้กับงาน factorize จำนวนเฉพาะ ตัวอย่างเช่น อาจจัดสรร divisor ที่เป็นไปได้ทั้งหมดที่ลงท้ายด้วยตัวเลข 1, 3, 7, 9 ให้กับ core สี่ตัวตามลำดับ
• การดำเนินงาน: อัลกอริทึม factorize จำนวนเฉพาะรัน ดำเนินการหาร หรือขั้นตอน factorize อื่นๆ บนทรัพยากรที่จัดสรรจนงานเสร็จสมบูรณ์

การควบคุม/การจัดการ — การจัดการ workload

• ระบบประสานงานลำดับและเวลาของงาน factorize จำนวนเฉพาะเพื่อเพิ่ม throughput ให้สูงสุด
• กรณีที่ง่ายที่สุดที่จะนึกถึงคือ core หนึ่งพบตัวประกอบจำนวนเฉพาะเป้าหมาย ควรหยุดการคำนวณบน core อื่นๆ เพื่อให้ใช้งานได้สำหรับงานถัดไป

สภาพแวดล้อม HPC ใช้ซอฟต์แวร์พิเศษในการดำเนินขั้นตอนเหล่านี้และจัดการทรัพยากร ในส่วนถัดไป เราจะเรียนรู้เกี่ยวกับระบบซอฟต์แวร์การจัดการทรัพยากรที่นำมาใช้กันอย่างแพร่หลาย: Slurm

ตัวอย่างกับทรัพยากรควอนตัม:

เวิร์กโฟลว์ที่จะเป็นหัวข้อของบทเรียนอื่นๆ ในคอร์สนี้คือการหาสถานะพื้นฐานและพลังงานทางเคมีโดยใช้ sample-based quantum diagonalization (SQD) ซึ่งครอบคลุมอย่างละเอียดในบทเรียนที่ 4 และคุณสามารถเยี่ยมชมคอร์สนี้เกี่ยวกับ SQD และวิธีการที่เกี่ยวข้องบน IBM Quantum Learning สิ่งที่เราต้องทราบสำหรับการอภิปรายนี้คือเวิร์กโฟลว์เกี่ยวข้องกับ:

• เตรียม quantum circuit
• วัด quantum circuit
• ใช้ผลการวัดเพื่อ project ปัญหาเข้าไปใน subspace ที่มีประโยชน์
• Diagonalize matrix ที่เล็กกว่าที่ถูก project โดยใช้ทรัพยากรการประมวลผลคลาสสิก
• การวนซ้ำ ทั้งเพื่อให้แน่ใจ self-consistency ผ่านการพิจารณาอย่าง charge conservation และการวนซ้ำที่เป็นไปได้ของ quantum circuit หากมี variational parameter

การวางแผน — การประมาณทรัพยากร

• แมป electronic orbital ไปยัง qubit เพื่อกำหนดจำนวน qubit ที่คุณต้องการ
• รวม Hamiltonian ที่ถูกแมปของระบบและสถานะ (อาจเป็นแบบ variational) เข้าใน quantum circuit และตรวจสอบ transpiled two-qubit depth ที่ถูก transpile ให้แน่ใจว่าสมเหตุสมผล
• ประมาณขนาดของ subspace ที่คุณจะ project เข้าไป จากนี้ ประมาณว่าการ diagonalize ต้องการเวลา CPU และหน่วยความจำเท่าใด
• วางแผนการ parallelize งานของคุณ — คุณจะใช้ CPU/core กี่ตัว?

การจัดสรร — การจัดตารางเวลา

• ผู้ใช้เลือก QPU กระบวนการ transpilation แมป qubit ใน abstract quantum circuit ของคุณไปยัง physical qubit บน QPU โดยอัตโนมัติ สิ่งนี้มีความสำคัญเนื่องจาก abstract circuit อาจสมมติการเชื่อมต่อโดยตรงที่ไม่มีบน chip รวมถึงเหตุผลอื่นๆ
• เมื่อ submit งานผ่าน Qiskit Runtime งานเข้าคิวสำหรับ QPU ที่เลือก ผู้ใช้ไม่มีการควบคุมเวลาคิว แม้ว่าอาจแตกต่างสำหรับระบบ dedicated
• ทรัพยากรการประมวลผลคลาสสิกรอผลควอนตัม
• งาน diagonalization ถูก submit ให้กับทรัพยากร HPC เมื่อ submit งาน scheduler กำหนด CPU core และหน่วยความจำให้กับงาน diagonalization
• การดำเนินงาน: อัลกอริทึม diagonalization รัน diagonalize matrix ที่ถูก project ขนาดเล็กกว่าจนงานเสร็จสมบูรณ์

การควบคุม/การจัดการ — การจัดการ workload

• ระบบประสานงานลำดับและเวลาของขั้นตอนควอนตัมและคลาสสิกตลอด ตัวอย่างเช่น เมื่อ matrix ที่ถูก project ถูก diagonalize แล้วและได้พลังงานสถานะพื้นฐาน ขึ้นอยู่กับเกณฑ์การ convergence เวิร์กโฟลว์อาจวนกลับไปยัง quantum circuit ใหม่ (พร้อม variational parameter ใหม่)
• เมื่อเกณฑ์การ convergence ถูกตอบสนองโดยพลังงานสถานะพื้นฐาน การคำนวณบน core ทั้งหมดจะหยุด

สภาพแวดล้อม HPC ใช้ซอฟต์แวร์พิเศษในการดำเนินขั้นตอนเหล่านี้และจัดการทรัพยากร ในส่วนถัดไป เราจะเรียนรู้เกี่ยวกับระบบซอฟต์แวร์การจัดการทรัพยากรที่นำมาใช้กันอย่างแพร่หลาย: Slurm สิ่งสำคัญคือต้องสังเกตว่า Slurm ไม่มีเครื่องมือสำหรับทุกขั้นตอนที่อธิบายข้างต้น Slurm ไม่รองรับการวางแผนงาน หรือการจัดการ workload โดยละเอียดอย่างการสื่อสารระหว่างส่วนประกอบ workload สิ่งนี้เหมาะสมกับสถานะปัจจุบันของควอนตัมคอมพิวติ้งใน HPC เนื่องจาก QPU โดยทั่วไปเข้าถึงผ่านเครือข่าย

ทดสอบความเข้าใจ

สมมติว่าคุณกำลังค้นหาในฐานข้อมูลที่ไม่ได้เรียงลำดับเพื่อหาองค์ประกอบที่เราจะเรียกว่า 'เป้าหมาย' สำหรับแต่ละการกระทำต่อไปนี้ ระบุว่าสอดคล้องกับขั้นตอนใดของการจัดการทรัพยากร: (a) การประมาณขนาดของฐานข้อมูลและเวลาที่ต้องการในการตรวจสอบแต่ละองค์ประกอบ (b) การทำให้แน่ใจว่าการพบเป้าหมายบน GPU หนึ่งตัวจะหยุดกระบวนการบน GPU อื่นๆ เพื่อเพิ่มพื้นที่ว่างสำหรับปัญหาถัดไป (c) การแบ่ง search space ออกเป็นพื้นที่สำหรับ GPU แต่ละตัว (สมมติว่ามี 10 ตัว) เพื่อค้นหา

คำตอบ:

(a) การวางแผน (b) การควบคุม/การจัดการ (c) การจัดสรร/การจัดตารางเวลา

ซอฟต์แวร์: Slurm

ในส่วนนี้ เราจะนำแนวคิดที่เรียนรู้ในบทนี้ไปใช้ฝึกใช้งานระบบการจัดการทรัพยากรที่ได้รับความนิยม: Slurm

บทนำสู่ Slurm

Slurm คือระบบการจัดการทรัพยากรแบบ open-source ที่ใช้กันอย่างแพร่หลายในสภาพแวดล้อม HPC มันมีชุดเครื่องมือที่ครอบคลุมสำหรับการจัดการทรัพยากร การจัดตารางงาน และการตรวจสอบประสิทธิภาพระบบ

เราจะครอบคลุมพื้นฐานของการใช้ Slurm รวมถึง:

• การ submit งาน
• การจัดสรรทรัพยากร
• การตรวจสอบงาน

เนื่องจากการให้ทรัพยากร HPC แก่นักเรียนแต่ละคนในคอร์สนี้เป็นเรื่องยากมาก เราจะ "โกง" นิดหน่อยและให้ repository พร้อม Docker image ที่จำลอง HPC cluster จริงพร้อม Slurm แต่ในขนาดเล็ก สิ่งนี้จะช่วยให้เราฝึกแนวคิดที่เรียนรู้ในสภาพแวดล้อมที่ปลอดภัยและทำซ้ำได้

สังเกตว่าปัจจุบันทรัพยากรทั้งควอนตัมและคลาสสิกถูกจัดสรรตลอดระยะเวลาของการทดลองทั้งหมด ปัจจุบันไม่มีการจัดสรรแบบ interleaved ของทรัพยากรผสม ข้อจำกัดสุดท้ายคือแม้เมื่องานเริ่มต้นแล้ว ระบบควอนตัมจะไม่ถูกควบคุมโดยตรงตามที่ผู้ใช้ HPC ทั่วไปอาจคาดหวัง งานถูกเปิดบน x86-node สุ่ม ซึ่งดำเนินการ Qiskit Runtime service และ runtime service นั้นเชื่อมต่อกับ scheduler อีกตัวที่ผู้ใช้ไม่มีการควบคุมโดยตรง เวิร์กโฟลว์และปัญหาที่เกี่ยวข้องนี้อาจเป็นที่รู้จักสำหรับผู้ใช้ HPC ที่มีประสบการณ์ในช่วงแรกที่ขอ exclusive access สู่ GPU node (การใช้ดั้งเดิมของ gres)

คำแนะนำการติดตั้งและภาพรวมของการตั้งค่า

เพื่อฝึกการรวมทรัพยากรควอนตัมและ HPC คุณจะต้องเข้าถึงสภาพแวดล้อม HPC จริงหรือจำลองสภาพแวดล้อม HPC บนเครื่องของคุณ คู่มือการติดตั้งสำหรับการตั้งค่าในเครื่องโดยใช้ Docker สามารถพบได้ในrepository นี้ คู่มือนี้ลิงก์ไปยังการสนับสนุนสำหรับการตั้งค่าบัญชี IBM Cloud® และการติดตั้ง SPANK plugin สำหรับ QRMI นอกจากนี้ใน repository นั้นยังมีไฟล์ Python หลายไฟล์เพื่อทดสอบสภาพแวดล้อมของคุณ

เมื่อติดตั้งเสร็จแล้ว ใช้คำสั่งด้านล่างเพื่อตรวจสอบ compute resource ของ Slurm ที่ terminal ของคุณ หากการติดตั้งสำเร็จ คุณควรยืนยันได้ว่ามี 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
...

เรามีสอง partition หรือกลุ่ม node: normal และ quantum partition normal ประกอบด้วย node ที่เข้าถึงได้เฉพาะทรัพยากรคลาสสิก quantum partition เข้าถึงทรัพยากรควอนตัมได้ คุณสามารถดูรายละเอียดของแต่ละ node โดยรัน scontrol show nodes

รัน hello world ง่ายๆ ใน Slurm

ก่อนอื่น ให้รันตัวอย่าง classical hello world ง่ายๆ กับ Slurm เราจะใช้ Python สำหรับตัวอย่าง ให้สร้าง hello_world.py ซึ่งอธิบายตัวเองได้

$ vim hello_world.py

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

ตอนนี้เราต้องบอก resource manager ว่าเราต้องการทรัพยากรใดในการดำเนินโปรแกรมนี้ Slurm มีวิธีระบุ metadata ทั้งหมดสำหรับงานผ่าน submission script ซึ่งก็แค่ shell script พร้อม annotation เฉพาะ Slurm Annotation เหล่านี้ช่วยให้คุณระบุความต้องการทรัพยากร schedule parameter และอื่นๆ ได้ ให้สร้าง shell script hello_world.sh สำหรับสิ่งนี้

$ 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
~

ไปดู submission file และดูว่าเกิดอะไรขึ้นที่นี่

#SBATCH directive คือ annotation เฉพาะเพื่อบอกความต้องการในการดำเนินโปรแกรม ที่นี่คุณสามารถระบุจำนวนทรัพยากร — จำนวน node จำนวน task ต่อ node จำนวน task และ CPU ต่อ node และ task — และตัวเลือกอื่นๆ เช่น ชื่อของไฟล์ output รายการตัวเลือกทั้งหมดมีอยู่ในเอกสารสำหรับ Slurm

ตอนนี้ถึงเวลารัน Slurm job ของเรา sbatch คือคำสั่งที่รับ submission file และเพิ่มงานเข้าคิวเพื่อดำเนินการใน Slurm

$ sbatch hello_world.sh

Submitted batch job 63

ให้ตรวจสอบสถานะของโปรแกรมโดยใช้คำสั่ง squeue

$ squeue

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

เมื่องานเสร็จสิ้น เราสามารถตรวจสอบผลลัพธ์โดยดูที่ไฟล์ output

$ cat hello_world_logs.txt
Hello, World!

ทดสอบความเข้าใจ

จาก Slurm shell script ด้านล่าง อะไรคือ (a) ชื่อของงาน (b) ชื่อของไฟล์ Python และ (c) ชื่อของไฟล์ output? (d) สุดท้าย สิ่งนี้สามารถใช้ทรัพยากรควอนตัมได้หรือไม่?

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

คำตอบ:

(a) hello-learner (b) hello-learner_qm.py (c) hello-learner.out (d) ได้ สามารถทำได้ มันใช้ quantum partition

รันตัวอย่าง Qiskit hello world ง่ายๆ ใน Slurm

ต่อไป ให้ลองใช้ทรัพยากรควอนตัมด้วย ให้สร้างและรันโปรแกรม "Hello, Qiskit" ง่ายๆ ที่ใช้ทรัพยากรควอนตัม

$ 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)

ที่นี่เราจะใช้ quantum resource management interface (QRMI) ซึ่งเป็น Slurm SPANK plugin สำหรับการรองรับทรัพยากรและงานควอนตัมที่พัฒนาร่วมกันโดย IBM, Pasqal, The Hartree Center และ RPI เราสร้าง simple pauli-2-design circuit พร้อม initial value สุ่มและ observable ง่ายๆ และเราจะรันโดยใช้ Estimator เพื่อรับ expectation value เพื่อรัน เราจะต้องการ submission script hello_qiskit.sh อีกครั้ง ซึ่งจะมีทรัพยากรควอนตัมเป็นความต้องการ

$ 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
~

มาดู submission file และดูว่าเกิดอะไรขึ้นที่นั่น เรามีตัวเลือกใหม่หนึ่งตัวคือ gres gres คือตัวเลือก Slurm เพื่อกำหนดทรัพยากรการประมวลผลพิเศษ ในกรณีนี้ทรัพยากรใหม่จะเป็นทรัพยากรควอนตัมของเรา เนื่องจากเราระบุทรัพยากรและ partition ของ cluster ที่มีทรัพยากรควอนตัม Qiskit primitives ของเราจะใช้ทรัพยากรที่จัดสรรเหล่านี้เพื่อดำเนินการ quantum payload

ตอนนี้ถึงเวลารัน Slurm job ของเรา

$ sbatch hello_qiskit.sh

จากนั้น ให้ตรวจสอบสถานะของโปรแกรมโดยใช้คำสั่ง squeue

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

เราสามารถดู log และผลลัพธ์หลังจากงานเสร็จสิ้น

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

สรุป

จนถึงตอนนี้ เราได้เรียนรู้ว่าทรัพยากรการประมวลผลคืออะไรและวิธีใช้เพื่อรันโปรแกรมในสภาพแวดล้อมแบบ heterogeneous เราได้สร้างและดำเนินการโปรแกรม 'Hello World' สองโปรแกรม: โปรแกรมหนึ่งสำหรับทรัพยากรคลาสสิกและอีกโปรแกรมสำหรับทรัพยากรควอนตัม และเราได้เรียนรู้วิธีสร้าง shell script เพื่อ submit งานและดูผลลัพธ์

ในบทเรียนต่อไป เราจะสร้างความรู้เกี่ยวกับการควบคุมทรัพยากรนี้เพื่อนำโมเดลการเขียนโปรแกรมไปใช้กับทรัพยากรที่เราได้รับระหว่างการดำเนินงาน

โค้ดและสคริปต์ทั้งหมดที่ใช้ในบทนี้พร้อมให้ใช้งานภายในGitHub repositoryของเรา