הרצת מעגלים קוונטיים

צפו בסרטון על מעגלים קוונטיים ו-primitives מאת Olivia Lanes, או פתחו את הסרטון בחלון נפרד ב-YouTube.

סקירת השיעור

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

1. מה הם למעשה מחשבי הקוונטים של IBM®. תצטרכו לדעת את יסודות מאפייני החומרה כדי לעצב בצורה מיטבית את ה-Circuit הקוונטיים שלכם להרצה עליה.

2. מה זה Qiskit, מה זה primitives, וכיצד נוכל להשתמש בהם כדי ליצור ולהריץ Circuit קוונטיים.

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

חומרה – מעבדים קוונטיים של IBM

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

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

קווי שידור מיקרוגל מוטבעים על השבב כדי להעביר אותות מיקרוגל ל-Qubit. כשאנחנו מיישמים פולסי מיקרוגל מכויילים במיוחד — עם תדר, משרעת, צורה ומשך ספציפיים — על הקווים, אנחנו יכולים לגרום ל-Qubit לעשות דברים ספציפיים. זה מהווה את הבסיס של ה-Gate הקוונטיים שלנו. אנחנו מייצרים את השבב כך ש-Qubit שכנים מחוברים במבנה סריג ספציפי הנקרא סריג hex כבד. הקישוריות הזו — ה-טופולוגיה כביכול — של המעבדים שלנו היא גורם חשוב לקחת בחשבון בעת עיצוב Circuit, כפי שנדון מאוחר יותר בשיעור.

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

ל-IBM יש עשרות מחשבים קוונטיים ברחבי העולם, ולאחרונה שדרגנו את הצי שלנו לכלול אך ורק מעבדים גדולים מ-100 Qubit. חלקם ממוקמים במרכז נתונים קוונטי של IBM בצפון מדינת ניו יורק ופרוסים דרך הענן לשימוש כולם — וחלקם הם מערכות ייעודיות, on-premises שתומכות בשותפים ב-IBM Quantum® Network. אפשר להיכנס ל-quantum.cloud.ibm.com כדי לראות אילו מעבדים נגישים לכם.

כל מעבד מפרט שלושה מדדי ביצועים, שדנו בהם בשיעור הקודם, אבל כתזכורת, הם: מספר Qubit, EPLG ו-CLOPS.

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

• EPLG, או "שגיאות לכל Gate בשכבה." זה מדד של איכות ה-Qubit וה-Gate הקוונטיים. הוא מודד את השגיאה הממוצעת שכל Gate מכניס ב-Circuit שמסבך Qubit שכנים בשרשרת של 100 Qubit. אתם רוצים שזה יהיה קטן ככל האפשר.

• CLOPS, או "פעולות שכבת Circuit לשנייה." זה מכמת את מהירות המעבד. הוא מודד כמה שכבות של Circuit ספציפי לבנצ'מרקינג הנקרא Circuit נפח קוונטי יכולה יחידת עיבוד קוונטי (QPU) לבצע ביחידת זמן. ככל שהמספר גבוה יותר, כך נוכל לחשב מהר יותר.

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

תוכנה: Qiskit ו-Qiskit Runtime

כדי להפוך את הבעיה הקוונטית שלכם להוראות למחשב קוונטי, תשתמשו ב-Qiskit, ערכת פיתוח התוכנה בקוד פתוח שתוכננה לעבודה על מחשבים קוונטיים שפותחה על ידי IBM. יש גם את מערכת האקולוגיה של Qiskit — אוסף של מדריכי תוכנה ופונקציות שבונים על או מרחיבים את הפונקציונליות הבסיסית של Qiskit — ו-Qiskit Runtime — שירות מחשוב קוונטי ומודל תכנות שמאפשר למשתמשים לעצב ולמטב את עומסי העבודה הקוונטיים שלהם ולהריץ אותם ביעילות באמצעות Qiskit Runtime Primitives.

primitive הוא אבן בניין קטנה שאפשר להשתמש בה לעיצוב Circuit או עבודה גדולה יותר. שני ה-primitives החשובים ביותר עבורנו הם ה-Sampler וה-Estimator, שנדון בהם ביתר עומק בקרוב.

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

