Lumaktaw sa pangunahing nilalaman

SQD at SKQD

Sa kabanatang ito, titingnan natin kung paano nagtutulungan ang quantum at klasikal na mga computer upang malutas ang isa sa pinakamahalagang hamon sa agham: ang tumpak na pagtatantya ng enerhiya ng mga molekula at materyales.

Inilalarawan ni Iskandar Sitdikov ang algorithmic na pamamaraan sa sumusunod na video.

Hamiltonian​

Ang susi sa problemang ito ay isang mathematical operator — ang Hamiltonian, na kumakatawan sa kabuuang enerhiya ng isang sistema. Para sa computational na layunin, maaari nating isipin ang Hamiltonian na ito bilang isang malaking matrix. Ang mga solusyong hinahanap natin — lalo na ang ground state ng sistema — ay ang pinakamababang eigenvalue ng matrix na ito. Ang hamon, gayunpaman, ay para sa mga praktikal na problema, napakalaki ng Hamiltonian matrix na ito. Lumalaki ito nang exponential ayon sa laki ng sistema, at mabilis na nagiging masyadong malaki (2n2^n kung saan nn ang bilang ng mga qubit) para maiimbak o malutas nang direkta kahit ng pinakamakapangyarihang supercomputer.

H=(H0,0H0,1⋯H0,N−1H1,0H1,1⋯H1,N−1⋮⋮⋱⋮HN−1,0HN−1,1⋯HN−1,N−1)(N=2n)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)

Upang malutas ito, gumagamit tayo ng isang makapangyarihang estratehiya na tinatawag na subspace method. Sa halip na harapin ang buong matrix, maingat tayong pumipili ng maliit at makabuluhang bahagi — isang "subspace" — na naniniwala tayong naglalaman ng pinakamahalagang impormasyon tungkol sa mababang-enerhiyang solusyong hinahanap natin.

(⋱⋮⋯Hi,j⋯⋮⋱)Full Hamiltonian→ProjectH~Projected Hamiltonian=(⟨b1∣H∣b1⟩⋯⟨b1∣H∣bL⟩⋮⋱⋮⟨bL∣H∣b1⟩⋯⟨bL∣H∣bL⟩)→Diagonalize(E00⋱0EL−1)Eigenvalues\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}}

Kapag natukoy na ang maliit na subspace na ito sa pamamagitan ng isang set ng basis states na {∣bi⟩}\{|b_i\rangle\}, ini-project ang buong Hamiltonian dito upang lumikha ng bagong, mas maliit na matrix na H~\tilde{H}. Ang bawat elemento ng matrix na ito ay kinakalkula mula sa mga basis state ng subspace at sa orihinal na Hamiltonian tulad ng sa ⟨bi∣H∣bj⟩\langle b_i | H | b_j \rangle. Ang maliit na matrix na ito ay madaling ma-diagonalize sa isang klasikal na computer, at ang mga resultang eigenvalue ay ang ating tinantyang mga enerhiya.

Gaya ng maaari mong hulaan, ang tagumpay ng buong pamamaraang ito ay lubos na nakasalalay sa pagpili ng isang "magandang" subspace. Kung hindi tumpak na kinakatawan ng ating subspace ang tunay na ground state, ang ating panghuling sagot ay magiging mali. Dito pumapasok ang mga quantum computer: pinapayagan nila tayong maghanda at mag-sample mula sa mga kumplikadong quantum state na idinisenyo upang matukoy ang mga mahahalagang subspace na ito. Para sa tunay na napakalaking mga problema, tulad ng mga kumplikadong istruktura ng kemikal o mga binding site, maaaring mahirap pa ring i-diagonalize ang projected matrix. Kaya naman, ang ganitong mga problema ay perpektong angkop para pagsamahin ang mga kalakasan ng parehong quantum at klasikal na computing resources.

Sa mga sumusunod na seksyon, tutuklasin natin ang dalawang advanced na algorithm — SQD at SKQD — na gumagamit ng quantum mechanics upang mahanap at maitayo ang mga subspace na ito. Para sa mas malalim na pag-aaral, may buong kurso sa IBM Quantum learning na nakatuon sa mga paksang ito nang detalyado. Para sa ating layunin sa kursong ito, pananatilihin natin ang paliwanag sa mataas na antas.

