Google I / O 18 تا 20 مه بازگشت دارد! فضا را ذخیره کنید و برنامه خود را بسازید اکنون ثبت نام کنید

فیلم های پیشنهادی: بازیابی

مشاهده در TensorFlow.org در Google Colab اجرا کنید مشاهده منبع در GitHub دانلود دفترچه یادداشت

سیستم های توصیه گر در دنیای واقعی اغلب از دو مرحله تشکیل شده اند:

  1. مرحله بازیابی وظیفه انتخاب یک مجموعه اولیه متشکل از صدها نامزد از بین همه نامزدهای احتمالی را دارد. هدف اصلی این مدل از بین بردن م candidatesثر همه داوطلبانی است که کاربر به آنها علاقه ندارد. از آنجا که مدل بازیابی ممکن است با میلیون ها کاندیدا سروکار داشته باشد ، بنابراین باید از نظر محاسباتی کارآمد باشد.
  2. مرحله رتبه بندی ، خروجی های مدل بازیابی را می گیرد و آنها را تنظیم می کند تا بهترین تعداد ممکن از توصیه ها را انتخاب کند. وظیفه آن این است که مجموعه مواردی که کاربر ممکن است به آنها علاقه مند شود را در لیست کوتاه نامزدهای احتمالی قرار دهد.

در این آموزش ، ما به مرحله اول ، بازیابی خواهیم پرداخت. اگر به مرحله رتبه بندی علاقه مند هستید ، نگاهی به آموزش رتبه بندی ما بیندازید.

مدل های بازیابی اغلب از دو مدل فرعی تشکیل شده اند:

  1. یک مدل پرس و جو که با استفاده از ویژگی های پرسش ، نمایه پرس و جو را محاسبه می کند (به طور معمول یک بردار تعبیه شده با بعد ثابت)
  2. یک مدل کاندیدا با استفاده از ویژگی های کاندیدا نمایندگی کاندیدا را محاسبه می کند (یک بردار به همان اندازه)

سپس خروجی های دو مدل با هم ضرب می شوند تا نمره میل ترکیبی پرسش و پاسخ داده شوند ، و نمرات بالاتر بیانگر همخوانی بهتر بین داوطلب و پرس و جو است.

در این آموزش ، ما قصد داریم چنین مدل دو برج را با استفاده از مجموعه داده Movielens بسازیم و آموزش دهیم.

ما قصد داریم به:

  1. داده های ما را دریافت کنید و آنها را به یک مجموعه آموزش و آزمون تقسیم کنید.
  2. مدل بازیابی را پیاده سازی کنید.
  3. متناسب و ارزیابی کنید.
  4. با ایجاد یک شاخص نزدیکترین همسایگان (ANN) ، آن را برای سرویس دهی کارآمد صادر کنید.

مجموعه داده

مجموعه داده Movielens یک مجموعه داده کلاسیک از گروه تحقیقاتی GroupLens در دانشگاه مینه سوتا است. این مجموعه شامل مجموعه ای از رتبه بندی ها است که توسط مجموعه ای از کاربران به فیلم ها داده می شود و یک اسب بخار در زمینه تحقیقات سیستم است.

داده ها به دو روش قابل درمان هستند:

  1. می توان اینگونه تعبیر کرد که کاربران کدام فیلم ها را تماشا کرده اند (و رتبه بندی کرده اند) و کدام یک را تماشا نکردند. این نوعی بازخورد ضمنی است ، جایی که ساعتهای کاربران به ما می گویند کدام چیزها را ترجیح می دهند ببینند و ترجیح می دهند کدام چیزها را نبینند.
  2. همچنین می تواند بیانگر میزان علاقه کاربران به فیلم هایی که تماشا می کنند ، باشد. این نوعی بازخورد صریح است: با توجه به اینکه کاربر فیلمی را تماشا کرده است ، می توانیم با دیدن رتبه ای که داده اند تقریباً بگوییم که چقدر دوست دارند.

در این آموزش ، ما بر روی سیستم بازیابی تمرکز کرده ایم: مدلی که مجموعه ای از فیلم ها را از کاتالوگ پیش بینی می کند که کاربر احتمالاً تماشا می کند. غالباً ، داده های ضمنی در اینجا بیشتر کاربرد دارد و بنابراین ما قصد داریم با Movielens به عنوان یک سیستم ضمنی رفتار کنیم. این بدان معنی است که هر فیلمی که کاربر تماشا کرده مثالی مثبت است و هر فیلمی که ندیده است یک مثال منفی ضمنی است.

