TensorFlow חוזר ל-Google I/O ב-14 במאי! הירשם עכשיו

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

ניצול תכונות ההקשר

הצג באתר TensorFlow.org

הפעל בגוגל קולאב

צפה במקור ב-GitHub

הורד מחברת

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

גורמים רבים משפיעים על האם תכונות מעבר למזהות שימושיות במודל ממליץ:

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

במדריך זה, נתנסה בשימוש בתכונות מעבר לכותרות סרטים ומזהי משתמש למודל MovieLens שלנו.

מוקדמות

ראשית אנו מייבאים את החבילות הדרושות.

pip install -q tensorflow-recommenders
pip install -q --upgrade tensorflow-datasets

import os
import tempfile

import numpy as np
import tensorflow as tf
import tensorflow_datasets as tfds

import tensorflow_recommenders as tfrs

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

ratings = tfds.load("movielens/100k-ratings", split="train")
movies = tfds.load("movielens/100k-movies", split="train")

ratings = ratings.map(lambda x: {
    "movie_title": x["movie_title"],
    "user_id": x["user_id"],
    "timestamp": x["timestamp"],
})
movies = movies.map(lambda x: x["movie_title"])

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

timestamps = np.concatenate(list(ratings.map(lambda x: x["timestamp"]).batch(100)))

max_timestamp = timestamps.max()
min_timestamp = timestamps.min()

timestamp_buckets = np.linspace(
    min_timestamp, max_timestamp, num=1000,
)

unique_movie_titles = np.unique(np.concatenate(list(movies.batch(1000))))
unique_user_ids = np.unique(np.concatenate(list(ratings.batch(1_000).map(
    lambda x: x["user_id"]))))

הגדרת דגם

מודל שאילתה

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

class UserModel(tf.keras.Model):

  def __init__(self, use_timestamps):
    super().__init__()

    self._use_timestamps = use_timestamps

    self.user_embedding = tf.keras.Sequential([
        tf.keras.layers.StringLookup(
            vocabulary=unique_user_ids, mask_token=None),
        tf.keras.layers.Embedding(len(unique_user_ids) + 1, 32),
    ])

    if use_timestamps:
      self.timestamp_embedding = tf.keras.Sequential([
          tf.keras.layers.Discretization(timestamp_buckets.tolist()),
          tf.keras.layers.Embedding(len(timestamp_buckets) + 1, 32),
      ])
      self.normalized_timestamp = tf.keras.layers.Normalization(
          axis=None
      )

      self.normalized_timestamp.adapt(timestamps)

  def call(self, inputs):
    if not self._use_timestamps:
      return self.user_embedding(inputs["user_id"])

    return tf.concat([
        self.user_embedding(inputs["user_id"]),
        self.timestamp_embedding(inputs["timestamp"]),
        tf.reshape(self.normalized_timestamp(inputs["timestamp"]), (-1, 1)),
    ], axis=1)

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

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

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

מודל מועמד

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

class MovieModel(tf.keras.Model):

  def __init__(self):
    super().__init__()

    max_tokens = 10_000

    self.title_embedding = tf.keras.Sequential([
      tf.keras.layers.StringLookup(
          vocabulary=unique_movie_titles, mask_token=None),
      tf.keras.layers.Embedding(len(unique_movie_titles) + 1, 32)
    ])

    self.title_vectorizer = tf.keras.layers.TextVectorization(
        max_tokens=max_tokens)

    self.title_text_embedding = tf.keras.Sequential([
      self.title_vectorizer,
      tf.keras.layers.Embedding(max_tokens, 32, mask_zero=True),
      tf.keras.layers.GlobalAveragePooling1D(),
    ])

    self.title_vectorizer.adapt(movies)

  def call(self, titles):
    return tf.concat([
        self.title_embedding(titles),
        self.title_text_embedding(titles),
    ], axis=1)

דגם משולב

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

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

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