Sample-based Quantum Diagonalization​

Ang Sample-based Quantum Diagonalization (SQD) ay isang makapangyarihang variational algorithm na nagpapatupad ng subspace method sa quantum na paraan. Iniiwasan nito ang mga mahal at kumplikadong pamamaraan tulad ng Hadamard tests sa pamamagitan ng paggamit ng quantum computer upang maghanda ng trial state at mag-sample ng mga bitstring, na nagtatakda ng subspace para sa klasikal na diagonalization.

A schematic of the workflow specific to sample-based quantum diagonalization. The steps include a variational quantum circuit, using measurements to project the Hamiltonian into a subspace, then using a classical optimizer to update variational parameters in the circuit and repeating.

Maaaring hatiin ang SQD algorithm sa mga sumusunod na hakbang:

Hakbang 1: Ihanda ang Ansatz state​

Hayaan nating H=∑j=1QαjPjH = \sum_{j=1}^Q \alpha_j P_j ang Hamiltonian sa nn na qubit. Kahit ang tunay na ground state ay maaaring suportado sa lahat ng 2n2^n na basis state, pinaka-epektibo ang SQD sa mga sitwasyon kung saan ang ground state ay maaaring mahusay na ma-approximate ng isang maliit na subspace (isang polynomial-sized na set ng mga bitstring).

Upang maitayo ang subspace na ito, nagsisimula tayo sa isang input state na ∣ϕ0⟩|\phi_0\rangle, tulad ng Hartree-Fock (HF) state sa kimika. Pagkatapos ay nag-aaplay tayo ng isang parameterized quantum circuit, U(θ)U(\theta), na kilala bilang ang ansatz.

A diagram showing the overlap of the computational basis states making up the ansatz and those making up the true ground state. Specifically, the image shows that the two regions will have some overlap, but might not perfectly match.

Inilalarawan ng diagram na ito ang layunin ng isang magandang ansatz. Inihahanda ng ansatz ang isang quantum state na ang suporta (ang set ng mga basis state na binubuo nito) ay dapat na may malaking overlap sa suporta ng tunay na ground state. Pinapayagan tayo ng circuit na ito na mabilis na i-project ang ansatz sa mga computational basis state, na gagamitin pa sa klasikal na diagonalization. Sa madaling salita: hindi natin kailangang hulaan ang isang ansatz na siya mismo ang ground state; kailangan lang nitong maglaman ng parehong mga basis state. Pagkatapos, ang klasikal na diagonalization ng projected Hamiltonian ang magbibigay sa atin ng superposition ng mga basis state na pinakamalapit sa ground state.

Hakbang 2: I-sample ang subspace​

Sa pamamagitan ng pag-sample mula sa circuit na inihanda ng ansatz, nakakakuha tayo ng koleksyon ng mga bitstring, {bj}j=1L\{b_j\}_{j=1}^L. Ang mga bitstring na ito ang nagtatakda ng basis ng ating piniling subspace. Ang quantum runtime para sa hakbang na ito ay tinutukoy ng depth ng circuit at ng bilang ng mga sample na kinuha.

Hakbang 3: I-project at i-diagonalize nang klasikal​

Gamit ang mga na-sample na bitstring, ini-project natin ang Hamiltonian sa subspace na kanilang sinasaglaw. Para sa bawat pares ng mga bitstring (j,k)(j, k), klasikal na kinakalkula natin ang matrix element na H~jk=⟨bj∣H∣bk⟩\tilde{H}_{jk} = \langle b_j | H | b_k \rangle. Dahil sparse ang mga Pauli operator, ang hakbang na ito ay klasikal na mahusay para sa mga pisikal na Hamiltonian. Ang resultang maliit na matrix na H~\tilde{H} ay idi-diagonalize pagkatapos sa isang klasikal na processor upang matantya ang ground state at ang enerhiya nito.

Hakbang 4: I-optimize ang ansatz (opsyonal)​

