গুগল I / O মে 18-20 মে! স্থান সংরক্ষণ করুন এবং আপনার সময়সূচীটি এখনই নিবন্ধ করুন

চলচ্চিত্রের প্রস্তাব: পুনরুদ্ধার

টেনসরফ্লো.আর.জে দেখুন গিটহাবের উত্স দেখুন নোটবুক ডাউনলোড করুন

রিয়েল-ওয়ার্ল্ড সুপারিশকারী সিস্টেমগুলি প্রায়শই দুটি পর্যায়ে গঠিত হয়:

  1. সমস্ত সম্ভাব্য প্রার্থী থেকে শত শত প্রার্থীর একটি প্রাথমিক সেট নির্বাচন করার জন্য পুনরুদ্ধার পর্যায়ে দায়বদ্ধ। এই মডেলটির মূল উদ্দেশ্য হ'ল ব্যবহারকারীদের আগ্রহী নয় এমন সমস্ত প্রার্থীকে দক্ষতার সাথে আগাছা ছড়িয়ে দেওয়া Because কারণ পুনরুদ্ধার মডেল কয়েক মিলিয়ন প্রার্থীর সাথে কাজ করছে, এটি গণনাগতভাবে দক্ষ হতে হবে।
  2. র‌্যাঙ্কিং পর্যায়ে পুনরুদ্ধার মডেলের আউটপুট নেয় এবং সর্বোত্তম সম্ভাব্য কয়েকটি প্রস্তাবনা নির্বাচন করতে তাদের সূক্ষ্ম সুর দেয়। এর কাজটি হ'ল সম্ভাব্য প্রার্থীদের সংক্ষিপ্ত তালিকায় ব্যবহারকারীদের আগ্রহী আইটেমগুলির সেটটি সঙ্কুচিত করা।

এই টিউটোরিয়ালে, আমরা প্রথম পর্যায়ে ফোকাস করতে যাচ্ছি, পুনরুদ্ধার। আপনি যদি র‌্যাঙ্কিং পর্যায়ে আগ্রহী হন তবে আমাদের র‌্যাঙ্কিং টিউটোরিয়ালটি দেখুন।

পুনরুদ্ধার মডেল প্রায়শই দুটি উপ-মডেল দ্বারা গঠিত:

  1. কোয়েরি বৈশিষ্ট্যগুলি ব্যবহার করে ক্যোয়ারী উপস্থাপনা (সাধারণত একটি স্থির-মাত্রিক এম্বেডিং ভেক্টর) গণনা করা একটি কোয়েরি মডেল।
  2. প্রার্থীর বৈশিষ্ট্যগুলি ব্যবহার করে প্রার্থীর উপস্থাপনা (সমান আকারের ভেক্টর) গণনা করা একটি প্রার্থী মডেল

দুটি মডেলের আউটপুটগুলি একসাথে একটি ক্যোয়ারী-প্রার্থী অ্যাফিনিটি স্কোর দেওয়ার জন্য একত্রে গুণিত হয়, উচ্চতর স্কোর প্রার্থী এবং ক্যোয়ারির মধ্যে আরও ভাল ম্যাচ প্রকাশ করে।

এই টিউটোরিয়ালে, আমরা মুভিলেনস ডেটাসেট ব্যবহার করে এই জাতীয় একটি দুটি-টাওয়ার মডেল তৈরি এবং প্রশিক্ষণ দিতে যাচ্ছি।

আমরা যাচ্ছি:

  1. আমাদের ডেটা পান এবং এটিকে প্রশিক্ষণ এবং পরীক্ষার সেটে ভাগ করুন।
  2. পুনরুদ্ধার মডেলটি প্রয়োগ করুন।
  3. এটি ফিট করুন এবং মূল্যায়ন করুন।
  4. আনুমানিক নিকটতম প্রতিবেশী (এএনএন) সূচক তৈরি করে দক্ষ পরিবেশনার জন্য এটি রফতানি করুন।

ডেটাসেট

মুভিলেনস ডেটাসেট হ'ল মিনেসোটা বিশ্ববিদ্যালয়ের গ্রুপলেন্স গবেষণা গ্রুপের একটি ক্লাসিক ডেটাসেট। এটিতে ব্যবহারকারীদের সেট দ্বারা সিনেমাগুলিতে দেওয়া রেটিংয়ের একটি সেট রয়েছে এবং এটি সুপারিশকারী সিস্টেম গবেষণার একটি ওয়ার্কহর্স।

