SQD และ SKQD

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

Iskandar Sitdikov อธิบายแนวทางอัลกอริทึมในวิดีโอต่อไปนี้

Hamiltonian

กุญแจสำคัญของปัญหานี้คือ mathematical operator — Hamiltonian ซึ่งแทนพลังงานรวมของระบบ เพื่อวัตถุประสงค์ในการประมวลผล เราสามารถคิด Hamiltonian นี้ว่าเป็น matrix ขนาดใหญ่ คำตอบที่เราต้องการ — โดยเฉพาะ ground state ของระบบ — คือ eigenvalue ที่ต่ำที่สุดของ matrix นี้ ความท้าทายอย่างไรก็ตามคือสำหรับปัญหาเชิงปฏิบัติ Hamiltonian matrix นี้มีขนาดใหญ่มาก มันเติบโตแบบ exponential กับขนาดของระบบ กลายเป็นใหญ่เกินไป ($2^n$ ซึ่ง $n$ คือจำนวน qubit) สำหรับแม้แต่ซูเปอร์คอมพิวเตอร์ที่ทรงพลังที่สุดที่จะเก็บหรือแก้โดยตรง

$$H = \begin{pmatrix} H_{0,0} & H_{0,1} & \cdots & H_{0,N-1} \\ H_{1,0} & H_{1,1} & \cdots & H_{1,N-1} \\ \vdots & \vdots & \ddots & \vdots \\ H_{N-1,0} & H_{N-1,1} & \cdots & H_{N-1,N-1} \end{pmatrix} \quad (N=2^n)$$

เพื่อหลีกเลี่ยงสิ่งนี้ เราใช้กลยุทธ์ที่ทรงพลังที่รู้จักในชื่อ subspace method แทนที่จะจัดการกับ matrix ทั้งหมด เราเลือก slice ที่เล็กและเกี่ยวข้องอย่างชาญฉลาด — "subspace" — ที่เราเชื่อว่ามีข้อมูลสำคัญที่สุดเกี่ยวกับคำตอบพลังงานต่ำที่เราต้องการ

$$\underset{\text{Full Hamiltonian}}{\begin{pmatrix} \ddots & \vdots \\ \cdots & H_{i,j} & \cdots \\ & \vdots & \ddots \end{pmatrix}} \quad \xrightarrow{\text{Project}} \quad \underset{\text{Projected Hamiltonian}}{\tilde{H}} = \begin{pmatrix} \langle b_1 | H | b_1 \rangle & \cdots & \langle b_1 | H | b_L \rangle \\ \vdots & \ddots & \vdots \\ \langle b_L | H | b_1 \rangle & \cdots & \langle b_L | H | b_L \rangle \end{pmatrix} \quad \xrightarrow{\text{Diagonalize}} \quad \underset{\text{Eigenvalues}}{\begin{pmatrix} E_0 & & 0 \\ & \ddots & \\ 0 & & E_{L-1} \end{pmatrix}}$$

เมื่อ subspace ขนาดเล็กนี้ถูกกำหนดโดยชุดของ basis state $\{|b_i\rangle\}$ Hamiltonian เต็มรูปแบบจะถูก project ลงบนมันเพื่อสร้าง matrix ขนาดเล็กใหม่ $\tilde{H}$ แต่ละองค์ประกอบของ matrix นี้คำนวณจาก basis state ของ subspace และ Hamiltonian ดั้งเดิมตาม $\langle b_i | H | b_j \rangle$ matrix ขนาดเล็กนี้จากนั้นสามารถ diagonalize ได้อย่างง่ายดายบนคอมพิวเตอร์คลาสสิก และ eigenvalue ที่ได้คือพลังงานที่ประมาณของเรา

