WEBVTT

00:00:00.000 --> 00:00:03.680
זרימת הבינה המלאכותית שלכם לא נכשלה בגלל בינה מלאכותית, היא נכשלה כי היא בטחה בכם.

00:00:03.820 --> 00:00:05.380
זה החלק שאף אחד לא רוצה לשמוע.

00:00:05.540 --> 00:00:11.200
בניתם אוטומציה, קראתה לחכמה, ואז הזנתם לנתונים אפויים למחצה מתופס שמי שהוא מילה ביום שישי אחר הצהריים.

00:00:11.380 --> 00:00:13.000
הנחתם שאוטומציה פירושה אמינות,

00:00:13.240 --> 00:00:18.660
כשלמעשה אוטומציה פשוט מגבירה את השגיאות שלכם מהר יותר ועם יותר ביטחון מכל מתמחה שיכול היה אי פעם.

00:00:18.840 --> 00:00:20.820
הרשו לי לתרגם את זה לספייסקית.

00:00:20.820 --> 00:00:24.480
זרימת Copilot Studio שלכם לא התפוררה כי מייקרוסופט פישלה.

00:00:24.620 --> 00:00:27.680
היא התפוררה כי נתוני כלת גרועים טופלו כמו אמת הבשורה.

00:00:27.880 --> 00:00:32.640
שדה חסר פה, אימייל שגוי שם, ופתאום הנתונים שלכם נראים כאילו נערך על ידי פעוטות.

00:00:32.740 --> 00:00:34.620
הבינה המלאכותית לא התנהגה לא בסדר.

00:00:34.800 --> 00:00:37.140
היא עשתה בדיוק את מה שאמרת לה, בדיוק לא נכון.

00:00:37.280 --> 00:00:38.020
אז מה חסר?

00:00:38.180 --> 00:00:39.540
ממשל, אימות אמיתי.

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

00:00:45.060 --> 00:00:48.320
שם נכנסת לתמונה בקשת המידע או פעולת ה-RFI.

00:00:48.520 --> 00:00:51.280
חישבו על זה כעל חומת האש האנושית, והיא לא נותנת לנתונים.

00:00:51.900 --> 00:00:53.340
לפוצץ את האוטומציה שלכם.

00:00:53.540 --> 00:00:57.480
זה שם את זה בווידוד, קופה בדיקה אנושית, ורק אז מאפשר לזרימה להמשיך.

00:00:57.640 --> 00:01:01.500
בסוף זה, תדעו מדוע היא התאמות נתונים, לולאות ריק ופעולות בינה מלאכותית,

00:01:01.580 --> 00:01:05.680
חסרות היגיון ממשיכות להתרחש, ואיך מנגנון תאימות קטן אחד מבטל את שלושתם.

00:01:05.680 --> 00:01:10.500
ספוילר, הבעיה היא לא שהזרימות שלכם אוטומטיות מדי, אלא שהן לא נשלטות מספיק.

00:01:10.600 --> 00:01:13.120
הסוד המלוכלך של אוטומציה של בינה מלאכותית.

00:01:13.220 --> 00:01:14.800
בינה מלאכותית אוהבת דיוק.

00:01:14.980 --> 00:01:16.240
משתמשים אוהבים קאוס.

00:01:16.440 --> 00:01:19.160
זוהי נקודת העברת הגדולה של אוטומציה ארגונית.

00:01:19.280 --> 00:01:24.000
כל חובב קופיילוט סטודיה הוא מאמין שהזרימות שלו חסינות כדורים כי הבינה המלאכותית מטפלת בהן.

00:01:24.000 --> 00:01:28.120
ובכן, האמת, הבינה המלאכותית מטפלת בכל מה שאתם מזינים אותה, טוב או רע, ללא שיפוטיות.

00:01:28.260 --> 00:01:29.760
היא צייטנית, לא אינטליגנטית.

00:01:29.920 --> 00:01:33.520
היא לא שואלת, האם אנחנו בטוחים שלמבקר הזה יש סיווג בטיחות למעבדה?

00:01:33.620 --> 00:01:38.240
היא פשוט מזמינה את הפגישה, מעדכנת את הרשומה ומתפללת שהצוות המשפטי לעולם לא יגלה.

00:01:38.400 --> 00:01:41.080
דמיינו זרימה שנבנתה לניהול בקשות גישה למתקנים.

00:01:41.080 --> 00:01:45.400
היא מקבלת תגובות מעובדים או מבקרים חיצוניים ומוסיפה אותן לטבלת דייטווארס.

00:01:45.520 --> 00:01:46.980
בראש שלכם זה נקי.

00:01:47.120 --> 00:01:50.300
במציאות, מי שהוא משאיר את שדה מטרת הביקור ריק או מקליד פגישה.

00:01:50.460 --> 00:01:52.120
זו לא מטרה, זו משיכת כתפיים.

00:01:52.300 --> 00:01:55.960
אבל האוטומציה שלך קוראת את זה כתקף ומעבירה את זה בשמחה להבטחה.

00:01:56.080 --> 00:02:00.280
מזל טוב, עכשיו אישרת לאדם לא ידוע להיכנס לבניין מוגבל לפגישה.

00:02:00.280 --> 00:02:05.540
כאשר צוות הביקורת יבדוק את זה, הם יתייגו את הזרימה שלך כסכנת תאימות, לא פלט טכני.

00:02:05.660 --> 00:02:08.720
כך רוב זרימות העבודה המונעות על ידי בינה מלאכותית נכשלות.

00:02:08.860 --> 00:02:11.820
לא בגלל שגיאות לוגיות, אלא בגלל אמון עיוור בכלת אנושי.

00:02:11.940 --> 00:02:14.180
האוטומציה מניחה מבנה במקום שאין כזה.

00:02:14.340 --> 00:02:16.120
היא צורכת הצהרות במקום עובדות.

00:02:16.140 --> 00:02:18.700
היא לא בודקת תוקף כי אף פעם לא אמרת לה לעשות זאת.

00:02:18.800 --> 00:02:21.720
וכאשר הנתונים הפגומים האלה מתפשטים במורד הזרם לדטאברס,