class MovielensModel(tfrs.models.Model):

  def __init__(self, use_timestamps):
    super().__init__()
    self.query_model = tf.keras.Sequential([
      UserModel(use_timestamps),
      tf.keras.layers.Dense(32)
    ])
    self.candidate_model = tf.keras.Sequential([
      MovieModel(),
      tf.keras.layers.Dense(32)
    ])
    self.task = tfrs.tasks.Retrieval(
        metrics=tfrs.metrics.FactorizedTopK(
            candidates=movies.batch(128).map(self.candidate_model),
        ),
    )

  def compute_loss(self, features, training=False):
    # We only pass the user id and timestamp features into the query model. This
    # is to ensure that the training inputs would have the same keys as the
    # query inputs. Otherwise the discrepancy in input structure would cause an
    # error when loading the query model after saving it.
    query_embeddings = self.query_model({
        "user_id": features["user_id"],
        "timestamp": features["timestamp"],
    })
    movie_embeddings = self.candidate_model(features["movie_title"])

    return self.task(query_embeddings, movie_embeddings)

ניסויים

הכן את הנתונים

תחילה חילקנו את הנתונים לסט הדרכה ולסט בדיקות.

tf.random.set_seed(42)
shuffled = ratings.shuffle(100_000, seed=42, reshuffle_each_iteration=False)

train = shuffled.take(80_000)
test = shuffled.skip(80_000).take(20_000)

cached_train = train.shuffle(100_000).batch(2048)
cached_test = test.batch(4096).cache()

קו בסיס: אין תכונות חותמת זמן

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

model = MovielensModel(use_timestamps=False)
model.compile(optimizer=tf.keras.optimizers.Adagrad(0.1))

model.fit(cached_train, epochs=3)

train_accuracy = model.evaluate(
    cached_train, return_dict=True)["factorized_top_k/top_100_categorical_accuracy"]
test_accuracy = model.evaluate(
    cached_test, return_dict=True)["factorized_top_k/top_100_categorical_accuracy"]

print(f"Top-100 accuracy (train): {train_accuracy:.2f}.")
print(f"Top-100 accuracy (test): {test_accuracy:.2f}.")