واردات

بیایید ابتدا واردات خود را از مسیر خارج کنیم.

pip install -q tensorflow-recommenders
pip install -q --upgrade tensorflow-datasets
pip install -q scann
import os
import pprint
import tempfile

from typing import Dict, Text

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

آماده سازی مجموعه داده

بیایید ابتدا نگاهی به داده ها بیندازیم.

ما از مجموعه داده MovieLens از مجموعه داده های Tensorflow استفاده می کنیم . بارگذاری movielens/100k_ratings یک محصول movielens/100k_ratings بدست می tf.data.Dataset شی object tf.data.Dataset حاوی داده های رتبه بندی و بارگیری movielens/100k_movies یک شی tf.data.Dataset حاوی داده های فیلم است.

توجه داشته باشید که از آنجا که مجموعه داده های MovieLens فاقد انشعابات از پیش تعیین شده است ، بنابراین همه داده ها تحت تقسیم train .

# Ratings data.
ratings = tfds.load("movielens/100k-ratings", split="train")
# Features of all the available movies.
movies = tfds.load("movielens/100k-movies", split="train")

مجموعه داده های رتبه بندی فرهنگ نامه شناسه فیلم ، شناسه کاربر ، رتبه بندی اختصاص داده شده ، مهر زمان ، اطلاعات فیلم و اطلاعات کاربر را برمی گرداند:

for x in ratings.take(1).as_numpy_iterator():
  pprint.pprint(x)
{'bucketized_user_age': 45.0,
 'movie_genres': array([7]),
 'movie_id': b'357',
 'movie_title': b"One Flew Over the Cuckoo's Nest (1975)",
 'raw_user_age': 46.0,
 'timestamp': 879024327,
 'user_gender': True,
 'user_id': b'138',
 'user_occupation_label': 4,
 'user_occupation_text': b'doctor',
 'user_rating': 4.0,
 'user_zip_code': b'53211'}

مجموعه داده فیلم ها شامل شناسه فیلم ، عنوان فیلم و اطلاعات مربوط به ژانرهای آن است. توجه داشته باشید که ژانرها با برچسب های عدد صحیح کدگذاری می شوند.

for x in movies.take(1).as_numpy_iterator():
  pprint.pprint(x)
{'movie_genres': array([4]),
 'movie_id': b'1681',
 'movie_title': b'You So Crazy (1994)'}

در این مثال ، ما می خواهیم روی داده های رتبه بندی تمرکز کنیم. سایر آموزش ها نحوه استفاده از داده های اطلاعات فیلم و همچنین بهبود کیفیت مدل را بررسی می کنند.

ما فقط user_id و movie_title در مجموعه داده ها نگهداری می کنیم.

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

برای تناسب و ارزیابی مدل ، باید آن را به یک مجموعه آموزش و ارزیابی تقسیم کنیم. در سیستم توصیه کننده صنعتی ، این کار به احتمال زیاد توسط زمان انجام می شود: داده های به موقع T $ برای پیش بینی تعاملات بعد از $ T $ استفاده می شود.

در این مثال ساده ، بیایید با استفاده از تقسیم تصادفی ، 80٪ از رتبه ها را در مجموعه قطارها و 20٪ را در مجموعه آزمون قرار دهیم.

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)

بیایید همچنین شناسه های کاربری منحصر به فرد و عناوین فیلم موجود در داده ها را کشف کنیم.

این مهم است زیرا ما باید بتوانیم مقادیر خام ویژگی های طبقه بندی شده خود را برای جاسازی بردارها در مدل های خود ترسیم کنیم. برای انجام این کار ، ما به یک واژگان نیاز داریم که یک مقدار ویژگی خام را به یک عدد صحیح در یک محدوده مجاور ترسیم کند: این به ما امکان می دهد تا تعبیه های مربوطه را در جداول تعبیه شده خود جستجو کنیم.

movie_titles = movies.batch(1_000)
user_ids = ratings.batch(1_000_000).map(lambda x: x["user_id"])