Maaaring gawing iterative ang proseso. Sa pamamagitan ng pagtrato sa tinantyang ground state energy bilang isang cost function, maaari nating i-optimize ang mga parameter ng circuit (θ\theta) gamit ang mga pamamaraan tulad ng gradient descent upang mapabuti ang ansatz, at sa gayon, ang energy approximation sa susunod na iteration.

Mga pangunahing kalamangan ng SQD​

Nag-aalok ang SQD ng ilang makapangyarihang katangian na nagpapaging nangungunang kandidato para sa pagpapakita ng quantum advantage:

  • Matibay na katatagan sa ingay: Ipagpalagay na ang tunay na ground state ay suportado lamang sa dalawang bitstring. Kung ma-sample ang mga ito, kahit maliit ang kanilang overlap sa ating ansatz, itatalaga ng diagonalization ang tamang timbang sa kanila at epektibong bababalewalain ang lahat ng iba pang labis at maingay na bitstring na maaaring na-sample din. Ang likas na pag-filter na ito ang nagpapaging partikular na tolerante sa ingay ang SQD.
  • Klasikal na paberipikasyon: Hindi tulad ng QPE o VQA, ang SQD ay nagbubunga ng isang klasikal na approximation sa ground state. Nangangahulugan ito na ang sinumang may access sa listahan ng mga bitstring at ang kanilang mga timbang ay maaaring muling kalkulahin at i-verify ang energy estimate nang direkta sa isang klasikal na computer.

Ginamit na ang SQD upang tantiyahin ang ground-state dissociation energy ng N2_2 at ang mga electronic property ng [2Fe-2S] at [4Fe-4S] cluster [2], na may mga circuit na kasinlaki ng 77 qubit at 10,570 gate.

Subukan ang iyong pag-unawa​

Tama o Mali: Maaaring ilapat ang SQD sa mga kemikal na sistema.

Sagot:

Tama

Subukan ang iyong pag-unawa​

Tawagan nating AA ang set ng lahat ng computational basis state na bumubuo sa iyong ansatz. Tawagan nating GG ang set ng lahat ng computational basis state na bumubuo sa tunay na ground state ng iyong sistema. Alin sa mga sumusunod ang katumbas ng isang "magandang" ansatz? Piliin ang lahat ng naaangkop.

(a) A⊂GA \subset G \\ (b) A⊆GA \subseteq G\\ (c) G⊂AG \subset A\\ (d) G⊆AG \subseteq A\\

Sagot:

(c) at (d)

SKQD (Sample-based Krylov Quantum Diagonalization)​

Ang Sample-based Krylov Quantum Diagonalization (SKQD) ay isa pang makapangyarihang quantum sample-based algorithm na nagtatayo sa mga prinsipyo ng SQD. Kahit ang layunin nito ay pareho — ang makahanap ng magandang subspace para sa diagonalization — gumagamit ang SKQD ng mas istrakturadong pamamaraan sa pagbuo ng mga bitstring, lalo na para sa mga problema tulad ng mga lattice Hamiltonian.

Ang pangunahing ideya ng SKQD ay sa halip na mag-optimize ng parameterized circuit upang makahanap ng magandang ansatz, maaaring tiyak na marating ang ground state sa pamamagitan ng pag-sample mula sa isang set ng mga state na nabuo ng sariling likas na time evolution ng sistema — ang Krylov subspace. Maaaring hatiin ang SKQD algorithm sa mga sumusunod na hakbang:

Hakbang 1: Itayo ang Krylov subspace gamit ang time evolution​

Nagsisimula ang proseso sa isang paunang state na ∣ϕ0⟩.|\phi_0\rangle. Mahalaga, hindi natin kailangan ng paunang state na ito na may "magandang" overlap sa ground state. Kailangan lamang nitong maging "polynomial na malaki", o inilarawan ng isang polynomial sa laki ng sistema. Ang algorithm mismo ang magtutulak ng estado palapit nang palapit sa ground state ng sistema. Inilalapat ng SKQD ang time evolution operator, e−iHte^{-iHt}, para sa iba't ibang haba ng oras. Lumilikha ito ng isang set ng dd na iba't ibang quantum state, na tinukoy bilang:

∣ϕj⟩=e−i δtjH∣ϕ0⟩,para sa j=0,1,…,d−1|\phi_j\rangle = e^{-i \,\delta t j H}|\phi_0\rangle, \quad \text{para sa } j = 0, 1, \dots, d-1 \quad \text{}

