Ansaetze וצורות וריאציוניות

בלב כל האלגוריתמים הוריאציוניים עומרת הרעיון המרכזי של ניתוח ההבדלים בין מצבים, שמחוברים בנוחות דרך מיפוי עם תכונות טובות (למשל, רציפות, גזירות) מתוך קבוצה של פרמטרים או משתנים — ומכאן השם.

ראשית, נבחן כיצד לבנות מעגלים פרמטריים ביד. נשתמש במעגלים אלה כדי להגדיר צורה וריאציונית המייצגת אוסף של מצבים פרמטריים שהאלגוריתם הוריאציוני שלנו יחקור. לאחר מכן, נבנה את ה-ansatz שלנו על ידי הפעלת הצורה הוריאציונית על מצב הייחוס שלנו.

נחקור גם כיצד לבצע פשרה בין מהירות לדיוק תוך כדי חקר מרחב החיפוש הזה.

מעגלים קוונטיים פרמטריים

אלגוריתמים וריאציוניים פועלים על ידי חקר והשוואה של טווח מצבים קוונטיים $|\psi(\vec{\theta})\rangle$, התלויים בקבוצה סופית של $k$ פרמטרים $\vec{\theta} = (\theta^0, \ldots, \theta^{k-1})$. ניתן להכין מצבים אלה באמצעות מעגל קוונטי פרמטרי, שבו שערים מוגדרים עם פרמטרים כוונונים. ניתן ליצור מעגל פרמטרי זה מבלי לקבוע זוויות ספציפיות עדיין:

# 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"))

צורה וריאציונית ו-Ansatz

כדי לבצע אופטימיזציה איטרטיבית ממצב ייחוס $|\rho\rangle$ למצב יעד $|\psi(\vec\theta)\rangle$, עלינו להגדיר צורה וריאציונית $U_V(\vec{\theta})$ המייצגת אוסף של מצבים פרמטריים שהאלגוריתם הוריאציוני שלנו יחקור:

$$\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}$$

שים לב שהמצב הפרמטרי תלוי הן במצב הייחוס $|\rho\rangle$, שאינו תלוי בפרמטרים כלשהם, והן בצורה הוריאציונית $U_V(\vec{\theta})$, שתמיד תלויה בפרמטרים. אנו מתייחסים לשילוב של שני חלקים אלה כ-ansatz: $U_A(\vec\theta) := U_V(\vec\theta)U_R$.

כשאנו בונים את ה-ansatz שלנו לייצג אוסף של מצבים פרמטריים לחקירה, אנו נתקלים בבעיה חשובה: ממדיות. מערכת של $n$ Qubit (כלומר, מרחב הילברט) כוללת מספר עצום של מצבים קוונטיים שונים במרחב הקונפיגורציה. היינו זקוקים למספר גדול ומסורבל של פרמטרים כדי לחקור אותה במלואה. כמותית, הממדיות שלה היא $D = 2^{2n}$. ולמצות את המדה, מורכבות זמן הריצה של אלגוריתמי חיפוש ודומיהם גדלה באופן מעריכי עם הממדיות — תופעה המכונה לעיתים בספרות "קללת הממדיות".

כדי להתמודד עם בעיה זו, נהוג להטיל אילוצים סבירים על הצורה הוריאציונית כך שרק המצבים הרלוונטיים ביותר ייחקרו. מציאת ansatz קטוע ויעיל היא תחום מחקר פעיל, אך נסקור שני עיצובים נפוצים.

Ansaetze היוריסטיים ופשרות

אם אין לך מידע על הבעיה הספציפית שיכול לסייע בהגבלת הממדיות, תוכל לנסות משפחה שרירותית של מעגלים פרמטריים עם פחות מ-$2^{2n}$ פרמטרים. עם זאת, יש כמה פשרות לשקול:

• מהירות: על ידי צמצום מרחב החיפוש, האלגוריתם יכול לרוץ מהר יותר.
• דיוק: צמצום המרחב עלול להוציא את הפתרון האמיתי לבעיה, מה שיוביל לפתרונות לא אופטימליים.
• רעש: מעגלים עמוקים יותר מושפעים מרעש, לכן עלינו לבחון את הקישוריות, השערים ואמינות השערים של ה-ansatz שלנו.

קיימת פשרה יסודית בין איכות (או אפילו פתירות) לבין מהירות: ככל שיש יותר פרמטרים, כך סביר יותר למצוא תוצאה מדויקת, אך כך האלגוריתם ייקח יותר זמן לרוץ.

מעגלים N-local

אחת הדוגמאות הנפוצות ביותר של ansaetze היוריסטיים הם מעגלי N-local, מכמה סיבות:

• יישום יעיל: ה-ansatz ה-N-local מורכב בדרך כלל משערים מקומיים פשוטים שניתן ליישם ביעילות על מחשב קוונטי, תוך שימוש במספר קטן של Qubit פיזיים. זה מקל על בניית מעגלים קוונטיים ואופטימיזציה שלהם.
• תופס קורלציות חשובות: ה-ansatz ה-N-local יכול לתפוס קורלציות חשובות בין ה-Qubit במערכת קוונטית, אפילו עם מספר קטן של שערים. הסיבה לכך היא ששערים מקומיים יכולים לפעול על Qubit שכנים וליצור שזירה ביניהם, שיכולה להיות חשובה לסימולציה של מערכות קוונטיות מורכבות.

מעגלים אלה מורכבים משכבות סיבוב ושזירה המתחלפות אחת או יותר פעמים באופן הבא:

• כל שכבה מורכבת משערים בגודל של לכל היותר $N$, כאשר $N$ חייב להיות קטן ממספר ה-Qubit.
• עבור שכבת סיבוב, השערים מוערמים זה על זה. ניתן להשתמש בפעולות סיבוב סטנדרטיות, כגון RX או CRZ.
• עבור שכבת שזירה, ניתן להשתמש בשערים כמו שערי Toffoli או CX עם אסטרטגיית שזירה.
• שני סוגי השכבות יכולים להיות פרמטריים או לא, אך לפחות אחד מהם חייב לכלול פרמטרים. אחרת, ללא פרמטר אחד לפחות, לא יהיו וריאציות!
• אופציונלית, שכבת סיבוב נוספת מתווספת לסוף המעגל.

לדוגמה, בואו ניצור מעגל NLocal בן חמישה Qubit עם בלוקי סיבוב המורכבים משערי RX ו-CRZ, בלוקי שזירה המורכבים מ-שערי Toffoli הפועלים על Qubit $[0,1,2]$, $[0,2,3]$, $[4,2,1]$ ו-$[3,1,0]$ ו-$2$ חזרות של כל שכבה.

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

בדוגמה לעיל, השער הגדול ביותר הוא שער Toffoli, הפועל על שלושה Qubit, מה שהופך את המעגל ל-$3$-local. הסוג הנפוץ ביותר של מעגלי $N$-local הוא מעגלי $2$-local עם שערי סיבוב של Qubit בודד ושערי שזירה של $2$ Qubit.

בואו ניצור מעגל $2$-local באמצעות המחלקה TwoLocal של Qiskit. התחביר זהה ל-NLocal, אך יש כמה הבדלים. לדוגמה, רוב השערים, כגון RX, RZ ו-CNOT, ניתן להעביר כמחרוזות מבלי לייבא את השערים או ליצור מופע Parameter.

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

במקרה זה, השתמשנו בפיזור שזירה ליניארי, שבו כל Qubit משולב עם הבא. למידע על אסטרטגיות אחרות, עיין ב-תיעוד TwoLocal.

Efficient SU2

efficient_su2 הוא מעגל יעיל לחומרה המורכב משכבות של פעולות Qubit בודד הפורסות את SU(2) ושזירות CX. זהו דפוס היוריסטי שניתן להשתמש בו להכנת פונקציות גל ניסיוניות לאלגוריתמים קוונטיים וריאציוניים או כמעגל סיווג ללמידת מכונה.