তথ্য দুটি উপায়ে চিকিত্সা করা যেতে পারে:

  1. ব্যবহারকারীরা কোন সিনেমা দেখেছেন (এবং রেট করেছেন), এবং কোনটি তারা করেন নি তা প্রকাশ করার জন্য এটি ব্যাখ্যা করা যেতে পারে। এটি অন্তর্নিহিত প্রতিক্রিয়ার একটি ফর্ম, যেখানে ব্যবহারকারীদের ঘড়িগুলি আমাদের জানায় যে তারা কোন জিনিসগুলি দেখতে পছন্দ করে এবং কোনটি তারা দেখতে চাইবে না।
  2. এটি ব্যবহারকারীরা যে সিনেমাগুলি দেখেছেন তাদের কতটা পছন্দ হয়েছে তা প্রকাশ করেও দেখা যেতে পারে। এটি সুস্পষ্ট প্রতিক্রিয়ার একটি ফর্ম: কোনও ব্যবহারকারী কোনও সিনেমা দেখেছেন, আমরা প্রদত্ত রেটিংটি দেখে তারা কতটা পছন্দ করেছে তা মোটামুটি বলতে পারি।

এই টিউটোরিয়ালে, আমরা একটি পুনরুদ্ধার সিস্টেমের উপর ফোকাস করছি: এমন একটি মডেল যা ব্যবহারকারীরা সম্ভবত দেখার জন্য ক্যাটালগ থেকে মুভিগুলির সেটগুলির পূর্বাভাস দেয়। প্রায়শই, অন্তর্নিহিত ডেটা এখানে আরও দরকারী, এবং তাই আমরা মুভিলেনসকে একটি অন্তর্নিহিত সিস্টেম হিসাবে বিবেচনা করব। এর অর্থ হ'ল একজন ব্যবহারকারী যে মুভি দেখেছেন তা প্রতিটি ইতিবাচক উদাহরণ এবং তারা যে সিনেমা দেখেনি তারা প্রতিটি অন্তর্ভুক্ত নেতিবাচক উদাহরণ।

আমদানি

আসুন প্রথমে আমাদের আমদানিগুলি বন্ধ করে দেওয়া যাক।

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/100k_ratings লোড করা একটি tf.data.Dataset ডেটা tf.data.Dataset একটি tf.data.Dataset অবজেক্ট এবং movielens/100k_movies লোড করে একটি মুভি ডেটা সম্বলিত একটি tf.data.Dataset অবজেক্ট দেয়।

নোট করুন যেহেতু মুভিলেন্সের ডেটাসেটের পূর্বনির্ধারিত স্প্লিট নেই, তাই সমস্ত ডেটা 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 after এর পরে ইন্টারঅ্যাকশন পূর্বাভাস দেওয়ার জন্য time T time অবধি ডেটা ব্যবহৃত হত $

তবে এই সাধারণ উদাহরণে, আসুন একটি র‌্যান্ডম স্প্লিট ব্যবহার করি, ট্রেনের সেটটিতে রেটিংয়ের 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

উচ্চতর মানগুলি এমন মডেলগুলির সাথে সামঞ্জস্য করবে যা আরও সঠিক হতে পারে তবে এটি ফিট করার ক্ষেত্রেও ধীর এবং বেশি মানানসই প্রবণ হবে।

দ্বিতীয়টি হ'ল মডেলটি নিজেই সংজ্ঞায়িত করা। এখানে, আমরা প্রথমে ব্যবহারকারী আইডিকে পূর্ণসংখ্যায় রূপান্তর করতে কেরাস প্রিপ্রোসেসিং স্তরগুলি ব্যবহার করতে যাচ্ছি এবং তারপরে 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 সাবক্লাসটি সংজ্ঞায়িত করার সময়, আমরা সহজেই স্ট্যান্ডার্ড কেরাস উপাদানগুলি ব্যবহার করে একটি নির্বিচারে জটিল মডেলটিতে প্রসারিত করতে পারি, যতক্ষণ না আমরা শেষে embedding_dimension দেশব্যাপী আউটপুট ফেরত দেব।