Circuit קוונטיים

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

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

Gate מיוצגים על ידי סמלים שונים על החוטים של ה-Qubit המעורבים. Gate של Qubit בודד — כמו Gate הדאמר, המתואר להלן (התיבה עם ה-H) — משפיע רק על ה-Qubit שהחוט שלו מונח עליו. Gate של ריבוי Qubit — כמו Gate CNOT, המוצג גם כן להלן (סימן הפלוס בעיגול עם קו המחובר ל-q0) — משפיעים על שניים או יותר Qubit. ב-Gate CNOT המתואר, מצב q1 משתנה בהתאם למצב q0. לאחר ביצוע כל ה-Gate, אנחנו יכולים למדוד את ה-Qubit, המסומן על ידי ה-Gate השחורים עם סמל המדידה. תוצאות המדידות נכתבות לרגיסטרים קלאסיים, אוטובוס "meas" בקו כפול למטה.

מאפיין חשוב אחד של Circuit הוא עומקו. עומק של Circuit קוונטי הוא המספר המינימלי של "שכבות" של Gate קוונטיים, המבוצעים במקביל, הנדרשות להשלמת ה-Circuit. Gate קוונטיים יכולים להיות מבוצעים במקביל (בו-זמנית) בכל פעם שאין להם Qubit משותפים. אבל אם שניים או יותר Gate פועלים על אותו Qubit אז לא נוכל לבצע אותם במקביל — יש לבצע אותם בשתי שכבות נפרדות, אחת אחרי השנייה.

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

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

עיצוב Circuit קוונטי: Qiskit patterns

אז, כיצד אנחנו ניגשים לעיצוב והרצת Circuit קוונטי? הדרך הקלה ביותר להבין תהליך עבודה טיפוסי של מחשוב קוונטי היא דרך Qiskit patterns. Qiskit patterns הם מסגרת מושגית המאפשרת למשתמשים להריץ עומסי עבודה קוונטיים על ידי יישום שלבים מסוימים עם כלים מודולריים. זה מאפשר לבצע משימות מחשוב קוונטי על ידי תשתית מחשוב הטרוגנית עוצמתית (CPU/GPU/QPU). ניתן לבצע את השלבים כשירות ויכולים לשלב ניהול משאבים, המאפשר קומפוזביליות חלקה של יכולות חדשות כשהן מפותחות.

הנה השלבים העיקריים, שמשתמשי Qiskit מנוסים ככל הנראה יכירו.

1. מיפוי (Map). שלב זה מפרמל כיצד אנחנו לוקחים בעיה כללית שאנחנו מעוניינים בה ומבינים כיצד למפות אותה על מחשב קוונטי בצורת Circuit קוונטי.

2. אופטימיזציה (Optimize). בשלב זה אנחנו משתמשים ב-Transpiler של Qiskit כדי לנתב ולפרוס את ה-Circuit על חומרת Qubit פיזית בפועל. זה כולל תרגום ה-Gate הקוונטיים הבודדים לרצפי פעולות המבוצעות על החומרה וכן אופטימיזציה בפריסת ה-Gate.

3. הרצה (Execute). Qiskit Runtime primitives מספקים את הממשק לחומרת IBM Quantum המאפשר לרוץ Circuit שעברו transpilation. שלב זה כולל גם שימוש בטכניקות דיכוי שגיאות והפחתת שגיאות, שניתן להפשיט אותן ברובן מהמשתמש.

4. עיבוד לאחר מכן (Post-process). בשלב זה הנתונים ממעבד הקוונטים עצמו מעובדים, ומספקים למשתמש תוצאות שימושיות על הבעיה המקורית. בעיקרון, זה מכסה כל ניתוח נוסף של הנתונים שנרכשו.

מיפוי (Map)

שלב המיפוי בעצם שואל את השאלה: "כיצד אתרגם את הבעיה שלי ל-Circuit קוונטי שניתן להריץ בסבירות על חומרה קוונטית?" אין ספק בכך: מיפוי הוא בעיה קשה ותחום מחקר פעיל. אין שיטה כושלת-הכל שמבטיחה הצלחה, אבל יש הנחיות מומלצות ודוגמאות לבעיות שאנחנו כבר יודעים למפות.

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

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