00:02:21.720 --> 00:02:24.820
לוחות מכוונים של פאוור ביי, או אפילו למערכת משאבי האנוש שלך,

00:02:24.960 --> 00:02:26.120
הם מדביקים כל רשומה עוקבת.

00:02:26.240 --> 00:02:28.780
מה שהתחיל כנוחות הופך לשחיתות מערכתית.

00:02:28.960 --> 00:02:31.700
צוותי ממשל קוראים לזה פער אמינות הנתונים.

00:02:31.940 --> 00:02:35.180
כל החלטה אוטומטית צריכה להיות קשורה לכלת מאומת.

00:02:35.360 --> 00:02:39.040
בלי נקודת ביקורת זו, אתה לא מבצע אוטומציה, אתה מעיץ טעויות.

00:02:39.240 --> 00:02:43.400
האירוניה היא שרוב האנשים מתכננים זרימות כדי להסיר חיכוך אנושי כאשר הצעד החכם יותר,

00:02:43.400 --> 00:02:45.860
ולהוסיף אותן בחזרה למקום הנכון באופן אסטרטגי.

00:02:45.940 --> 00:02:49.440
אז, מייקרוסופט סוף סוף החליטה להפוך את הזרימות שלך לפחות תמימות.

00:02:49.540 --> 00:02:53.980
פעולת בקשת המידע היא דרכם להחדיר בדיקת שפיות למערכת נאיבית אחרת.

00:02:54.180 --> 00:02:56.400
היא עוצרת את הביצוע באמצע ואומרת,

00:02:56.540 --> 00:02:59.520
חכו רגע, אדם צריך לאשר את זה לפני שנמשיך.

00:02:59.720 --> 00:03:03.520
רגע ההמתנה הזה אינו חוסר יעילות, אלא משמעת ממשל בפעולה.

00:03:03.520 --> 00:03:06.680
כשחושבים על זה ככה, אוטומציה ללא אימות אינה התקדמות,

00:03:06.680 --> 00:03:09.260
אלא הפרת מדיניות עם ממשק משתמש נוצץ.

00:03:09.400 --> 00:03:11.880
כל שדה לא מאומת, כל תפריט נפתח ריק,

00:03:12.120 --> 00:03:15.920
כל תיבת טקסט שמתייחסים אליה כאמת היא הפרה פוטנציאלית של תאימות.

00:03:16.020 --> 00:03:21.420
תכונת ה-RFI קיימת בדיוק כדי להחזיר את הקאוס לסדר תופס Outlook אחד בכל פעם.

00:03:21.760 --> 00:03:25.540
וברגע שצפיתם בזרימה גרועה אחת משחיתה את אגם הנתונים שלכם,

00:03:25.540 --> 00:03:30.260
תאריכו את הרגע הזה כי האלטרנטיבה אינה אוטומציה מהירה יותר, אלא אסון מהיר יותר.

00:03:30.640 --> 00:03:32.980
היכנסו ל-RFI, האדם בלולאה.

00:03:32.980 --> 00:03:38.260
פעולת בקשת המידע, בקיצור RFI, היא הרגע שבו האוטומציה שלכם לומדת ענבה.

00:03:38.480 --> 00:03:41.720
זוהי המקבילה של Copilot Studio להרמת יד דיגיטלית ואמירה,

00:03:41.920 --> 00:03:44.220
חכו, אני צריך אדם לפני שאני הורס הכל.

00:03:44.260 --> 00:03:45.920
וכן, זה בדיוק מה שהיא עושה.

00:03:46.080 --> 00:03:48.480
זה לא סתם מילוי תפסים או בקשה מהודרת.

00:03:48.480 --> 00:03:53.880
זהו נקודת בקרה ברמת תאימות שמפרידה בין נתונים מאומתים ונקיים לבין כאוס טהור.

00:03:54.020 --> 00:03:55.080
הנה מה שזה באמת.

00:03:55.080 --> 00:04:00.240
פעולת ה-RFI נמצאת בתוך זרימת הסוכן שלך ועוצרת את התקדמותה עד שמישהו, אדם אמיתי,

00:04:00.500 --> 00:04:02.380
מגיב להודעה ניתנת לפעולה של Outlook.

00:04:02.580 --> 00:04:04.320
הודעה זו אינה הודעה פסיבית.

00:04:04.540 --> 00:04:10.840
זהו תופס מיני מוטמע ממש בתוך Outlook שנועד עם שדות חובה שהנמען חייב למלא לפני שהזרימת תתקדם.

00:04:11.040 --> 00:04:12.580
בזמן שהם מהרהר בתשובותיהם,

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

00:04:17.280 --> 00:04:22.500
רק כאשר השדות מלאים, כל ערך נדרש מסופק, כל תיבת סימון מסומנת, הזרימה ממשיכה.

00:04:22.640 --> 00:04:24.780
חישבו על זה כגישה מותנית לזרימות עבודה.

00:04:24.980 --> 00:04:28.180
לא הייתם נותנים למכונה לא מאומתת להתחבר לרשת הארגונית שלכם?

00:04:28.400 --> 00:04:31.400
אז למה לתת לנתונים לא מאומתים להיכנס לטבלת דייטווורס שלכם?

00:04:31.540 --> 00:04:33.980
RFI אוכף בדיוק את סוג ההפסקה הזה.

00:04:34.140 --> 00:04:37.080
הביצוע מושהה עד שהמציאות מתיישרת עם המדיניות.

00:04:37.140 --> 00:04:38.580
והנה הטוויסט החכם.

00:04:38.640 --> 00:04:39.340
זה סינכרוני.

00:04:39.340 --> 00:04:41.920
משמעות הדבר היא שהזרימה מחכה לאמת.

00:04:42.100 --> 00:04:43.700
זה לא מנחש, זה לא מסיק.

00:04:43.920 --> 00:04:47.920
זה פשוט ממתין עד שנאמר לו באופן סופי הנתונים האלה מוכנים לשימוש.