unique_movie_titles = np.unique(np.concatenate(list(movie_titles)))
unique_user_ids = np.unique(np.concatenate(list(user_ids)))

unique_movie_titles[:10]
array([b"'Til There Was You (1997)", b'1-900 (1994)',
       b'101 Dalmatians (1996)', b'12 Angry Men (1957)', b'187 (1997)',
       b'2 Days in the Valley (1996)',
       b'20,000 Leagues Under the Sea (1954)',
       b'2001: A Space Odyssey (1968)',
       b'3 Ninjas: High Noon At Mega Mountain (1998)',
       b'39 Steps, The (1935)'], dtype=object)

پیاده سازی یک مدل

انتخاب معماری مدل ما بخشی اساسی در مدل سازی است.

از آنجا که ما در حال ساخت مدل بازیابی دو برج هستیم ، می توانیم هر برج را جداگانه بسازیم و سپس آنها را در مدل نهایی ترکیب کنیم.

برج پرس و جو

بیایید با برج پرس و جو شروع کنیم.

اولین قدم تصمیم گیری در مورد ابعاد پرس و جو و نمایش کاندیداها است:

embedding_dimension = 32

مقادیر بالاتر با مدل هایی مطابقت دارد که ممکن است دقت بالاتری داشته باشند ، اما در عین حال کندتر از آن متناسب و مستعد بیشتر از حد مناسب هستند.

مورد دوم تعریف خود مدل است. در اینجا ، ما می خواهیم از لایه های پیش پردازش Keras استفاده کنیم تا ابتدا شناسه های کاربر را به اعداد صحیح تبدیل کنیم و سپس آن ها را از طریق یک لایه Embedding به تعبیه های کاربر تبدیل کنیم. توجه داشته باشید که ما از لیست شناسه های کاربری منحصر به فرد خود که قبلاً محاسبه کردیم به عنوان واژگان استفاده می کنیم:

user_model = tf.keras.Sequential([
  tf.keras.layers.experimental.preprocessing.StringLookup(
      vocabulary=unique_user_ids, mask_token=None),
  # We add an additional embedding to account for unknown tokens.
  tf.keras.layers.Embedding(len(unique_user_ids) + 1, embedding_dimension)
])

یک مدل ساده مانند این دقیقاً مربوط به یک رویه کلاسیک سازی ماتریس کلاسیک است . در حالی که تعریف زیر کلاس tf.keras.Model مدل برای این مدل ساده ممکن است بیش از حد باشد ، ما می توانیم با استفاده از م standardلفه های استاندارد Keras ، آن را به راحتی به مدل پیچیده خودسرانه گسترش دهیم ، البته به tf.keras.Model که یک خروجی embedding_dimension -wide را در انتها برگردانیم.

برج نامزد

ما می توانیم همین کار را با برج نامزد انجام دهیم.

movie_model = tf.keras.Sequential([
  tf.keras.layers.experimental.preprocessing.StringLookup(
      vocabulary=unique_movie_titles, mask_token=None),
  tf.keras.layers.Embedding(len(unique_movie_titles) + 1, embedding_dimension)
])

معیارهای

در داده های آموزشی ما جفت های مثبت (کاربر ، فیلم) داریم. برای اینکه بفهمیم مدل ما چقدر خوب است ، باید امتیاز قرابت را که مدل برای این جفت محاسبه می کند با نمره سایر نامزدهای احتمالی مقایسه کنیم: اگر نمره جفت مثبت بالاتر از همه نامزدهای دیگر باشد ، مدل ما بسیار دقیق است

برای این کار می توان از معیار tfrs.metrics.FactorizedTopK استفاده کرد. این معیار دارای یک استدلال مورد نیاز است: مجموعه داده نامزدها که به عنوان منفی ضمنی برای ارزیابی استفاده می شوند.

در مورد ما ، این مجموعه داده movies ها است که از طریق مدل فیلم ما به تعبیه شده تبدیل می شود:

metrics = tfrs.metrics.FactorizedTopK(
  candidates=movies.batch(128).map(movie_model)
)

ضرر - زیان

م nextلفه بعدی ضرر است که برای آموزش مدل ما استفاده می شود. TFRS چندین لایه ضرر و وظیفه دارد تا این کار را آسان کند.

