Ansaetze at variational forms

Sa puso ng lahat ng variational algorithms ay ang pangunahing ideya ng pagsusuri ng mga pagkakaiba sa pagitan ng mga estado, na maginhawang nauugnay sa pamamagitan ng ilang mabait na mapping (halimbawa, tuluy-tuloy, differentiable) mula sa isang hanay ng mga parameter o variable — kaya ang pangalan.

Una, susuriin natin kung paano bumuo ng mga parameterized circuit nang mano-mano. Gagamitin natin ang mga circuit na ito para tukuyin ang isang variational form na kumakatawan sa isang koleksyon ng mga parameterized state para sa ating variational algorithm na tuklasin. Pagkatapos, bubuuin natin ang ating ansatz sa pamamagitan ng paglapat ng variational form na ito sa ating reference state.

Susuriin din natin kung paano mag-trade-off ng bilis kumpara sa katumpakan habang tinutuklas ang search space na ito.

Parameterized Quantum Circuits

Ang mga variational algorithm ay gumagana sa pamamagitan ng pagtuklas at paghahambing ng isang hanay ng mga quantum state $|\psi(\vec{\theta})\rangle$, na nakasalalay sa isang limitadong hanay ng $k$ na mga parameter $\vec{\theta} = (\theta^0, \ldots, \theta^{k-1})$. Ang mga estado na ito ay maaaring ihanda gamit ang isang parameterized quantum circuit, kung saan ang mga gate ay tinukoy na may mga nababagong parameter. Posible itong lumikha ng parameterized circuit nang hindi pa nagbi-bind ng mga tiyak na anggulo:

# Added by doQumentation — required packages for this notebook
!pip install -q qiskit rustworkx

from qiskit.circuit import QuantumCircuit, Parameter

theta = Parameter("θ")

qc = QuantumCircuit(3)
qc.rx(theta, 0)
qc.cx(0, 1)
qc.x(2)

qc.draw("mpl")

from math import pi

angle_list = [pi / 3, pi / 2]
circuits = [qc.assign_parameters({theta: angle}) for angle in angle_list]

for circuit in circuits:
    display(circuit.draw("mpl"))

Variational Form at Ansatz

Para paulit-ulit na mag-optimize mula sa isang reference state $|\rho\rangle$ patungo sa isang target state $|\psi(\vec\theta)\rangle$, kailangan nating tukuyin ang isang variational form $U_V(\vec{\theta})$ na kumakatawan sa isang koleksyon ng mga parameterized state para sa ating variational algorithm na tuklasin:

$$\begin{aligned} |0\rangle \xrightarrow{U_R} U_R|0\rangle & = |\rho\rangle \xrightarrow{U_V(\vec{\theta})} U_A(\vec{\theta})|0\rangle \\[1mm] & = U_V(\vec{\theta})U_R|0\rangle \\[1mm] & = U_V(\vec{\theta})|\rho\rangle \\[1mm] & = |\psi(\vec{\theta})\rangle \\[1mm] \end{aligned}$$

Pansinin na ang parameterized state ay nakasalalay sa parehong reference state $|\rho\rangle$, na hindi nakasalalay sa anumang parameter, at sa variational form $U_V(\vec{\theta})$, na laging nakasalalay sa mga parameter. Tinutukoy natin ang kumbinasyon ng dalawang kalahating ito bilang isang ansatz: $U_A(\vec\theta) := U_V(\vec\theta)U_R$.

Habang binubuo natin ang ating ansatz para kumatawan sa isang koleksyon ng mga parameterized state para sa ating variational algorithm na tuklasin, natutuklasan natin ang isang mahalagang isyu: dimensionality. Ang isang $n$-qubit na sistema (iyon ay, Hilbert space) ay may napakaraming natatanging quantum state sa configuration space. Kakailanganin natin ng isang napakaraming bilang ng mga parameter para lubos itong tuklasin. Sa dami, ang dimensionality nito ay $D = 2^{2n}$. Para lalong mapahirap ang sitwasyon, ang runtime complexity ng mga search algorithm, at iba pang katulad, ay lumalaki nang exponential sa dimensionality na ito, isang penomenong madalas na tinutukoy sa literatura bilang ang curse of dimensionality.

