โมเดลการเขียนโปรแกรม

โมเดลการเขียนโปรแกรมคือข้อกำหนดพื้นฐานที่กำหนดวิธีการสร้างและดำเนินการซอฟต์แวร์ โมเดลเหล่านี้ให้กรอบการทำงานสำหรับนักพัฒนาในการแสดงอัลกอริทึมและจัดระเบียบโค้ด โดยมักจะสรุปรายละเอียดระดับต่ำของฮาร์ดแวร์หรือสภาพแวดล้อมการดำเนินการที่อยู่เบื้องหลัง โมเดลที่แตกต่างกันเหมาะสำหรับปัญหาและสถาปัตยกรรมฮาร์ดแวร์ที่แตกต่างกัน โดยมีระดับของการสรุปและการควบคุมที่หลากหลาย

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

โมเดลการเขียนโปรแกรมสำหรับ QPU

เราจะเริ่มต้นด้วยโมเดลการเขียนโปรแกรมสำหรับคอมพิวเตอร์ควอนตัม โมเดลการเขียนโปรแกรมพื้นฐานที่นักพัฒนาควอนตัมแทบทุกคนรู้จักคือ quantum circuit (วงจรควอนตัม) เราจะไม่ลงลึกในรายละเอียดของโมเดล quantum circuit ที่นี่ เนื่องจากเรามีการบรรยายโดย John Watrousที่อธิบายเรื่องนี้อย่างละเอียดแล้ว เราจะกล่าวเพียงว่า Circuit สร้างขึ้นจากชุดของเส้น (เรียกว่า wire) ที่แทน qubit, gate ที่แทนการดำเนินการบนสถานะควอนตัม และชุดของการวัด

แนวคิดโมเดลการเขียนโปรแกรมที่สำคัญอีกอย่างสำหรับควอนตัมคอมพิวติ้งคือสิ่งที่เราเรียกว่า computational primitives ซึ่งเป็นตัวแทนของงานทั่วไปที่สุดที่ผู้ใช้ต้องการทำกับคอมพิวเตอร์ควอนตัม ขณะนี้มี primitives หลายตัว รวมถึง Executor ในคอร์สนี้เราจะเน้นที่ primitives Sampler และ Estimator เป็นหลัก Sampler ให้ความสามารถในการสุ่มตัวอย่างสถานะที่เตรียมโดย quantum circuit ซึ่งบอกว่า computational basis states ใดที่ประกอบขึ้นเป็นสถานะควอนตัมที่เตรียมบน quantum circuit ของคุณ Estimator ช่วยให้คุณประมาณค่าความคาดหวังของ observable สำหรับระบบในสถานะที่เตรียมโดย quantum circuit ของคุณ บริบทที่พบบ่อยคือการประมาณพลังงานของระบบในสถานะเฉพาะ

สิ่งสุดท้ายที่เราจะพูดถึงในส่วนนี้คือ transpilation Transpilation คือกระบวนการเขียน Circuit ที่กำหนดขึ้นใหม่เพื่อให้ตรงกับข้อจำกัดทางกายภาพและ Instruction Set Architecture (ISA) ของอุปกรณ์ควอนตัมเฉพาะ คล้ายกับ compiler แบบคลาสสิก หมายความว่าการแปลงการดำเนินการ unitary แบบ abstract ไปเป็น native gate set ที่อุปกรณ์เป้าหมายสามารถดำเนินการได้ นอกจากนี้ยังปรับให้คำสั่ง Circuit มีประสิทธิภาพสำหรับการดำเนินการบนคอมพิวเตอร์ควอนตัมที่มีสัญญาณรบกวน โดยที่ routine ค่อยๆ เปลี่ยนโครงสร้างของ Circuit โดยใช้ขั้นตอนการเพิ่มประสิทธิภาพหลายขั้น

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

มี qubit กี่ตัวใน Circuit ด้านล่าง?

คำตอบ:

สี่ตัว

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