প্রার্থী টাওয়ার

আমরা প্রার্থী টাওয়ার দিয়েও একই কাজ করতে পারি।

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)
)

ক্ষতি

পরের উপাদানটি হ'ল আমাদের মডেলটি প্রশিক্ষণের জন্য ব্যবহৃত ক্ষতি। এটি সহজ করার জন্য টিএফআরএসের বেশ কয়েকটি ক্ষতির স্তর এবং কার্য রয়েছে।

এই উদাহরণে, আমরা Retrieval টাস্ক অবজেক্টটি ব্যবহার করব: একটি সুবিধাযুক্ত মোড়ক যা লোকসানের কাজ এবং মেট্রিক গণনার সাথে একত্রে বান্ডিল করে:

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

টাস্কটি নিজেই একটি কেরাস স্তর যা ক্যোয়ারী এবং প্রার্থী এম্বেডিংগুলিকে আর্গুমেন্ট হিসাবে গ্রহণ করে এবং গণিত ক্ষতি ফিরিয়ে দেয়: আমরা মডেলটির প্রশিক্ষণ লুপটি প্রয়োগ করতে এটি ব্যবহার করব।

পুরো মডেল

আমরা এখন এটি সমস্ত একসাথে একটি মডেল হিসাবে রাখতে পারি। টিএফআরএস একটি বেস মডেল ক্লাস ( tfrs.models.Model ) tfrs.models.Model যা বিল্ডিং মডেলগুলিকে প্রবাহিত করে: আমাদের __init__ পদ্ধতিতে উপাদানগুলি সেটআপ করা, এবং কাঁচা বৈশিষ্ট্য গ্রহণ এবং লোকসানের মান ফিরিয়ে দেওয়া, compute_loss পদ্ধতিটি প্রয়োগ করা 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 বেস ক্লাসটি একটি সহজ সুবিধার শ্রেণি: এটি আমাদের একই পদ্ধতি ব্যবহার করে প্রশিক্ষণ এবং পরীক্ষার ক্ষতি উভয়ই গণনা করতে দেয়।

ফণা অধীনে, এটি এখনও একটি সরল কেরাস মডেল। আপনি tf.keras.Model থেকে উত্তরাধিকার tf.keras.Model এবং train_step এবং test_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

ফিটিং এবং মূল্যায়ন

মডেলটি সংজ্ঞায়িত করার পরে, আমরা মডেলটিকে ফিট করতে এবং মূল্যায়নের জন্য স্ট্যান্ডার্ড কেরাস ফিটিং এবং মূল্যায়ন রুটিনগুলি ব্যবহার করতে পারি।

প্রথমে মডেলটি ইনস্ট্যান্ট করি।

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>

মডেলগুলি প্রশিক্ষণ দেওয়ার সাথে সাথে লোকসান কমছে এবং শীর্ষ-কে পুনরুদ্ধার মেট্রিকের একটি সেট আপডেট হয়েছে। এগুলি আমাদের জানায় যে সত্যিকারের ইতিবাচকটি পুরো পরীক্ষার্থী সেট থেকে শীর্ষ-পুনরুদ্ধারকৃত আইটেমগুলিতে রয়েছে। উদাহরণস্বরূপ, 0.2 এর একটি শীর্ষ -5 স্বতন্ত্র নির্ভুলতা মেট্রিক আমাদের বলবে যে গড় হিসাবে সত্যিকারের ধনাত্মকটি 20% সময়ের শীর্ষ 5 পুনরুদ্ধার করা আইটেমগুলিতে থাকে।

মনে রাখবেন যে, এই উদাহরণে আমরা প্রশিক্ষণের সময় মেট্রিকগুলি মূল্যায়নের পাশাপাশি মূল্যায়ন করি। যেহেতু বড় প্রার্থীর সেটগুলির সাথে এটি বেশ ধীর হতে পারে, প্রশিক্ষণে মেট্রিক গণনা বন্ধ করা বুদ্ধিমান হতে পারে এবং কেবল মূল্যায়নে এটি চালানো যেতে পারে।