در این مثال ، ما از شی task Retrieval task استفاده خواهیم کرد: یک بسته بندی راحت که تابع از دست دادن و محاسبه متریک را با هم ترکیب می کند:

task = tfrs.tasks.Retrieval(
  metrics=metrics
)

این وظیفه خود یک لایه Keras است که از جستجوگرها و تعبیه شده های نامزد به عنوان آرگومان استفاده می کند و تلفات محاسبه شده را برمی گرداند: ما برای اجرای حلقه آموزش مدل از آن استفاده خواهیم کرد.

مدل کامل

اکنون می توانیم همه را در یک مدل قرار دهیم. TFRS یک کلاس مدل پایه ( tfrs.models.Model ) را tfrs.models.Model که مدل های ساختمانی را ساده می کند: تمام کاری که ما باید انجام دهیم این است که اجزای سازنده را در روش __init__ کنیم و روش compute_loss استفاده از ویژگی های خام و بازگرداندن مقدار ضرر ، پیاده سازی کنیم. .

سپس مدل پایه از ایجاد حلقه آموزش مناسب متناسب با مدل ما مراقبت خواهد کرد.

class MovielensModel(tfrs.Model):

  def __init__(self, user_model, movie_model):
    super().__init__()
    self.movie_model: tf.keras.Model = movie_model
    self.user_model: tf.keras.Model = user_model
    self.task: tf.keras.layers.Layer = task

  def compute_loss(self, features: Dict[Text, tf.Tensor], training=False) -> tf.Tensor:
    # We pick out the user features and pass them into the user model.
    user_embeddings = self.user_model(features["user_id"])
    # And pick out the movie features and pass them into the movie model,
    # getting embeddings back.
    positive_movie_embeddings = self.movie_model(features["movie_title"])

    # The task computes the loss and the metrics.
    return self.task(user_embeddings, positive_movie_embeddings)

کلاس پایه tfrs.Model یک کلاس ساده است: به ما امکان می دهد با استفاده از همان روش ، تلفات آموزشی و آزمون را محاسبه کنیم.

زیر کاپوت ، هنوز یک مدل ساده Keras است. شما می توانید از قابلیت های مشابه توسط وارث از رسیدن به tf.keras.Model و فارغ از train_step و test_step توابع (نگاه کنید به راهنمای برای جزئیات بیشتر):

class NoBaseClassMovielensModel(tf.keras.Model):

  def __init__(self, user_model, movie_model):
    super().__init__()
    self.movie_model: tf.keras.Model = movie_model
    self.user_model: tf.keras.Model = user_model
    self.task: tf.keras.layers.Layer = task

  def train_step(self, features: Dict[Text, tf.Tensor]) -> tf.Tensor:

    # Set up a gradient tape to record gradients.
    with tf.GradientTape() as tape:

      # Loss computation.
      user_embeddings = self.user_model(features["user_id"])
      positive_movie_embeddings = self.movie_model(features["movie_title"])
      loss = self.task(user_embeddings, positive_movie_embeddings)

      # Handle regularization losses as well.
      regularization_loss = sum(self.losses)

      total_loss = loss + regularization_loss

    gradients = tape.gradient(total_loss, self.trainable_variables)
    self.optimizer.apply_gradients(zip(gradients, self.trainable_variables))

    metrics = {metric.name: metric.result() for metric in self.metrics}
    metrics["loss"] = loss
    metrics["regularization_loss"] = regularization_loss
    metrics["total_loss"] = total_loss

    return metrics

  def test_step(self, features: Dict[Text, tf.Tensor]) -> tf.Tensor:

    # Loss computation.
    user_embeddings = self.user_model(features["user_id"])
    positive_movie_embeddings = self.movie_model(features["movie_title"])
    loss = self.task(user_embeddings, positive_movie_embeddings)

    # Handle regularization losses as well.
    regularization_loss = sum(self.losses)

    total_loss = loss + regularization_loss

    metrics = {metric.name: metric.result() for metric in self.metrics}
    metrics["loss"] = loss
    metrics["regularization_loss"] = regularization_loss
    metrics["total_loss"] = total_loss

    return metrics

با این حال ، در این آموزش ها ، ما به استفاده از کلاس پایه tfrs.Model تا تمرکز خود را بر روی مدل سازی حفظ کنیم و برخی از tfrs.Model خلاصه کنیم.