from qiskit.circuit.library import efficient_su2

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

Ansaetze ספציפיים לבעיה

בעוד ש-ansaetze היוריסטיים ויעילים לחומרה עוזרים לנו לפתור בעיה בצורה נאיבית, נוכל להשתמש בידע ספציפי לבעיה כדי להגביל את מרחב חיפוש המעגל לסוג ספציפי. זה יסייע לנו להשיג מהירות מבלי לאבד דיוק בתהליך החיפוש שלנו.

אופטימיזציה

בבעיית max-cut, אנו רוצים לחלק את הצמתים של גרף בצורה שמקסמת את מספר הקשתות בין צמתים בקבוצות שונות. חלוקת ה-max-cut הרצויה לגרף שלהלן ברורה: הצומת ה-0 בשמאל צריך להיות מופרד משאר הצמתים בימין על ידי חתך.

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

כדי להשתמש באלגוריתם QAOA לבעיית max-cut, אנו זקוקים להמילטוניאן פאולי המקודד את העלות כך שערך הציפייה המינימלי של האופרטור מתאים למספר המרבי של קשתות בין הצמתים בשתי קבוצות שונות.

לדוגמה פשוטה זו, האופרטור הוא צירוף לינארי של איברים עם אופרטורי Z על צמתים המחוברים בקשת (זכור ש-Qubit ה-0 הוא הרחוק ביותר מימין): $ZZII + IZZI + ZIIZ + IZIZ + IIZZ$. לאחר בניית האופרטור, ניתן לבנות בקלות את ה-ansatz לאלגוריתם QAOA באמצעות מעגל QAOAAnsatz מספריית המעגלים של Qiskit.

# 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")

התמונה הקודמת ממחישה את ה-ansatz בשערים בסיסיים לבהירות. עם זאת, ניתן לבטא אותו במספר רמות של פירוק על ידי שינוי הארגומנט reps או על ידי ציור המעגל ללא שיטת ה-decompose. לדוגמה, הייצוג הבא מציג ישירות את מבנה QAOA עם ערך reps ברירת מחדל, שהוא reps=1.

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

למידת מכונה קוונטית

בלמידת מכונה, יישום נפוץ הוא סיווג נתונים לשתי קטגוריות או יותר. זה כולל קידוד נקודת נתונים למפת מאפיינים הממפה וקטורי מאפיינים קלאסיים אל מרחב הילברט הקוונטי. בניית מפות מאפיינים קוונטיות מבוססות על מעגלים קוונטיים פרמטריים שקשה לסמל אותם קלאסית היא צעד חשוב לקראת השגת יתרון פוטנציאלי על גישות למידת מכונה קלאסיות ומהווה תחום מחקר פעיל.

ניתן להשתמש ב-zz_feature_map כדי ליצור מעגל פרמטרי. נוכל להעביר את נקודות הנתונים שלנו למפת המאפיינים ($x$) וצורה וריאציונית נפרדת להעברת משקלים כפרמטרים ($\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")

סיכום

בשיעור זה, למדת כיצד להגדיר את מרחב החיפוש שלך עם צורה וריאציונית:

• הכנת מצבים עם מעגל קוונטי פרמטרי, שבו שערים מוגדרים עם פרמטרים כוונונים
• כיצד לבנות ansaetze שמבצעים פשרה בין מהירות לדיוק
• Ansaetze היוריסטיים
• Ansaetze ספציפיים לבעיה

עומס העבודה הוריאציוני ברמה גבוהה שלנו נראה כך:

עבור כל פרמטר וריאציוני $\vec\theta$, ייוצר מצב קוונטי שונה. כדי למצוא את הפרמטרים האופטימליים, עלינו להגדיר פונקציית עלות ספציפית לבעיה לעדכון איטרטיבי של פרמטרי ה-ansatz שלנו.