সাহায্য Kaggle উপর TensorFlow সঙ্গে গ্রেট বেরিয়ার রিফ রক্ষা চ্যালেঞ্জ যোগদান

চলচ্চিত্রগুলির প্রস্তাবনা: র‌্যাঙ্কিং

TensorFlow.org এ দেখুন Google Colab-এ চালান GitHub-এ উৎস দেখুন নোটবুক ডাউনলোড করুন

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

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

আমরা দ্বিতীয় পর্যায়ে ফোকাস করতে যাচ্ছি, র‌্যাঙ্কিং। আপনি আহরণ পর্যায়ে আগ্রহী, আমাদের কটাক্ষপাত আছে আহরণ টিউটোরিয়াল।

এই টিউটোরিয়ালে, আমরা যাচ্ছি:

  1. আমাদের ডেটা পান এবং এটিকে একটি প্রশিক্ষণ এবং পরীক্ষার সেটে ভাগ করুন।
  2. একটি র‌্যাঙ্কিং মডেল বাস্তবায়ন করুন।
  3. ফিট এবং এটি মূল্যায়ন.

আমদানি

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

pip install -q tensorflow-recommenders
pip install -q --upgrade tensorflow-datasets
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

ডেটাসেট প্রস্তুত করা হচ্ছে

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

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

ratings = ratings.map(lambda x: {
    "movie_title": x["movie_title"],
    "user_id": x["user_id"],
    "user_rating": x["user_rating"]
})
2021-10-02 11:04:25.388548: E tensorflow/stream_executor/cuda/cuda_driver.cc:271] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected

আগের মতো, আমরা ট্রেন সেটে 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 = ratings.batch(1_000_000).map(lambda x: x["movie_title"])
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)))

একটি মডেল বাস্তবায়ন

স্থাপত্য

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

একাধিক স্তুপীকৃত ঘন স্তরের সমন্বয়ে গঠিত একটি মডেল র‍্যাঙ্কিং কাজের জন্য একটি অপেক্ষাকৃত সাধারণ স্থাপত্য। আমরা এটি নিম্নরূপ বাস্তবায়ন করতে পারি:

class RankingModel(tf.keras.Model):

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

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

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

    # Compute predictions.
    self.ratings = 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)
  ])

  def call(self, inputs):

    user_id, movie_title = inputs

    user_embedding = self.user_embeddings(user_id)
    movie_embedding = self.movie_embeddings(movie_title)

    return self.ratings(tf.concat([user_embedding, movie_embedding], axis=1))

এই মডেলটি ব্যবহারকারীর আইডি এবং চলচ্চিত্রের শিরোনাম নেয় এবং একটি পূর্বাভাসিত রেটিং আউটপুট করে:

RankingModel()((["42"], ["One Flew Over the Cuckoo's Nest (1975)"]))
WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor, but we receive a <class 'list'> input: ['42']
Consider rewriting this model with the Functional API.
WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor, but we receive a <class 'list'> input: ['42']
Consider rewriting this model with the Functional API.
WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor, but we receive a <class 'list'> input: ["One Flew Over the Cuckoo's Nest (1975)"]
Consider rewriting this model with the Functional API.
WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor, but we receive a <class 'list'> input: ["One Flew Over the Cuckoo's Nest (1975)"]
Consider rewriting this model with the Functional API.
<tf.Tensor: shape=(1, 1), dtype=float32, numpy=array([[0.03740937]], dtype=float32)>

ক্ষতি এবং মেট্রিক্স

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

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

আমরা একসাথে ব্যবহার করব সঙ্গে MeanSquaredError অর্ডার রেটিং ভবিষ্যদ্বাণী করা হবে Keras ক্ষতি।

task = tfrs.tasks.Ranking(
  loss = tf.keras.losses.MeanSquaredError(),
  metrics=[tf.keras.metrics.RootMeanSquaredError()]
)

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

সম্পূর্ণ মডেল

আমরা এখন একটি মডেল হিসাবে এটি সব একসাথে রাখতে পারেন. TFRS একটি বেস মডেল শ্রেণী (অনাবৃত tfrs.models.Model ) যা স্ফীতি মডেলের streamlines: সব আমরা কি করতে প্রয়োজন উপাদান স্থাপন হয় __init__ পদ্ধতি, এবং বাস্তবায়ন compute_loss পদ্ধতি, কাঁচা বৈশিষ্ট্য গ্রহণ এবং একটি ক্ষতি মান ফিরে .

বেস মডেল তখন আমাদের মডেলের সাথে মানানসই উপযুক্ত প্রশিক্ষণ লুপ তৈরি করার যত্ন নেবে।

