TensorFlow.js: אימון מחדש של מודל זיהוי ספאם בתגובות לטיפול במקרי קצה

1. לפני שמתחילים

ה-codelab הזה מבוסס על התוצאה הסופית של ה-codelab הקודם בסדרה הזו, בנושא זיהוי ספאם בתגובות באמצעות TensorFlow.js.

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

התוצאה הסופית של ה-codelab מוצגת בהמשך:

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

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

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

דרישות מוקדמות

• השלמתם את ה-codelab הראשון בסדרה הזו.
• ידע בסיסי בטכנולוגיות אינטרנט, כולל HTML,‏ CSS ו-JavaScript.

מה תפַתחו

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

בואו נתחיל לפרוץ…

מה תלמדו

תצטרכו:

• זיהוי מקרים חריגים שהמודל שעבר אימון מקדים לא הצליח לטפל בהם
• מאמנים מחדש את המודל לסיווג ספאם שנוצר באמצעות Model Maker.
• ייצאו את המודל הזה שמבוסס על Python לפורמט TensorFlow.js לשימוש בדפדפנים.
• מעדכנים את המודל המתארח ואת המילון שלו במודל החדש שאומן ובודקים את התוצאות

בשיעור Lab הזה אנחנו מניחים שיש לכם ידע ב-HTML5, ב-CSS וב-JavaScript. תריצו גם קוד Python דרך מחברת 'co lab' כדי לאמן מחדש את המודל שנוצר באמצעות Model Maker, אבל לא נדרש ידע ב-Python כדי לעשות את זה.

2. הגדרת סביבת עבודה לתכנות

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

ב-Glitch, פשוט לוחצים על הלחצן remix this כדי ליצור עותק של הפרויקט ולערוך את קבוצת הקבצים החדשה.

אפשרות חלופית: שימוש בעורך האינטרנט המועדף או עבודה מקומית אם רוצים להוריד את הקוד ולעבוד באופן מקומי עם השרת שלכם, או בעורך אונליין אחר, פשוט יוצרים מחדש את הקבצים שמוצגים בסביבת Node.js Express לפי בחירתכם, ומעתיקים את הקוד מה-boilerplate של Glitch לסביבה המקומית של כל קובץ.

3. זיהוי מקרים חריגים בפתרון הקודם

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

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

תגובות לגיטימיות שפורסמו ללא בעיה (שלילי אמיתי):

1. "וואו, אהבתי את הסרטון הזה, עבודה מדהימה". הסתברות לספאם: 47.91854%
2. "אהבתי מאוד את ההדגמות האלה! יש לך פרטים נוספים?" הסתברות לספאם: 47.15898%
3. "איזה אתר יכול לספק לי מידע נוסף?" הסתברות לספאם: 15.32495%

זה מצוין, ההסתברויות לכל האפשרויות שלמעלה נמוכות למדי, והן עוברות בהצלחה את ערך ברירת המחדל של SPAM_THRESHOLD הסתברות מינימלית של 75% לפני שננקטת פעולה (מוגדר בקוד script.js מתוך ה-Codelab הקודם).

עכשיו ננסה לכתוב עוד תגובות בוטות שיסומנו כספאם למרות שהן לא כאלה...

תגובות לגיטימיות שסומנו כספאם (תוצאות חיוביות שגויות):

1. "מישהו יכול לשלוח קישור לאתר של המסכה שהוא לובש?" הסתברות לספאם: 98.46466%
2. "Can I buy this song on Spotify? מישהו יכול לעדכן אותי?" הסתברות לספאם: 94.40953%
3. "האם מישהו יכול ליצור איתי קשר ולספק לי פרטים על הורדת TensorFlow.js?" הסתברות לספאם: 83.20084%

אויש… נראה שהתגובות הלגיטימיות האלה מסומנות כספאם, למרות שהן אמורות להיות מאושרות. מה הפתרון?

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

תגובות ספאם שסומנו כספאם (חיוביים אמיתיים):

1. "זה מגניב, אבל כדאי לך לבדוק את קישורי ההורדה באתר שלי, הם טובים יותר!" הסתברות לספאם: 99.77873%
2. "I know some people who can get you some medicines just see my pr0file for details" Probability Spam: 98.46955%
3. "כדאי להיכנס לפרופיל שלי כדי להוריד עוד סרטונים מדהימים וטובים יותר! http://example.com" סבירות לספאם: 96.26383%

