WEBVTT

00:00:00.000 --> 00:00:04.180
הנושא של היום הוא משהו שכמעט כולם שמעו עליו, אבל כמעט אף אחד לא יודע להסביר במילים פשוטות.

00:00:04.300 --> 00:00:06.960
רג, יצירה מוגברת, שניפה, Retrieval Augmented Generation.

00:00:07.180 --> 00:00:12.000
ראיתם את ראשי הטבות האלו בכל מקום, בהודעות של מייקרוסופט, בכנסים על בינה מלאכותית ובבלוגים, אבל מה זה באמת אומר?

00:00:12.160 --> 00:00:14.000
וחשוב מכך, למה שיהיה לכם אכפת.

00:00:14.160 --> 00:00:17.840
הנה העניין, מודלי שפה גדולים כמו GPT-4O הם עוצמתיים.

00:00:17.840 --> 00:00:22.540
הם יכולים לכתוב חיבורים, לסכם מסמכים ואפילו ליצור קוד, אבל יש להם שתי בעיות גדולות.

00:00:22.700 --> 00:00:24.580
ראשית, הידע שלהם כפו בזמן.

00:00:24.820 --> 00:00:27.600
שאלו את צ'אט GPT על מה שהוא שקרה אתמול, ואין לו מושג.

00:00:27.760 --> 00:00:33.180
שנית, המודלים האלו מעולם לא ראו את הנתונים הפנימיים של החברה שלכם, את המדיניות שלכם, פרטי מוצרים או אימיילים של לקוחות.

00:00:33.240 --> 00:00:38.620
אז כשאתם שואלים מודל שפה שאלה על העסק שלכם, הוא מנחש, וכאן נכנסת לתמונה היצירה מוגברת שליפה.

00:00:38.620 --> 00:00:41.760
רג הוא לא מודל חדש, הוא לא גרסה גדולה או טובה יותר של GPT.

00:00:41.940 --> 00:00:43.200
זו גישה שונה לחלוטין.

00:00:43.360 --> 00:00:51.820
במקום לבקש מהמודל לשלוף תשובות מהזיכרון שבו אומן, רג מחפש קודם את המידע הנכון בנתונים שלכם ומגיש אותו למודל יחד עם השאלה.

00:00:51.820 --> 00:00:57.260
המודל משתמש בהקשר הזה כדי לתת לכם תשובות המבוססות על תוכן אמיתי ועדכני, לא על ניחושים.

00:00:57.400 --> 00:01:01.000
ללא רג, הבינה המלאכותית שלכם עובדת על בסיס זיכרון מלפני חודשים או שנים.

00:01:01.120 --> 00:01:03.940
עם רג, היא עובדת על בסיס המסמכים האמיתיים שלכם ברגע זה.

00:01:04.120 --> 00:01:09.580
זה ההבדל בין בינה מלאכותית שנשמעת בטוחה בעצמה, אך עלולה לטעות, לבין כזו שמראה לכם בדיוק מאיפה הגיעה התשובה.

00:01:09.680 --> 00:01:10.800
הנה מה שנזכור היום.

00:01:10.960 --> 00:01:13.960
ראשית, נבחן את שתי הבעיות שהופכות את רג להכרחי.

00:01:13.960 --> 00:01:17.960
לאחר מכן, נפרק מה זה בעצם רג השליפה, ההעשרה והיצירה.

00:01:17.960 --> 00:01:23.460
בהמשך, נעבור על שירותי Azure המרכזיים, Azure Eye Search, Azure Open AI ו-Azure Eye Foundry.

00:01:23.600 --> 00:01:26.900
ונסיים עם דוגמה אמיתית כדי שתוכלו לראות איך כל החלקים מתחברים.

00:01:27.100 --> 00:01:28.220
נתחיל בבעיה עצמה.

00:01:28.420 --> 00:01:30.860
ברגע שתראו אותה, הפתרון יהפוך למובן מעיליו.

00:01:31.020 --> 00:01:32.900
שתי הבעיות שיש למודלי שפה גדולים.

00:01:33.020 --> 00:01:34.760
אז מה לא בסדר במודלי שפה גדולים?

00:01:34.900 --> 00:01:36.340
שני דברים, למען האמת.

00:01:36.540 --> 00:01:38.140
ראשית, הידע שלהם כפו.

00:01:38.260 --> 00:01:39.020
תחשבו על זה.

00:01:39.020 --> 00:01:43.400
כש-GPT-4 או אומן, הוא למד מתמונת מצב של האינטרנט שכבר בת חודשים או שנים,

00:01:43.620 --> 00:01:46.900
לכן הוא לא מכיר מוצרים חדשים, תקנות עדכניות או חדשות מאתמול.