สมมติว่าคุณกำลังจำลองอิเล็กตรอนในโมเลกุล คุณต้องการประมาณ (a) พลังงานสถานะพื้นฐานของโมเลกุล และ (b) computational basis states ใดที่โดดเด่นที่สุดในสถานะพื้นฐานของโมเลกุล ในแต่ละกรณี คุณจะใช้ primitive Estimator หรือ Sampler?

คำตอบ:

(a) Estimator (b) Sampler

โมเดลการเขียนโปรแกรมแบบคลาสสิก

มีโมเดลการเขียนโปรแกรมสำหรับคอมพิวเตอร์คลาสสิกหลายแบบ แต่ในส่วนนี้เราจะเน้นที่สองแบบที่ได้รับความนิยมมากที่สุด ได้แก่ parallel programming และ task workflows การใช้โมเดลทั้งสองนี้ควบคู่กับโมเดลการเขียนโปรแกรมควอนตัม สามารถแสดงเวิร์กโฟลว์ quantum-classical แบบไฮบริดที่มีความซับซ้อนใดๆ ได้เกือบทั้งหมด

Parallel Programming

Parallel programming คือโมเดลที่แบ่งโปรแกรมออกเป็นปัญหาย่อยที่สามารถดำเนินการพร้อมกันได้ มีสองกระบวนทัศน์หลักของ parallel programming:

• Shared memory parallelism (Open Multiprocessing หรือ OpenMP): ใช้เพื่อใช้ประโยชน์จาก core หลายตัวภายใน compute node เดียว Thread ของการดำเนินการใช้ memory space เดียวร่วมกัน

• Distributed memory parallelism (Message Passing Interface หรือ MPI): ใช้สำหรับการขยายขนาดข้าม compute node แยกกันหลายตัว แต่ละ process มี memory space แยกของตัวเอง

ที่นี่ เราจะเน้นที่โมเดล distributed memory เนื่องจากมีความจำเป็นสำหรับ multi-node supercomputing และการประสานงานงาน quantum-classical แบบ heterogeneous ขนาดใหญ่

มีแนวคิดบางอย่างที่เราต้องเข้าใจเพื่อทำงานในโมเดล parallel programming แบบ distributed memory:

• Process — อินสแตนซ์อิสระของโปรแกรมที่มี memory space ของตัวเอง
• Rank — ตัวระบุจำนวนเต็มเฉพาะที่กำหนดให้กับแต่ละ process ใช้เพื่อระบุผู้ส่งและผู้รับระหว่างการสื่อสารโดยเฉพาะ (ไม่จำเป็นต้องหมายถึง "อันดับ" ในแง่ของการจัดลำดับความสำคัญ)
• Synchronization — กลไกสำหรับการประสานงานระหว่าง rank และ process ที่แตกต่างกัน
• Single program, multiple data (SPMD) — โมเดลการประมวลผลแบบ abstract ซึ่งโปรแกรม source code อินสแตนซ์เดียวทำงานพร้อมกันบน process หลายตัว โดยแต่ละตัวทำงานกับชุดข้อมูลย่อยที่แตกต่างกันของข้อมูลทั้งหมด
• Message passing — กระบวนทัศน์การสื่อสารที่ใช้ในสถาปัตยกรรม distributed memory ซึ่งช่วยให้ process อิสระแลกเปลี่ยนข้อมูลและผลลัพธ์ระหว่างกัน โดยอาศัยการดำเนินการ 'send' และ 'receive' อย่างชัดเจนเพื่อประสานงานการดำเนินการระหว่าง compute node ต่างๆ

มีมาตรฐานที่เรียกว่า MPI ซึ่งนำกระบวนทัศน์ message passing นี้ไปใช้กับสถาปัตยกรรมแบบขนาน MPI ทำหน้าที่เป็นตัวรวบรวมแนวคิดทั้งหมดที่ระบุไว้ข้างต้น โดยให้การเรียกไลบรารีที่เฉพาะเจาะจงที่จำเป็นสำหรับการจัดการ process การกำหนด rank การอำนวยความสะดวกในการ synchronization และการเปิดใช้งาน message passing ภายใต้โมเดล SPMD การรวบรวมแนวคิดทั้งหมดเหล่านี้ เราสามารถพูดได้ว่าการดำเนินการของโปรแกรมแบบขนานเกิดขึ้นในลักษณะดังต่อไปนี้:

• โปรแกรม compiled เดียว (ไฟล์ binary เดียวกัน) ถูกคัดลอกและดำเนินการโดย job launcher เพื่อสร้าง parallel process หลายตัวข้าม node หลายตัว
• การควบคุม flow หลักของโปรแกรมถูกกำหนดโดย rank ของ process นี่คือหลักการ SPMD ในการทำงาน: โปรแกรมใช้ conditional logic (เช่น if (rank == 0)) เพื่อให้แน่ใจว่าเฉพาะส่วนที่ถูก parallelize บางส่วนของโค้ดเท่านั้นที่ดำเนินการโดย worker process ในขณะที่ master process (มักเป็น Rank 0) จัดการการเริ่มต้นและการรวมผลลัพธ์สุดท้าย
• การสื่อสารระหว่าง process เกิดขึ้นผ่าน message passing (โดยใช้ MPI) ซึ่งถูกเรียกเมื่อใดก็ตามที่ process ต้องการแลกเปลี่ยนข้อมูลหรือผลลัพธ์ระหว่างกับ rank อื่น

ในเชิงภาพจะมีลักษณะประมาณนี้:

มาลองนำแนวคิดที่เพิ่งเรียนรู้ไปใช้กับโค้ดกัน

ขั้นแรก เราจะลองรัน "hello world" แบบขนานง่ายๆ โดยใช้ OpenMPI ซึ่งเป็น implementation ของ MPI protocol ซึ่งเป็นมาตรฐานสำหรับ message passing ใน parallel programming ที่นี่ เราจะใช้แพ็กเกจ Python mpi4py ซึ่งเป็น Python binding สำหรับมาตรฐาน Message Passing Interface (MPI)

$ vim mpi-hello-world.py

from mpi4py import MPI
import sys

comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()

sys.stdout.write(f"[Rank {rank}] Hello from process {rank} of {size}!\n")

if rank == 0:
    data = {'answer': 42, 'pi': 3.14}
    sys.stdout.write(f"[Rank {rank}] Sending: {data}\n")
    comm.send(data, dest=1, tag=42)
elif rank == 1:
    data = comm.recv(source=0, tag=42)
    sys.stdout.write(f"[Rank {rank}] Received: {data}\n")

~
~

เราจะใช้สอง node เพื่อรันโปรแกรมนี้ ซึ่งเราจะระบุในสคริปต์การ submit

$ vim mpi-hello-world.sh

#!/bin/bash
#
#SBATCH --job-name=mpi-hello-world
#SBATCH --output=mpi-hello-world.out
#SBATCH --nodes=2
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=1
#SBATCH --partition=normal

/usr/lib64/openmpi/bin/mpirun python /data/ch3/parallel/mpi-hello-world.py

จากนั้นรัน shell script

$ sbatch mpi-hello-world.sh

เราสามารถตรวจสอบ result log ของงานได้

$ cat mpi-hello-world.out | grep Rank

[Rank 1] Hello from process 1 of 2!
[Rank 0] Hello from process 0 of 2!
[Rank 0] Sending: {'answer': 42, 'pi': 3.14}
[Rank 1] Received: {'answer': 42, 'pi': 3.14}

ที่นี่เราใช้สอง node และ process บนแต่ละ node ตอนนี้ถูกระบุด้วย rank — Rank 0 และ Rank 1 — ซึ่งใช้ตัดสิน control flow ของโปรแกรม

Task Workflows