ดังที่คุณอาจเดาได้ ความสำเร็จของแนวทางทั้งหมดนี้ขึ้นอยู่กับการเลือก "subspace ที่ดี" อย่างมาก ถ้า subspace ของเราไม่แทน ground state ที่แท้จริงได้อย่างแม่นยำ คำตอบสุดท้ายของเราจะผิดพลาด นี่คือที่ที่คอมพิวเตอร์ควอนตัมเข้ามา: ช่วยให้เราเตรียมและสุ่มตัวอย่างจากสถานะควอนตัมที่ซับซ้อนซึ่งออกแบบมาเพื่อระบุ subspace ที่สำคัญเหล่านี้ สำหรับปัญหาขนาดใหญ่มากจริงๆ เช่น โครงสร้างเคมีที่ซับซ้อนหรือ binding site แม้แต่ matrix ที่ถูก project ก็ยังอาจมีความท้าทายในการ diagonalize ดังนั้นปัญหาดังกล่าวจึงเหมาะอย่างยิ่งสำหรับการใช้จุดแข็งของทั้งทรัพยากรควอนตัมและคลาสสิก

ในส่วนต่อไป เราจะสำรวจอัลกอริทึมขั้นสูงสองตัว SQD และ SKQD ซึ่งใช้กลศาสตร์ควอนตัมเพื่อค้นหาและสร้าง subspace เหล่านี้ สำหรับการเจาะลึก มีคอร์สเต็มรูปแบบบน IBM Quantum learning ที่อุทิศให้กับหัวข้อเหล่านี้โดยละเอียด สำหรับวัตถุประสงค์ในคอร์สนี้ เราจะคงการอธิบายในระดับสูง

Sample-based Quantum Diagonalization

Sample-based Quantum Diagonalization (SQD) คืออัลกอริทึม variational ที่ทรงพลังซึ่งนำ subspace method ไปใช้ในแบบควอนตัม มันหลีกเลี่ยงขั้นตอนที่ซับซ้อนและมีค่าใช้จ่ายสูงอย่าง Hadamard test โดยใช้คอมพิวเตอร์ควอนตัมเพื่อเตรียม trial state และสุ่มตัวอย่าง bitstring ซึ่งกำหนด subspace สำหรับ classical diagonalization

อัลกอริทึม SQD สามารถแบ่งออกเป็นขั้นตอนต่อไปนี้:

ขั้นตอนที่ 1: เตรียม Ansatz state

ให้ $H = \sum_{j=1}^Q \alpha_j P_j$ เป็น Hamiltonian บน $n$ qubit แม้ว่า ground state ที่แท้จริงอาจรองรับ basis state ทั้งหมด $2^n$ ตัว SQD มีประสิทธิภาพสูงสุดในกรณีที่ ground state สามารถ approximate ได้ดีด้วย subspace แบบ sparse (ชุดของ bitstring ที่มีขนาดเป็น polynomial)

เพื่อสร้าง subspace นี้ เราเริ่มต้นด้วย input state $|\phi_0\rangle$ เช่น สถานะ Hartree-Fock (HF) ในเคมี จากนั้นเราใช้ parameterized quantum circuit $U(\theta)$ ซึ่งเรียกว่า ansatz

ไดอะแกรมนี้แสดงเป้าหมายของ ansatz ที่ดี ansatz เตรียมสถานะควอนตัมที่ support (ชุดของ basis state ที่ประกอบขึ้น) ควรมี overlap ที่มากกับ support ของ ground state ที่แท้จริง Circuit นี้ช่วยให้เรา project ansatz ไปยัง computational basis state อย่างรวดเร็ว ซึ่งจะถูกใช้ต่อไปใน classical diagonalization กล่าวอีกนัยหนึ่ง: เราไม่จำเป็นต้องเดา ansatz ที่เป็น ground state แต่เราต้องการเพียงให้มันมี basis state เดียวกัน จากนั้น classical diagonalization ของ Hamiltonian ที่ถูก project จะให้ superposition ของ basis state ที่ approximate ground state ได้ดีที่สุด

ขั้นตอนที่ 2: สุ่มตัวอย่าง subspace