אוקיי, אז זה עובד כצפוי עם סף 75% המקורי שלנו, אבל בהתחשב בכך שבשלב הקודם שינית את SPAM_THRESHOLD כך שרמת הביטחון תהיה מעל 98.5%, המשמעות היא ש-2 דוגמאות כאן יעברו, אז יכול להיות שהסף גבוה מדי. אולי 96% זה יותר טוב? אבל אם תעשו את זה, אחת התגובות בקטע הקודם (תוצאות חיוביות שגויות) תסומן כספאם למרות שהיא לגיטימית, כי היא קיבלה דירוג של 98.46466%.

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

בואו נמשיך…

תגובות ספאם שאושרו לפרסום (תוצאות שליליות שגויות):

1. "אפשר לעבור לפרופיל שלי כדי להוריד עוד סרטונים מדהימים וטובים יותר!" הסתברות לספאם: 7.54926%
2. ‫"Get a discount on our gym training classes see pr0file!" הסתברות לספאם: 17.49849%
3. "omg GOOG stock just shot right up! כדאי להזמין לפני שייגמר!" הסתברות לספאם: 20.42894%

במקרה של התגובות האלה, לא תוכלו לעשות שום דבר פשוט על ידי שינוי נוסף של הערך SPAM_THRESHOLD. הורדת הסף לספאם מ-96% ל-9% בערך תוביל לסימון תגובות אמיתיות כספאם – אחת מהן קיבלה דירוג של 58% למרות שהיא לגיטימית. הדרך היחידה להתמודד עם תגובות כאלה היא לאמן מחדש את המודל עם מקרים חריגים כאלה שכלולים בנתוני האימון, כדי שהוא ילמד להתאים את התפיסה שלו לגבי מה נחשב ספאם ומה לא.

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

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

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

4. אימון מחדש של המודל לזיהוי תגובות ספאם

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

סיכום מוכן מראש של המודל

המודל המוכן מראש שבו השתמשתם הוא מודל שנוצר על ידי צד שלישי באמצעות Model Maker, והוא מבוסס על מודל של הטמעת מילים ממוצעת.

הערה: למרות ש-Model Maker תוכנן במיוחד למשתמשי TF Lite (מפתחי אפליקציות נייטיב), הוא תומך גם בייצוא לפורמט המודל TensorFlow.js, כך שאפשר להשתמש במודל שנוצר לזיהוי תגובות ספאם גם בסביבת האינטרנט.

המערכת בנתה את המודל באמצעות Model Maker, ולכן תצטרכו לעבור ל-Python כדי לאמן מחדש את המודל, ואז לייצא את המודל שנוצר לפורמט TensorFlow.js כדי שתוכלו להשתמש בו בדפדפן. למזלנו, Model Maker מאפשר להשתמש במודלים שלו בקלות רבה, כך שיהיה לכם פשוט לעקוב אחרי ההוראות. אנחנו נדריך אתכם בתהליך, אז אל תדאגו אם אף פעם לא השתמשתם ב-Python!

כדאי לדעת: מהנדסי ML של JavaScript בדרך כלל מבצעים את כל העבודה שלהם באמצעות TensorFlow.js – אולי דרך Node.js לאימון מודלים בסביבת צד שרת. היום אנחנו מראים לכם איך להשתמש בקוד מ-Model Maker כדי שתוכלו לעבוד בביטחון עם מודלים שנוצרו בשפות אחרות כמו Python, ואז לייצא את המודלים האלה כדי לעבוד ב-TensorFlow.js. זו מיומנות חשובה ללמוד, כי הרבה מחקרים מגיעים מהאקדמיה, ובדרך כלל הם נכתבים ב-Python בזמן הכתיבה.

Colabs

ב-codelab הזה לא נתעסק בהגדרת שרת Linux עם כל כלי Python השונים שמותקנים בו, אלא פשוט נריץ קוד דרך דפדפן האינטרנט באמצעות Colab Notebook. מחברות העבודה האלה יכולות להתחבר ל'קצה העורפי' – שזה פשוט שרת עם כמה דברים שהותקנו מראש, שממנו אפשר להריץ קוד שרירותי בדפדפן האינטרנט ולראות את התוצאות. האפשרות הזו שימושית מאוד ליצירת אב-טיפוס מהיר או לשימוש במדריכים כמו זה.