00:01:47.100 --> 00:01:50.480
שאלו אותו על שינוי במדיניות משבוע שעבר ואין לו דרך לדעת.

00:01:50.620 --> 00:01:53.160
המידע הזה פשוט לא נמצא בנתוני האימון שלו.

00:01:53.340 --> 00:01:56.480
שנית, מודלי שפה מעולם לא ראו את הנתונים הפרטיים שלכם,

00:01:56.600 --> 00:01:59.880
המסמכים הפנימיים, אימיילים של לקוחות או מסדי נתונים קנייניים.

00:02:00.040 --> 00:02:01.840
למודל אין שום גישה לכל אלו.

00:02:01.840 --> 00:02:04.760
אז כשעובד שואל על התהליכים העסקיים הספציפיים שלכם,

00:02:04.940 --> 00:02:05.900
המודל לא יכול לענות.

00:02:05.980 --> 00:02:07.180
הוא לא יודע מה שאתם יודעים.

00:02:07.300 --> 00:02:09.500
יש אנשים שחושבים שכיוונון עדין, פיינטונינג, פותר זאת.

00:02:09.620 --> 00:02:12.180
אתם לוקחים את מודל הבסיס ומאמנים אותו קצת יותר על הנתונים שלכם.

00:02:12.300 --> 00:02:13.960
אבל לכיוונון עדין יש בעיות משלו.

00:02:14.120 --> 00:02:14.660
זה יקר.

00:02:14.840 --> 00:02:17.160
אתם משלמים על זמן GPU ומאמצי הנדסה.

00:02:17.280 --> 00:02:19.000
זה לא פותר בעיות של חוסר עדכניות.

00:02:19.220 --> 00:02:22.460
ברגע שביצעתם כיוונון עדין, המודל עדיין קפוא באותה נקודת זמן.

00:02:22.460 --> 00:02:26.220
והוא לא יכול לטפל בנתונים שמשתנים לעיתים קרובות כמו מלאי או מחירים.

00:02:26.360 --> 00:02:29.160
כיוונון עדין זה כמו ללמד מי שהוא ספר לימוד בעל פה.

00:02:29.340 --> 00:02:32.120
זה שימושי, אבל הוא עדיין לא יכול לחפש בעיתון של היום.

00:02:32.280 --> 00:02:33.880
הפתרון האמיתי פשוט יותר.

00:02:34.060 --> 00:02:36.980
תנו למודל גישה לידע שלכם ברגע שהוא צריך לענות,

00:02:37.220 --> 00:02:39.240
במקום לנסות לדחוף הכל לזיכרון שלו.

00:02:39.380 --> 00:02:40.820
אל תחריכו אותו לשנן הכל.

00:02:40.920 --> 00:02:43.800
תנו לו לחפש דברים בזמן אמת מתוך הנתונים האמיתיים שלכם.

00:02:43.940 --> 00:02:44.820
זה מה שרג עושה.

00:02:44.980 --> 00:02:46.840
רעיון פשוט, אבל הוא משנה הכל.

00:02:52.460 --> 00:02:58.020
אנחנו קודם מוצאים את המידע הרלוונטי ואז מזינים אותו למודל לצד השאלה.

00:02:58.200 --> 00:02:59.420
זה הרעיון המרכזי.

00:02:59.540 --> 00:03:02.800
שלושה צעדים פשוטים, שליפה, העשרה ויצירה.

00:03:02.920 --> 00:03:04.340
תן לי לתת לכם אנלוגיה.

00:03:04.480 --> 00:03:05.520
תחשבו על ספרן.

00:03:05.720 --> 00:03:07.900
אתם נכנסים לספרייה ושואלים שאלה.

00:03:08.020 --> 00:03:10.660
לא הייתם מצפים מהספרן לשנן כל ספר, נכון?

00:03:10.840 --> 00:03:11.780
זה יהיה מגוחך.

00:03:11.920 --> 00:03:14.100
במקום זאת, אתם מבקשים ממנו למצוא את הספר הנכון,

00:03:14.260 --> 00:03:16.080
לפתוח בעמוד הנכון ולקרוא לכם את התשובה.

00:03:16.180 --> 00:03:17.700
הספרן לא משנן שום דבר.

00:03:22.460 --> 00:03:23.340
צירה אחר כך.

00:03:23.480 --> 00:03:25.040
אז הנה איך זה עובד בפועל.

00:03:25.180 --> 00:03:26.320
משתמש שואל שאלה.

00:03:26.440 --> 00:03:28.940
המערכת מחפשת במאגר ידע, במסמכים שלכם,

00:03:29.080 --> 00:03:31.060
בנתונים שלכם, במידע הפרטי שלכם.