نصب و ارزیابی

پس از تعریف مدل ، می توانیم از روال های استاندارد و مناسب ارزیابی Keras برای تناسب و ارزیابی مدل استفاده کنیم.

بیایید ابتدا مدل را نمونه برداری کنیم.

model = MovielensModel(user_model, movie_model)
model.compile(optimizer=tf.keras.optimizers.Adagrad(learning_rate=0.1))

سپس داده های آموزش و ارزیابی را مرتب کنید ، دسته ای کنید و حافظه پنهان کنید.

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

سپس مدل را آموزش دهید:

model.fit(cached_train, epochs=3)
Epoch 1/3
10/10 [==============================] - 5s 298ms/step - factorized_top_k/top_1_categorical_accuracy: 1.6250e-04 - factorized_top_k/top_5_categorical_accuracy: 0.0029 - factorized_top_k/top_10_categorical_accuracy: 0.0082 - factorized_top_k/top_50_categorical_accuracy: 0.0680 - factorized_top_k/top_100_categorical_accuracy: 0.1419 - loss: 69885.1072 - regularization_loss: 0.0000e+00 - total_loss: 69885.1072
Epoch 2/3
10/10 [==============================] - 3s 289ms/step - factorized_top_k/top_1_categorical_accuracy: 0.0020 - factorized_top_k/top_5_categorical_accuracy: 0.0150 - factorized_top_k/top_10_categorical_accuracy: 0.0315 - factorized_top_k/top_50_categorical_accuracy: 0.1565 - factorized_top_k/top_100_categorical_accuracy: 0.2807 - loss: 67523.3700 - regularization_loss: 0.0000e+00 - total_loss: 67523.3700
Epoch 3/3
10/10 [==============================] - 3s 278ms/step - factorized_top_k/top_1_categorical_accuracy: 0.0029 - factorized_top_k/top_5_categorical_accuracy: 0.0211 - factorized_top_k/top_10_categorical_accuracy: 0.0437 - factorized_top_k/top_50_categorical_accuracy: 0.1842 - factorized_top_k/top_100_categorical_accuracy: 0.3126 - loss: 66302.9609 - regularization_loss: 0.0000e+00 - total_loss: 66302.9609
<tensorflow.python.keras.callbacks.History at 0x7f16a7780898>

با آموزش مدل ، ضرر در حال سقوط است و مجموعه ای از معیارهای بازیابی top-k به روز می شوند. اینها به ما می گویند که آیا مثبت واقعی در موارد بازیابی شده از کل مجموعه نامزدها است. به عنوان مثال ، یک معیار دقت طبقه بندی بالا 5 در 0.2 به ما می گوید که به طور متوسط ​​، مثبت واقعی در 5 مورد برتر بازیابی شده 20٪ از زمان است.

توجه داشته باشید که ، در این مثال ، ما معیارها را در حین آموزش و همچنین ارزیابی ارزیابی می کنیم. از آنجا که این می تواند با مجموعه های نامزد بزرگ بسیار کند باشد ، ممکن است محتاطانه باشد که محاسبه معیار را در آموزش خاموش کرده و فقط در ارزیابی آن را اجرا کنید.

سرانجام ، ما می توانیم مدل خود را در مجموعه آزمون ارزیابی کنیم:

model.evaluate(cached_test, return_dict=True)
5/5 [==============================] - 1s 164ms/step - factorized_top_k/top_1_categorical_accuracy: 9.0000e-04 - factorized_top_k/top_5_categorical_accuracy: 0.0099 - factorized_top_k/top_10_categorical_accuracy: 0.0221 - factorized_top_k/top_50_categorical_accuracy: 0.1248 - factorized_top_k/top_100_categorical_accuracy: 0.2327 - loss: 31079.0628 - regularization_loss: 0.0000e+00 - total_loss: 31079.0628
{'factorized_top_k/top_1_categorical_accuracy': 0.0008999999845400453,
 'factorized_top_k/top_5_categorical_accuracy': 0.009850000031292439,
 'factorized_top_k/top_10_categorical_accuracy': 0.022050000727176666,
 'factorized_top_k/top_50_categorical_accuracy': 0.12475000321865082,
 'factorized_top_k/top_100_categorical_accuracy': 0.23274999856948853,
 'loss': 28244.76953125,
 'regularization_loss': 0,
 'total_loss': 28244.76953125}