Ang koleksyon ng mga time-evolved state na ito ay bumubuo ng isang Krylov basis. Ang hakbang na ito ay partikular na epektibo para sa mga lattice Hamiltonian kung saan hindi malaki ang bilang ng mga term sa Hamiltonian. Para sa mga problemang kemikal, ang time evolution na ito ay maaaring magresulta sa napakalalim na mga circuit, kaya naman madalas na inirerekomenda ang SQD para sa mga kasong iyon.

Hakbang 2: Mag-sample mula sa mga Krylov basis state​

Susunod, kinukuha ang mga bitstring sample mula sa bawat isa sa dd na iba't ibang state (∣ϕ0⟩,∣ϕ1⟩,…,∣ϕd−1⟩|\phi_0\rangle, |\phi_1\rangle, \dots, |\phi_{d-1}\rangle) na inihanda sa nakaraang hakbang. Lahat ng bitstring na ito ay pinagsama upang mabuo ang basis para sa subspace.

Hakbang 3: I-project at i-diagonalize nang klasikal​

Ang hakbang na ito ay kapareho ng sa SQD. Ginagamit ang mga nakolektang bitstring upang i-project ang buong Hamiltonian sa subspace na kanilang sinasaglaw. Ang resultang maliit na matrix, H~\tilde{H}, ay idi-diagonalize pagkatapos sa isang klasikal na computer upang mahanap ang ground state energy.

Mga pangunahing kalamangan at garantiya ng SKQD​

Ang istrakturadong pamamaraan ng SKQD ay nagbibigay ng natatanging mga benepisyo:

  • Napatunayang convergence: Ang pangunahing kalamangan ng SKQD ay ang teoreytikal nitong garantiya ng convergence sa ilalim ng mga tiyak at malinaw na tinukoy na kondisyon. Kung ang tunay na ground state ay sparse (maaaring mahusay na ma-approximate ng polynomial na bilang ng mga bitstring) at ang energy gap sa unang excited state ay hindi masyadong maliit, napatunayang epektibo ang pamamaraan. Sa ilalim ng mga kondisyong ito, ginagarantiyahan ng SKQD na mahahanap nito ang mga mahalaga na bitstring na bumubuo sa ground state at maaaring ma-approximate ang ground state energy nang may mataas na katumpakan. Nangangailangan lamang ito ng polynomial na bilang ng mga quantum na eksperimento at shot. Inilalagay ng garantiyang ito ang sample-based na pamamaraan sa mahigpit na teoreytikal na pundasyon, katulad ng mga natatag na pamamaraan tulad ng quantum phase estimation.

  • Mga nakabahaging benepisyo sa SQD: Katulad ng SQD, ang SKQD ay mayroon ding katangian ng katatagan sa ingay. Sa madaling salita, hangga't mayroon ang lahat ng magagandang bitstring sa set ng mga na-sample na bitstring, halos zero ang timbang na itatalaga ng diagonalization sa mga maling bitstring, na ginagawang matibay sa ingay ang pamamaraan. Bukod pa rito, dahil ang solusyon ay galing sa isang klasikal na HPC, ang enerhiya ng solusyon ay klasikal na mabe-verify.

Sa mga eksperimento, ginamit ang SKQD na may hanggang 70 qubit at libu-libong gate upang pag-aralan ang ground state ng mga kumplikadong 4-impurity Anderson model, na nakamit ang mahusay na kasunduan sa mga makabagong klasikal na pamamaraan tulad ng DMRG.[1]

Subukan ang iyong pag-unawa​

Anong bahagi ng SKQD algorithm ang nagpapaging mas angkop nito para sa mga pisikal na problema tulad ng spin lattice kaysa sa mga kemikal na problema? Bakit?

Sagot:

Ang time evolution ay nangangailangan ng mga Trotter circuit, na napakalalim para sa mga Hamiltonian na kumplikado at hindi sparse. Ang mga spin lattice interaction ay pinamumunuan ng mga spin matrix, na katumbas ng mga Pauli matrix. Kaya naman, ang mga Hamiltonian para sa mga spin lattice ay may tendensyang mas macompact na maipahayag sa mga Pauli matrix, lalo na ang mga may nearest-neighbor interaction.

