এই পৃষ্ঠাটি Cloud Translation API অনুবাদ করেছে।

তালিকাভুক্ত র .্যাঙ্কিং

TensorFlow.org-এ দেখুন

Google Colab-এ চালান

GitHub-এ উৎস দেখুন

নোটবুক ডাউনলোড করুন

ইন মৌলিক র্যাংকিং টিউটোরিয়াল , আমরা একটি মডেল যা ব্যবহারকারী / সিনেমা বিদ্যমান জোড়া জন্য রেটিং পূর্বাভাস দিতে পারি প্রশিক্ষণ দিয়েছিলেন। মডেলটিকে পূর্বাভাসিত রেটিংগুলির গড় বর্গক্ষেত্র ত্রুটি কমানোর জন্য প্রশিক্ষিত করা হয়েছিল৷

যাইহোক, পৃথক মুভিতে মডেলের ভবিষ্যদ্বাণী অপ্টিমাইজ করা অগত্যা মডেলদের প্রশিক্ষণের জন্য সেরা পদ্ধতি নয়। মহান নির্ভুলতার সাথে স্কোর ভবিষ্যদ্বাণী করার জন্য আমাদের র‌্যাঙ্কিং মডেলের প্রয়োজন নেই। পরিবর্তে, ব্যবহারকারীর পছন্দের অর্ডারের সাথে মেলে এমন আইটেমগুলির একটি অর্ডারকৃত তালিকা তৈরি করতে মডেলের ক্ষমতা সম্পর্কে আমরা আরও যত্নশীল।

পৃথক ক্যোয়ারী/আইটেম জোড়ায় মডেলের ভবিষ্যদ্বাণীগুলি অপ্টিমাইজ করার পরিবর্তে, আমরা সামগ্রিকভাবে একটি তালিকার মডেলের র‌্যাঙ্কিং অপ্টিমাইজ করতে পারি। এই পদ্ধতি র্যাঙ্কিং listwise বলা হয়।

এই টিউটোরিয়ালে, আমরা তালিকা অনুসারে র‌্যাঙ্কিং মডেল তৈরি করতে টেনসরফ্লো সুপারিশকারী ব্যবহার করব। এটা করার জন্য, আমরা র্যাঙ্কিং লোকসান এবং মেট্রিকস দ্বারা উপলব্ধ ব্যবহার করতে হবে TensorFlow রাঙ্কিং , একটি TensorFlow প্যাকেজ যে উপর দৃষ্টি নিবদ্ধ করে পদে শেখার ।

প্রাথমিক

তাহলে TensorFlow রাঙ্কিং আপনার রানটাইম পরিবেশে উপলব্ধ নেই, আপনি এটি ব্যবহার ইনস্টল করতে পারেন pip :

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

তারপর আমরা সমস্ত প্রয়োজনীয় প্যাকেজ আমদানি করতে পারি:

import pprint

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

/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/pkg_resources/__init__.py:119: PkgResourcesDeprecationWarning: 0.18ubuntu0.18.04.1 is an invalid version and will not be supported in a future release
  PkgResourcesDeprecationWarning,

import tensorflow_ranking as tfr
import tensorflow_recommenders as tfrs

/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow_addons/utils/ensure_tf_install.py:67: UserWarning: Tensorflow Addons supports using Python ops for all Tensorflow versions above or equal to 2.4.0 and strictly below 2.7.0 (nightly versions are not supported). 
 The versions of TensorFlow you are currently using is 2.7.0 and is not supported. 
Some things might work, some things might not.
If you were to encounter a bug, do not file an issue.
If you want to make sure you're using a tested and supported configuration, either change the TensorFlow version or the TensorFlow Addons's version. 
You can find the compatibility matrix in TensorFlow Addon's readme:
https://github.com/tensorflow/addons
  UserWarning,

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

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"],
    "user_rating": x["user_rating"],
})
movies = movies.map(lambda x: x["movie_title"])

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