פשוט נכנסים לכתובת colab.research.google.com ומוצג מסך הפתיחה כמו שמופיע כאן:

עכשיו לוחצים על הלחצן New Notebook (מחברת חדשה) בפינה השמאלית התחתונה של החלון הקופץ, וצריך להופיע מסמך Colab ריק כמו זה:

מצוין! השלב הבא הוא לחבר את ה-frontend של Colab לשרת backend כלשהו כדי שתוכלו להריץ את קוד Python שתכתבו. כדי לעשות את זה, לוחצים על Connect (חיבור) בפינה השמאלית העליונה ובוחרים באפשרות Connect to hosted runtime (חיבור לזמן ריצה מתארח).

אחרי החיבור, במקום הסמל של ה-Wi-Fi אמורים להופיע סמלים של זיכרון RAM ודיסק, כמו בתמונה הבאה:

יפה מאוד! עכשיו אפשר להתחיל לכתוב קוד ב-Python כדי לאמן מחדש את המודל של Model Maker. כל שעליך לעשות הוא לבצע את השלבים הבאים.

שלב 1

מעתיקים את הקוד שבהמשך לתא הריק הראשון. הכלי יתקין בשבילכם את TensorFlow Lite Model Maker באמצעות מנהל החבילות של Python שנקרא pip (הוא דומה ל-npm, שרוב הקוראים של ה-code lab הזה מכירים יותר מהמערכת האקולוגית של JS):

!apt-get install libasound-dev portaudio19-dev libportaudio2 libportaudiocpp0
!pip install -q tflite-model-maker

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

לוחצים על לחצן ההפעלה כדי להריץ את הקוד שהוקלד בתא.

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

עכשיו תראו את הכלי ליצירת מודלים בתהליך ההתקנה:

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

שלב 2

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

בתא הבא שיופעל יהיו כמה ייבואים שהקוד בשאר המחברת יצטרך להשתמש בהם. מעתיקים את הקוד שבהמשך ומדביקים אותו בתא החדש שנוצר:

import numpy as np
import os

from tflite_model_maker import configs
from tflite_model_maker import ExportFormat
from tflite_model_maker import model_spec
from tflite_model_maker import text_classifier
from tflite_model_maker.text_classifier import DataLoader

import tensorflow as tf
assert tf.__version__.startswith('2')
tf.get_logger().setLevel('ERROR')

מדובר בפעולות די סטנדרטיות, גם אם אתם לא מכירים את Python. אתם רק מייבאים כמה כלי עזר ואת הפונקציות של Model Maker שנדרשות לסיווג הספאם. בנוסף, המערכת תבדוק אם אתם מריצים TensorFlow 2.x, שנדרש לשימוש ב-Model Maker.

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

שלב 3

לאחר מכן תורידו את הנתונים משרת מרוחק למכשיר שלכם, ותגדירו את המשתנה training_data להיות הנתיב של הקובץ המקומי שהורדתם:

data_file = tf.keras.utils.get_file(fname='comment-spam-extras.csv', origin='https://storage.googleapis.com/jmstore/TensorFlowJS/EdX/code/6.5/jm_blog_comments_extras.csv', extract=False)

ב-Model Maker אפשר לאמן מודלים מקובצי CSV פשוטים כמו זה שהורדתם. צריך רק לציין באילו עמודות נמצא הטקסט ובאילו עמודות נמצאות התוויות. בשלב 5 נסביר איך עושים את זה. אתם יכולים להוריד את קובץ ה-CSV בעצמכם כדי לראות מה הוא מכיל.

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

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

מריצים את התא הזה, ואחרי שההרצה מסתיימת, מוסיפים תא חדש ועוברים לשלב 4.

שלב 4

כשמשתמשים ב-Model Maker, לא יוצרים מודלים מאפס. בדרך כלל משתמשים במודלים קיימים ואז מתאימים אותם לצרכים שלכם.

ב-Model Maker יש כמה הטמעות של מודלים שכבר עברו למידה, שאפשר להשתמש בהן, אבל הכי פשוט ומהיר להתחיל עם average_word_vec, שבו השתמשתם בסדנת ה-codelab הקודמת כדי לבנות את האתר. זה הקוד:

spec = model_spec.get('average_word_vec')
spec.num_words = 2000
spec.seq_len = 20
spec.wordvec_dim = 7