Epoch 1/3
WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor. Received: inputs={'user_id': <tf.Tensor 'IteratorGetNext:2' shape=(None,) dtype=string>, 'timestamp': <tf.Tensor 'IteratorGetNext:1' shape=(None,) dtype=int64>}. Consider rewriting this model with the Functional API.
WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor. Received: inputs={'user_id': <tf.Tensor 'IteratorGetNext:2' shape=(None,) dtype=string>, 'timestamp': <tf.Tensor 'IteratorGetNext:1' shape=(None,) dtype=int64>}. Consider rewriting this model with the Functional API.
WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor. Received: inputs={'user_id': <tf.Tensor 'IteratorGetNext:2' shape=(None,) dtype=string>, 'timestamp': <tf.Tensor 'IteratorGetNext:1' shape=(None,) dtype=int64>}. Consider rewriting this model with the Functional API.
WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor. Received: inputs={'user_id': <tf.Tensor 'IteratorGetNext:2' shape=(None,) dtype=string>, 'timestamp': <tf.Tensor 'IteratorGetNext:1' shape=(None,) dtype=int64>}. Consider rewriting this model with the Functional API.
40/40 [==============================] - 10s 169ms/step - factorized_top_k/top_1_categorical_accuracy: 0.0092 - factorized_top_k/top_5_categorical_accuracy: 0.0172 - factorized_top_k/top_10_categorical_accuracy: 0.0256 - factorized_top_k/top_50_categorical_accuracy: 0.0824 - factorized_top_k/top_100_categorical_accuracy: 0.1473 - loss: 14579.4628 - regularization_loss: 0.0000e+00 - total_loss: 14579.4628
Epoch 2/3
40/40 [==============================] - 9s 173ms/step - factorized_top_k/top_1_categorical_accuracy: 0.0020 - factorized_top_k/top_5_categorical_accuracy: 0.0126 - factorized_top_k/top_10_categorical_accuracy: 0.0251 - factorized_top_k/top_50_categorical_accuracy: 0.1129 - factorized_top_k/top_100_categorical_accuracy: 0.2133 - loss: 14136.2137 - regularization_loss: 0.0000e+00 - total_loss: 14136.2137
Epoch 3/3
40/40 [==============================] - 9s 174ms/step - factorized_top_k/top_1_categorical_accuracy: 0.0021 - factorized_top_k/top_5_categorical_accuracy: 0.0155 - factorized_top_k/top_10_categorical_accuracy: 0.0307 - factorized_top_k/top_50_categorical_accuracy: 0.1389 - factorized_top_k/top_100_categorical_accuracy: 0.2535 - loss: 13939.9265 - regularization_loss: 0.0000e+00 - total_loss: 13939.9265
WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor. Received: inputs={'user_id': <tf.Tensor 'IteratorGetNext:2' shape=(None,) dtype=string>, 'timestamp': <tf.Tensor 'IteratorGetNext:1' shape=(None,) dtype=int64>}. Consider rewriting this model with the Functional API.
WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor. Received: inputs={'user_id': <tf.Tensor 'IteratorGetNext:2' shape=(None,) dtype=string>, 'timestamp': <tf.Tensor 'IteratorGetNext:1' shape=(None,) dtype=int64>}. Consider rewriting this model with the Functional API.
40/40 [==============================] - 10s 189ms/step - factorized_top_k/top_1_categorical_accuracy: 0.0036 - factorized_top_k/top_5_categorical_accuracy: 0.0226 - factorized_top_k/top_10_categorical_accuracy: 0.0427 - factorized_top_k/top_50_categorical_accuracy: 0.1729 - factorized_top_k/top_100_categorical_accuracy: 0.2944 - loss: 13711.3802 - regularization_loss: 0.0000e+00 - total_loss: 13711.3802
5/5 [==============================] - 3s 267ms/step - factorized_top_k/top_1_categorical_accuracy: 0.0010 - factorized_top_k/top_5_categorical_accuracy: 0.0078 - factorized_top_k/top_10_categorical_accuracy: 0.0184 - factorized_top_k/top_50_categorical_accuracy: 0.1051 - factorized_top_k/top_100_categorical_accuracy: 0.2126 - loss: 30995.8988 - regularization_loss: 0.0000e+00 - total_loss: 30995.8988
Top-100 accuracy (train): 0.29.
Top-100 accuracy (test): 0.21.

זה נותן לנו דיוק 100 הבסיסי של כ-0.2.

לכידת דינמיקה של זמן עם תכונות זמן

האם התוצאה משתנה אם נוסיף תכונות זמן?

model = MovielensModel(use_timestamps=True)
model.compile(optimizer=tf.keras.optimizers.Adagrad(0.1))

model.fit(cached_train, epochs=3)

train_accuracy = model.evaluate(
    cached_train, return_dict=True)["factorized_top_k/top_100_categorical_accuracy"]
test_accuracy = model.evaluate(
    cached_test, return_dict=True)["factorized_top_k/top_100_categorical_accuracy"]

print(f"Top-100 accuracy (train): {train_accuracy:.2f}.")
print(f"Top-100 accuracy (test): {test_accuracy:.2f}.")