ต่อไปมาพูดถึงโมเดลการเขียนโปรแกรม Task workflow Task workflow เปลี่ยนการประมวลผลเป็น directed acyclic graph (DAG) ในกราฟนี้ แต่ละ node แทนงานหรือ job เฉพาะ และ edge (ลูกศรที่เชื่อม node) แทนการพึ่งพา (ข้อมูลและลำดับ) ระหว่างงานเหล่านั้น Scheduler คือส่วนประกอบที่แมปงานกับทรัพยากรและประสานงานการดำเนินการ

ตัวอย่างที่เป็นรูปธรรมของโมเดล task workflow ที่นำไปใช้กับควอนตัมคอมพิวติ้งคือ Qiskit patterns framework Qiskit pattern คือกรอบการทำงานทั่วไปที่ออกแบบมาเพื่อแบ่งปัญหาเฉพาะโดเมนออกเป็นลำดับขั้นตอน โดยเฉพาะสำหรับงานควอนตัม สิ่งนี้ช่วยให้การรวมกันได้อย่างราบรื่นของความสามารถใหม่ที่พัฒนาโดยนักวิจัย IBM Quantum® (และคนอื่นๆ) และเปิดใช้งานอนาคตที่งานควอนตัมดำเนินการโดยโครงสร้างพื้นฐานการประมวลผลแบบ heterogeneous (CPU/GPU/QPU) ที่ทรงพลัง สี่ขั้นตอนของ Qiskit pattern คือ mapping, optimization, execution และ post-processing ซึ่งงานทั้งหมดดำเนินการตามลำดับในรูปแบบ pipeline แต่ด้วย task workflows เราไม่ได้ถูกจำกัดไว้กับลำดับการดำเนินการแบบเชิงเส้นและสามารถดำเนินการงานแบบขนานได้ แต่ละงานของเวิร์กโฟลว์อาจเป็น parallel job ทั้งหมดในตัวเอง ดังนั้นคุณสามารถผสมและจับคู่โมเดลเหล่านี้เพื่ออธิบายอัลกอริทึมที่ซับซ้อนโดยพลการ และ workload manager อย่าง Slurm จะจัดการสิ่งเหล่านี้

ภาพด้านบนแสดง Qiskit pattern ในการทำงาน เวิร์กโฟลว์มีโครงสร้างกราฟที่มีสี่ขั้นตอน โครงสร้างแบบสาขานี้ถูกประสานงานและดำเนินการโดย scheduler ปัญหาถูกแมปเป็นรูปแบบที่ดำเนินการบนควอนตัมได้ (quantum circuit) ในขั้นตอนแรก ในขั้นตอนถัดไป quantum circuit นี้ถูกปรับให้เหมาะสมสำหรับฮาร์ดแวร์ควอนตัมเฉพาะ ภาพแสดงสิ่งนี้เป็น parallel process ซึ่งแสดงให้เห็นว่าสามารถใช้กลยุทธ์การเพิ่มประสิทธิภาพหลายแบบพร้อมกันได้ quantum circuit ที่ปรับให้เหมาะสมแล้วจะถูกดำเนินการบนฮาร์ดแวร์ควอนตัมจริง นี่คือขั้นตอนที่สามของภาพซึ่ง scheduler ทำงานกับหน่วยประมวลผลควอนตัมสีม่วงหนึ่งหน่วย สุดท้าย ผลลัพธ์จะถูก post-process โดยทรัพยากรคลาสสิก

ทำไมต้องทั้งสอง?

แล้วทำไมเราต้องใช้ทั้ง parallel programming และ task workflows? แม้จะมีการพูดมากเรื่อง quantum parallelism แต่ก็ควรชี้แจงว่าไม่ใช่ทุกอย่างที่เป็นแบบขนานในควอนตัมคอมพิวติ้ง