00:04:48.080 --> 00:04:51.840
עכשיו, מפתה להניח שההנחיות שלך מהבינה המלאכותית כבר מטפלות בזה.

00:04:52.000 --> 00:04:54.040
אחרי הכל, הנחיות נשמעות חכמות.

00:04:54.200 --> 00:04:57.520
הן מעמתות פרטים, מסכמות תוכן, אפילו מזהות שדות חסרים.

00:04:57.700 --> 00:04:59.120
אבל הנחיות רק מפרשות.

00:04:59.340 --> 00:05:00.620
הן חושבות שהמידע הגיוני.

00:05:00.780 --> 00:05:01.780
הן חסרות סמכות.

00:05:01.980 --> 00:05:03.440
בקשות לבקשות מאשרות.

00:05:03.440 --> 00:05:06.220
הן הופכות את מה שנראה בסדר למעומת רשמית.

00:05:06.360 --> 00:05:09.780
הנחיות מקרבות הבנה, בקשות לבקשות, אוכפות תאימות.

00:05:09.980 --> 00:05:13.180
בשילוב, אחת בודקת היגיון, השנייה בודקת אחריות.

00:05:13.380 --> 00:05:14.860
הנה מקרה מהעולם האמיתי.

00:05:15.040 --> 00:05:20.520
זרימת מתקן שמעבדת בקשות גישה של מבקרים השתמשה בהנחיית בינה מלאכותית כדי לעמת ערכים ממיקרוסופט פורמס.

00:05:20.640 --> 00:05:26.160
אם המבקר תכנן לגשת למעבדה, הבינה המלאכותית בדקה מידע בטיחותי, סוג עבודה, אישור וציוד מגן.

00:05:26.160 --> 00:05:29.700
כאשר המשתמש דילג על סעיף זה, ההנחיה סימנה אותו כלו שלם.

00:05:29.860 --> 00:05:30.960
הזן RFI.

00:05:31.320 --> 00:05:33.660
הזרימה יצרה אוטומטית הודעה לשולח.

00:05:33.940 --> 00:05:36.440
אנה ספק פרטי בטיחות לפני אישור גישה.

00:05:36.620 --> 00:05:41.640
הנמען פתח את ההודעה הניתנת לפעולה באטלוק, הזן את המידע הנדרש ולחץ על שלח.

00:05:41.820 --> 00:05:47.920
רק אז זרימת הסוכנים המשיכה, עדכנה את רשומת דייטוורס, סימנה את האישור כתקף, ושמרה על שקט מוחלט של המבקרים.

00:05:48.120 --> 00:05:51.540
וכן, ניתן להקצות מספר משתמשים, המגיב הראשון מנצח.

00:05:51.540 --> 00:05:57.420
ניסיונות עוקבים ננעלים כמיותרים, מה שמבטיח המינות מבוססת חותמות זמן ומונעים עריכות סטרות.

00:05:57.600 --> 00:06:01.320
כל הגשת RFI משאירה שובל מסודר מבחינה פורנזית.

00:06:01.620 --> 00:06:03.560
מי הגיב? מתי? מה הם הזינו?

00:06:03.800 --> 00:06:06.600
זה זהב לצוותי ממשל שאובססים על העקיבות.

00:06:06.780 --> 00:06:10.180
RFIS לא רק מתקנים נתונים שבורים, הם מתקנים אחריות שבורה.

00:06:10.320 --> 00:06:13.700
הם מבדאים שאף אחד לא יוכל למשוך בכתפיו ולומר, אה, המערכת עשתה את זה.

00:06:13.700 --> 00:06:18.680
כי אם הנתונים עברו דרך שער RFI, מישהו, איפשהו, היה צריך ללחוץ על שלח עם שמו עליו.

00:06:18.840 --> 00:06:21.180
זוהי אחריות דיגיטלית ברמת התופס.

00:06:21.520 --> 00:06:26.080
כך אתם מחזירים אחריות לאוטומציה, במכוון, בכל רם, בגאווה.

00:06:26.580 --> 00:06:30.880
RFI לא מעט אתכם, הוא מונע מהזרימה שלכם לרוץ לחומת תאימות.

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

00:06:38.340 --> 00:06:40.300
למה ממשל מתחיל באימות אנושי?

00:06:40.400 --> 00:06:45.820
אוטומציה מעולם לא הייתה אמורה להוציא בני אדם מהלולאה, היא הייתה אמורה להוציא את הצלנותה מהלולאה.

00:06:45.920 --> 00:06:50.740
ובכל זאת, איך שהוא, במרוץ לאוטומציה של הכל, החלטנו שאימות הוא אופציונלי.

00:06:50.940 --> 00:06:51.260
זה לא.

00:06:51.460 --> 00:06:58.040
כל אוטומציה ששווה לסמוך עליה כוללת נקודת אישור אנושית, הרגע שבו מי שאומרים אצבע ואומר, כן, זה מדויה.

00:06:58.200 --> 00:07:02.200
אחרת, אתם לא בונים תהליך עסקי, אתם בונים חרושת שמורות עם יעילות מכונה.

00:07:02.200 --> 00:07:11.140
אנשי ממשל מבינים זאת באופן אינסטינקטיבי, מכיוון שכל מסגרת תימות ISO, SOC, GDPR, בחרו את ראשי הטבעות האהובים עליכם, סובבת סביב נקודות החלטה הניתנות למעקב.

00:07:11.260 --> 00:07:11.840
מי אישר מה?

00:07:12.020 --> 00:07:12.900
מתי זה נעשה?

00:07:13.060 --> 00:07:14.520
תחת אילו תנאי נתונים.

00:07:14.800 --> 00:07:18.920
אלה לא שאלות בירוקרטיות, הן הפיגומים של אוטומציה ניתנת להגנה.

00:07:19.080 --> 00:07:23.140
פעולת RFI מכניסה את הרגעים הניתנים לתשובה ישירות לזרימה שלכם.

00:07:23.140 --> 00:07:29.380
בלעדיה, דוח הביקורת שלכם נקרא כמו רומן מסתורין, מלא באירועים, אבל אין מוסד מבאמת גרם להם.