โดยการสุ่มตัวอย่างจาก circuit ที่เตรียมโดย ansatz เราได้คอลเลกชันของ bitstring $\{b_j\}_{j=1}^L$ bitstring เหล่านี้กำหนด basis ของ subspace ที่เราเลือก quantum runtime สำหรับขั้นตอนนี้ถูกกำหนดโดย depth ของ circuit และจำนวนตัวอย่างที่ได้

ขั้นตอนที่ 3: Project และ diagonalize แบบคลาสสิก

โดยใช้ bitstring ที่สุ่มตัวอย่าง เรา project Hamiltonian เข้าไปใน subspace ที่พวกมัน span สำหรับแต่ละคู่ของ bitstring $(j, k)$ เราคำนวณ matrix element $\tilde{H}_{jk} = \langle b_j | H | b_k \rangle$ แบบคลาสสิก เนื่องจาก Pauli operator มีความ sparse ขั้นตอนนี้จึงมีประสิทธิภาพแบบคลาสสิกสำหรับ physical Hamiltonian matrix ขนาดเล็ก $\tilde{H}$ ที่ได้จากนั้นถูก diagonalize บน classical processor เพื่อประมาณ ground state และพลังงาน

ขั้นตอนที่ 4: Optimize ansatz (ไม่บังคับ)

กระบวนการสามารถทำซ้ำได้ โดยถือว่าพลังงาน ground state ที่ประมาณเป็น cost function เราสามารถ optimize circuit parameter ($\theta$) โดยใช้วิธีอย่าง gradient descent เพื่อปรับปรุง ansatz และส่งผลให้การประมาณพลังงานดีขึ้นในการวนซ้ำถัดไป

ข้อดีสำคัญของ SQD

SQD มีคุณสมบัติที่ทรงพลังหลายอย่างที่ทำให้เป็นผู้สมัครชั้นนำสำหรับการสาธิตความได้เปรียบเชิงควอนตัม:

• ความทนทานต่อ noise ที่แข็งแกร่ง: สมมติว่า ground state ที่แท้จริงรองรับเพียงสอง bitstring ถ้าบิตสตริงเหล่านั้นถูกสุ่มตัวอย่างเลย แม้ว่า overlap กับ ansatz ของเราจะน้อย การ diagonalize จะกำหนด weight ที่เหมาะสมให้กับพวกมันและละเว้น bitstring ที่เกินจำเป็นและมี noise ทั้งหมดที่อาจถูกสุ่มตัวอย่างด้วยอย่างมีประสิทธิภาพ การกรองโดยธรรมชาตินี้ทำให้ SQD มีความทนทานต่อ noise เป็นพิเศษ
• ความสามารถตรวจสอบได้แบบคลาสสิก: ต่างจาก QPE หรือ VQA SQD ให้ classical approximation ของ ground state ซึ่งหมายความว่าใครก็ตามที่มีรายการ bitstring และ weight สามารถคำนวณและตรวจสอบการประมาณพลังงานได้โดยตรงบนคอมพิวเตอร์คลาสสิก

SQD ได้ถูกใช้เพื่อประมาณ ground-state dissociation energy ของ N$_2$ และคุณสมบัติทางอิเล็กทรอนิกส์ของ [2Fe-2S] และ [4Fe-4S] cluster แล้ว[2] พร้อม circuit ที่ใหญ่ถึง 77 qubit และ 10,570 gate

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

จริงหรือเท็จ: SQD สามารถนำไปใช้กับระบบเคมีได้

คำตอบ:

จริง

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

เรียก set ของ computational basis state ทั้งหมดที่ประกอบขึ้นเป็น ansatz ของคุณว่า $A$ เรียก set ของ computational basis state ทั้งหมดที่ประกอบขึ้นเป็น ground state ที่แท้จริงของระบบของคุณว่า $G$ ข้อใดต่อไปนี้สอดคล้องกับ ansatz ที่ "ดี"? เลือกทั้งหมดที่ใช้ได้

(a) $A \subset G \\$ (b) $A \subseteq G\\$ (c) $G \subset A\\$ (d) $G \subseteq A\\$

คำตอบ:

(c) และ (d)