אחרי שמדביקים את הקוד בתא החדש, מריצים אותו.

הסבר על

num_words

פרמטר

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

הסבר על

wordvec_dim

פרמטר

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

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

במקרה של מילים שמקבלות ציון גבוה ב'מימד הרפואי', יכול להיות שמימד שני שמתאם בין מילים לגוף האדם יהיה שימושי. מילים כמו leg (רגל), arm (זרוע), neck (צוואר) עשויות לקבל כאן ציון גבוה, וגם ציון גבוה למדי בממד הרפואי.

המודל יכול להשתמש בממדים האלה כדי לזהות מילים שסביר יותר שהן קשורות לספאם. יכול להיות שהודעות ספאם יכילו יותר מילים שקשורות גם לרפואה וגם לחלקי גוף האדם.

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

הסבר על

seq_len

פרמטר

בדרך כלל, המודלים מאוד נוקשים בכל מה שקשור לערכי הקלט. במקרה של מודל שפה, המשמעות היא שמודל השפה יכול לסווג משפטים באורך מסוים וקבוע. האורך הזה נקבע על ידי הפרמטר seq_len, שמייצג את'אורך הרצף'. כשממירים מילים למספרים (או לטוקנים), משפט הופך לרצף של הטוקנים האלה. לכן המודל יאומן (במקרה הזה) לסווג ולזהות משפטים שמכילים 20 טוקנים. אם המשפט ארוך יותר, הוא ייקטע. אם הוא קצר יותר, הוא ירופד – בדיוק כמו בCodelab הראשון בסדרה הזו.

שלב 5 – טעינת נתוני האימון

קודם הורדתם את קובץ ה-CSV. עכשיו צריך להשתמש בכלי לטעינת נתונים כדי להפוך את זה לנתוני אימון שהמודל יכול לזהות.

data = DataLoader.from_csv(
      filename=data_file,
      text_column='commenttext', 
      label_column='spam', 
      model_spec=spec,
      delimiter=',',
      shuffle=True,
      is_training=True)

train_data, test_data = data.split(0.9)

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

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

לאחר מכן תשתמשו ב-data.split() כדי לפצל את הנתונים לנתוני אימון ולנתוני בדיקה. הערך ‎ .9 מציין ש-90% ממערך הנתונים ישמשו לאימון, והשאר לבדיקה.

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

שלב 6 – בניית המודל

מוסיפים עוד תא שבו נוסיף קוד לבניית המודל:

model = text_classifier.create(train_data, model_spec=spec, epochs=50)

הפעולה הזו יוצרת מודל לסיווג טקסט באמצעות Model Maker, ומציינים את נתוני האימון שרוצים להשתמש בהם (שהוגדרו בשלב 4), את מפרט המודל (שגם הוא הוגדר בשלב 4) ומספר תקופות האימון, במקרה הזה 50.

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

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

לכן, כשתגיעו לאפוקה ה-50, המודל ידווח על רמת דיוק גבוהה בהרבה. במקרה הזה, 99.1%!

שלב 7 – ייצוא המודל

אחרי שמסיימים את האימון, אפשר לייצא את המודל. ‫TensorFlow מאמן מודל בפורמט משלו, וצריך להמיר אותו לפורמט TensorFlow.js כדי להשתמש בו בדף אינטרנט. פשוט מדביקים את הטקסט הבא בתא חדש ומריצים אותו:

model.export(export_dir="/js_export/", export_format=[ExportFormat.TFJS, ExportFormat.LABEL, ExportFormat.VOCAB])
!zip -r /js_export/ModelFiles.zip /js_export/

אחרי שמריצים את הקוד הזה, לוחצים על סמל התיקייה הקטן בצד ימין של Colab כדי לנווט לתיקייה שאליה ייצאתם את הקובץ (בספריית הבסיס – יכול להיות שתצטרכו לעלות רמה אחת) ולמצוא את חבילת ה-ZIP של הקבצים שייצאתם בתיקייה ModelFiles.zip.

כדאי להוריד את קובץ ה-ZIP הזה למחשב עכשיו, כי תשתמשו בקבצים האלה בדיוק כמו ב-codelab הראשון:

מצוין! החלק של Python הסתיים, ועכשיו אפשר לחזור ל-JavaScript שאתם מכירים ואוהבים. סוף סוף!