00:07:29.480 --> 00:07:34.320
כדי לראות את ההבדל, חישבו על RFI כגיליון חתימה דיגיטלי המוטמע בהאותלו.

00:07:34.520 --> 00:07:39.960
הזרימה נעצרת עד שהחתימה האנושית מגיעה באופן אלקטרוני, אוטומטי ונרשמת.

00:07:40.060 --> 00:07:45.660
כאשר המשתמש מכיש על שלח, התגובה שלו, מזהה הדואר אלקטרוני שלו וחותמת הזמן שלו נרשמים.

00:07:45.660 --> 00:07:53.940
משמעות הדבר היא שכל שלב אוטומציה עוקב, החל מאישור גישת מבקרים ועד לרישום תנועות, מקושר חזרה לפעולה אנושית מאומתת.

00:07:54.100 --> 00:07:58.680
ניתן לעקוב אחר שושלת הנתונים עד לאדם עקשן מספיק כדי להשאיר שדה רע.

00:07:58.920 --> 00:08:01.900
בביקורת תאימות, זה לא רק מועיל, זו הישרדות.

00:08:02.040 --> 00:08:03.720
עכשיו, בואו נדבר על אמינות.

00:08:03.920 --> 00:08:09.000
אוטומציה סובלת ממה שמאנדסים מכנים כשל שקט, דברים שנשברים באופן בלתי נראה.

00:08:09.000 --> 00:08:13.840
ערך נעלם, תנאי מתקלקל, ואף אחד לא שם לב עד שהפלט נראה אבסורדי.

00:08:14.200 --> 00:08:15.940
RFI הורגים את השתיקה.

00:08:16.080 --> 00:08:17.880
הם מציגים נקודת ביקורת קולית.

00:08:18.140 --> 00:08:20.520
שדה חסר לא חומק, הוא עוצר את התהליך.

00:08:20.680 --> 00:08:23.280
אין תפסים שדלגו עליהם, אין קלט של תווים כלליים.

00:08:23.460 --> 00:08:26.960
האדם מקבל הודעה מעשית הדורשת תשומת לב לפני שהמכונה ממשיכה.

00:08:27.100 --> 00:08:29.800
אנשי מקצוע בתחום הממשל קוראים לזה בקרה מונעת.

00:08:29.960 --> 00:08:32.140
משתמשים ממוצעים קוראים לזה בייביסיטר מעצבן.

00:08:32.140 --> 00:08:35.960
אבל אותם משתמשים הם בדרך כלל אלה שכותבים מיילים של התנצלות לתאימות מאוחר יותר.

00:08:36.120 --> 00:08:36.960
הנה הקסם.

00:08:37.120 --> 00:08:41.080
על ידי התמאה תאימות אנושי, אתם הופכים אמינות מניחוש למתמטיקה.

00:08:41.240 --> 00:08:46.300
אתם יודעים בדיוק כמה זרימות הושלמו עם נתונים מאומתים מכיוון שפעולות ה-RFI אומרות לכם.

00:08:46.460 --> 00:08:48.820
כל אחד מהם הופך לצומת אחריות מדיד.

00:08:49.000 --> 00:08:51.600
הארגון עובר מעני חושב שהזרימות שלנו יציבות,

00:08:51.760 --> 00:08:53.340
לאנחנו יכולים להוכיח שהן יציבות.

00:08:53.340 --> 00:08:57.380
זוהי בגרות ממשל שמוגדרת לא על ידי בירוקרטיה, אלא על ידי טלמטריה.

00:08:57.540 --> 00:09:01.960
מלבד הסרקזם, עקרון האישור האנושי הזה אינו מיושן, הוא נצחי.

00:09:02.980 --> 00:09:04.000
חישבו על ייצור.

00:09:04.200 --> 00:09:06.160
מכונות מרכיבות, פקחים מעמתים.

00:09:06.340 --> 00:09:07.220
חישבו על מימון.

00:09:07.400 --> 00:09:09.520
אלגוריתמים מחשבים, רואי חשבון חותמים.

00:09:09.720 --> 00:09:11.860
אוטומציה ללא פיקוח היא משוואה לא גמורה.

00:09:11.860 --> 00:09:16.540
פעולת ה-RFI נותנת לקו-פיילוט סטודיו את החצי החסר, סכום בדיקה מאומת על ידי המשתמש.

00:09:16.540 --> 00:09:18.980
זה מביא משמעת במקום שבו הייתה רק נוחות.

00:09:19.180 --> 00:09:20.660
וכן, זה אכן מעט עותך.

00:09:20.840 --> 00:09:21.160
מעט.

00:09:21.300 --> 00:09:22.980
עיכוב זהו תכונה לא פגם.

00:09:23.180 --> 00:09:28.360
מהירות ללא אימות היא כמו נהיגה במכונית ספורט ללא בלמים, מלהיבה עד שאתה רואה את חומת התאימות.

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

00:09:33.180 --> 00:09:35.940
כאשר ההשאיה מסתיימת, האוטומציה מעיצה שוב.

00:09:36.100 --> 00:09:39.200
רק שעכשיו היא הולכת לכיוון שתוכל להגן עליו בבית המשפט.

00:09:39.200 --> 00:09:41.480
ההקבלה לפיכוח על איכות הנתונים ברורה.

00:09:41.680 --> 00:09:46.960
בניהול ארגוני, אימות אינו עוסק בחוסר אמון ביוצרי נתונים, אלא בהגנה על המערכות התלויות בהן.

00:09:47.120 --> 00:09:53.320
ברגע שתגובות RFI נכנסות לדטאברס, הן הופכות לעובדות ניתנות לאימות במקום לסדות טקסט שאינם ניתנים לאימות.

00:09:53.320 --> 00:09:59.300
המעבר הזה, סובקטיבי לאובייקטיבי, הוא מה שמעלה זרימה אוטומטית משימושית למוכנה לביקורת.

00:09:59.300 --> 00:10:04.880
החלק החכם באמת, שלבו RFI עם אימות בינה מלאכותית גנרטיבי ותשיגו ביטחון כפול.