Para kontrahin ang balakid na ito, karaniwang ginagawa ang pagpapataw ng ilang makatwirang mga hadlang sa variational form upang ang pinaka-releban lamang na mga estado ang matuklas. Ang paghahanap ng isang mahusay na truncated ansatz ay isang aktibong larangan ng pananaliksik, ngunit sasaklawin natin ang dalawang karaniwang disenyo.

Heuristic ansaetze at mga trade-off

Kung wala kang anumang impormasyon tungkol sa iyong partikular na problema na makakatulong na limitahan ang dimensionality, maaari kang subukan ng isang arbitrary na pamilya ng mga parameterized circuit na may mas kaunti sa $2^{2n}$ na mga parameter. Gayunpaman, may ilang mga trade-off na dapat isaalang-alang:

• Bilis: Sa pamamagitan ng pagbabawas ng search space, ang algorithm ay maaaring tumakbo nang mas mabilis.
• Katumpakan: Ang pagbabawas ng espasyo ay maaaring magdulot ng panganib na mailabas ang aktwal na solusyon sa problema, na humahantong sa mga suboptimal na solusyon.
• Ingay: Ang mga mas malalim na circuit ay naaapektuhan ng ingay, kaya kailangan nating mag-eksperimento sa connectivity, gates, at gate fidelity ng ating ansatz.

Mayroon isang pundamental na trade-off sa pagitan ng kalidad (o kahit solusyon) at bilis: habang mas maraming parameter, mas malamang na makahanap ng tumpak na resulta, ngunit mas matagal na tatakbo ang algorithm.

N-local circuits

Isa sa pinaka-malawakang ginagamit na mga halimbawa ng heuristic ansaetze ay ang N-local circuits, dahil sa ilang dahilan:

• Mahusay na implementasyon: Ang N-local ansatz ay karaniwang binubuo ng mga simpleng, lokal na gates na maaaring ipatupad nang mahusay sa isang quantum computer, gamit ang isang maliit na bilang ng mga pisikal na qubit. Ginagawa nitong mas madaling bumuo at mag-optimize ng mga quantum circuit.
• Nakakakuha ng mahahalagang ugnayan: Ang N-local ansatz ay kayang makuha ang mahahalagang ugnayan sa pagitan ng mga qubit sa isang quantum system, kahit na may maliit na bilang ng mga gate. Ito ay dahil ang mga lokal na gate ay maaaring kumilos sa mga katabing qubit at lumikha ng entanglement sa pagitan nila, na maaaring mahalaga para sa pag-simulate ng mga kumplikadong quantum system.

Ang mga circuit na ito ay binubuo ng mga rotation at entanglement layer na paulit-ulit na alternately isa o higit pang beses tulad ng sumusunod:

• Ang bawat layer ay binubuo ng mga gate na may sukat na hindi hihigit sa $N$, kung saan ang $N$ ay dapat na mas mababa sa bilang ng mga qubit.
• Para sa isang rotation layer, ang mga gate ay nakapatong sa isa't isa. Maaari tayong gumamit ng mga karaniwang rotation operation, tulad ng RX o CRZ.
• Para sa isang entanglement layer, maaari tayong gumamit ng mga gate tulad ng Toffoli gates o CX na may entanglement strategy.
• Ang parehong uri ng layer ay maaaring parameterized o hindi, ngunit hindi bababa sa isa sa kanila ay kailangang maglaman ng mga parameter. Kung hindi, nang wala kahit isang parameter, walang magaganap na mga variation!
• Opsyonal, isang karagdagang rotation layer ang idinaragdag sa dulo ng circuit.

Halimbawa, gumawa tayo ng limang-qubit na NLocal circuit na may mga rotation block na binubuo ng RX at CRZ gate, mga entanglement block na binubuo ng Toffoli gates na kumikilos sa mga qubit $[0,1,2]$, $[0,2,3]$, $[4,2,1]$ at $[3,1,0]$ at $2$ na paulit-ulit ng bawat layer.