শেষ পর্যন্ত, আমরা পরীক্ষার সেটটিতে আমাদের মডেলটি মূল্যায়ন করতে পারি:

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. মডেল ব্যবহারকারীদের ইতিমধ্যে দেখা কিছু সিনেমা পুনরায় সুপারিশ করছে। এই পরিচিত-ধনাত্মক ঘড়িগুলি শীর্ষস্থানীয় কে সুপারিশের বাইরে পরীক্ষা চলচ্চিত্রকে ভিড় করতে পারে।

পূর্বের দেখা সিনেমাগুলি পরীক্ষার সুপারিশ থেকে বাদ দিয়ে দ্বিতীয় ঘটনাটিকে মোকাবেলা করা যেতে পারে। এই পদ্ধতিটি সুপারিশকারী সিস্টেমের সাহিত্যে তুলনামূলকভাবে সাধারণ, তবে আমরা এই টিউটোরিয়ালে এটি অনুসরণ করি না। যদি অতীতের ঘড়ির প্রস্তাব না দেওয়া গুরুত্বপূর্ণ, আমাদের অত্যাধিক ব্যবহারকারীর ইতিহাস এবং প্রাসঙ্গিক তথ্য থেকে স্বয়ংক্রিয়ভাবে এই আচরণটি শিখার জন্য উপযুক্ত নির্দিষ্ট মডেলগুলি আশা করা উচিত। অধিকন্তু, একই আইটেমটি একাধিকবার সুপারিশ করা উপযুক্ত (যেমন, একটি চিরসবুজ টিভি সিরিজ বা নিয়মিত কেনা আইটেম)।

ভবিষ্যদ্বাণী করা

এখন আমাদের কাছে একটি মডেল রয়েছে, আমরা ভবিষ্যদ্বাণী করতে সক্ষম হতে চাই। এটি করার জন্য আমরা 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 স্তরটি সম্ভাব্য অনেক প্রার্থীর সাথে একটি মডেল পরিবেশন করতে খুব ধীর হতে চলেছে। নিম্নলিখিত বিভাগগুলি দেখায় যে আনুমানিক পুনরুদ্ধার সূচকটি ব্যবহার করে কীভাবে এটির গতি বাড়ানো যায়।

মডেল পরিবেশন

মডেলটি প্রশিক্ষিত হওয়ার পরে আমাদের এটি মোতায়েন করার একটি উপায় প্রয়োজন।

দ্বি-টাওয়ার পুনরুদ্ধার মডেলটিতে পরিবেশনার দুটি উপাদান রয়েছে:

  • একটি পরিবেশনকারী ক্যোয়ারী মডেল, ক্যোয়ারির বৈশিষ্ট্যগুলি গ্রহণ করে এবং এগুলি এম্বেডিংয়ে কোয়েরিতে রূপান্তরিত করে এবং
  • একটি পরিবেশন প্রার্থী মডেল। এটি প্রায়শই নিকটবর্তী নিকটবর্তী প্রতিবেশী (এএনএন) সূচক রূপ নেয় যা ক্যোয়ারী মডেল দ্বারা উত্পাদিত একটি প্রশ্নের জবাবে প্রার্থীদের দ্রুত আনুমানিক অনুসন্ধানের অনুমতি দেয়।

টিএফআরএসে, উভয় উপাদানকে একটি একক রফতানযোগ্য মডেল হিসাবে প্যাকেজ করা যেতে পারে, যা আমাদের এমন একটি মডেল দেয় যা কাঁচা ব্যবহারকারী আইডি নেয় এবং সেই ব্যবহারকারীর শীর্ষস্থানীয় চলচ্চিত্রের শিরোনাম ফেরত দেয়। এই করতে মডেল রপ্তানি মাধ্যমে সম্পন্ন করা হয় 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 প্যাকেজটি ব্যবহার করতে পারি। এটি টিএফআরএসের একটি alচ্ছিক নির্ভরতা এবং আমরা এই টিউটোরিয়ালটির শুরুতে পৃথকভাবে এটি ইনস্টল করেছি !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 স্তরটি 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. চলচ্চিত্রের মেটাডেটা ব্যবহার: কোল্ড-স্টার্টকে প্রশমিত করতে আরও জটিল মুভি মডেল তৈরি করা।