טיפ: ה-notebook של Colab שכתבתם זה עתה יישמר אל תיקיית Google Drive כברירת מחדל בתיקייה בשם Colab Notebooks, אם תרצו להריץ מחדש את כל הקוד עם קובץ CSV חדש כדי לאמן אותו שוב. אם תבחרו לעשות את זה מאוחר יותר, הקפידו להתחיל מלמעלה ולהריץ כל תא לפי הסדר כדי למנוע בעיות. אם רוצים, אפשר גם לערוך כל תא לפני שמריצים אותו.

5. הצגת המודל החדש של למידת מכונה

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

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

מה יש לך כאן?

• ‫model.json – זה אחד מהקבצים שמרכיבים את מודל TensorFlow.js שאומן. תצטרכו להפנות לקובץ הספציפי הזה בקוד ה-JS.
• ‫group1-shard1of1.bin – זהו קובץ בינארי שמכיל חלק גדול מהנתונים השמורים של מודל TensorFlow.js המיוצא, וצריך לארח אותו איפשהו בשרת כדי להוריד אותו באותה ספרייה כמו model.json שלמעלה.
• ‫vocab – הקובץ המוזר הזה ללא סיומת הוא משהו מ-Model Maker שמראה לנו איך לקודד מילים במשפטים כדי שהמודל יבין איך להשתמש בהן. בקטע הבא נסביר על כך בהרחבה.
• ‫labels.txt – מכיל רק את שמות המחלקות שהמודל יחזה. במודל הזה, אם פותחים את הקובץ בעורך טקסט, מופיעות בו רק המילים false ו-true, שמציינות את התוצאה של החיזוי: 'לא ספאם' או 'ספאם'.

אירוח קבצי המודל של TensorFlow.js

קודם צריך למקם את הקבצים model.json ו-*.bin שנוצרו בשרת אינטרנט כדי שתוכלו לגשת אליהם דרך דף האינטרנט.

הערה: אם אתם לא משתמשים ב-Glitch ומריצים במקום זאת שרת Node.js Express משלכם, אתם יכולים פשוט למקם את הקבצים האלה בלי לבצע שינויים בתיקייה www כדי להפעיל אותם. צריך לבצע את שלבי ההעלאה הבאים רק אם משתמשים ב-Glitch.com לאירוח הקבצים.

מחיקה של קבצים קיימים של מודלים

מכיוון שאתם ממשיכים את התוצאה הסופית של ה-codelab הראשון בסדרה הזו, אתם צריכים קודם למחוק את קובצי המודל הקיימים שהועלו. אם אתם משתמשים ב-Glitch.com, פשוט בודקים את חלונית הקבצים בצד ימין כדי למצוא את model.json ו-group1-shard1of1.bin, לוחצים על התפריט הנפתח (3 נקודות) של כל קובץ ובוחרים באפשרות מחיקה כמו שמוצג:

העלאת קבצים חדשים ל-Glitch

מצוין! עכשיו מעלים את הרשומות החדשות:

1. פותחים את התיקייה assets (נכסים) בחלונית הימנית של פרויקט Glitch ומוחקים נכסים ישנים שהועלו אם יש להם את אותם שמות.
2. לוחצים על העלאת נכס ובוחרים את group1-shard1of1.bin שרוצים להעלות לתיקייה הזו. אחרי ההעלאה, הוא אמור להיראות כך:

3. מצוין! עכשיו עושים את אותו הדבר גם לקובץ model.json, כך שצריכים להיות 2 קבצים בתיקיית הנכסים, כמו בדוגמה הבאה:

4. אם לוחצים על הקובץ group1-shard1of1.bin שהועלה, אפשר להעתיק את כתובת ה-URL למיקום שלו. מעתיקים את הנתיב הזה כמו שמוצג כאן:

5. בפינה הימנית התחתונה של המסך, לוחצים על כלים > טרמינל. מחכים שחלון הטרמינל ייטען.
6. אחרי שהכלי נטען, מקלידים את הפקודה הבאה ואז לוחצים על Enter כדי לשנות את הספרייה לתיקייה www:

טרמינל:

cd www