SKQD (Sample-based Krylov Quantum Diagonalization)

Sample-based Krylov Quantum Diagonalization (SKQD) คืออัลกอริทึม quantum sample-based ที่ทรงพลังอีกตัวหนึ่งที่สร้างขึ้นบนหลักการของ SQD แม้ว่าเป้าหมายของมันจะเหมือนกัน — ค้นหา subspace ที่ดีสำหรับ diagonalization — SKQD ใช้วิธีการที่มีโครงสร้างมากขึ้นในการสร้าง bitstring โดยเฉพาะสำหรับปัญหาอย่าง lattice Hamiltonian

แนวคิดหลักของ SKQD คือแทนที่จะ optimize parameterized circuit เพื่อหา ansatz ที่ดี สามารถ converge ไปยัง ground state ได้อย่างพิสูจน์ได้โดยการสุ่มตัวอย่างจากชุดของสถานะที่สร้างขึ้นโดย natural time evolution ของระบบเอง — Krylov subspace อัลกอริทึม SKQD สามารถแบ่งออกเป็นขั้นตอนต่อไปนี้:

ขั้นตอนที่ 1: สร้าง Krylov subspace ด้วย time evolution

กระบวนการเริ่มต้นด้วย initial state $|\phi_0\rangle$ สิ่งสำคัญคือเราไม่จำเป็นต้องให้ initial state นี้มี overlap ที่ "ดี" กับ ground state มันจำเป็นต้องเป็น "polynomial ขนาดใหญ่" เท่านั้น หรืออธิบายด้วย polynomial ในขนาดระบบ อัลกอริทึมเองจะขับ state ให้ใกล้เคียง ground state ของระบบมากขึ้นเรื่อยๆ SKQD ใช้ time evolution operator $e^{-iHt}$ สำหรับความยาวเวลาที่แตกต่างกัน ซึ่งสร้างชุดของ $d$ สถานะควอนตัมที่แตกต่างกัน กำหนดเป็น:

$$|\phi_j\rangle = e^{-i \,\delta t j H}|\phi_0\rangle, \quad \text{for } j = 0, 1, \dots, d-1 \quad \text{}$$

คอลเลกชันของสถานะที่วิวัฒน์ตามเวลานี้ก่อเป็น Krylov basis ขั้นตอนนี้มีประสิทธิภาพเป็นพิเศษสำหรับ lattice Hamiltonian ซึ่งจำนวน term ใน Hamiltonian ไม่มาก สำหรับปัญหาเคมี time evolution นี้สามารถส่งผลให้ circuit ลึกมาก ซึ่งเป็นเหตุผลที่มักแนะนำ SQD สำหรับกรณีเหล่านั้น

ขั้นตอนที่ 2: สุ่มตัวอย่างจาก Krylov basis state

ต่อไป ตัวอย่าง bitstring ถูกเก็บรวบรวมจากแต่ละสถานะ $d$ ที่แตกต่างกัน ($|\phi_0\rangle, |\phi_1\rangle, \dots, |\phi_{d-1}\rangle$) ที่เตรียมในขั้นตอนก่อนหน้า bitstring ทั้งหมดเหล่านี้จากนั้นถูกรวมกันเพื่อก่อ basis สำหรับ subspace

ขั้นตอนที่ 3: Project และ diagonalize แบบคลาสสิก

ขั้นตอนนี้เหมือนกันกับใน SQD bitstring ที่เก็บรวบรวมถูกใช้เพื่อ project Hamiltonian เต็มรูปแบบเข้าไปใน subspace ที่พวกมัน span matrix ขนาดเล็ก $\tilde{H}$ ที่ได้จากนั้นถูก diagonalize บนคอมพิวเตอร์คลาสสิกเพื่อหาพลังงาน ground state

ข้อดีสำคัญและการรับประกันของ SKQD

แนวทางที่มีโครงสร้างของ SKQD ให้ประโยชน์เฉพาะตัว:

• การ convergence ที่พิสูจน์ได้: ข้อดีสำคัญของ SKQD คือการรับประกันทางทฤษฎีของการ convergence ภายใต้เงื่อนไขเฉพาะที่กำหนดไว้อย่างดี ถ้า ground state ที่แท้จริงมีความ sparse (สามารถ approximate ได้ดีด้วยจำนวน bitstring เป็น polynomial) และ energy gap ไปยัง first excited state ไม่เล็กเกินไป วิธีการนี้ถูกพิสูจน์แล้วว่าทำงานได้อย่างมีประสิทธิภาพ ภายใต้เงื่อนไขเหล่านี้ SKQD รับประกันว่าจะหา bitstring สำคัญที่ประกอบขึ้น ground state และสามารถ approximate พลังงาน ground state ได้อย่างแม่นยำสูง สิ่งนี้ต้องการเพียงจำนวน quantum experiment และ shot เป็น polynomial เท่านั้น การรับประกันนี้วาง sample-based approach บนฐานทางทฤษฎีที่เข้มงวด คล้ายกับวิธีที่ได้รับการยืนยันอย่าง quantum phase estimation

• ประโยชน์ร่วมกับ SQD: คล้ายกับ SQD SKQD ยังมีคุณสมบัติความทนทานต่อ noise ด้วย กล่าวอีกนัยหนึ่ง ตราบเท่าที่มี bitstring ที่ดีทั้งหมดอยู่ในชุดของ bitstring ที่สุ่มตัวอย่าง การ diagonalize จะกำหนด weight เกือบเป็นศูนย์ให้กับ bitstring ที่ไม่ถูกต้อง ทำให้กระบวนการทนทานต่อ noise นอกจากนี้ เนื่องจากคำตอบถูกผลิตจาก HPC แบบคลาสสิก พลังงานของคำตอบสามารถตรวจสอบได้แบบคลาสสิก

ในการทดลอง SKQD ถูกใช้กับ qubit มากถึง 70 ตัวและ gate นับพัน เพื่อศึกษา ground state ของ complex 4-impurity Anderson model บรรลุความสอดคล้องที่ยอดเยี่ยมกับวิธีคลาสสิกชั้นนำอย่าง DMRG[1]

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

ส่วนใดของอัลกอริทึม SKQD ที่ทำให้มันเหมาะสมกับปัญหาทางกายภาพอย่าง spin lattice มากกว่าปัญหาเคมี? เพราะอะไร?

คำตอบ:

Time evolution ต้องการ Trotter circuit ซึ่งลึกมากสำหรับ Hamiltonian ที่ซับซ้อนและไม่ sparse Spin lattice interaction ถูกควบคุมโดย spin matrix ซึ่งเทียบเท่ากับ Pauli matrix ดังนั้น Hamiltonian สำหรับ spin lattice มักแสดงได้อย่างกระชับมากขึ้นใน Pauli matrix โดยเฉพาะ nearest-neighbor interaction

SQD และ SKQD ในฐานะ heterogeneous computing

เพื่อรวบรวมทั้งหมดเข้าด้วยกัน เราสามารถแสดง sample-based algorithm เป็นการรวมกันของโมเดลการเขียนโปรแกรมที่แตกต่างกันบนชุดของทรัพยากรแบบ heterogeneous ตัวอย่างเช่น เราสามารถแสดงอัลกอริทึมของเราเป็น task workflow

รูปนี้แสดงเวิร์กโฟลว์พื้นฐานสี่ขั้นตอน ขั้นแรก เราจะมีงานสำหรับการเตรียม quantum circuit ที่ overlap กับ target state ตามด้วยงานสำหรับ transpilation ซึ่งต้องการเพียงทรัพยากรคลาสสิกในการดำเนินการ ถัดไปจะเป็นงานที่ใช้ primitive เพื่อดำเนินการ quantum circuit ซึ่งต้องการทรัพยากรควอนตัม สุดท้าย เราจะมีงาน post-processing ซึ่งอาจเป็น parallel diagonalization algorithm ที่รันบน node หลายตัว