class MovielensModel(tfrs.models.Model):

  def __init__(self):
    super().__init__()
    self.ranking_model: tf.keras.Model = RankingModel()
    self.task: tf.keras.layers.Layer = tfrs.tasks.Ranking(
      loss = tf.keras.losses.MeanSquaredError(),
      metrics=[tf.keras.metrics.RootMeanSquaredError()]
    )

  def call(self, features: Dict[str, tf.Tensor]) -> tf.Tensor:
    return self.ranking_model(
        (features["user_id"], features["movie_title"]))

  def compute_loss(self, features: Dict[Text, tf.Tensor], training=False) -> tf.Tensor:
    labels = features.pop("user_rating")

    rating_predictions = self(features)

    # The task computes the loss and the metrics.
    return self.task(labels=labels, predictions=rating_predictions)

মানানসই এবং মূল্যায়ন

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

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

model = MovielensModel()
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 [==============================] - 2s 26ms/step - root_mean_squared_error: 2.1718 - loss: 4.3303 - regularization_loss: 0.0000e+00 - total_loss: 4.3303
Epoch 2/3
10/10 [==============================] - 0s 8ms/step - root_mean_squared_error: 1.1227 - loss: 1.2602 - regularization_loss: 0.0000e+00 - total_loss: 1.2602
Epoch 3/3
10/10 [==============================] - 0s 8ms/step - root_mean_squared_error: 1.1162 - loss: 1.2456 - regularization_loss: 0.0000e+00 - total_loss: 1.2456
<keras.callbacks.History at 0x7f28389eaa90>

মডেল ট্রেনিংয়ের সাথে সাথে লোকসান কমছে এবং RMSE মেট্রিক উন্নত হচ্ছে।

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

model.evaluate(cached_test, return_dict=True)
5/5 [==============================] - 2s 14ms/step - root_mean_squared_error: 1.1108 - loss: 1.2287 - regularization_loss: 0.0000e+00 - total_loss: 1.2287
{'root_mean_squared_error': 1.1108061075210571,
 'loss': 1.2062578201293945,
 'regularization_loss': 0,
 'total_loss': 1.2062578201293945}

RMSE মেট্রিক যত কম হবে, রেটিং অনুমান করার ক্ষেত্রে আমাদের মডেল তত বেশি নির্ভুল।

র‌্যাঙ্কিং মডেল পরীক্ষা করা হচ্ছে

এখন আমরা সিনেমার একটি সেটের জন্য ভবিষ্যদ্বাণী গণনা করে র‌্যাঙ্কিং মডেল পরীক্ষা করতে পারি এবং তারপর ভবিষ্যদ্বাণীগুলির উপর ভিত্তি করে এই চলচ্চিত্রগুলিকে র‌্যাঙ্ক করতে পারি:

test_ratings = {}
test_movie_titles = ["M*A*S*H (1970)", "Dances with Wolves (1990)", "Speed (1994)"]
for movie_title in test_movie_titles:
  test_ratings[movie_title] = model({
      "user_id": np.array(["42"]),
      "movie_title": np.array([movie_title])
  })

print("Ratings:")
for title, score in sorted(test_ratings.items(), key=lambda x: x[1], reverse=True):
  print(f"{title}: {score}")
Ratings:
M*A*S*H (1970): [[3.584712]]
Dances with Wolves (1990): [[3.551556]]
Speed (1994): [[3.5215874]]

পরিবেশনের জন্য রপ্তানি করা হচ্ছে

মডেলটি পরিবেশনের জন্য সহজেই রপ্তানি করা যেতে পারে:

tf.saved_model.save(model, "export")
2021-10-02 11:04:38.235611: W tensorflow/python/util/util.cc:348] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
WARNING:absl:Found untraced functions such as ranking_1_layer_call_and_return_conditional_losses, ranking_1_layer_call_fn, ranking_1_layer_call_fn, ranking_1_layer_call_and_return_conditional_losses, ranking_1_layer_call_and_return_conditional_losses while saving (showing 5 of 5). These functions will not be directly callable after loading.
INFO:tensorflow:Assets written to: export/assets
INFO:tensorflow:Assets written to: export/assets

আমরা এখন এটিকে আবার লোড করতে পারি এবং ভবিষ্যদ্বাণী করতে পারি:

loaded = tf.saved_model.load("export")

loaded({"user_id": np.array(["42"]), "movie_title": ["Speed (1994)"]}).numpy()
array([[3.5215874]], dtype=float32)

পরবর্তী পদক্ষেপ

উপরের মডেলটি আমাদের একটি র্যাঙ্কিং সিস্টেম তৈরির দিকে একটি শালীন সূচনা দেয়।

অবশ্যই, একটি ব্যবহারিক র‌্যাঙ্কিং সিস্টেম তৈরির জন্য অনেক বেশি প্রচেষ্টা প্রয়োজন।

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

অপ্টিমাইজ করার যোগ্য উদ্দেশ্যগুলির একটি সাবধানে বোঝারও প্রয়োজন। একটি recommender একাধিক উদ্দেশ্য সেরা অনুকূল রূপ নির্মাণের শুরু করার জন্য, আমাদের কটাক্ষপাত আছে একাধিক কার্য টিউটোরিয়াল।