Epoch 1/3
WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor. Received: inputs={'user_id': <tf.Tensor 'IteratorGetNext:2' shape=(None,) dtype=string>, 'timestamp': <tf.Tensor 'IteratorGetNext:1' shape=(None,) dtype=int64>}. Consider rewriting this model with the Functional API.
WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor. Received: inputs={'user_id': <tf.Tensor 'IteratorGetNext:2' shape=(None,) dtype=string>, 'timestamp': <tf.Tensor 'IteratorGetNext:1' shape=(None,) dtype=int64>}. Consider rewriting this model with the Functional API.
WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor. Received: inputs={'user_id': <tf.Tensor 'IteratorGetNext:2' shape=(None,) dtype=string>, 'timestamp': <tf.Tensor 'IteratorGetNext:1' shape=(None,) dtype=int64>}. Consider rewriting this model with the Functional API.
WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor. Received: inputs={'user_id': <tf.Tensor 'IteratorGetNext:2' shape=(None,) dtype=string>, 'timestamp': <tf.Tensor 'IteratorGetNext:1' shape=(None,) dtype=int64>}. Consider rewriting this model with the Functional API.
40/40 [==============================] - 10s 175ms/step - factorized_top_k/top_1_categorical_accuracy: 0.0057 - factorized_top_k/top_5_categorical_accuracy: 0.0148 - factorized_top_k/top_10_categorical_accuracy: 0.0238 - factorized_top_k/top_50_categorical_accuracy: 0.0812 - factorized_top_k/top_100_categorical_accuracy: 0.1487 - loss: 14606.0927 - regularization_loss: 0.0000e+00 - total_loss: 14606.0927
Epoch 2/3
40/40 [==============================] - 9s 176ms/step - factorized_top_k/top_1_categorical_accuracy: 0.0026 - factorized_top_k/top_5_categorical_accuracy: 0.0153 - factorized_top_k/top_10_categorical_accuracy: 0.0304 - factorized_top_k/top_50_categorical_accuracy: 0.1375 - factorized_top_k/top_100_categorical_accuracy: 0.2512 - loss: 13958.5635 - regularization_loss: 0.0000e+00 - total_loss: 13958.5635
Epoch 3/3
40/40 [==============================] - 9s 177ms/step - factorized_top_k/top_1_categorical_accuracy: 0.0026 - factorized_top_k/top_5_categorical_accuracy: 0.0189 - factorized_top_k/top_10_categorical_accuracy: 0.0393 - factorized_top_k/top_50_categorical_accuracy: 0.1713 - factorized_top_k/top_100_categorical_accuracy: 0.3015 - loss: 13696.8511 - regularization_loss: 0.0000e+00 - total_loss: 13696.8511
WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor. Received: inputs={'user_id': <tf.Tensor 'IteratorGetNext:2' shape=(None,) dtype=string>, 'timestamp': <tf.Tensor 'IteratorGetNext:1' shape=(None,) dtype=int64>}. Consider rewriting this model with the Functional API.
WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor. Received: inputs={'user_id': <tf.Tensor 'IteratorGetNext:2' shape=(None,) dtype=string>, 'timestamp': <tf.Tensor 'IteratorGetNext:1' shape=(None,) dtype=int64>}. Consider rewriting this model with the Functional API.
40/40 [==============================] - 9s 172ms/step - factorized_top_k/top_1_categorical_accuracy: 0.0050 - factorized_top_k/top_5_categorical_accuracy: 0.0323 - factorized_top_k/top_10_categorical_accuracy: 0.0606 - factorized_top_k/top_50_categorical_accuracy: 0.2254 - factorized_top_k/top_100_categorical_accuracy: 0.3637 - loss: 13382.7869 - regularization_loss: 0.0000e+00 - total_loss: 13382.7869
5/5 [==============================] - 1s 237ms/step - factorized_top_k/top_1_categorical_accuracy: 0.0012 - factorized_top_k/top_5_categorical_accuracy: 0.0097 - factorized_top_k/top_10_categorical_accuracy: 0.0214 - factorized_top_k/top_50_categorical_accuracy: 0.1259 - factorized_top_k/top_100_categorical_accuracy: 0.2468 - loss: 30699.8529 - regularization_loss: 0.0000e+00 - total_loss: 30699.8529
Top-100 accuracy (train): 0.36.
Top-100 accuracy (test): 0.25.

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

הצעדים הבאים

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