SQD at SKQD bilang heterogeneous computing​

Upang maibuod ang lahat, maaari nating katawanin ang mga sample-based na algorithm bilang kombinasyon ng iba't ibang programming model sa isang set ng mga heterogeneous na resources. Halimbawa, maaari nating katawanin ang ating algorithm bilang isang task workflow.

A schematic of the workflow specific to sample-based quantum diagonalization. The steps include a variational quantum circuit, using measurements to project the Hamiltonian into a subspace, then using a classical optimizer to update variational parameters in the circuit and repeating.

Inilalarawan ng figure na ito ang pundamental na apat na yugto ng workflow. Una, magkakaroon tayo ng task para sa paghahanda ng quantum circuit na may overlap sa ating target state, na sinusundan ng task para sa transpilation, na nangangailangan lamang ng klasikal na resources upang maisagawa. Susunod ay ang isang task na gumagamit ng mga primitive upang isagawa ang ating quantum circuit, na nangangailangan ng quantum resources. Sa wakas, mayroon tayong post-processing task, na maaaring mismo ay isang parallel diagonalization algorithm na tumatakbo sa maraming node.

Bukod pa rito, maaari nating gustong patakbuhin ang isa sa mga algorithm na ito nang maraming beses habang binabago natin ang ating ansatz, o maaari nating gustong patakbuhin ang mga ito nang ganap na parallel na may iba't ibang populasyon.

A schematic of an SQD workload being split among several resources. It shows several processes running sequentially, using the results of one iteration to inform the next, but also performing many such processes in parallel.

Gaya ng makikita sa itaas, maaari kang magpatakbo ng maraming workflow nang sabay-sabay habang ginagawa ang mga sumusunod:

  • Binabago ang mga parameter o istruktura ng ansatz upang mahanap ang pinaka-epektibo.
  • Nagsisimula sa iba't ibang paunang estado o configuration ("populasyon") upang maiwasan ang mga lokal na minimum at matiyak ang mas matibay na resulta.

Ang multi-layered na pamamaraang ito, na pinagsama ang task-based heterogeneity at workflow-level parallelism, ay susi sa pag-unlock ng buong potensyal ng mga algorithm na ito.

Programming practice​

Sanayin natin ang SKQD algorithm, ipinapakita ang heterogeneous workflow na inilarawan kanina. Ang proseso ay nahahati sa apat na natatanging yugto, bawat isa ay may sariling Python script at kaukulang shell script para sa pagsusumite ng trabaho.

Mapping (mapping.py at mapping.sh)​

Ang unang hakbang sa ating workflow ay ang pagtukoy sa pisikal na problema at ang pagmamapa nito sa isang set ng mga quantum circuit.

Tinutukoy ng mapping.py ang mga parameter para sa isang tiyak na problema sa pisika — sa kasong ito, isang Anderson impurity model na may pitong bath site (n_bath = 7). Itinatayo nito ang one-body (h1e) at two-body (h2e) na integral na kumakatawan sa Hamiltonian ng sistema.


...

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],
        )

Pagkatapos ay binubuo nito ang mga quantum circuit na kinakailangan para sa SKQD algorithm. Nagsisimula ito sa paggawa ng paunang state (initial_state) at pagkatapos ay inilalapat ang mga time-evolution operator para sa iba't ibang bilang ng hakbang (d = 8) upang mabuo ang iba't ibang Krylov basis state, ∣ϕj⟩=(e−iHt)j∣ϕ0⟩|\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))

Sine-save ng script ang listahan ng 8 na nabuo na circuit (bawat isa ay may nakadugtong na mga sukat) sa isang file na pinangalanang circuits.qpy.

Ang mapping.sh ay isang Slurm batch script na ginagamit upang isumite ang trabaho ng mapping.py. Dahil ito ay isang klasikal na computation, humihiling ito ng mga resources mula sa isang karaniwang 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 at optimization.sh)​

Kapag nagawa na ang ating mga circuit, kailangang i-optimize at i-compile ang mga ito upang mapatakbo nang mahusay sa target na quantum hardware.