00:03:31.160 --> 00:03:33.380
כל מה שנמצא מוזן למודל השפה הגדול,

00:03:33.380 --> 00:03:35.640
והמודל מייצר תשובה המבוססת על ההקשר הזה.

00:03:35.780 --> 00:03:36.900
והנה החלק שחשוב.

00:03:37.080 --> 00:03:39.220
ה-LLM לעולם לא רואה את הנתונים הגולמיים שלכם.

00:03:39.320 --> 00:03:41.260
הוא רואה רק את מה שמערכת השליפה מגישה לו.

00:03:41.380 --> 00:03:42.120
זה לא חיסרון.

00:03:42.320 --> 00:03:43.620
זה בעצם מאפיין הבטחה.

00:03:43.620 --> 00:03:46.240
המסמכים הרגישים שלכם נשארים בהכסון שלכם.

00:03:46.360 --> 00:03:48.640
בזמן השאילתה, המודל מקבל רק את הקטעים הרלוונטיים

00:03:48.640 --> 00:03:50.280
שהוא צריך כדי לענות על אותה שאלה ספציפית,

00:03:50.440 --> 00:03:52.760
ללא אימון על הנתונים שלכם, ללא שינון, ללא דליפת מידע.

00:03:52.860 --> 00:03:54.800
הנתונים שלכם נשארים איפה שהם שייכים.

00:03:54.800 --> 00:03:57.260
אז, רג פותר את שתי הבעיות שדיברנו עליהן קודם.

00:03:57.360 --> 00:03:58.380
נתונים לא מעודכנים.

00:03:58.580 --> 00:03:59.060
לא בעיה.

00:03:59.260 --> 00:04:00.920
מאגר הידע שלכם נשאר עדכני.

00:04:01.080 --> 00:04:01.940
נתונים פרטיים.

00:04:01.940 --> 00:04:04.200
המודל רואה רק את מה שאתה בוחר לשלוף.

00:04:04.380 --> 00:04:06.500
זה כמו לתת לספרן גישה לארון הטיוק שלך.

00:04:06.700 --> 00:04:08.820
אך לאפשר לו להוציא רק את התיקייה שאתה צריך,

00:04:08.980 --> 00:04:10.040
בדיוק כשאתה צריך אותה.

00:04:10.160 --> 00:04:12.020
התמאות וקטוריות וחיפוש סמנטי.

00:04:12.120 --> 00:04:14.600
כעת, אולי אתה תוהה כיצד החיפוש הזה עובד בפועל.

00:04:14.600 --> 00:04:18.120
זה לא עניין של התאמת מילות מפתח או הרצת חיפוש טקסטואלי במסמכים שלך.

00:04:18.240 --> 00:04:19.540
זה מה שהוא חכם הרבה יותר.

00:04:19.740 --> 00:04:22.500
זה נקרא חיפוש סמנטי והוא מבוסס על התמאות וקטוריות.

00:04:22.500 --> 00:04:24.100
הרשה לי להסביר מהי התמאה.

00:04:24.220 --> 00:04:27.820
התמאה וקטורית היא רשימה ארוכה של מספרים הלוחדת את המשמעות של קטע טקסט,

00:04:27.960 --> 00:04:28.940
כמו קאורדינטות על מפה.

00:04:29.060 --> 00:04:32.080
לכל מסמך יש קאורדינטה משלו על מפת המשמעויות הזו.

00:04:32.180 --> 00:04:33.080
כשאתה שואל שאלה,

00:04:33.080 --> 00:04:35.500
המערכת הופכת גם את השאלה שלך לקאורדינטות,

00:04:35.680 --> 00:04:37.560
ואז מוצאת את המסמכים הקרובים ביותר אליה.

00:04:37.680 --> 00:04:39.260
המפתח כאן הוא הסמנטיקה.

00:04:39.420 --> 00:04:41.180
זה לא על מציאת המילים המדויקות,

00:04:41.400 --> 00:04:42.440
זה על הבנת מושגים.

00:04:42.600 --> 00:04:44.560
אם תחפש מלונות בתקציב נמוך,

00:04:44.780 --> 00:04:49.300
המערכת תוכל למצוא מסמכים על אירוח זול גם אם המילים המדויקות האלו לא מופיעות.

00:04:49.400 --> 00:04:49.680
למה?

00:04:49.840 --> 00:04:50.980
כי המשמעות קרובה.

00:04:51.100 --> 00:04:55.360
ההתמאות של תקציב נמוך וזול יושבות ממש אחת ליד השנייה על אותה מפה.

00:04:55.360 --> 00:04:58.800
מודל קטן ומיוחד, כמו Text Embedding 3 Large של Azure,

00:04:59.000 --> 00:05:00.140
יוצר את ההתמאות האלה.