บทเรียนก่อนหน้าเกี่ยวกับเวิร์กโฟลว์ SQD กล่าวถึง process บางอย่างที่ไม่สามารถ parallelize ได้ ตัวอย่างเช่น เราต้องการผลลัพธ์ของการวัดควอนตัมจำนวนมากเพื่อ project matrix ของเราเข้าไปใน subspace ที่มีมิติที่จัดการได้ ในทางกลับกัน เราต้องการ matrix ที่ถูก diagonalize และ state vector ที่เกี่ยวข้องเพื่อตรวจสอบ self-consistency ของการวัดควอนตัม (โดยใช้ เช่น charge conservation) หลังจากนั้นทั้งหมด เราต้องตัดสินใจว่าพลังงานสถานะพื้นฐาน converge เพียงพอสำหรับวัตถุประสงค์ของเราหรือไม่ ขั้นตอนเหล่านี้จำเป็นต้องดำเนินการตามลำดับและต้องการการทดสอบเงื่อนไขการ convergence และ self-consistency ก่อนที่จะดำเนินการต่อ

เวิร์กโฟลว์นี้จะถูกทบทวนอย่างละเอียดและนำไปใช้ในส่วนถัดไป สิ่งเดียวที่คุณต้องได้จากส่วนนี้คือ task workflows เป็นสิ่งจำเป็น

Programming Practice

ความงดงามของโมเดลการเขียนโปรแกรมคือคุณสามารถผสมและจับคู่ได้ทั้งหมด เมื่อรู้จักโมเดลการเขียนโปรแกรมแบบควอนตัมและคลาสสิก คุณสามารถอธิบายการประมวลผลแบบ heterogeneous ที่มีความซับซ้อนใดๆ ก็ได้และดำเนินการบนฮาร์ดแวร์ มาฝึกกันด้วยตัวอย่างเล็กๆ ของเวิร์กโฟลว์ที่รวมกัน ซึ่งนำ Qiskit pattern (map, optimize, execute และ post-process) มาใช้ภายใน Slurm ที่เราเรียนรู้ในบทที่แล้ว แต่ละงานในสี่งานจะเป็น Slurm job แยกต่างหากพร้อมทรัพยากรของตัวเอง งาน optimization จะใช้ MPI เพื่อ optimize Circuit แบบขนาน (เพื่อเป็นตัวอย่างเท่านั้น เหมือนภาพด้านบน) งาน execution จะใช้ทรัพยากรควอนตัมและโมเดลการเขียนโปรแกรมควอนตัม (Circuit และ Sampler) งานสุดท้าย — post-processing — จะใช้ MPI แบบขนานอีกครั้งกับทรัพยากรคลาสสิก

Mapping

โปรแกรม mapping.py ออกแบบมาเพื่อสร้าง PauliTwoDesign circuit ซึ่งใช้กันทั่วไปในวรรณกรรม quantum machine learning และวรรณกรรม quantum benchmark พร้อม observable ง่ายๆ ที่วัด qubit ที่ $(n-1)^\text{th}$ ในทิศทาง $Z$ ของระบบ $n$-qubit ที่มี parameter เริ่มต้นแบบสุ่ม แต่ละอย่างเหล่านี้ (quantum circuit ที่แปลงเป็นไฟล์ qasm, observable และ parameter) จะถูกบันทึกลงในไฟล์แยกต่างหากภายใต้ data directory และจะถูกใช้เป็น input ในขั้นตอน optimization

Shell script ของขั้นตอนนี้ (mapping.sh) คือ

#!/bin/bash
#
#SBATCH --job-name=mapping
#SBATCH --output=mapping.out
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=1
#SBATCH --partition=normal

srun python /data/ch3/workflows/mapping.py

ซึ่งกำหนดชื่องาน รูปแบบ output และจำนวน node/task/CPU

Optimization

โปรแกรม optimization.py เริ่มต้นด้วยการนำไฟล์จากขั้นตอน mapping มา ที่นี่คุณจะใช้ QRMI เพื่อนำทรัพยากรควอนตัมเข้ามาในโปรแกรมนี้

qrmi = QRMI()
resources = qrmi.resources()
quantum_resource = resources[0]
...