عملکرد مجموعه آزمون بسیار بدتر از عملکرد آموزش است. این به دو عامل مربوط می شود:

  1. مدل ما به دلیل اینکه می تواند آن را به خاطر بسپارد ، احتمالاً عملکرد بهتری در داده هایی که دیده است ، دارد. این پدیده بیش از حد مناسب به ویژه هنگامی که مدل ها پارامترهای زیادی دارند بسیار شدید است. این امر می تواند با منظم سازی مدل و استفاده از ویژگی های کاربر و فیلم که به تعمیم بهتر مدل در دیده نشده بودن مدل کمک می کند.
  2. این مدل برخی از فیلم های تماشا شده کاربران را دوباره توصیه می کند. این ساعت های شناخته شده مثبت می توانند فیلم های آزمایشی را از توصیه های برتر K جمع کنند.

با کنار گذاشتن فیلم های قبلاً دیده شده از توصیه های آزمون می توان با پدیده دوم مقابله کرد. این روش در ادبیات سیستم های توصیه گر نسبتاً رایج است ، اما ما در این آموزش ها از آن پیروی نمی کنیم. اگر توصیه نکردن ساعتهای گذشته مهم است ، باید انتظار داشته باشیم که مدلهای مشخص و مشخصی از طریق سابقه کاربر گذشته و اطلاعات متنی ، این رفتار را به طور خودکار بیاموزند. بعلاوه ، معمولاً توصیه می شود که یک مورد را چندین بار توصیه کنید (مثلاً یک مجموعه تلویزیونی همیشه سبز یا یک کالای خریداری شده به طور منظم).

پیشگویی

اکنون که مدلی داریم ، دوست داریم بتوانیم پیش بینی کنیم. برای این کار می توانیم از لایه tfrs.layers.factorized_top_k.BruteForce استفاده کنیم.

# Create a model that takes in raw query features, and
index = tfrs.layers.factorized_top_k.BruteForce(model.user_model)
# recommends movies out of the entire movies dataset.
index.index(movies.batch(100).map(model.movie_model), movies)

# Get recommendations.
_, titles = index(tf.constant(["42"]))
print(f"Recommendations for user 42: {titles[0, :3]}")
Recommendations for user 42: [b'Bridges of Madison County, The (1995)'
 b'Father of the Bride Part II (1995)' b'Rudy (1993)']

البته ، لایه BruteForce برای ارائه مدلی با نامزدهای احتمالی بسیار کند پیش می رود. بخشهای زیر نشان می دهد که چگونه با استفاده از یک شاخص تقریبی بازیابی ، این کار را تسریع کنید.

خدمت مدل

پس از آموزش مدل ، ما به روشی برای استقرار آن نیاز داریم.

در یک مدل بازیابی با دو برج ، سرویس دهی دارای دو جز است:

  • یک مدل پرس و جو در خدمت ، ویژگی های پرس و جو را دریافت می کند و آنها را به یک تعویض پرس و جو تبدیل می کند ، و
  • یک مدل نامزد خدمت. این اغلب به صورت فهرست تقریبی نزدیکترین همسایگان (ANN) است که امکان جستجوی سریع تقریبی نامزدها را در پاسخ به یک پرسش تولید شده توسط مدل پرسش فراهم می کند.

در TFRS ، هر دو م componentsلفه می توانند در یک مدل قابل صادرات بسته بندی شوند و مدلی را به ما بدهند که شناسه خام کاربر را گرفته و عناوین فیلم های برتر را برای آن کاربر بازگرداند. این است از طریق صادرات مدل به انجام SavedModel فرمت، که باعث می شود این امکان را به خدمت با استفاده از TensorFlow خدمت .

برای استقرار مدلی مانند این ، ما به سادگی لایه BruteForce که در بالا ایجاد کردیم صادر می کنیم:

# Export the query model.
with tempfile.TemporaryDirectory() as tmp:
  path = os.path.join(tmp, "model")

  # Save the index.
  index.save(path)

  # Load it back; can also be done in TensorFlow Serving.
  loaded = tf.keras.models.load_model(path)

  # Pass a user id in, get top predicted movie titles back.
  scores, titles = loaded(["42"])

  print(f"Recommendations: {titles[0][:3]}")