00:05:00.260 --> 00:05:01.680
זה לא מודל שפה ענקי,

00:05:01.840 --> 00:05:05.820
אלא כלי ממוקד שעושה עבודה אחת להפוך טקסט למספרי קאורדינטות.

00:05:06.020 --> 00:05:08.000
זה מה שהופך את רג לעוצמתי כל כך.

00:05:08.120 --> 00:05:11.140
המסמכים שלך מומרים להתמאות פעם אחת במהלך האינדוקס.

00:05:11.280 --> 00:05:12.500
ואז, כשאילתה מגיעה,

00:05:12.640 --> 00:05:15.140
המערכת מוצאת את התוכן הרלוונטי ביותר במילי שניות,

00:05:15.400 --> 00:05:18.520
גם אם המילים המדויקות של המשתמש לא מופיעות בשום מקום במסמכים.

00:05:18.520 --> 00:05:21.620
היא מבינה כוונה לא רק את מילות המפתח שהקלדת.

00:05:21.940 --> 00:05:24.080
Azure Eye Search, מנוע השליפה.

00:05:24.180 --> 00:05:25.860
אז עכשיו אתה מבין את הקונספט.

00:05:26.040 --> 00:05:27.620
שליפה תחילה ואז יצירה.

00:05:27.740 --> 00:05:29.620
אבל איפה כל השליפה הזו בעצם קורה?

00:05:29.620 --> 00:05:32.140
זה המקום שבו Azure Eye Search נכנס לתמונה.

00:05:32.300 --> 00:05:34.280
Azure Eye Search הוא השירות שמאכסן,

00:05:34.440 --> 00:05:36.140
מאנדקס ושולף את התוכן שלך.

00:05:36.280 --> 00:05:39.160
תחשוב עליו כמערכת הטיוק עבור אפליקציית הרג שלך.

00:05:39.280 --> 00:05:41.900
הוא מטפל בשתי משימות עיקריות ובוא נעבור עליהן.

00:05:41.900 --> 00:05:43.080
ראשית, אינדוקס.

00:05:43.240 --> 00:05:45.240
זה הפיכת הנתונים שלך למוכנים לחיפוש.

00:05:45.380 --> 00:05:46.360
שנית, חיפוש.

00:05:46.600 --> 00:05:49.560
זה איתור התוכן הנכון בפועל כאשר מישהו שואל שאלה.

00:05:49.720 --> 00:05:51.560
בוא נעבור על תהליך האינדוקס תחילה.

00:05:51.560 --> 00:05:54.680
אתה מתחיל בהפניית Azure Eye Search למקור הנתונים שלך,

00:05:54.920 --> 00:05:57.340
שיכול להיות מכה לכסון ענן מלא בקבצי PDF,

00:05:57.740 --> 00:05:59.640
מסד נתונים סיכואל עם רשומות לקוחות,

00:05:59.800 --> 00:06:01.040
או כל מספר מקורות אחרים.

00:06:01.220 --> 00:06:02.760
השירות קורא את המסמכים האלה,

00:06:02.760 --> 00:06:04.380
מפרק אותם לחלקים קטנים יותר,

00:06:04.500 --> 00:06:06.180
הנקראים צ'נקים, צ'נקס,

00:06:06.360 --> 00:06:08.240
יוצר התמאות וקטוריות עבור כל חלק

00:06:08.240 --> 00:06:10.460
באמצעות אותו מודל התמאה שדיברנו עליו קודם,

00:06:10.600 --> 00:06:11.940
ומאכסן הכל באינדקס חיפוש.

00:06:11.940 --> 00:06:15.180
תחשבו על האינדקס כעל כתלוג ענק ומאורגן היטב.

00:06:15.320 --> 00:06:17.460
כל פיסת תוכן מקבלת מזהה ייחודי,

00:06:17.660 --> 00:06:20.620
מקטע טקסט וסט קואורדינטות על מפת המשמעות הזו.

00:06:20.720 --> 00:06:22.180
עכשיו, תהליך החיפוש.

00:06:22.340 --> 00:06:23.820
כאשר משתמש שואל שאלה,

00:06:23.820 --> 00:06:27.000
AI Search הופך את השאלה לוקטור באמצעות אותו מודל התמאה,

00:06:27.220 --> 00:06:29.200
ואז שורק את האינדקס כדי למצוא קטעים

00:06:29.200 --> 00:06:32.220
שהקואורדינטות שלהם הן הקרובות ביותר לאלו של השאלה.

00:06:32.320 --> 00:06:33.780
הוא מחזיר את ההתאמות המובילות,

00:06:33.780 --> 00:06:36.260
בדרך כלל 5 עד 10 הרלוונטיות ביותר,