from qiskit.circuit.library import NLocal, CCXGate, CRZGate, RXGate
from qiskit.circuit import Parameter

theta = Parameter("θ")
ansatz = NLocal(
    num_qubits=5,
    rotation_blocks=[RXGate(theta), CRZGate(theta)],
    entanglement_blocks=CCXGate(),
    entanglement=[[0, 1, 2], [0, 2, 3], [4, 2, 1], [3, 1, 0]],
    reps=2,
    insert_barriers=True,
)
ansatz.decompose().draw("mpl")

Sa halimbawa sa itaas, ang pinakamalaking gate ay ang Toffoli gate, na kumikilos sa tatlong qubit, na ginagawang $3$-local ang circuit. Ang pinaka-karaniwang uri ng $N$-local circuit ay ang $2$-local circuit na may mga single-qubit rotation gate at $2$-qubit entanglement gate.

Gumawa tayo ng $2$-local circuit gamit ang Qiskit's TwoLocal class. Ang syntax ay katulad ng NLocal, ngunit may ilang mga pagkakaiba. Halimbawa, karamihan sa mga gate, tulad ng RX, RZ, at CNOT, ay maaaring ipasa bilang mga string nang hindi ini-import ang mga gate o lumilikha ng Parameter instance.

from qiskit.circuit.library import TwoLocal

ansatz = TwoLocal(
    num_qubits=5,
    rotation_blocks=["rx", "rz"],
    entanglement_blocks="cx",
    entanglement="linear",
    reps=2,
    insert_barriers=True,
)
ansatz.decompose().draw("mpl")

Sa kasong ito, ginamit natin ang linear entanglement distribution, kung saan ang bawat qubit ay entangled sa susunod. Para malaman ang tungkol sa iba pang mga estratehiya, sumangguni sa TwoLocal documentation.

Efficient SU2

Ang efficient_su2 ay isang hardware-efficient circuit na binubuo ng mga layer ng single-qubit operation na sumasaklaw sa SU(2) at mga CX entanglement. Ito ay isang heuristic pattern na maaaring gamitin para maghanda ng mga trial wave function para sa mga variational quantum algorithm o bilang isang classification circuit para sa machine learning.

from qiskit.circuit.library import efficient_su2

ansatz = efficient_su2(4, su2_gates=["rx", "y"], entanglement="linear", reps=1)
ansatz.decompose().draw("mpl")

Problem-specific ansaetze

Habang ang mga heuristic at hardware efficient ansaetze ay tumutulong sa atin na malutas ang isang problema sa isang simpleng paraan, maaari tayong gumamit ng problem-specific na kaalaman para limitahan ang ating circuit search space sa isang tiyak na uri. Makakatulong ito sa atin na makakuha ng bilis nang hindi nawawala ang katumpakan sa ating proseso ng paghahanap.

Optimization

Sa isang max-cut problem, nais nating hatiin ang mga node ng isang graph sa paraang nagpapalaki sa bilang ng mga gilid sa pagitan ng mga node sa magkaibang grupo. Ang nais na max-cut partition para sa graph sa ibaba ay malinaw: ang ika-0 node sa kaliwa ay dapat paghiwalayin mula sa natitirang mga node sa kanan sa pamamagitan ng isang cut.

import rustworkx as rx
from rustworkx.visualization import mpl_draw

n = 4
G = rx.PyGraph()
G.add_nodes_from(range(n))
# The edge syntax is (start, end, weight)
edges = [(0, 1, 1.0), (0, 2, 1.0), (0, 3, 1.0), (1, 2, 1.0), (2, 3, 1.0)]
G.add_edges_from(edges)

mpl_draw(
    G, pos=rx.shell_layout(G), with_labels=True, edge_labels=str, node_color="#1192E8"
)