כמו כן, זכרו שלחומרה שאתם הולכים להשתמש בה יש טופולוגיה ספציפית, כפי שדנו בחלק החומרה. חלק מה-Qubit מחוברים, וחלקם לא — תצטרכו למפות את הבעיה שלכם ל-Circuit שמכבד את טופולוגיית hex הכבד של מעבדי IBM Quantum.

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

אופטימיזציה (Optimize)

בשלב הבא, נצטרך לבחור מעבד קוונטי שיש לו מספיק Qubit באיכות גבוהה מספיק שנוכל להריץ את ה-Circuit הקוונטי שלנו. קבלו את ההחלטות האלה בהנחיית שלושת המדדים שדנו בהם בחלק החומרה: מספר Qubit, EPLG ו-CLOPS.

לאחר מכן אנחנו מבצעים אופטימיזציה של ה-Circuit לחומרה שנבחרה. ראשית, עלינו לפרוס ולנתב את ה-Circuit ביעילות. פריסה (Layout) מתייחסת למיפוי ה-Qubit הוירטואליים ב-Circuit ל-Qubit הפיזיים על המעבד. ניתוב (Routing) מתייחס לכיוון ה-Circuit כך שהקישוריות בין ה-Qubit הוירטואליים ב-Circuit תתאים לקישוריות של ה-Qubit הפיזיים על המעבד. יש כמה דברים לזכור בשלב הפריסה והניתוב.

1. לא כל ה-Qubit מחוברים. חלקם רחוקים מאוד זה מזה על השבב, ועלינו לצמצם או לבטל אינטראקציות למרחקים ארוכים בכל מקום אפשרי. ניתן ליישם רצף של Gate SWAP בין Qubit שכנים כדי להעביר את המידע של ה-Qubit, אבל Gate SWAP יקרים ונוטים לשגיאות, כך שייתכן שיש דרכים טובות יותר לעשות זאת. נסו להימנע מיותר מדי Gate SWAP יקרים.

2. פריסה וניתוב הם תהליכים איטרטיביים. ניתן לעשות זאת ביד, אבל יש גם כלי Qiskit הנקרא mapomatic, שיכול לתת המלצות לפריסת Qubit פיזי בהתבסס על שיעורי שגיאה משוערים. ה-Transpiler (שנדון בו בקרוב) יכול גם לתת הצעה מושכלת.

בשלב הבא, אנחנו יכולים לאחד רצפי Gate של Qubit בודד הפועלים על אותו Qubit ל-Gate בודדים — וכן אנחנו יכולים לפעמים להיפטר מ-Gate מיותרים או שילוב של Gate. לדוגמה, שילובים מסוימים של Gate יכולים להצטמצם לשילובים פשוטים יותר — ולמעשה, לפעמים שילוב של Gate עשוי להיות שווה ערך לפעולת הזהות, כך שנוכל פשוט למחוק אותם. ניתן לעשות זאת באופן אוטומטי באמצעות ה-Transpiler של Qiskit — אבל ניתן גם לעשות זאת ידנית Gate-Gate אם אתם רוצים יותר שליטה.

לאחר ששיפרנו את פריסת ה-Circuit, הניתוב וספירת ה-Gate — בין אם ביד ובין אם באמצעות ה-Transpiler — בדרך כלל נרצה לדמיין את ה-Circuit שלנו כדי לוודא שהתזמון של כל ה-Gate הגיוני. יש ארגומנט שניתן לסמן ב-Transpiler כדי לדמיין את ציר הזמן של ה-Circuit, ולוודא שהכל מסודר כפי שהייתם מצפים.

Qiskit Transpiler

כפי שנזכר קודם, ניתן להשתמש ב-Qiskit Transpiler כדי לסייע בשלבים המוקדמים של תהליך העבודה של patterns. עכשיו בוא נחפור ביתר פירוט ליכולותיו. הוא יכול לשכתב Circuit קלט נתון כך שיתאים לטופולוגיה של מכשיר קוונטי ספציפי ולמטב את ה-Circuit להרצה ועמידות בפני רעש. הוא גם שוכתב Circuit נתון ל-Gate בסיס של המעבד הקוונטי הספציפי שבחרתם להשתמש.