นอกจากนี้ เราอาจต้องการรันอัลกอริทึมเหล่านี้หลายครั้งในขณะที่เราเปลี่ยน ansatz หรืออาจต้องการรันแบบขนานอย่างสมบูรณ์กับ population ที่แตกต่างกัน

ดังแสดงข้างต้น คุณอาจรัน workflow หลายอันพร้อมกันในขณะที่ทำสิ่งต่อไปนี้:

• เปลี่ยน parameter หรือโครงสร้างของ ansatz เพื่อหาตัวที่มีประสิทธิภาพสูงสุด
• เริ่มต้นด้วย initial state หรือ configuration ("population") ที่แตกต่างกันเพื่อหลีกเลี่ยง local minima และให้ผลลัพธ์ที่แข็งแกร่งกว่า

แนวทาง multi-layer นี้ ซึ่งรวม task-based heterogeneity กับ workflow-level parallelism คือกุญแจสำคัญในการปลดล็อคศักยภาพสูงสุดของอัลกอริทึมเหล่านี้

Programming Practice

ให้ฝึกอัลกอริทึม SKQD สาธิตเวิร์กโฟลว์แบบ heterogeneous ที่อธิบายไว้ก่อนหน้า กระบวนการแบ่งออกเป็นสี่ขั้นตอนที่แยกกัน แต่ละขั้นตอนมี Python script และ shell script ที่สอดคล้องสำหรับการ submit งาน

Mapping (mapping.py และ mapping.sh)

ขั้นตอนแรกในเวิร์กโฟลว์ของเราคือการกำหนดปัญหาทางกายภาพและแมปมันเป็นชุดของ quantum circuit

mapping.py กำหนด parameter สำหรับปัญหาฟิสิกส์เฉพาะ — ในกรณีนี้คือ Anderson impurity model พร้อม seven bath site (n_bath = 7) มันสร้าง one-body (h1e) และ two-body (h2e) integral ที่แทน Hamiltonian ของระบบ

...

n_bath = 7  # number of bath sites

...

# One body matrix elements in the "position" basis
h1e = -t * np.diag(np.ones(n_bath), k=1) - t * np.diag(np.ones(n_bath), k=-1)
h1e[impurity_index, impurity_index + 1] = -V
h1e[impurity_index + 1, impurity_index] = -V
h1e[impurity_index, impurity_index] = eps

# Two body matrix elements in the "position" basis
h2e = np.zeros((n_bath + 1, n_bath + 1, n_bath + 1, n_bath + 1))
h2e[impurity_index, impurity_index, impurity_index, impurity_index] = U

...

# The one-body time evolution
free_fermion_evolution = ffsim.qiskit.OrbitalRotationJW(n_modes, Utar)

# The two-body time evolution
def append_diagonal_evolution(dt, U, impurity_qubit, num_orb, q_circuit):
    """Append two-body time evolution to a quantum circuit."""
    if U != 0:
        q_circuit.append(
            CPhaseGate(-dt / 2 * U),
            [impurity_qubit, impurity_qubit + num_orb],
        )

มันจากนั้นสร้าง quantum circuit ที่ต้องการสำหรับอัลกอริทึม SKQD เริ่มต้นด้วยการสร้าง initial state (initial_state) และจากนั้นใช้ time-evolution operator สำหรับจำนวน step ที่แตกต่างกัน (d = 8) เพื่อสร้าง Krylov basis state ที่แตกต่างกัน $|\phi_j\rangle = (e^{-iHt})^j |\phi_0\rangle$

# The reference state
def initial_state(q_circuit, norb, nocc):
    """Prepare an initial state."""
    for i in range(nocc):
        q_circuit.append(XGate(), [i])
        q_circuit.append(XGate(), [norb + i])
    rot = XXPlusYYGate(np.pi / 2, -np.pi / 2)

    for i in range(3):
        for j in range(nocc - i - 1, nocc + i, 2):
            q_circuit.append(rot, [j, j + 1])
            q_circuit.append(rot, [norb + j, norb + j + 1])
    q_circuit.append(rot, [j + 1, j + 2])
    q_circuit.append(rot, [norb + j + 1, norb + j + 2])

