דף זה תורגם על ידי Cloud Translation API.

Codelab לאופטימיזציה של רכישות מתוך האפליקציה בזמן אמת

1. סקירה כללית

ברוכים הבאים ל-Codelab בנושא אופטימיזציה של רכישות מתוך האפליקציה במכשיר בזמן אמת. ב-codelab הזה תלמדו איך להשתמש ב-TensorFlow Lite וב-Firebase כדי לאמן ולפרוס מודל התאמה אישית מותאם אישית באפליקציה.

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

מה תלמדו

איסוף נתוני ניתוח דרך Firebase Analytics
עיבוד מקדים של נתוני ניתוח באמצעות BigQuery
אימון מודל פשוט של למידת מכונה (ML) לאופטימיזציה של רכישות מתוך האפליקציה (IAP) במכשיר
פריסה של מודלים של TFLite ב-Firebase ML וגישה אליהם מהאפליקציה
מדידה של מודלים שונים וניסוי בהם באמצעות Firebase A/B Testing
אימון ופריסה של מודלים חדשים על סמך הנתונים העדכניים ביותר בתדירות קבועה

מה צריך

Android Studio מגרסה 3.4 ואילך
מכשיר בדיקה פיזי עם Android מגרסה 2.3 ואילך ו-Google Play Services מגרסה 9.8 ואילך, או אמולטור עם Google Play Services מגרסה 9.8 ואילך
אם משתמשים במכשיר בדיקה פיזי, כבל חיבור
ידע בסיסי בלמידת מכונה

איך תוכלו להשתמש במדריך הזה?

לקרוא את המאמר

לקרוא את המאמר ולבצע את התרגילים

מה מידת שביעות הרצון שלך מהניסיון שלך בפיתוח אפליקציות ל-Android?

מתחילים

בינוניים

מומחים

2. תיאור הבעיה

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

3. קבלת הקוד לדוגמה

משכפלים את המאגר ב-GitHub משורת הפקודה.

git clone https://github.com/googlecodelabs/firebase-iap-optimization.git

המאגר הזה מכיל:

Jupyter notebook‏ (‎.ipynb) שמאמן את מודל ההתאמה האישית ומארז אותו בתוך מודל TFLite
אפליקציית Kotlin לדוגמה שמשתמשת במודל TFLite כדי לבצע תחזיות במכשיר

4. הפעלת האפליקציה באמצעות Firebase

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

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

5. איסוף אירועי ניתוח נתונים באפליקציה

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

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

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

הורדת נתונים לדוגמה (אופציונלי)

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

איסוף נתונים באמצעות Firebase Analytics SDK

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

התקנה של Firebase Analytics SDK

כדי להתחיל להשתמש ב-Firebase Analytics באפליקציה, אפשר לפעול לפי ההוראות במסמכי התיעוד של Google Analytics. המאגר firebase-iap-optimization שהעתקתם בתחילת סדנת הקוד הזו כבר כולל את Firebase Analytics SDK.

רישום ביומן של אירועים מותאמים אישית

אחרי שמגדירים את Firebase Analytics SDK, אפשר להתחיל לתעד ביומן את האירועים שנדרשים כדי לאמן את המודל.

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

MainActivity.kt

firebaseAnalytics.setUserId("player1")

בשלב הבא נוכל לתעד ביומן אירועים של שחקנים. כדי לבצע אופטימיזציה של IAP, אנחנו רוצים לתעד ביומן כל מבצע IAP שמוצג למשתמש, ואת העובדה שהמשתמש לחץ על המבצע הזה. כך נקבל שני אירועי ניתוח נתונים – offer_iap ו-offer_accepted. אנחנו גם נעקוב אחרי מזהה offer_id ייחודי כדי שנוכל להשתמש בו מאוחר יותר כדי לשלב את הנתונים האלה ולבדוק אם הצעת המחיר אושרה.

MainActivity.kt

predictButton?.setOnClickListener {
  predictionResult = iapOptimizer.predict()

  firebaseAnalytics.logEvent("offer_iap"){
    param("offer_type", predictionResult)
    param("offer_id", sessionId)
  }
}

acceptButton?.setOnClickListener {
  firebaseAnalytics.logEvent("offer_accepted") {
    param("offer_type", predictionResult)
    param("offer_id", sessionId)
  }
}

מידע נוסף על רישום אירועים מותאמים אישית זמין במסמכי התיעוד בנושא רישום אירועים ביומן ב-Firebase Analytics.

6. עיבוד נתונים מראש ב-BigQuery

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

כדי לעשות זאת, נתחיל בייצוא אירועי Analytics ל-BigQuery.

קישור פרויקט Firebase ל-BigQuery

כדי לקשר ל-BigQuery פרויקט מ-Firebase, כולל את האפליקציות שלו:

נכנסים ל-Firebase.
לוחצים על ובוחרים באפשרות Project Settings (הגדרות הפרויקט).
בדף Project Settings (הגדרות הפרויקט), לוחצים על הכרטיסייה Integrations (שילובים).
בכרטיס BigQuery, לוחצים על 'קישור'.

(אופציונלי) ייצוא האוספים של Firestore ל-BigQuery

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

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

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

הכנת נתונים ב-BigQuery

בשלבים הבאים נשתמש ב-BigQuery כדי להפוך את נתוני הניתוח הגולמי שלנו לנתונים שאפשר להשתמש בהם לאימון המודל.

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

המשתמש
מצב המשחק
המבצע המוצג
אם המשתמשים לחצו על המבצע המוצג או לא

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

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

כדי לראות אם לוחצים על כל מבצע לרכישה מתוך האפליקציה, נצטרך להצטרף לאירועים offer_iap ו-offer_accepted שרשמנו בשלב הקודם.