00:06:36.460 --> 00:06:37.840
ועושה את כל זה במילי שניות.

00:06:37.980 --> 00:06:39.680
יש לכם כאן כמה אפשרויות חזקות.

00:06:39.900 --> 00:06:42.000
חיפוש וקטורי טהור מוצא תוכן לפי משמעות,

00:06:42.200 --> 00:06:44.840
כך שמושגים דומים מופיעים גם עם המילים המדויקות לא תואמות.

00:06:44.840 --> 00:06:47.440
חיפוש מילות מפתח עובד כמו מנוע חיפוש מסורתי,

00:06:47.600 --> 00:06:48.900
ומוצא התאמות מילים מדויקות,

00:06:49.060 --> 00:06:50.640
או שניתן להשתמש בחיפוש היברידי,

00:06:50.720 --> 00:06:51.780
המשלב את שתי הגישות,

00:06:51.920 --> 00:06:53.560
וזו בדרך כלל הבחירה הטובה ביותר.

00:06:53.560 --> 00:06:55.680
יש גם משהו שנקרא דירוב סמנטי מחדש,

00:06:55.840 --> 00:06:57.240
שלוקח את התוצאות הראשוניות,

00:06:57.280 --> 00:07:00.180
וממיין אותן שוב בהתבסס על מידת הדיוק שלהן במענה לשאלה.

00:07:00.280 --> 00:07:03.220
זה כמו מעבר שני שתופס דברים שהראשון אולי פספס.

00:07:03.220 --> 00:07:04.740
דבר אחד שכדאי לדעת,

00:07:04.900 --> 00:07:06.620
Azure Eye Search עלול להיות יקר.

00:07:06.740 --> 00:07:10.400
הרמה הבסיסית מתחילה בסביבות 75 דולר לחודש ומטפסת משם.

00:07:10.520 --> 00:07:11.580
אם אתם רק מתנסים,

00:07:11.780 --> 00:07:12.860
השתמשו ברמה החינמית,

00:07:12.960 --> 00:07:15.200
או ודו שאתם מוחקים את המשאבים שלכם בסיום.

00:07:15.360 --> 00:07:16.220
לשימוש בייצור,

00:07:16.220 --> 00:07:18.360
אם זאת, העלות בדרך כלל משתלמת.

00:07:18.500 --> 00:07:21.200
אתם קונים מהירות ואמינות בקנה מידה גדול.

00:07:21.840 --> 00:07:23.900
Azure Open AI plus Eye Foundry,

00:07:24.160 --> 00:07:25.140
יצירה ותזמור.

00:07:25.140 --> 00:07:28.040
אז, כעת הנתונים שלכם מעונדקסים ומוכנים לשליפה,

00:07:28.240 --> 00:07:31.700
אבל ה-LLM עדיין צריך להבין את השאלה שלכם ולהפיק תשובה מוצקה.

00:07:31.800 --> 00:07:34.880
כאן נכנסים לתמונה Azure Open AI ו-Azure Eye Foundry.

00:07:35.020 --> 00:07:39.880
Azure Open AI מספק את מודל השפה בפועל GPT-4O, GPT-4.1,

00:07:40.100 --> 00:07:41.120
או כל מודל שתבחרו.

00:07:41.280 --> 00:07:42.420
זהו מנוע היצירה.

00:07:42.420 --> 00:07:46.320
הוא מקבל הנחיה, פרומפט, הכוללת גם את השאלה המקורית מהמשתמש,

00:07:46.420 --> 00:07:48.600
וגם את ההקשר ש-Azure Eye Search שלף.

00:07:48.720 --> 00:07:52.320
המודל קורא את ההקשר הזה ומייצר תשובה בהתבסס על מה שהוא מוצא.

00:07:52.320 --> 00:07:55.460
עכשיו, אי אפשר פשוט לזרוק הכל פנימה ולקוות לטוב.

00:07:55.620 --> 00:07:57.100
אתם צריכים הנחיית מערכת,

00:07:57.320 --> 00:08:00.140
סט הוראות שאתם נותנים למודל מראש לגבי איך להתנהג.

00:08:00.260 --> 00:08:02.460
אתם אומרים לו להשתמש רק בהקשר המסופק,

00:08:02.640 --> 00:08:03.860
לציין את המקורות שלו,

00:08:04.020 --> 00:08:05.760
והכי חשוב, להגיד, אני לא יודע,

00:08:05.760 --> 00:08:08.780
אם המידע הרלוונטי לא נמצא במסמכים שנשלפו.

00:08:08.940 --> 00:08:10.340
זה מה ששומר על המודל קנה.

00:08:10.540 --> 00:08:11.760
ללא הנחיית מערכת טובה,