...

# Generate the initial state
qubits = QuantumRegister(2 * n_modes, name="q")
init_state = QuantumCircuit(qubits)
initial_state(init_state, n_modes, n_modes // 2)

...

d = 8  # Number of Krylov basis states
circuits = []
for i in range(d):
    circ = init_state.copy()
    circuits.append(circ)
    for _ in range(i):
        append_diagonal_evolution(dt, U, impurity_index, n_modes, circ)
        circ.append(free_fermion_evolution, qubits)
        append_diagonal_evolution(dt, U, impurity_index, n_modes, circ)
    circ.measure_all()

print(circuits[0].draw(scale=0.4, fold=-1))

Script บันทึกรายการ circuit 8 ตัวที่สร้างขึ้น (แต่ละตัวมีการวัดที่ต่อท้าย) ลงในไฟล์ชื่อ circuits.qpy

mapping.sh คือ Slurm batch script ที่ใช้สำหรับ submit งาน mapping.py เนื่องจากนี่คือการประมวลผลแบบคลาสสิก มันร้องขอทรัพยากรจาก standard CPU partition (--partition=normal)

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

srun python /data/ch4/sqd/mapping.py

Optimization (optimization.py และ optimization.sh)

เมื่อมี circuit แล้ว circuit เหล่านั้นต้องถูก optimize และ compile เพื่อรันอย่างมีประสิทธิภาพบนฮาร์ดแวร์ควอนตัมเป้าหมาย

ใน optimization.py script นี้ขั้นแรกโหลดไฟล์ circuits.qpy ที่สร้างในขั้นตอน mapping และดึงข้อมูลทรัพยากรควอนตัมโดย QRMI() ซึ่งเป็น quantum resource manager จากนั้นใช้ generate_preset_pass_manager ของ Qiskit พร้อม optimization level สูง (optimization_level=3) เพื่อแปลง abstract logical circuit เป็น Instruction Set Architecture (ISA) circuit กระบวนการนี้เขียน circuit ใหม่โดยใช้ native gate ของฮาร์ดแวร์และ optimize เพื่อลด depth และลด error

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

pass_manager = generate_preset_pass_manager(
    optimization_level=3,
    target=target
)
isa_circuits = pass_manager.run(circuits)

circuit ที่ถูก transpile และพร้อมสำหรับฮาร์ดแวร์ถูกบันทึกลงในไฟล์ใหม่ isa_circuits.qpy

คล้ายกับ mapping script Slurm job นี้รันบน classical CPU partition (--partition=normal) ด้วย เนื่องจาก transpilation คืองานแบบคลาสสิก

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

srun python /data/ch4/sqd/mapping.py

Execution (execution.py และ execution.sh)

นี่คือขั้นตอนเดียวที่ใช้คอมพิวเตอร์ควอนตัม ที่นี่ เราดำเนินการ circuit ที่ถูก optimize และเก็บตัวอย่างการวัด

execution.py โหลดไฟล์ isa_circuits.qpy ที่ถูก optimize แล้วจากนั้น initialize SamplerV2 primitive ที่เชื่อมต่อกับทรัพยากรควอนตัม มันจากนั้นเรียก sampler.run() เพื่อดำเนินการ circuit บน QPU สำหรับจำนวน shot ที่กำหนด (shots=500)

...

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

# Sample from the circuits
noisy_sampler = Sampler(quantum_resource)
job = noisy_sampler.run(isa_circuits, shots=500)

เมื่อสิ้นสุดการดำเนินการ ผลลัพธ์ที่วัดได้ (bitstring) จาก circuit ทั้งหมดถูกเก็บรวบรวมและรวมกัน และ count ของพวกมันถูกบันทึกลงในไฟล์ counts.json

Slurm script execution.sh แตกต่างจากตัวอื่นๆ ในขั้นตอนนี้ มันร้องขอให้รันบน quantum partition (--partition=quantum) และร้องขอ QPU หนึ่งตัวโดยเฉพาะ (--gres=qpu:1)

#!/bin/bash
#
#SBATCH --job-name=sqd-execution
#SBATCH --output=sqd-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/ch4/sqd/execution.py

Post-processing (postprocessing.py และ postprocessing.sh)

ในขั้นตอนสุดท้าย เรากลับมายังคอมพิวเตอร์คลาสสิกเพื่อวิเคราะห์ข้อมูลจากการทดลองควอนตัมและคำนวณผลลัพธ์สุดท้าย: พลังงาน ground state ของระบบเป้าหมาย

โปรแกรม postprocessing.py ขั้นแรกอ่านไฟล์ counts.json ที่มีผลการวัด จากนั้น reconstruct Hamiltonian ของ Anderson model (โดยใช้ parameter เดียวกับใน mapping.py) มันจากนั้นส่ง bitstring ที่วัดได้และนิยาม Hamiltonian ไปยังฟังก์ชัน diagonalize_fermionic_hamiltonian ฟังก์ชันนี้ดำเนินการ SKQD logic หลัก: ใช้ bitstring เพื่อสร้าง projected Hamiltonian $\tilde{H}$ และ diagonalize มันเพื่อหาพลังงาน ground state

...

def callback(results: list[SCIResult]):
    result_history.append(results)
    iteration = len(result_history)
    print(f"Iteration {iteration}")
    for i, result in enumerate(results):
        print(f"\tSubsample {i}")
        print(f"\t\tEnergy: {result.energy}")
        print(f"\t\tSubspace dimension: {np.prod(result.sci_state.amplitudes.shape)}")

rng = np.random.default_rng(24)
result = diagonalize_fermionic_hamiltonian(
    h1e,
    h2e,
    bit_array,
    samples_per_batch=300,
    norb=n_modes,
    nelec=nelec,
    num_batches=3,
    max_iterations=10,
    symmetrize_spin=True,
    callback=callback,
    seed=rng,
)

สุดท้าย มัน print พลังงาน SKQD ที่คำนวณได้และเปรียบเทียบกับพลังงานที่แน่นอนที่ทราบสำหรับปัญหานี้ แสดง absolute error สุดท้ายของการคำนวณ

job script สุดท้ายรันบน classical partition (--partition=normal) เนื่องจากการวิเคราะห์ทั้งหมดเป็นแบบคลาสสิก สำหรับ subspace ขนาดใหญ่ ขั้นตอนนี้อาจต้องการทรัพยากร HPC แบบคลาสสิกมากขึ้น

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

srun python /data/ch4/sqd/postprocessing.py

สรุป

แค่นั้นเลย! เราได้ผ่านแนวคิดและตัวอย่างหลายอย่างที่จะช่วยให้คุณเริ่มต้นกับการจัดการโปรแกรม hybrid ที่ซับซ้อน แน่นอนนี่เป็นเพียงจุดเริ่มต้นของทุกสิ่งที่คุณสามารถทำได้กับการรวมทรัพยากรควอนตัมและ HPC แบบคลาสสิก

เพื่อสำรวจกรณีการใช้งานและอัลกอริทึมเพิ่มเติม เรียกดูเอกสารและบทแนะนำบน IBM Quantum Platform และอย่าลืมเยี่ยมชมทรัพยากรที่แชร์ในบทเรียนถัดไปสำหรับข้อมูลเพิ่มเติมเกี่ยวกับอัลกอริทึมและซอฟต์แวร์สำหรับทั้งนักวิทยาศาสตร์การประมวลผลและผู้ดูแลระบบ data center

อ้างอิง

[1] Quantum-Centric Algorithm for Sample-Based Krylov Diagonalization. https://arxiv.org/abs/2501.09702

[2] Chemistry beyond the scale of exact diagonalization on a quantum-centric supercomputer. https://www.science.org/doi/10.1126/sciadv.adu9991