WARNING:absl:Found untraced functions such as query_with_exclusions while saving (showing 1 of 1). These functions will not be directly callable after loading.
WARNING:absl:Found untraced functions such as query_with_exclusions while saving (showing 1 of 1). These functions will not be directly callable after loading.
INFO:tensorflow:Assets written to: /tmp/tmpedp1pofu/model/assets
INFO:tensorflow:Assets written to: /tmp/tmpedp1pofu/model/assets
WARNING:tensorflow:No training configuration found in save file, so the model was *not* compiled. Compile it manually.
WARNING:tensorflow:No training configuration found in save file, so the model was *not* compiled. Compile it manually.
Recommendations: [b'Bridges of Madison County, The (1995)'
 b'Father of the Bride Part II (1995)' b'Rudy (1993)']

همچنین برای تسریع در پیش بینی ها می توانیم یک شاخص بازیابی تقریبی صادر کنیم. این امکان را می دهد که به طور موثر توصیه های ده ها میلیون کاندیدا را برطرف کنید.

برای این کار می توانیم از پکیج scann استفاده کنیم. این وابستگی اختیاری TFRS است و ما در ابتدای این آموزش با فراخوانی !pip install -q scann آن را جداگانه نصب کردیم.

پس از نصب می توانیم از لایه ScaNN استفاده کنیم:

scann_index = tfrs.layers.factorized_top_k.ScaNN(model.user_model)
scann_index.index(movies.batch(100).map(model.movie_model), movies)
<tensorflow_recommenders.layers.factorized_top_k.ScaNN at 0x7f16c1480400>

این لایه جستجوی تقریبی را انجام می دهد: این باعث می شود بازیابی کمی دقیق تر باشد ، اما ترتیب سفارشات در مجموعه های بزرگ نامزد سریعتر است.

# Get recommendations.
_, titles = scann_index(tf.constant(["42"]))
print(f"Recommendations for user 42: {titles[0, :3]}")
Recommendations for user 42: [b'Sleepless in Seattle (1993)' b'Father of the Bride Part II (1995)'
 b'Hunchback of Notre Dame, The (1996)']

صادرات آن برای خدمت به آسانی صادرات لایه BruteForce است:

# Export the query model.
with tempfile.TemporaryDirectory() as tmp:
  path = os.path.join(tmp, "model")

  # Save the index.
  scann_index.save(
      path,
      options=tf.saved_model.SaveOptions(namespace_whitelist=["Scann"])
  )

  # Load it back; can also be done in TensorFlow Serving.
  loaded = tf.keras.models.load_model(path)

  # Pass a user id in, get top predicted movie titles back.
  scores, titles = loaded(["42"])

  print(f"Recommendations: {titles[0][:3]}")
WARNING:absl:Found untraced functions such as query_with_exclusions while saving (showing 1 of 1). These functions will not be directly callable after loading.
WARNING:absl:Found untraced functions such as query_with_exclusions while saving (showing 1 of 1). These functions will not be directly callable after loading.
INFO:tensorflow:Assets written to: /tmp/tmprglhaqg1/model/assets
INFO:tensorflow:Assets written to: /tmp/tmprglhaqg1/model/assets
WARNING:tensorflow:No training configuration found in save file, so the model was *not* compiled. Compile it manually.
WARNING:tensorflow:No training configuration found in save file, so the model was *not* compiled. Compile it manually.
Recommendations: [b'Sleepless in Seattle (1993)' b'Father of the Bride Part II (1995)'
 b'Hunchback of Notre Dame, The (1996)']

برای کسب اطلاعات بیشتر در مورد استفاده و تنظیم مدل های بازیابی سریع تقریبی ، به آموزش ارائه خدمات کارآمد ما نگاهی بیندازید.

مراحل بعدی

با این کار آموزش بازیابی به پایان می رسد.

برای گسترش آنچه در اینجا ارائه شده است ، نگاهی به موارد زیر بیندازید:

  1. یادگیری مدل های چند کاره: بهینه سازی مشترک برای رتبه بندی و کلیک.
  2. استفاده از فراداده فیلم: ساختن یک مدل فیلم پیچیده تر برای کاهش شروع کار.