Para magamit ang QAOA algorithm para sa isang max-cut problem, kailangan natin ng isang Pauli Hamiltonian na nag-encode ng gastos sa paraang ang minimum na expected value ng operator ay tumutugma sa maximum na bilang ng mga gilid sa pagitan ng mga node sa dalawang magkaibang grupo.

Para sa simpleng halimbawa na ito, ang operator ay isang linear na kumbinasyon ng mga term na may Z operator sa mga node na konektado ng isang gilid (alalahanin na ang ika-0 qubit ay pinaka-malayo sa kanan): $ZZII + IZZI + ZIIZ + IZIZ + IIZZ$. Kapag ang operator ay naitayo na, ang ansatz para sa QAOA algorithm ay madaling maitayo sa pamamagitan ng paggamit ng QAOAAnsatz circuit mula sa Qiskit circuit library.

# Pre-defined ansatz circuit, operator class and visualization tools
from qiskit.circuit.library import QAOAAnsatz
from qiskit.quantum_info import SparsePauliOp

# Problem to Hamiltonian operator
hamiltonian = SparsePauliOp.from_list(
    [("ZZII", 1), ("IZZI", 1), ("ZIIZ", 1), ("IZIZ", 1), ("IIZZ", 1)]
)
# QAOA ansatz circuit
ansatz = QAOAAnsatz(hamiltonian, reps=2)
# Draw
ansatz.decompose(reps=3).draw("mpl")

Ipinapakita ng nakaraang larawan ang ansatz sa mga basic gate para sa kalinawan. Gayunpaman, maaari itong ipahayag sa maraming antas ng decomposition sa pamamagitan ng pagbabago ng reps argument o sa pamamagitan ng pagguhit ng circuit nang walang decompose method. Halimbawa, ang sumusunod na representasyon ay direktang nagpapakita ng QAOA structure na may default na reps value, na reps=1.

ansatz.decompose(reps=2).draw("mpl")

Quantum Machine Learning

Sa machine learning, isang karaniwang aplikasyon ay ang pag-uuri ng data sa dalawa o higit pang kategorya. Kasama dito ang pag-encode ng isang datapoint sa isang feature map na nagma-map ng mga klasikal na feature vector sa quantum Hilbert space. Ang pagbuo ng mga quantum feature map batay sa mga parameterized quantum circuit na mahirap i-simulate nang klasikal ay isang mahalagang hakbang patungo sa pagkuha ng potensyal na kalamangan kumpara sa mga klasikal na machine learning approach at isang aktibong larangan ng kasalukuyang pananaliksik.

Ang zz_feature_map ay maaaring gamitin para lumikha ng parameterized circuit. Maaari tayong ipasa ang ating mga data point sa feature map ($x$) at isang hiwalay na variational form para ipasa ang mga timbang bilang mga parameter ($\theta$).

from qiskit.circuit.library import zz_feature_map, TwoLocal

data = [0.1, 0.2]

zz_feature_map_reference = zz_feature_map(feature_dimension=2, reps=2)
zz_feature_map_reference = zz_feature_map_reference.assign_parameters(data)

variation_form = TwoLocal(2, ["ry", "rz"], "cz", reps=2)
vqc_ansatz = zz_feature_map_reference.compose(variation_form)
vqc_ansatz.decompose().draw("mpl")

Buod

Sa araling ito, natuto ka kung paano tukuyin ang iyong search space gamit ang isang variational form:

• Maghanda ng mga estado gamit ang isang parameterized quantum circuit, kung saan ang mga gate ay tinukoy na may mga nababagong parameter
• Kung paano bumuo ng mga ansaetze na nag-trade-off ng bilis kumpara sa katumpakan
• Heuristic ansaetze
• Problem-specific ansaetze

Ang ating mataas na antas na variational workload ay ganito ang hitsura:

Para sa bawat variational parameter $\vec\theta$, isang iba't ibang quantum state ang malilikha. Para mahanap ang mga optimal na parameter, kailangan nating tukuyin ang isang problem-specific na cost function para paulit-ulit na i-update ang mga parameter ng ating ansatz.