Sa optimization.py, una itong naglo-load ng circuits.qpy file na ginawa sa mapping stage at nagdadala ng impormasyon tungkol sa quantum resource sa pamamagitan ng QRMI(), isang quantum resource manager. Pagkatapos ay gumagamit ito ng generate_preset_pass_manager ng Qiskit na may mataas na optimization level (optimization_level=3) upang i-convert ang mga abstract, lohikal na circuit sa Instruction Set Architecture (ISA) circuit. Ang prosesong ito ay muling nagsusulat ng mga circuit gamit ang mga native gate ng hardware at ini-optimize ang mga ito upang mabawasan ang depth at maminimize ang mga 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)

Ang mga na-transpile, hardware-ready na circuit ay sine-save sa isang bagong file, isa_circuits.qpy.

Katulad ng mapping script, ang Slurm job na ito ay tumatakbo rin sa isang klasikal na CPU partition (--partition=normal), dahil ang transpilation ay isang klasikal na gawain.

#!/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 at execution.sh)​

Ito ang tanging yugto kung saan ginagamit ang isang quantum computer. Dito, isinasagawa natin ang mga na-optimize na circuit at kinokolekta ang mga measurement sample.

Naglo-load ang execution.py ng na-optimize na isa_circuits.qpy file, pagkatapos ay nagpapasinaya ng SamplerV2 primitive na konektado sa isang quantum resource. Pagkatapos ay tinatawag nito ang sampler.run() upang isagawa ang mga circuit sa QPU para sa isang tinukoy na bilang ng 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)

Sa katapusan ng execution, ang mga nasukat na resulta (bitstring) mula sa lahat ng circuit ay kinokolekta at pinagsama, at ang kanilang mga bilang ay sine-save sa isang counts.json file.

Ang Slurm script na execution.sh ay naiiba sa mga iba sa yugtong ito. Humihiling ito na patakbuhin sa quantum partition (--partition=quantum) at partikular na humihiling ng isang 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 at postprocessing.sh)​

Sa huling hakbang, bumabalik tayo sa isang klasikal na computer upang suriin ang data mula sa quantum na eksperimento at kalkulahin ang panghuling resulta: ang ground state energy ng ating target na sistema.

Una itong binabasa ng postprocessing.py ang counts.json file na naglalaman ng mga resulta ng sukat. Pagkatapos ay muling itinatayo nito ang Hamiltonian ng Anderson model (gamit ang parehong mga parameter tulad ng sa mapping.py). Pagkatapos ay ipinapasa nito ang mga nasukat na bitstring at ang kahulugan ng Hamiltonian sa function na diagonalize_fermionic_hamiltonian. Isinasagawa ng function na ito ang pangunahing SKQD logic: ginagamit nito ang mga bitstring upang maitayo ang projected Hamiltonian na H~\tilde{H} at idi-diagonalize ito upang mahanap ang ground state energy.


...

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

Sa wakas, ini-print nito ang nakalkulang SKQD energy at inihahambing ito sa kilalang eksaktong enerhiya para sa problemang ito, na nagpapakita ng panghuling absolute error ng computation.

Ang panghuling job script ay tumatakbo sa isang klasikal na partition (--partition=normal), dahil lahat ng pagsusuri ay klasikal. Para sa malalaking subspace, ang hakbang na ito ay maaaring mangailangan ng higit pang klasikal na HPC resources.

#!/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

Buod​

At iyon na! Dumaan na tayo sa ilang konsepto at halimbawa na makakatulong sa iyong makapagsimula sa pamamahala ng mga kumplikadong hybrid na programa. Siyempre, ito ay simula pa lamang ng lahat ng maaari mong gawin sa kombinasyon ng quantum at klasikal na HPC resources.

Upang tuklasin ang higit pang mga kaso ng paggamit at mga algorithm, i-browse ang aming dokumentasyon at mga tutorial sa IBM Quantum Platform, at tiyaking bisitahin ang mga resources na ibinabahagi sa susunod na aralin para sa karagdagang impormasyon tungkol sa mga algorithm at software para sa parehong mga computational scientist at data center administrator.

Mga Sanggunian​

[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