all_offers_joined – תצוגה ב-BigQuery

SELECT
  iap_offers.*,
  CASE
    WHEN accepted_offers.accepted IS NULL THEN FALSE ELSE TRUE
  END
  is_clicked,
FROM
  `iap-optimization.ml_sample.accepted_offers` AS accepted_offers
RIGHT JOIN
  `iap-optimization.ml_sample.iap_offers` AS iap_offers
ON
 accepted_offers.offer_id =iap_offers.offer_id;

all_offers_with_user_data – תצוגה ב-BigQuery

SELECT
  offers.is_clicked,
  offers.presented_powerup,
  offers.last_run_end_reason,
  offers.event_timestamp,
  users.*
FROM
  `iap-optimization.ml_sample.all_offers_joined` AS offers
LEFT JOIN
  `iap-optimization.ml_sample.all_users` AS users
ON
  users.user_id = offers.user_id;

ייצוא מערך נתונים של BigQuery ל-Google Cloud Storage

לבסוף, אפשר לייצא את מערך הנתונים ב-BigQuery ל-GCS כדי שנוכל להשתמש בו באימון המודל.

7. אימון מודל האופטימיזציה

נתונים שנדגמו

כדי להמשיך עם שאר הקודלאב, אפשר להשתמש בנתונים מהשלב הקודם, 'עיבוד נתונים מראש ב-BigQuery', או בנתונים לדוגמה שאפשר להוריד כאן.

הגדרת הבעיה

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

הסבר על שיטת 'בינדיטים לפי הקשר'

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

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

הנתונים הבאים ישמשו אותנו בתחזית:

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

ניצול לעומת חקירה

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

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

אימון המודל

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

הכשרה מקומית

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

לא צריך GPU כדי להשתמש ב-codelab הזה, אבל אם אתם צריכים מכונה חזקה יותר כדי לבחון את הנתונים שלכם ולאמן את המודל שלכם, תוכלו לקבל מכונה של AI Platform Notebook כדי לזרז את האימון.

בסקריפט האימון שסופק, יצרנו איטרטור שיוצר נתוני אימון מקובצי ה-CSV שייצאנו מ-BigQuery. לאחר מכן השתמשנו בנתונים כדי להתחיל לאמן את המודל שלנו באמצעות Keras. פרטים על אימון המודל מופיעים בהערות של מסמך ה-notebook ב-Python.

מדידת ביצועי המודל

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

בסיום האימון, אנחנו משתמשים בנתונים ב-test.csv כדי לבדוק שוב את המודל שלנו. המודל מעולם לא ראה את הנתונים האלה, כך שאנחנו יכולים להיות בטוחים שהתוצאה לא נובעת מהתאמה יתר. במקרה הזה, הביצועים של המודל טובים יותר ב-28% מהביצועים של הסוכן האקראי.

ייצוא מודל TFLite

עכשיו יש לנו מודל מאומן שאפשר להשתמש בו, אבל הוא נמצא כרגע בפורמט TensorFlow. נצטרך לייצא את המודל בפורמט TFLite כדי שניתן יהיה להריץ אותו במכשירים ניידים.

train.ipynb

converter = tflite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()

with tf.io.gfile.GFile('iap-optimizer.tflite', 'wb') as f:
  f.write(tflite_model)

מכאן אפשר להוריד את המודל ולצרף אותו לאפליקציה.

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

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

כדי ללמוד איך לפרוס את המודל ב-Firebase ML, אפשר לעיין בקודלאב הוספת Firebase לאפליקציית Android שמבוססת על TFLite. אפשר לפרוס באמצעות מסוף Firebase או באמצעות Python API.

8. ביצוע חיזויים במכשיר

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

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

בשלב הבא, אנחנו נותנים למודל קלט לבדיקה באופן הבא:

IapOptimzer.kt

  val testInput = mapOf(
    "coins_spent" to                       2048f,
    "distance_avg" to                      1234f,
    "device_os" to                         "ANDROID",
    "game_day" to                          10f,
    "geo_country" to                       "Canada",
    "last_run_end_reason" to               "laser"
  )

לפי המודל, sparky_armor הוא שדרוג ה-IAP הטוב ביותר למשתמש הספציפי הזה.

מדידת הדיוק של המודל

כדי למדוד את הדיוק של המודל שלנו, אנחנו יכולים פשוט לעקוב אחרי המוצרים של IAP שהמודל שלנו צפה, ולבדוק אם המשתמשים לוחצים עליהם באמצעות Firebase Analytics. אפשר להשתמש בנתונים האלה יחד עם בדיקות A/B של Firebase כדי למדוד את הביצועים בפועל של המודל. אפשר גם לבצע בדיקות A/B על גרסאות שונות של המודל. מידע נוסף על בדיקות A/B ב-Firebase זמין במאמר יצירת ניסויים של הגדרת תצורה מרחוק ב-Firebase עם בדיקות A/B.

9. (אופציונלי): עדכון המודל באופן קבוע באמצעות נתונים חדשים

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

הגדרת צינור עיבוד נתונים לאימון ולפריסה עם נתונים חדשים היא מעבר להיקף של Codelab הזה. כדי להתחיל, אפשר לעיין ב-Google Cloud AI Platform וב-TFX.

10. כל הכבוד!

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

אם יש לכם שאלות, אתם יכולים לפרסם אותן ב-Stack Overflow #firebase-machine-learning.

מה עסקנו בו

TensorFlow Lite
Firebase ML
Firebase Analytics
BigQuery

השלבים הבאים

אימון ופריסה של מודל אופטימיזציה לאפליקציה.