00:08:11.900 --> 00:08:15.220
המודל עלול לחזור לנתוני האימון שלו או גרוע מכך להמציא משהו.

00:08:15.220 --> 00:08:17.820
אז, איך בעצם מחברים את כל החלקים האלה יחד?

00:08:17.920 --> 00:08:19.820
כאן נכנס לתמונה Azure Eye Foundry.

00:08:20.000 --> 00:08:21.520
זהו הפורטל שבו יוצרים פרויקט,

00:08:21.620 --> 00:08:24.500
פורסים מודלים, מחברים מקורות נתונים ובודקים את הסוכן שלכם.

00:08:24.640 --> 00:08:27.480
חישבו עליו כעל מרכז הבקרה של כל מערך הרג שלכם.

00:08:27.620 --> 00:08:30.480
בתוך Foundry, ניתן להוסיף את אינדקס האזרי אי-סארץ

00:08:30.480 --> 00:08:33.320
כמקור ידע לסוכן ללא כתיבת קוד מותאם להגדרה הבסיסית.

00:08:33.320 --> 00:08:35.500
פשוט יוצרים חיבור, בוחרים את האינדקס,

00:08:35.620 --> 00:08:38.140
והסוכן יכול להתחיל לשאול אותו שאלות באופן אוטומטי.

00:08:38.260 --> 00:08:40.120
הפורטל מטפל באורכסטר הציעה.

00:08:40.200 --> 00:08:41.580
כאשר משתמש שואל שאלה,

00:08:41.740 --> 00:08:43.380
הסוכן יודע לפנות לאי-אי-סארץ,

00:08:43.620 --> 00:08:47.620
לקבל את המקטעים הרלוונטיים ולהעביר אותם ל-LLM יחד עם השאלה המקורית.

00:08:47.780 --> 00:08:48.980
הנה דוגמה קונקרטית.

00:08:48.980 --> 00:08:50.660
באחד המדריכים שנתקלתי בהם,

00:08:50.800 --> 00:08:53.940
מי שהוא בנה סוכן המלצות לסרטים באמצעות ערכת נתונים של נטפליקס.

00:08:53.940 --> 00:08:56.000
הם העלו קובץ CSV עם שמות סרטים,

00:08:56.180 --> 00:08:58.400
תיאורים ומידע על השחקנים ל-Azure Blob Storage,

00:08:58.640 --> 00:09:01.340
ואז השתמשו ב-Azure Eye Search כדי להינדקס את הנתונים.

00:09:01.560 --> 00:09:02.700
ב-Azure Eye Foundry,

00:09:02.920 --> 00:09:06.580
הם יצרו סוכן עם GPT-4O וחיברו את אינדקס האי-אי-סארץ.

00:09:06.740 --> 00:09:07.800
כאשר משתמש שאל,

00:09:07.940 --> 00:09:10.120
אני אוהב סרטי מתח, תן לי כמה המלצות.

00:09:10.280 --> 00:09:11.440
הסוכן חיפש באינדקס,

00:09:11.440 --> 00:09:14.820
מצא סרטי מתח מאותו מאגר נתונים ספציפי והחזיר המלצות.

00:09:14.820 --> 00:09:18.360
וזה העיקר, הוא המליץ רק על סרטים שהיו באמת באותו מאגר נתונים.

00:09:18.520 --> 00:09:21.020
הוא לא המציא כלום, לא שלף מנתוני האימון שלו,

00:09:21.220 --> 00:09:23.240
ועבד אך ורק על סמך התוכן שסופק לו.

00:09:23.400 --> 00:09:24.580
זה הכוח של רג.

00:09:24.740 --> 00:09:26.260
רג קלאסי מול רג סוכני.

00:09:26.400 --> 00:09:28.260
כעת, בואו נדבר על הקמת המערכת.

00:09:28.420 --> 00:09:30.920
ישנם שני דפוסים עיקריים, רג קלאסי ורג סוכני.

00:09:31.060 --> 00:09:33.000
באיזה מהם תבחרו תלוי במה שאתם בונים?

00:09:33.000 --> 00:09:34.960
רג קלאסי הוא הגישה הישירה.

00:09:35.100 --> 00:09:38.140
שאילת האחת נכנסת, חיפוש אחד מבוצע, ותשובה יוצאת.

00:09:38.240 --> 00:09:39.720
פשוט, מהיר, צפוי.

00:09:39.860 --> 00:09:43.940
חישבו על זה כמו לגשת לדלפק הקבלה בבניין משרדים ולבקש קובץ ספציפי אחד.

00:09:44.120 --> 00:09:46.700
פקידת הקבלה לוקחת אותו, מוסשת לכם, וזהו.