00:10:05.060 --> 00:10:07.940
בינה מלאכותית בודקת היגיון אנושי מאשר את המציאות.

00:10:08.100 --> 00:10:09.560
שתי עדשות, אמת אחת.

00:10:09.720 --> 00:10:15.300
זהו ניהול בסטריאו, והוא מתחיל ברגע שאתם מחליטים שאוטומציה ללא אחריות אינה חכמה היא פזיזה.

00:10:15.300 --> 00:10:18.940
חלק רביעי, נולעת הממשל של בינה מלאכותית בתוספת RFI.

00:10:19.060 --> 00:10:20.760
אימות בינה מלאכותית הוא חכם.

00:10:20.880 --> 00:10:22.860
אתם מזינים אותו בטקסט, הוא יורג שיפוט.

00:10:22.860 --> 00:10:26.920
נכון, שקר, תקף, לא שלם, זהו המקבילה המכונה להרמת גבה.

00:10:27.060 --> 00:10:29.540
אבל שיפוט ללא סמכות הוא עדיין ניחושים.

00:10:29.960 --> 00:10:31.840
ובאוטומציה, ניחושים הם האויב.

00:10:32.040 --> 00:10:37.540
זו הסיבה ששילוב הנחיות בינה מלאכותית עם פעולת RFI יוצרת מה שאני מכנה לולעת הממשל.

00:10:37.540 --> 00:10:40.740
מעגל סגור בין הנמכה מלאכותית לאישור אנושי.

00:10:40.840 --> 00:10:43.140
בינה מלאכותית מציעה בני אדם מעשרים.

00:10:43.360 --> 00:10:45.840
יחד הם בונים אמינות שאתם יכולים למעשה להוכיח.

00:10:46.000 --> 00:10:46.880
כך זה מתנהל.

00:10:46.880 --> 00:10:52.140
זרימת סוכן בקופילוט סטודיו מקבלת הגשה, נניח, מתופס של מייקרוסופט המבקש גישת מבקר.

00:10:52.260 --> 00:10:53.620
הפרטים נראים מזיקים.

00:10:53.820 --> 00:10:55.960
ג'יימס מבקר במטה לפגישת פרויקט.

00:10:56.120 --> 00:10:59.840
בקשת הבינה המלאכותית מעריכה אותה באמצעות לוגיקת האימות שבנית.

00:10:59.840 --> 00:11:03.760
האם היא כוללת את סוג הפגישה, משך הזמן, אישורי הבטיחות?

00:11:03.860 --> 00:11:07.620
תגובת המודל מורה לג'סון פרטים, תקפים נכון או לא נכון,

00:11:07.900 --> 00:11:11.140
וסיבה משך הזמן הצפוי חסר או מכיל מידע נדרש.

00:11:11.140 --> 00:11:13.000
זוהי נקודת הביקורת הראשונה.

00:11:13.200 --> 00:11:15.660
פסק הדין של הבקשה אינו פקודה, אלא ראיה.

00:11:15.820 --> 00:11:18.820
כעת ה-RFI ממשיך מהמקום שבו הבינה המלאכותית עצרה.

00:11:18.940 --> 00:11:22.900
עם הפלט של הבקשה המחזיר שקר, הזרימה מסתעפת לפעולת RFI.

00:11:23.060 --> 00:11:24.180
האוטומציה מושהת.

00:11:24.180 --> 00:11:29.920
היא יוצרת הודעה ניתנת לפעולה באטלוק שכותרתה משהו כמו דרוש פרטים נוספים עבור בקשת גישת מטה.

00:11:30.040 --> 00:11:33.760
בתוך הודעה זו, בדיוק השדות החסרים שהבינה המלאכותית זיהתה,

00:11:33.760 --> 00:11:37.700
תיאור מפורט, משך זמן צפוי וכל נתוני תאימות נדרשים אחרים.

00:11:37.880 --> 00:11:42.080
המערכת מקצה אותם למבקש המקורי באמצעות זהות הספרייה שלו מהתופס.

00:11:42.240 --> 00:11:44.380
ההודעה נוחתת בתיבת הדואר הנכנס שלו,

00:11:44.380 --> 00:11:48.120
ולפתע זרימת העבודה שנראתה אוטומטית לחלוטין אומרת כעת בנימוס,

00:11:48.320 --> 00:11:49.100
פספסת משהו.

00:11:49.220 --> 00:11:49.940
תקן את זה.

00:11:50.100 --> 00:11:53.720
כאשר הם מגיבים, הנתונים הללו לא רק מתקן את הרשומה.

00:11:54.160 --> 00:11:55.380
הם מעמתים את התיקון.

00:11:55.740 --> 00:11:58.960
ה-RFI לוחד חותמת זמן, זהות משתמש ותוכן חדש,

00:11:58.960 --> 00:12:04.200
ולאחר מכן מאחסן את הפרטים הללו כפלטים מובנים, מודפסים, נרשמים, בלתי ניתנים לשינוי.

00:12:04.340 --> 00:12:05.800
זרימת הסוכן מתחדשת,

00:12:06.000 --> 00:12:10.140
מעדכנת את שורת הנתונים וממירה את הסטטוס ממידע זקוק לתוקף.

00:12:10.140 --> 00:12:12.700
באותו רגע, לא רק שהשלמת את זרימת העבודה,

00:12:12.980 --> 00:12:15.380
אלא גם יצרת ארטיפקט ממשל הניתן לביקורת.

00:12:15.520 --> 00:12:16.760
כל תוצאה מתועדת.

00:12:16.920 --> 00:12:19.040
ההערכה הראשונית של הבינה המלאכותית,

00:12:19.200 --> 00:12:21.480
התיקון האנושי והמצב הסופי המאומת.

00:12:21.480 --> 00:12:23.640
השווה זאת לתרחיש שאינו RFI.

00:12:23.800 --> 00:12:25.980
הבינה המלאכותית עדיין תסמן פרטים חסרים,

00:12:26.180 --> 00:12:26.640
אבל אז מה?