7. לאחר מכן, משתמשים ב-wget כדי להוריד את 2 הקבצים שהועלו זה עתה. לשם כך, מחליפים את כתובות ה-URL שלמטה בכתובות ה-URL שיצרתם עבור הקבצים בתיקיית הנכסים ב-Glitch (צריך לבדוק את תיקיית הנכסים כדי לראות את כתובת ה-URL המותאמת אישית של כל קובץ).

שימו לב לרווח בין שתי כתובות ה-URL, ולכך שכתובות ה-URL שתצטרכו להשתמש בהן יהיו שונות מאלה שמוצגות, אבל ייראו דומות:

terminal

wget https://cdn.glitch.com/1cb82939-a5dd-42a2-9db9-0c42cab7e407%2Fmodel.json?v=1616111344958 https://cdn.glitch.com/1cb82939-a5dd-42a2-9db9-0c42cab7e407%2Fgroup1-shard1of1.bin?v=1616017964562

מעולה! עכשיו יש לכם עותק של הקבצים שהועלו לתיקייה www.

עם זאת, בשלב הזה ההורדה תתבצע עם שמות מוזרים. אם מקלידים ls בטרמינל ומקישים על Enter, יופיע משהו כזה:

8. משתמשים בפקודה mv כדי לשנות את שם הקבצים. מקלידים את השורות הבאות במסוף ומקישים על Enter אחרי כל שורה:

טרמינל:

mv *group1-shard1of1.bin* group1-shard1of1.bin
mv *model.json* model.json

9. בסיום, מקישים על refresh בטרמינל ומקישים על Enter כדי לרענן את פרויקט Glitch:

טרמינל:

refresh

אחרי הרענון, התיקיות model.json ו-group1-shard1of1.bin אמורות להופיע בתיקייה www בממשק המשתמש:

מצוין! השלב האחרון הוא לעדכן את הקובץ dictionary.js.

10. ממירים את קובץ אוצר המילים החדש שהורדתם לפורמט JS הנכון באופן ידני באמצעות עורך הטקסט או באמצעות הכלי הזה, ושומרים את הפלט שמתקבל בשם dictionary.js בתיקייה www. אם כבר יש לכם קובץ dictionary.js, אתם יכולים פשוט להעתיק ולהדביק את התוכן החדש מעליו ולשמור את הקובץ.

יש! עדכנתם בהצלחה את כל הקבצים ששונו, ואם תנסו עכשיו להשתמש באתר, תראו שהמודל שאומן מחדש אמור להיות מסוגל להתמודד עם המקרים הקיצוניים שהתגלו וללמוד מהם, כמו שמוצג כאן:

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

ננסה גם כמה וריאציות כדי לראות אם ההכללה טובה. במקור היה משפט שגוי כמו:

‫"omg GOOG stock just shot right up! כדאי להזדרז!"

עכשיו היא מסווגת כספאם בצורה נכונה, אבל מה קורה אם משנים אותה ל:

‫"So XYZ stock just increased in value! כדאי לקנות לפני שייגמר!"

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

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

6. מעולה!

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

סיכום

ב-Codelab הזה:

1. זיהיתם מקרים קיצוניים שלא פעלו כשנעשה שימוש במודל מוכן מראש לזיהוי תגובות ספאם
2. אימנו מחדש את המודל של Model Maker כדי להתחשב במקרים הקיצוניים שגיליתם
3. ייצאתם את המודל החדש שעבר אימון לפורמט TensorFlow.js
4. עדכנתם את אפליקציית האינטרנט כדי להשתמש בקבצים החדשים

מה השלב הבא?

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

שיתוף התוצרים עם Google

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

אל תשכחו לתייג אותנו ברשתות החברתיות באמצעות ההאשטאג #MadeWithTFJS כדי שהפרויקט שלכם יוצג בבלוג של TensorFlow או אפילו באירועים עתידיים. נשמח לראות מה יצא לך.

עוד Codelabs של TensorFlow.js ללימוד מעמיק

• שימוש באירוח ב-Firebase כדי לפרוס ולארח מודל TensorFlow.js בהיקף גדול.
• איך יוצרים מצלמת אינטרנט חכמה באמצעות מודל מוכן מראש לזיהוי אובייקטים עם TensorFlow.js

אתרים שכדאי לבדוק

• האתר הרשמי של TensorFlow.js
• מודלים מוכנים מראש של TensorFlow.js
• ‫TensorFlow.js API
• ‫TensorFlow.js Show & Tell – מקבלים השראה ורואים מה אחרים יצרו.