ডেটা প্রিপ্রসেসিং

যাইহোক, আমরা সরাসরি তালিকা অপ্টিমাইজেশানের জন্য MovieLens ডেটাসেট ব্যবহার করতে পারি না। তালিকা অনুসারে অপ্টিমাইজেশান সঞ্চালনের জন্য, আমাদের প্রতিটি ব্যবহারকারীর রেট করা সিনেমাগুলির একটি তালিকায় অ্যাক্সেস থাকতে হবে, তবে MovieLens 100K ডেটাসেটের প্রতিটি উদাহরণে শুধুমাত্র একটি সিনেমার রেটিং রয়েছে।

এটির কাছাকাছি পেতে আমরা ডেটাসেটকে রূপান্তরিত করি যাতে প্রতিটি উদাহরণে একটি ব্যবহারকারী আইডি এবং সেই ব্যবহারকারীর দ্বারা রেট করা চলচ্চিত্রগুলির একটি তালিকা থাকে। তালিকার কিছু সিনেমা অন্যদের থেকে উচ্চতর স্থান পাবে; আমাদের মডেলের লক্ষ্য হবে ভবিষ্যদ্বাণী করা যা এই ক্রম অনুসারে মেলে।

এই কাজের জন্য, আমরা ব্যবহার tfrs.examples.movielens.movielens_to_listwise সাহায্যকারী ফাংশন। এটি MovieLens 100K ডেটাসেট নেয় এবং উপরে আলোচিত তালিকার উদাহরণ সহ একটি ডেটাসেট তৈরি করে। বাস্তবায়ন বিবরণ খুঁজে পাওয়া যেতে পারে সোর্স কোড ।

tf.random.set_seed(42)

# Split between train and tests sets, as before.
shuffled = ratings.shuffle(100_000, seed=42, reshuffle_each_iteration=False)

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

# We sample 50 lists for each user for the training data. For each list we
# sample 5 movies from the movies the user rated.
train = tfrs.examples.movielens.sample_listwise(
    train,
    num_list_per_user=50,
    num_examples_per_list=5,
    seed=42
)
test = tfrs.examples.movielens.sample_listwise(
    test,
    num_list_per_user=1,
    num_examples_per_list=5,
    seed=42
)

আমরা প্রশিক্ষণ তথ্য থেকে একটি উদাহরণ পরিদর্শন করতে পারেন. উদাহরণটিতে একটি ব্যবহারকারী আইডি, 10টি মুভি আইডির একটি তালিকা এবং ব্যবহারকারীর দ্বারা তাদের রেটিং অন্তর্ভুক্ত রয়েছে৷

for example in train.take(1):
  pprint.pprint(example)

{'movie_title': <tf.Tensor: shape=(5,), dtype=string, numpy=
array([b'Postman, The (1997)', b'Liar Liar (1997)', b'Contact (1997)',
       b'Welcome To Sarajevo (1997)',
       b'I Know What You Did Last Summer (1997)'], dtype=object)>,
 'user_id': <tf.Tensor: shape=(), dtype=string, numpy=b'681'>,
 'user_rating': <tf.Tensor: shape=(5,), dtype=float32, numpy=array([4., 5., 1., 4., 1.], dtype=float32)>}

মডেল সংজ্ঞা

আমরা তিনটি ভিন্ন ক্ষতি সহ একই মডেলকে প্রশিক্ষণ দেব:

মানে বর্গক্ষেত্র ত্রুটি,
pairwise কবজা ক্ষতি, এবং
একটি তালিকা অনুসারে ListMLE ক্ষতি।

এই তিনটি ক্ষতি পয়েন্টওয়াইজ, পেয়ারওয়াইজ এবং লিস্টওয়াইজ অপ্টিমাইজেশনের সাথে মিলে যায়।

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