00:12:26.760 --> 00:12:27.760
היא עשויה לפרסם שגיאה,

00:12:27.860 --> 00:12:29.140
לשלוח דואר אלקטרוני מאורפל,

00:12:29.240 --> 00:12:30.140
או פשוט לשלוח לולאה,

00:12:30.260 --> 00:12:32.560
ולשאול את אותה שאלה ללא סוף עד שמישהו מתקן אותה ידנית.

00:12:32.560 --> 00:12:34.580
זהו הקשל השקט הידוע לשמצה.

00:12:34.680 --> 00:12:35.720
הזרימה רצה טכנית,

00:12:35.880 --> 00:12:37.540
אבל אי אפשר לסמוך על מה שהיא יצרה.

00:12:37.680 --> 00:12:38.920
על ידי שילוב RFI,

00:12:39.120 --> 00:12:40.660
אתה מבטל לחלוטין את השתיקה.

00:12:40.660 --> 00:12:43.660
הזרימה חייבת להמתין באופן גלוי עד שיגיעו נתונים מאומתים.

00:12:43.840 --> 00:12:44.780
זה לא בטוח מפני קשל,

00:12:44.980 --> 00:12:46.360
זה חסין מפני קשל מעצם התכנון.

00:12:46.500 --> 00:12:47.960
תחשוב על זה כמו הבטחה פיזית.

00:12:48.100 --> 00:12:50.260
הנחיית הבינה המלאכותית היא מצלמת המעקב.

00:12:50.380 --> 00:12:51.500
הוא צופה ומנתח.

00:12:51.500 --> 00:12:53.600
ה-RFI הוא הדלת הנעולה.

00:12:53.700 --> 00:12:56.280
הוא מסרב כניסה עד שתציג אישורים מאומתים.

00:12:56.460 --> 00:12:57.740
אתם צריכים את שניהם.

00:12:57.920 --> 00:12:59.760
מצלמות מרתיעות התנהגות רעה,

00:12:59.960 --> 00:13:00.940
מנעולים מונעים אותה.

00:13:01.060 --> 00:13:02.000
בעולם הממשל,

00:13:02.000 --> 00:13:04.000
הנחיות מזהות חוסר עקביות.

00:13:04.220 --> 00:13:06.120
RFI מונעים את התפשטותן.

00:13:06.540 --> 00:13:12.020
יחד, הן הופכות אוטומציה מבולגנת ומועדת לשגיאות לתהליך אימות דו של בי לאיכות נתונים.

00:13:12.020 --> 00:13:15.100
כל פלט RFI הוא רשומת ביקורת מיניאטורית.

00:13:15.260 --> 00:13:18.020
אובייקט הג'סון כולל לא רק את הערכים שהוגשו,

00:13:18.240 --> 00:13:20.800
אלא גם מי סיפק אותם, מתי ומאיזה הקשר.

00:13:20.980 --> 00:13:25.520
קציני ציות אוהבים את זה כי זה ממיר לוגיקת אימות מופשטת לראיות מוחשיות.

00:13:25.520 --> 00:13:30.400
כעת תוכלו להדגים שההחלטות הבינה המלאכותית שלכם מעולם לא היו אוטונומיות.

00:13:30.620 --> 00:13:32.500
הן עומתו על ידי אדם בזמן אמת.

00:13:32.700 --> 00:13:36.080
זה ההבדל בין הדגמה חכמה למערכת בקרה מוכנה לארגון.

00:13:36.080 --> 00:13:40.760
שיטות עבודה המומלצות לממשל של Power Platform מדגישות בדיוק את האימות הכפול הזה.

00:13:40.880 --> 00:13:43.160
הנמקה אוטומטית בתוספת אישור אנושי.

00:13:43.320 --> 00:13:44.480
זה מבטיח חזרתיות.

00:13:44.660 --> 00:13:48.380
אתם יכולים להריץ שוב את אותו תהליך מחר ולקבל תוצאות ניתנות לאימות.

00:13:48.500 --> 00:13:49.840
זה מבטיח יכולת הגנה.

00:13:49.840 --> 00:13:53.920
אם רגולטורים שואלים כיצד התקבלה החלטה, יש לכם הוכחה מילולית.

00:13:54.220 --> 00:13:55.360
וזה מבטיח המינות.

00:13:55.580 --> 00:14:00.420
כל ריצה של הזרימה מייצרת תוצאות עקביות עם ביטחון מדוד לא הנחות אופטימיות.

00:14:00.420 --> 00:14:06.500
כן, גישה זו מציגה עיכוב בדרך כלל 10 עד 15 שניות של המתנה בזמן שמשתמש משלים את ה-RFI שלו.

00:14:06.600 --> 00:14:12.420
אבל ההשאיה הקצרה הזו מונעת שעות, לפעמים ימים, של ניקוי לאחר אירוע כאשר נתונים גרועים מתפשטים ללא בדיקה.

00:14:12.560 --> 00:14:15.620
אנשים מתלוננים שה-RFI מעט-עט האוטומציות שלהם.

00:14:15.780 --> 00:14:18.060
זה כמו להתלונן שבלמים מעטים את המכונית שלך.

00:14:18.220 --> 00:14:21.020
הם עושים זאת, בכוונה, כדי שתוכל להמשיך לנהוג מחר.

00:14:21.180 --> 00:14:26.180
בסופו של דבר, לולאת ה-RFI של בינה מלאכותית לא רק מתקנת זרימות עבודה, היא מעצבת מחדש את האחריותיות.

00:14:26.180 --> 00:14:28.600
היא מלמדת את האוטומציה שלך להיות ספקנית.

00:14:28.740 --> 00:14:30.440
הבינה המלאכותית מזהה הנומליות.

00:14:30.620 --> 00:14:35.440
ה-RFI מעמד תיקונים, ויחד הם מתייחסים לנתונים לא כטקסט חד פעמי, אלא כמלאי מבוקר.

00:14:35.580 --> 00:14:37.840
כל פריט נבדק, נרשם וניתן להחזר.

00:14:45.620 --> 00:14:48.320
זה המקום שבו מתחילה אמינות ארגונית אמיתית.