00:09:46.820 --> 00:09:50.320
רג קלאסי עובד מצוין עבור שאלות ותשובות עובדתיות בנושא יחיד כמו

00:09:50.320 --> 00:09:52.260
מהי מדיניות החברה לגבי עבודה מרחוק?

00:09:52.260 --> 00:09:55.560
או, הראה לי את שלבי פתרון הבעיות עבור קוד השגיאה הזה.

00:09:55.740 --> 00:09:59.760
זה אמין, זול וקל לתיקון כשמשהו משתבש כי הזרימה לי נערית.

00:10:00.160 --> 00:10:01.440
רג סוכני הוא שונה.

00:10:01.660 --> 00:10:03.860
סוכן ה-AI מחליט איך לשלוף מידע.

00:10:03.980 --> 00:10:06.980
הוא יכול לשאול תתי שאלות מרובות, לחפש באינדקסים שונים,

00:10:07.240 --> 00:10:10.800
לבצע התרציות על תוצאות ולסנתז ממקורות שונים לפני מתן תשובה.

00:10:10.800 --> 00:10:15.020
זה כמו שיש מנהל בניין שמתאם עם מחלקות שונות כדי לאסוף את כל החלקים.

00:10:15.140 --> 00:10:16.660
הוא לא סתם לוקח קובץ אחד.

00:10:16.660 --> 00:10:21.300
הוא מדבר עם משאבי אנוש, בודק רישומים, מצליב מדיניות, ואז חוזר עם תשובה מלאה.

00:10:21.420 --> 00:10:26.840
מייקרוסופט הרחה בדיקות משלה ומצאה שאיג'נטיק רג מספק שיפור של קף מינוס 40% ברלוונטיות התשובות לשאלות מורכבות.

00:10:27.020 --> 00:10:30.820
זה משמעותי, אך הוא צורך פי 3 עד 10 יותר אסימונים, טוקנז, ומוסיף השיה.

00:10:30.980 --> 00:10:33.420
עבור שאלות פשוטות, המאמץ הנוסף הזה מבוזבז.

00:10:33.420 --> 00:10:35.180
רג קלאסי מטפל בהן מצוין.

00:10:35.360 --> 00:10:36.680
אז מתי משתמשים בכל אחד?

00:10:36.680 --> 00:10:40.560
קלאסי עבור שאילתות שגרתיות ובעלות נפח גבוה, שבהן המהירות והעלות הם החשובים ביותר.

00:10:40.680 --> 00:10:45.600
אג'נטיק עבור שאלות רב-שילוביות, מאורפלות או בינתחומיות, שבהן הדיוק מצדיק את כוח המחשוב הנוסף.

00:10:45.740 --> 00:10:47.740
סעיף חיבור, דוגמה מקצה לקצה.

00:10:47.880 --> 00:10:51.020
בואו נראה איך כל החלקים האלה מתחברים בעזרת דוגמה אמיתית.

00:10:51.020 --> 00:10:55.680
דמיינו שאתם בונים סוכן תמיכת לקוחות לסוכנות נסיעות בשם מריגולט הראבלס.

00:10:55.680 --> 00:11:00.560
יש לכם חוברות טיולים, ביקורות על מלונות ומסמכי מדיניות המפוזרים בארגון שלכם.

00:11:00.740 --> 00:11:06.260
אתם רוצים שלקוחות ישאלו שאלות ויקבלו תשובות מדויקות על סמך התוכן שלכם ולא ניחושים כלליים.

00:11:06.500 --> 00:11:09.820
שלב ראשון, החסנו את כל התוכן הזה ב-Azure Blob Storage.

00:11:09.820 --> 00:11:14.800
חוברות בתיקייה אחת, ביקורות באחרת, מדיניות בשלישית, פשוט קבצים בתוך קונטיינר.

00:11:14.920 --> 00:11:19.880
שלב שני, השתמשו ב-Azure Eye Search כדי להינדקס את הנתונים על ידי הרצת אשף עיבו הנתונים,

00:11:20.140 --> 00:11:22.580
הפנייתו להיחסון הבלוב שלכם ומתן לו לעבוד.

00:11:22.720 --> 00:11:28.260
השירות קורא כל מסמך, מחלק אותם לחתיכות, יוצר וקטורים, אמבדינגס ובוני אינדקס לחיפוש.

00:11:28.420 --> 00:11:30.080
כל התהליך לוקח כמה דקות.

00:11:30.340 --> 00:11:33.440
שלב שלישי, היכנסו ל-Azure Eye Foundry וצרו סוכן.

00:11:33.440 --> 00:11:37.480
התמיעו את GPT-4O כמודל שלכם, כתבו הנחיית מערכת System Prompt,

00:11:37.660 --> 00:11:40.280
שמורה לו להשתמש רק בהקשר המסופק ולצטט את המקורות,