จากนั้นดำเนินการ optimization แบบเบาๆ โดยตั้งค่า optimization_level=1 เพื่อ transpile quantum circuit และนำ layout ของ Circuit ไปใช้กับ observable แล้วบันทึกสิ่งเหล่านี้ไปยัง data folder

Shell script ของขั้นตอนนี้ (optimization.sh) คือ

#!/bin/bash
#SBATCH --job-name=optimization
#SBATCH --output=output/optimization.out
#SBATCH --ntasks=4
#SBATCH --partition=classical

srun python3 /tmp/optimization.py

ที่นี่ --ntasks=4 ร้องขอ classical task สี่ตัวจาก Slurm สำหรับ parallel process

Execution

นี่คือขั้นตอนควอนตัมหลักซึ่ง quantum circuit ที่ถูก optimize จากขั้นตอนก่อนหน้าถูกรันบน QPU โดย Estimator ในการทำสิ่งนี้ ขั้นแรกเราจะนำไฟล์สามไฟล์ — transpiled quantum circuit, observable และ initial parameter — แล้วส่งไปยัง Estimator มันจะให้ค่าประมาณของ observable และพิมพ์ออกมา

สคริปต์ execution.sh ใช้ประโยชน์จาก Slurm plugin เพื่อใช้ทรัพยากรควอนตัม

#!/bin/bash
#
#SBATCH --job-name=execution
#SBATCH --output=execution.out
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=1
#SBATCH --partition=quantum
#SBATCH --gres=qpu:1

srun python /data/ch3/workflows/execution.py

Post-processing

ขั้นตอน post-processing มักเกี่ยวข้องกับ classical diagonalization และการตรวจสอบ self-consistency นอกจากนี้อาจเป็นแบบวนซ้ำด้วย มีประโยชน์มากที่สุดที่จะพิจารณาขั้นตอน post-processing ในบทเรียนถัดไป ซึ่งบริบททางกายภาพและวัตถุประสงค์ของขั้นตอนแบบวนซ้ำมีความชัดเจน

รวบรวมทั้งหมดเข้าด้วยกัน

เราสามารถเชื่อมงานทั้งหมดเหล่านี้เป็นเวิร์กโฟลว์โดยใช้ argument dependency สำหรับคำสั่ง sbatch:

$ MAPPING_JOB=$(sbatch --parsable mapping.sh)
$ OPTIMIZE_JOB=$(sbatch --parsable --dependency=afterok:$MAPPING_JOB optimization.sh)
$ EXECUTE_JOB=$(sbatch --parsable --dependency=afterok:$OPTIMIZE_JOB execute.sh)

และเราสามารถตรวจสอบคิวการดำเนินการ Slurm ของเราได้

$ squeue
#             JOBID PARTITION     NAME     USER ST       TIME  NODES NODELIST(REASON)
#                 3 classical  mapping    admin PD       0:00      1 (None)
#                 4 classical optimiza    admin PD       0:00      1 (Dependency)
#                 5   quantum  execute    admin PD       0:00      1 (Dependency)

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

สรุป

ในบทเรียนนี้ เราได้สาธิตวิธีการรวมโมเดลการเขียนโปรแกรมแบบคลาสสิกและควอนตัมหลายแบบเพื่อสร้าง จัดการ และดำเนินการเวิร์กโฟลว์สี่ขั้นตอนที่สมบูรณ์ เราเริ่มต้นด้วยแนวคิดพื้นฐานของ quantum circuit และ primitive จากนั้นสำรวจโมเดลคลาสสิกอย่าง parallel programming และ task workflows โดยการรวมแนวคิดทั้งหมด เราสร้าง Qiskit pattern — map, optimize, execute และ post-process — ที่ประสานงานโดย Slurm workload manager พร้อม quantum circuit ง่ายๆ และ observable

ในบทเรียนถัดไป เราจะใช้กรอบการทำงานนี้เพื่อรัน sample-based quantum algorithm แสดงให้เห็นว่าเวิร์กโฟลว์นี้สามารถนำไปใช้แก้ปัญหาที่มีความหมายได้อย่างไร

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