ל-Qiskit יש ארבע צינורות transpilation מובנים המתאימים לרמות אופטימיזציה שונות, ואלא אם כן אתם כבר מכירים אופטימיזציה של Circuit קוונטי, אנחנו ממליצים להשתמש באחד מהם. כברירת מחדל, תהליך ה-transpilation כולל שישה שלבים אלה:

1. אתחול (Initialization). שלב זה מריץ כל פאסים ראשוניים הנדרשים לפני שאנחנו מתחילים לשבץ את ה-Circuit על ה-Backend. זה כולל בדרך כלל פריקת הוראות מותאמות אישית והמרת ה-Circuit לרק Gate של Qubit בודד ושני Qubit.

2. פריסה (Layout). שלב זה ממפה את ה-Qubit הוירטואליים ב-Circuit ל-Qubit הפיזיים על Backend. ראו Layout Stage לפרטים נוספים.

3. ניתוב (Routing). שלב זה רץ לאחר יישום פריסה ומזריק Gate (כגון Gate SWAP) לתוך ה-Circuit המקורי כדי להפוך אותו תואם לקישוריות ה-Backend. ראו Routing Stage לפרטים נוספים.

4. תרגום (Translation). שלב זה מתרגם את ה-Gate ב-Circuit לסט הבסיס של ה-Backend היעד. ראו Translation Stage לפרטים נוספים.

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

6. תזמון (Scheduling). שלב זה מיועד לכל פאסי תזמון המודעים לחומרה. ברמה גבוהה, ניתן לחשוב על התזמון כהכנסת עיכובים ל-Circuit כדי להתחשב בזמן סרק על ה-Qubit בין הרצת הוראות.

יש ארבע רמות אופטימיזציה הנעות בין 0 ל-3, שבהן רמות אופטימיזציה גבוהות יותר לוקחות יותר זמן ומאמץ חישובי אבל עשויות להניב Circuit טוב יותר. רמת אופטימיזציה 0 מיועדת לניסויי אפיון מכשיר ולכן ממפה רק את ה-Circuit הקלט למגבלות ה-Backend היעד, מבלי לבצע אופטימיזציות. רמת אופטימיזציה 3 מקדישה את המאמץ הרב ביותר לאופטימיזציה של ה-Circuit. עם זאת, מכיוון שרבות מטכניקות האופטימיזציה ב-Transpiler מבוססות על היוריסטיקות, השקעת מאמץ חישובי רב יותר לא תמיד מביאה לשיפור באיכות ה-Circuit הפלט. אם יש עניין נוסף בכך, ראו את תיעוד ה-Transpiler בתיעוד Qiskit.

דיכוי שגיאות

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

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

1. פיצול דינמי (Dynamical decoupling) משמש לביטול יעיל של חלק מהרעש הסביבתי שנוצר כאשר Qubit יושב סרק. על ידי יישום סדרה של Gate בזמנים ספציפיים, ניתן לגרום לכך שהרעש שמצטבר בחלק אחד של תקופת הסרק מבטל בערך את הרעש בחלק האחר.
2. עיוות פאולי (Pauli twirling) הוא דרך להכניס Gate אקראיים לא כדי לבטל את הרעש, כמו בפיצול דינמי, אלא כדי לפשט את הרעש. על ידי הכנסת Gate אקראיים, זה מונע מההשפעות של שגיאות שונות להצטבר במהירות, ומאפשר לאפיין את הרעש ביתר קלות, מכיוון שיש לו כעת אופי סטוכסטי. שיטה זו גם מהווה את הבסיס של טכניקת הפחתת שגיאות עוצמתית, שנדון בה להלן.

הרצה (Execute)

עכשיו אנחנו מוכנים להריץ את התוכנית הקוונטית. Qiskit Runtime primitives מספקים ממשק לחומרת IBM Quantum, והם גם מפשיטים דיכוי שגיאות והפחתת שגיאות מהמשתמש. יש שני primitives לבחור מהם: ה-Sampler וה-Estimator.