00:14:48.640 --> 00:14:50.980
מלכודות נפוצות כשמתעלמים מ-RFI.

00:14:51.240 --> 00:14:54.660
בואו נדבר על מה שקורה כשאתה מעמיד פנים ש-RFI לא קיים.

00:14:54.660 --> 00:14:56.100
ספוילר, זה לא יפה.

00:14:56.240 --> 00:15:02.060
זרימות שאינן RFI הן כמו בני נוער עם מבטחות לרכב, מתפקדות מבחינה טכנית ללא פיקוח בצורה קטסטרופלית.

00:15:02.240 --> 00:15:05.960
הן מקבלות כל מידע שתזין אותן ואז ממשיכות בביטחון אל תוך אסון.

00:15:06.160 --> 00:15:09.080
התחילו במצב הקשל הצפוי ביותר, קלת רק.

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

00:15:15.720 --> 00:15:21.860
ערך הניול הזה זורם במורד הזרם, שובר תנאים, מדלג על ענפים מגבילים ומבלבל כל פעולה תלויה.

00:15:22.060 --> 00:15:28.040
אתם בסופו של דבר עם זרימות שמצליחות לפי Power Automate, אך מספקות פלטים שלא היו עוברות מבחן לוגי בסיסי.

00:15:28.180 --> 00:15:32.300
לאחר מכן אתם מקבלים את רשומות הפנטום המפוארות בדטאברס, שורות ריקות עם חותמות זמן,

00:15:32.300 --> 00:15:35.640
אך ללא נתונים ממשיים שממלאים את הטבלאות שלכם כמו ארנבות אבק דיגיטליות.

00:15:35.800 --> 00:15:37.820
לאחר מכן מגיעים אישורים לא מדויקים.

00:15:38.020 --> 00:15:42.620
ללא אימות RFI, האוטומציה שלכם מניחה שהאדם שמילא את התופס הבין את כל הכללים.

00:15:42.780 --> 00:15:43.340
הוא לא הבין.

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

00:15:50.120 --> 00:15:52.020
ביום טוב, זה יוצר עבודה חוזרת.

00:15:52.220 --> 00:15:53.800
ביום רע, זה יוצר אחריות.

00:15:53.800 --> 00:15:58.240
זכרו, אישור אוטומטי שהוזן לדטאברס הופך לחלק ממסלול התאימות שלכם.

00:15:58.360 --> 00:16:01.360
ברגע שזה ננעל, למבקרים לא אכפת שהזרימה עשתה את זה.

00:16:01.520 --> 00:16:03.980
הם יקראו לזה קשל בקרה, והם יהיו צודקים.

00:16:04.160 --> 00:16:07.440
וכן, נתוני דטאברס פגומים נובעים באופן טבעי מהקאוס הזה.

00:16:07.600 --> 00:16:13.440
בכל פעם שמידע לא שלם מתגנב, קשרים בין טבלאות משברים, חיפושים נכשלים, שאילתות תלויות מחזירות שטויות,

00:16:13.440 --> 00:16:17.640
ולוחות מכוונים מציגים פתאום סכומים שגורמים למנהלי הכספים להיחנק מהקפה שלהם.

00:16:17.780 --> 00:16:21.800
ללא נקודות ביקורת של RFI, אף אחד מהפערים האלה לא נתפס בזמן היצירה.

00:16:21.920 --> 00:16:25.480
הם פשוט מצטברים עד שעונת הדיווח הופכת לתרגיל של הקצאת השמים.

00:16:25.680 --> 00:16:29.880
ואז יש את לולעת ההבהרה האנסופית של הבינה המלאכותית, זעקת העזרה של האוטומציה.

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

00:16:37.020 --> 00:16:40.980
זה כמו לנהל שיחה עם תשדבות ששכח את הנושא אבל מסרב להפסיק להקליד.

00:16:41.120 --> 00:16:45.460
הכל בגלל שלא נתת על הזרימה דרך להשהות ולחכות לתיקונים מאומתים אנושיים סופיים.

00:16:45.660 --> 00:16:46.780
זה מה ש-RFI עושה.

00:16:46.920 --> 00:16:50.300
זה שובר את המעגל הזה על ידי החזקת הביצוע כבין הרובה עד שהאמת תגיע.

00:16:50.300 --> 00:16:53.740
נקודות הכאב העסקיות מהתעלמות מ-RFI, כל הזרימה יורדת.

00:16:53.860 --> 00:16:56.920
החשיפה הרגולטורית גוברת כי אי אפשר להוכיח מי אישר מה.

00:16:57.060 --> 00:17:01.400
נתיבי ביקורת הופכים לבלתי אמינים משום ששרשרת הראיות שלכם מתחילה עם נתונים חלקיים.

00:17:01.580 --> 00:17:06.440
אם אתם חושבים שמבקרים נהנים משחזור פרשני של ערכים חסרים, ברור שמעולם לא פגשתם כזה.

00:17:06.600 --> 00:17:07.900
ובואו נחמת את העלות.

00:17:07.900 --> 00:17:17.440
בכל פעם שאוטומציה נכשלת בשקט עקב כלת שגוי, מי שהוא חייב לזהות את הבעיה באופן ידני, לתקן את הנתונים, להריץ מחדש את הזרימה ולעמת את כל המערכות במורד הזרם שלה.

00:17:17.600 --> 00:17:23.000
הכפילו את זה במאות טריגרים בחודש ופתאום לזרימת העבודה היעילה שלכם ללא קוד יש בייביסיטר במשרה מלאה.

00:17:23.120 --> 00:17:26.140
בקשות לאישור, RFI, עולות שניות, ניקוי עולה ימים.

00:17:26.320 --> 00:17:28.100
ובכל זאת, אנשים עדיין מתנגדים.

00:17:28.100 --> 00:17:32.500
הם טוענים ש-RFI מעט חדשנות מוסיף חיכוך או מאלץ בני אדם להתחבר מחדש.

00:17:32.620 --> 00:17:34.600
נכון, כן, ובאופן מפואר.