00:11:40.440 --> 00:11:42.940
ואז חברו את אינדקס ה-Azure Eye Search שלכם כמקור ידע.

00:11:42.940 --> 00:11:44.480
כמה לחיצות וזה מוכן.

00:11:44.600 --> 00:11:48.720
כעת לקוח שואל, מהו המלון עם הביקורות הטובות ביותר בדוביי מתחת למד מינוס 300 דולר?

00:11:48.840 --> 00:11:51.860
הסוכן לוקח את השאלה הזו ושולח אותה ל-Azure Eye Search.

00:11:51.860 --> 00:11:56.760
Azure Eye Search ממיר אותה לוקטור ומוצא את החלקים הרלוונטיים ביותר מתוך הביקורות והחוברות שלכם.

00:11:56.900 --> 00:12:00.180
חלקים אלה מועברים ל-GPT-4O יחד עם השאלה המקורית.

00:12:00.360 --> 00:12:05.600
המודל קורא אותם, מזהה את ההתאמה הטובה ביותר ומייצר תשובה עם ציטוטים המפנים חזרה למסמכי המקור שלכם.

00:12:05.720 --> 00:12:08.500
העניין הוא שה-LLM מעולם לא שינן את הנתונים האלה.

00:12:08.560 --> 00:12:10.560
ומעולם לא אומן על ביקורות המלונות שלכם.

00:12:10.680 --> 00:12:13.080
הוא עובד מהתוכן הספציפי שלכם בכל פעם מחדש.

00:12:13.200 --> 00:12:15.800
הוסיפו ביקורות חדשות מחר והתשובות התעדכנו אוטומטית.

00:12:15.800 --> 00:12:18.060
הסיר הוא חוברת מיושנת והיא תפסיק להופיע.

00:12:18.180 --> 00:12:19.820
המודל לא זקוק לאימון מחדש.

00:12:19.960 --> 00:12:21.720
הוא רק צריך את שכבת ההחזור הנכונה.

00:12:21.860 --> 00:12:23.960
אז איך בעצם מתחילים לבנות RAG ב-Azure?

00:12:24.160 --> 00:12:25.860
בואו נחלק את זה לשלושה שלבים.

00:12:26.020 --> 00:12:28.160
קודם כל, הכירו את הנתונים שלכם.

00:12:28.160 --> 00:12:33.080
לפני שבוחרים שירות, כדאי להבין איפה התוכן נמצא, איך הוא מאורגן ומי צריך לקבל גישה.

00:12:33.220 --> 00:12:35.740
הצלחת הרג תלויה לחלוטין באיכות הנתונים שלכם.

00:12:35.880 --> 00:12:37.300
בשלב הבא, שימרו על פשטות.

00:12:37.300 --> 00:12:39.220
אל תסבכו את ההגדרה יתר על המידה.

00:12:39.300 --> 00:12:42.880
השתמשו באשף עיבו הנתונים ב-Azure Eye Search כדי להינדקס קבוצת מסמכים אחת בלבד.

00:12:43.020 --> 00:12:44.640
ביצעו בדיקות עם שאילתות בסיסיות.

00:12:44.820 --> 00:12:48.040
ובדעו שהשליפה עובדת בצורה מושלמת לפני שמוסיפים את ה-LLM.

00:12:48.180 --> 00:12:51.840
רוב הקשלים ברג אינם בעיות של המודל, אלו בעיות של שליפת נתונים.

00:12:52.020 --> 00:12:53.940
השלב האחרון, הוסיפו את ה-LLM.

00:12:54.080 --> 00:12:57.280
ברגע שהחיפוש מחזיר את התוצאות הנכונות, רק אז שלבו את יכולות היצירה.

00:12:57.280 --> 00:13:00.640
זה הזמן לחבר את Azure OpenAI ולכתוב את הנחיית המערכת שלכם.

00:13:00.740 --> 00:13:04.100
העניין הוא שרג זה לא משהו שקונים, זה תבנית שאתם בונים.

00:13:04.340 --> 00:13:09.160
Azure נותנת לכם את החלקים, איכסון, חיפוש, מודלים ואת הדבק שמחבר ביניהם.

00:13:09.280 --> 00:13:11.620
אתם רק צריכים לחבר את הכל בצורה הנכונה.

00:13:11.620 --> 00:13:15.620
אם זה עזר לכם לראות את התמונה הגדולה, הרשמו לערוץ לעוד הסברים פשוטים.

00:13:15.780 --> 00:13:18.040
כתבו בתגובות מהו מקרה השימוש שלכם ברג.

00:13:18.200 --> 00:13:19.480
אשמח לדעת מה אתם בונים.