ה-Sampler של Qiskit Runtime מריץ את ה-Circuit פעמים רבות על מכשיר קוונטי, מבצע מדידות בכל ריצה, ומשחזר את התפלגות ההסתברות מהמחרוזות הבינאריות שהתקבלו. ככל שמבצע יותר ריצות (או shots), כך התוצאות יהיו מדויקות יותר, אבל זה דורש יותר זמן ומשאבים קוונטיים. ספציפית, הוא מחשב את ההסתברות לקבל כל מצב בסיס סטנדרטי אפשרי על ידי מדידת המצב שהוכן על ידי ה-Circuit.

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

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

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

ברמת עמידות 0, ה-Transpiler לא עושה כלום ל-Circuit שלכם.

ברמה 1, הוא מציג שיטה הנקראת Twirled Readout Error eXtinction (T-REX). T-REX משתמש בעיוות פאולי, כפי שנדון בחלק דיכוי השגיאות. כאמור, הכנסת Gate אקראיים ל-Circuit יכולה לגרום לרעש אפילו מורכב מאוד, שקשה לדגמן, להיראות סטוכסטי, והרבה יותר קל לתקן או להחסיר בעיבוד לאחר מכן.

ברמת עמידות 2, מתווסף Zero Noise Extrapolation (ZNE). זו טכניקה פופולרית שהיה לנו הרבה הצלחה אחרונה איתה. הרעיון מאחורי ZNE עשוי להיות מעט מפתיע — אנחנו למעשה מוסיפים רעש על גבי מה שכבר קיים! אבל זה מאפשר לנו לחלץ בכיוון ההפוך, לחזות כיצד היו נראות התוצאות אם היה פחות ופחות רעש.

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

סוג ספציפי אחד של ZNE נקרא Probabilistic Error Amplification (PEA). לאחר שלמדנו מודל רעש עבור Gate, PEA עובד על ידי דגימת שגיאות ממודל הרעש הזה והזרקתן בכוונה ל-Circuit. זה עדיין לא זמין ב-Qiskit, אבל יהיה מאוחר יותר השנה.

הצורה האחרונה של הפחתת שגיאות שנדון בה היא Probabilistic Error Cancellation (PEC). במקום להיות ברמת עמידות 3, PEC הוא יכולת מיוחדת שיש להפעיל ידנית ב-Qiskit, מכיוון שהמשאבים החישוביים הנדרשים לא מתרחבים היטב בהשוואה לטכניקות הפחתת שגיאות אחרות. אתם מתחילים בלמידה על הרעש שמשפיע על ה-Circuit שלכם — הריצו Circuit ללמידת רעש או לאפיון רעש לכל שכבה ייחודית של Gate של שני Qubit ב-Circuit שלכם. התוצאות האלה מאפשרות לכם לתאר את הרעש במונחים של אופרטורי פאולי. ברגע שאתם יודעים את מונחי הרעש האלה, ניתן לשנות את ה-Circuit שלכם כך שיהיה להם בפועל ה-Gate הפאולי ההפוך מובנים לביטול ערוצי הרעש האלה. במובנים מסוימים, התהליך דומה לאופן שבו אוזניות מבטלות רעש עובדות. עם זאת, דרך זו לביטול הרעש יקרה מאוד, עם זמן ריצה שגדל במהירות ובאופן אקספוננציאלי עם מספר ה-Gate, כך שייתכן שזו לא הבחירה הטובה ביותר עבור Circuit גדול מאוד.

עיבוד לאחר מכן (Post-process)

שלב העיבוד לאחר מכן הוא המקום שבו אנחנו מדמיינים ומנתחים את הפלט של ה-Circuit הקוונטי שלנו. יש מספר כלי Qiskit זמינים לכם לעשות זאת, כגון מודולי visualization ו-quantum-info. לא נכסה אותם כאן, אבל נראה את המודולים האלה בפעולה כשנצלול לדוגמאות יישום מסוימות בשיעורים עתידיים.

סיכום

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

בפעם הבאה, נסתכל על דוגמה ספציפית לשימוש בתהליך Qiskit patterns כדי לעצב ולהריץ Circuit קוונטי שפותר את הבעיה הקלאסית מתורת הגרפים הנקראת MaxCut.