class RankingModel(tfrs.Model):

  def __init__(self, loss):
    super().__init__()
    embedding_dimension = 32

    # Compute embeddings for users.
    self.user_embeddings = tf.keras.Sequential([
      tf.keras.layers.StringLookup(
        vocabulary=unique_user_ids),
      tf.keras.layers.Embedding(len(unique_user_ids) + 2, embedding_dimension)
    ])

    # Compute embeddings for movies.
    self.movie_embeddings = tf.keras.Sequential([
      tf.keras.layers.StringLookup(
        vocabulary=unique_movie_titles),
      tf.keras.layers.Embedding(len(unique_movie_titles) + 2, embedding_dimension)
    ])

    # Compute predictions.
    self.score_model = tf.keras.Sequential([
      # Learn multiple dense layers.
      tf.keras.layers.Dense(256, activation="relu"),
      tf.keras.layers.Dense(64, activation="relu"),
      # Make rating predictions in the final layer.
      tf.keras.layers.Dense(1)
    ])

    self.task = tfrs.tasks.Ranking(
      loss=loss,
      metrics=[
        tfr.keras.metrics.NDCGMetric(name="ndcg_metric"),
        tf.keras.metrics.RootMeanSquaredError()
      ]
    )

  def call(self, features):
    # We first convert the id features into embeddings.
    # User embeddings are a [batch_size, embedding_dim] tensor.
    user_embeddings = self.user_embeddings(features["user_id"])

    # Movie embeddings are a [batch_size, num_movies_in_list, embedding_dim]
    # tensor.
    movie_embeddings = self.movie_embeddings(features["movie_title"])

    # We want to concatenate user embeddings with movie emebeddings to pass
    # them into the ranking model. To do so, we need to reshape the user
    # embeddings to match the shape of movie embeddings.
    list_length = features["movie_title"].shape[1]
    user_embedding_repeated = tf.repeat(
        tf.expand_dims(user_embeddings, 1), [list_length], axis=1)

    # Once reshaped, we concatenate and pass into the dense layers to generate
    # predictions.
    concatenated_embeddings = tf.concat(
        [user_embedding_repeated, movie_embeddings], 2)

    return self.score_model(concatenated_embeddings)

  def compute_loss(self, features, training=False):
    labels = features.pop("user_rating")

    scores = self(features)

    return self.task(
        labels=labels,
        predictions=tf.squeeze(scores, axis=-1),
    )

মডেলদের প্রশিক্ষণ

আমরা এখন তিনটি মডেলের প্রতিটিকে প্রশিক্ষণ দিতে পারি।

epochs = 30

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

বর্গক্ষেত্র ত্রুটি মডেল গড়

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

mse_model = RankingModel(tf.keras.losses.MeanSquaredError())
mse_model.compile(optimizer=tf.keras.optimizers.Adagrad(0.1))

mse_model.fit(cached_train, epochs=epochs, verbose=False)

<keras.callbacks.History at 0x7f64791a5d10>

Pairwise কবজা ক্ষতি মডেল

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

এই ক্ষতি পৃথক সিনেমার জন্য নয়, বরং জোড়া সিনেমার জন্য গণনা করা হয়। তাই এই ক্ষতি ব্যবহার করে প্রশিক্ষণ যুগলভাবে হয়।

hinge_model = RankingModel(tfr.keras.losses.PairwiseHingeLoss())
hinge_model.compile(optimizer=tf.keras.optimizers.Adagrad(0.1))

hinge_model.fit(cached_train, epochs=epochs, verbose=False)

<keras.callbacks.History at 0x7f647914f190>

তালিকা অনুযায়ী মডেল