00:17:34.740 --> 00:17:38.740
התעלמות מ-RFI היא כמו להסיר חגורות בטיחות משום שאתם מעדיפים חופש תנועה.

00:17:38.860 --> 00:17:40.640
זוהי אופטימיות במסווה של רשלנות.

00:17:40.820 --> 00:17:45.900
ממשל קיים דווקא משום שאנשים שוכחים פרטים, ממהרים להגיב ומניחים שמכונות יתקנו את זה מאוחר יותר.

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

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

00:17:58.620 --> 00:18:04.580
דרמטי, רק במעט, בלי RFI, האוטומציה שלכם אינה תואמת, זוהי כתיבה יצירתית עם חותמות זמן.

00:18:04.740 --> 00:18:10.940
כל שדה מושמת הוא שקר שהמערכת שלכם מספרת לעצמה, וכל רשומה לא מעומתת היא הפרת מדיניות שמחכה לגילוי.

00:18:10.940 --> 00:18:15.720
התמורה של הכללת RFI אינה ניצחון אדמיניסטרטיבי, זו אישפיות תפעולית.

00:18:15.820 --> 00:18:21.820
ברגע שתראו כמה נקיים, עקביים וניתנים לביקור את הזרימות שלכם, תתאו איך אי פעם סבלתם את הקאוס הזה.

00:18:21.980 --> 00:18:25.040
RFI הופך אוטומציה מתרגיל אמון למערכת בקרה.

00:18:25.180 --> 00:18:31.820
אז, אם הזרימות שלכם ממשיכות להיקשל, אולי הבעיה אינה קופה אילות, אלא שאתם נותנים לתוכנה שלכם לפתוח בבני אדם ללא פיקוח.

00:18:32.020 --> 00:18:34.260
שידרוג הממשל שלא ידעתם שאתם צריכים.

00:18:34.260 --> 00:18:40.800
הנה העניין, רוב האנשים בסופו של דבר מבינים שאמינות אינה עניין של בינה מלאכותית חכמה יותר, אלא של ממשל מחמיר יותר.

00:18:40.980 --> 00:18:42.040
הבקשה למידע

00:18:42.040 --> 00:18:45.460
פעולה אינה ליטוש אופציונלי, זו השלמות מבנית.

00:18:45.640 --> 00:18:50.180
זה ההבדל בין האוטומציה שלנו עובדת לבין האוטומציה שלנו שיכולה להוכיח שהיא עובדה.

00:18:50.300 --> 00:18:54.920
כשאתם עופים RFI בזרימות קופה אילות סטודיו שלכם, אתם יוצרים לולעת אחריות סגורה.

00:18:54.920 --> 00:18:58.700
כל החלטה מאומתת, כל פער נפטר, כל רשומה ניתנת להגנה.

00:18:58.700 --> 00:19:00.240
זה הקסם האמיתי כאן.

00:19:00.380 --> 00:19:05.520
RFI לא רק הוקף כללי תאימות, הוא ממיר ממשל מופשט להתנהגות מוחשית של זרימת עבודה.

00:19:05.680 --> 00:19:09.280
הבינה המלאכותית שלכם לא רק סומכת על טקסט, היא בוחנת אותו גם כן.

00:19:09.480 --> 00:19:12.760
הזרימה שלכם לא רק רושמת נתונים, היא דורשת הבטחת איכות.

00:19:12.980 --> 00:19:17.780
זהו ממשל במסווה של פונקציונליות, וזו הסיבה שהוא מחולל בשקט מהפכה באמינות.

00:19:17.780 --> 00:19:22.140
חישבו על ממשל נתונים, תאימות ואמינות כשלוש זוויות של אותו משולש.

00:19:22.140 --> 00:19:26.000
בלי RFI, המבנה הזה קורס לקיצורי דרך ותירוצים.

00:19:26.180 --> 00:19:28.600
עם RFI, כל צד תומך באחרים.

00:19:29.180 --> 00:19:34.300
איכות הנתונים מבטיחה תאימות, תאימות אוכפת עקיבות, והעקיבות מחזקת אמינות.

00:19:34.520 --> 00:19:37.440
אתם מפסיקים לחבות את השריפות ומתחילים לבקר בביטחון.

00:19:37.620 --> 00:19:39.760
וכן, המבקרים שלכם באמת יחייכו.

00:19:39.880 --> 00:19:41.400
תוצאה מטרידה אך מדידה.

00:19:41.400 --> 00:19:42.860
אז הנה המסקנה שלכם.

00:19:42.960 --> 00:19:45.160
הפסיקו להתייחס לממשל כמו לבירוקרטיה.

00:19:45.360 --> 00:19:46.080
זהו שריון.

00:19:46.260 --> 00:19:50.260
RFI הוא הציפוי שמונע מהאוטומציות שלכם מלהתנגש בנתונים גרועים.

00:19:50.420 --> 00:19:54.520
אם זרימות העבודה שלכם עדיין לא המצוא אותו, אתם לא מנהלים ממשל, אתם שורדים מזל.

00:19:54.540 --> 00:19:57.580
ומכיוון שהמזל בסופו של דבר עוזל, חיזקו את הזרימות שלכם עכשיו.

00:19:57.760 --> 00:20:01.340
הוסיפו RFI-S לכל תהליך שבו נתונים חסרים או מפוקפקים עלולים לגרום לצרות.

00:20:01.480 --> 00:20:03.980
לימדו את הבינה המלאכותית שלכם לאמת, לא להניח.

00:20:03.980 --> 00:20:08.860
התייחסו לכל תגובת RFI כפי שהיא באמת חתימה של אחריותיות מוטמעת בקוד.

00:20:09.000 --> 00:20:13.580
אם ההסבר הזה הציל אתכם מיסיות אחד של איכות נתונים, גמות טובה, הרשמו.

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

00:20:20.000 --> 00:20:21.460
יעילות ללא אמינות היא קאוס.

00:20:21.640 --> 00:20:23.400
RFI הופך את זה לתרבותי.

00:20:23.400 --> 00:20:24.400
תודה.