ListMLE TensorFlow রাংক প্রকাশ থেকে হ্রাস তালিকা সর্বাধিক সম্ভাবনা মুল্যায়ন। ListMLE ক্ষতি গণনা করতে, আমরা প্রথমে একটি সর্বোত্তম র‌্যাঙ্কিং তৈরি করতে ব্যবহারকারীর রেটিং ব্যবহার করি। তারপরে আমরা ভবিষ্যদ্বাণীকৃত স্কোর ব্যবহার করে সর্বোত্তম র‌্যাঙ্কিং-এ প্রতিটি প্রার্থীর নিচের যেকোনো আইটেম দ্বারা আউট-র‌্যাঙ্ক হওয়ার সম্ভাবনা গণনা করি। উচ্চ রেটপ্রাপ্ত প্রার্থীরা কম রেটপ্রাপ্ত প্রার্থীদের দ্বারা র‍্যাঙ্কের বাইরে না হয় তা নিশ্চিত করার জন্য মডেলটি এমন সম্ভাবনা কমানোর চেষ্টা করে। আপনি কাগজ অধ্যায় 2.2 মধ্যে ListMLE বিবরণ সম্পর্কে আরও জানতে পারেন অবস্থান-সচেতন ListMLE: একটি অনুক্রমিক শিক্ষণ পদ্ধতি ।

মনে রাখবেন যে সম্ভাব্যতা যেহেতু একজন প্রার্থী এবং তার নীচে থাকা সমস্ত প্রার্থীর অনুকূলে র‌্যাঙ্কিংয়ের ক্ষেত্রে গণনা করা হয়, তাই ক্ষতিটি জুটিভিত্তিক নয় তবে তালিকা অনুসারে। তাই প্রশিক্ষণ তালিকা অপ্টিমাইজেশান ব্যবহার করে।

listwise_model = RankingModel(tfr.keras.losses.ListMLELoss())
listwise_model.compile(optimizer=tf.keras.optimizers.Adagrad(0.1))

listwise_model.fit(cached_train, epochs=epochs, verbose=False)

<keras.callbacks.History at 0x7f647b35f350>

মডেল তুলনা

mse_model_result = mse_model.evaluate(cached_test, return_dict=True)
print("NDCG of the MSE Model: {:.4f}".format(mse_model_result["ndcg_metric"]))

1/1 [==============================] - 0s 405ms/step - ndcg_metric: 0.9053 - root_mean_squared_error: 0.9671 - loss: 0.9354 - regularization_loss: 0.0000e+00 - total_loss: 0.9354
NDCG of the MSE Model: 0.9053

hinge_model_result = hinge_model.evaluate(cached_test, return_dict=True)
print("NDCG of the pairwise hinge loss model: {:.4f}".format(hinge_model_result["ndcg_metric"]))

1/1 [==============================] - 0s 457ms/step - ndcg_metric: 0.9058 - root_mean_squared_error: 3.8330 - loss: 1.0180 - regularization_loss: 0.0000e+00 - total_loss: 1.0180
NDCG of the pairwise hinge loss model: 0.9058

listwise_model_result = listwise_model.evaluate(cached_test, return_dict=True)
print("NDCG of the ListMLE model: {:.4f}".format(listwise_model_result["ndcg_metric"]))

1/1 [==============================] - 0s 432ms/step - ndcg_metric: 0.9071 - root_mean_squared_error: 2.7224 - loss: 4.5401 - regularization_loss: 0.0000e+00 - total_loss: 4.5401
NDCG of the ListMLE model: 0.9071

তিনটি মডেলের মধ্যে, ListMLE ব্যবহার করে প্রশিক্ষিত মডেলের সর্বোচ্চ NDCG মেট্রিক রয়েছে। এই ফলাফলটি দেখায় কিভাবে তালিকা অনুসারে অপ্টিমাইজেশান র‌্যাঙ্কিং মডেলগুলিকে প্রশিক্ষণের জন্য ব্যবহার করা যেতে পারে এবং সম্ভাব্যভাবে এমন মডেল তৈরি করতে পারে যা পয়েন্টওয়াইজ বা পেয়ারওয়াইজ ফ্যাশনে অপ্টিমাইজ করা মডেলগুলির চেয়ে ভাল পারফর্ম করতে পারে।