Google I/O एक लपेट है! TensorFlow सत्रों पर पकड़ बनाएं सत्र देखें

फिल्मों की सिफारिश करना: पुनर्प्राप्ति

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें नोटबुक डाउनलोड करें

वास्तविक दुनिया की अनुशंसा प्रणाली अक्सर दो चरणों से बनी होती है:

  1. पुनर्प्राप्ति चरण सभी संभावित उम्मीदवारों में से सैकड़ों उम्मीदवारों के प्रारंभिक सेट का चयन करने के लिए जिम्मेदार है। इस मॉडल का मुख्य उद्देश्य उन सभी उम्मीदवारों को कुशलतापूर्वक बाहर निकालना है जिनमें उपयोगकर्ता रुचि नहीं रखता है। क्योंकि पुनर्प्राप्ति मॉडल लाखों उम्मीदवारों से संबंधित हो सकता है, इसे कम्प्यूटेशनल रूप से कुशल होना चाहिए।
  2. रैंकिंग चरण पुनर्प्राप्ति मॉडल के आउटपुट लेता है और उन्हें सर्वोत्तम संभव मुट्ठी भर सिफारिशों का चयन करने के लिए ठीक करता है। इसका कार्य संभावित उम्मीदवारों की एक शॉर्टलिस्ट में उपयोगकर्ता की रुचि रखने वाली वस्तुओं के सेट को कम करना है।

इस ट्यूटोरियल में, हम पहले चरण, पुनर्प्राप्ति पर ध्यान केंद्रित करने जा रहे हैं। आप रैंकिंग चरण में रुचि रखते हैं, हमारे पर एक नजर है रैंकिंग ट्यूटोरियल।

पुनर्प्राप्ति मॉडल अक्सर दो उप-मॉडल से बने होते हैं:

  1. क्वेरी सुविधाओं का उपयोग करके क्वेरी प्रतिनिधित्व (आमतौर पर एक निश्चित-आयामी एम्बेडिंग वेक्टर) की गणना करने वाला एक क्वेरी मॉडल।
  2. उम्मीदवार सुविधाओं का उपयोग करके उम्मीदवार प्रतिनिधित्व (एक समान आकार का वेक्टर) की गणना करने वाला एक उम्मीदवार मॉडल

फिर दो मॉडलों के आउटपुट को एक साथ गुणा करके एक क्वेरी-उम्मीदवार आत्मीयता स्कोर दिया जाता है, जिसमें उच्च स्कोर उम्मीदवार और क्वेरी के बीच बेहतर मिलान को व्यक्त करते हैं।

इस ट्यूटोरियल में, हम Movielens डेटासेट का उपयोग करके ऐसे टू-टॉवर मॉडल का निर्माण और प्रशिक्षण करने जा रहे हैं।

करने के लिए जा रहे थे:

  1. हमारा डेटा प्राप्त करें और इसे प्रशिक्षण और परीक्षण सेट में विभाजित करें।
  2. एक पुनर्प्राप्ति मॉडल लागू करें।
  3. फिट करें और उसका मूल्यांकन करें।
  4. एक अनुमानित निकटतम पड़ोसियों (एएनएन) सूचकांक का निर्माण करके इसे कुशल सेवा के लिए निर्यात करें।

डेटासेट

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 एक पैदावार 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")
2021-10-02 11:05:34.633747: E tensorflow/stream_executor/cuda/cuda_driver.cc:271] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected

रेटिंग डेटासेट मूवी आईडी, उपयोगकर्ता आईडी, निर्दिष्ट रेटिंग, टाइमस्टैम्प, मूवी जानकारी और उपयोगकर्ता जानकारी का एक शब्दकोश देता है:

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'}
2021-10-02 11:05:35.718641: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.

मूवी डेटासेट में मूवी आईडी, मूवी का शीर्षक और यह डेटा किस विधा से संबंधित है। ध्यान दें कि शैलियों को पूर्णांक लेबल के साथ एन्कोड किया गया है।

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)'}
2021-10-02 11:05:35.893098: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.

इस उदाहरण में, हम रेटिंग डेटा पर ध्यान केंद्रित करने जा रहे हैं। अन्य ट्यूटोरियल यह पता लगाते हैं कि फिल्म सूचना डेटा का उपयोग कैसे करें और साथ ही मॉडल की गुणवत्ता में सुधार करें।

हम केवल रखने 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"])

मॉडल को फिट और मूल्यांकन करने के लिए, हमें इसे एक प्रशिक्षण और मूल्यांकन सेट में विभाजित करने की आवश्यकता है। एक औद्योगिक recommender प्रणाली में, यह सबसे अधिक संभावना समय के द्वारा किया जा जाएगा: समय तक का डेटा \(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 preprocessing परतों का उपयोग, और फिर एक के माध्यम से उपयोगकर्ता embeddings करने के लिए उन कन्वर्ट करने के लिए जा रहे हैं Embedding परत। ध्यान दें कि हम उन अद्वितीय उपयोगकर्ता आईडी की सूची का उपयोग करते हैं जिनकी गणना हमने पहले एक शब्दावली के रूप में की थी:

user_model = tf.keras.Sequential([
  tf.keras.layers.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 इस सरल मॉडल के लिए overkill हो सकता है, हम आसानी से यह एक मनमाने ढंग से जटिल मॉडल के लिए मानक Keras घटकों का उपयोग विस्तार कर सकते हैं, जब तक कि हम एक वापसी embedding_dimension अंत में व्यापक उत्पादन।

उम्मीदवार टॉवर

हम उम्मीदवार टॉवर के साथ भी ऐसा ही कर सकते हैं।

movie_model = 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)
])

मैट्रिक्स

हमारे प्रशिक्षण डेटा में हमारे पास सकारात्मक (उपयोगकर्ता, मूवी) जोड़े हैं। यह पता लगाने के लिए कि हमारा मॉडल कितना अच्छा है, हमें इस जोड़ी के लिए अन्य सभी संभावित उम्मीदवारों के स्कोर के लिए एफ़िनिटी स्कोर की तुलना करने की आवश्यकता है: यदि सकारात्मक जोड़ी के लिए स्कोर अन्य सभी उम्मीदवारों की तुलना में अधिक है, तो हमारा मॉडल अत्यधिक सटीक है।

ऐसा करने के लिए, हम उपयोग कर सकते हैं tfrs.metrics.FactorizedTopK मीट्रिक। मीट्रिक में एक आवश्यक तर्क है: उम्मीदवारों का डेटासेट जो मूल्यांकन के लिए निहित नकारात्मक के रूप में उपयोग किया जाता है।

हमारे मामले में, यह है कि में movies डाटासेट, हमारे फिल्म मॉडल के माध्यम से embeddings में परिवर्तित कर दिया:

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

नुकसान

अगला घटक हमारे मॉडल को प्रशिक्षित करने के लिए उपयोग किया जाने वाला नुकसान है। इसे आसान बनाने के लिए TFRS में कई नुकसान परतें और कार्य हैं।

इस उदाहरण में, हम का उपयोग कर देंगे Retrieval कि बंडलों एक साथ नुकसान समारोह और मीट्रिक गणना आवरण एक सुविधा: कार्य वस्तु:

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

कार्य स्वयं एक केरस परत है जो क्वेरी और उम्मीदवार एम्बेडिंग को तर्क के रूप में लेता है, और गणना की गई हानि देता है: हम इसका उपयोग मॉडल के प्रशिक्षण लूप को लागू करने के लिए करेंगे।

पूरा मॉडल

अब हम इन सबको मिलाकर एक मॉडल बना सकते हैं। TFRS एक बेस मॉडल वर्ग (उजागर करता 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 आधार वर्ग एक बस सुविधा वर्ग है: यह हमें ही विधि का उपयोग दोनों प्रशिक्षण और परीक्षण नुकसान की गणना करने के लिए अनुमति देता है।

हुड के तहत, यह अभी भी एक सादा केरस मॉडल है। आप से इनहेरिट द्वारा ही कार्यक्षमता प्राप्त कर सकते थे 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 बॉयलरप्लेट के कुछ मॉडलिंग और दूर सार पर ध्यान केंद्रित रखने के लिए आधार वर्ग।

फिटिंग और मूल्यांकन

मॉडल को परिभाषित करने के बाद, हम मॉडल को फिट और मूल्यांकन करने के लिए मानक केरस फिटिंग और मूल्यांकन दिनचर्या का उपयोग कर सकते हैं।

आइए पहले मॉडल को इंस्टेंट करें।

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 [==============================] - 6s 302ms/step - factorized_top_k/top_1_categorical_accuracy: 0.0011 - factorized_top_k/top_5_categorical_accuracy: 0.0094 - factorized_top_k/top_10_categorical_accuracy: 0.0203 - factorized_top_k/top_50_categorical_accuracy: 0.1001 - factorized_top_k/top_100_categorical_accuracy: 0.1772 - loss: 69885.1129 - regularization_loss: 0.0000e+00 - total_loss: 69885.1129
Epoch 2/3
10/10 [==============================] - 3s 286ms/step - factorized_top_k/top_1_categorical_accuracy: 0.0029 - factorized_top_k/top_5_categorical_accuracy: 0.0186 - factorized_top_k/top_10_categorical_accuracy: 0.0376 - factorized_top_k/top_50_categorical_accuracy: 0.1689 - factorized_top_k/top_100_categorical_accuracy: 0.2923 - loss: 67523.3707 - regularization_loss: 0.0000e+00 - total_loss: 67523.3707
Epoch 3/3
10/10 [==============================] - 3s 269ms/step - factorized_top_k/top_1_categorical_accuracy: 0.0036 - factorized_top_k/top_5_categorical_accuracy: 0.0224 - factorized_top_k/top_10_categorical_accuracy: 0.0459 - factorized_top_k/top_50_categorical_accuracy: 0.1880 - factorized_top_k/top_100_categorical_accuracy: 0.3162 - loss: 66302.9609 - regularization_loss: 0.0000e+00 - total_loss: 66302.9609
<keras.callbacks.History at 0x7f560e5ea090>

आप TensorBoard साथ प्रशिक्षण प्रक्रिया की निगरानी करना चाहते हैं, तो आप फिट () फ़ंक्शन करने के लिए एक TensorBoard कॉलबैक जोड़ सकते हैं और उसके बाद का उपयोग कर TensorBoard शुरू %tensorboard --logdir logs/fit । देखें TensorBoard प्रलेखन अधिक जानकारी के लिए।

मॉडल ट्रेन के रूप में, नुकसान कम हो रहा है और टॉप-के पुनर्प्राप्ति मेट्रिक्स का एक सेट अपडेट किया गया है। ये हमें बताते हैं कि क्या सही सकारात्मक पूरे उम्मीदवार सेट से टॉप-के पुनर्प्राप्त आइटम में है। उदाहरण के लिए, 0.2 की एक शीर्ष -5 श्रेणीबद्ध सटीकता मीट्रिक हमें बताएगी कि औसतन, वास्तविक सकारात्मक शीर्ष 5 पुनर्प्राप्त वस्तुओं में 20% समय है।

ध्यान दें कि, इस उदाहरण में, हम प्रशिक्षण के साथ-साथ मूल्यांकन के दौरान मेट्रिक्स का मूल्यांकन करते हैं। चूंकि यह बड़े उम्मीदवार सेट के साथ काफी धीमा हो सकता है, इसलिए प्रशिक्षण में मीट्रिक गणना को बंद करना और इसे केवल मूल्यांकन में चलाना समझदारी हो सकती है।

अंत में, हम परीक्षण सेट पर अपने मॉडल का मूल्यांकन कर सकते हैं:

model.evaluate(cached_test, return_dict=True)
5/5 [==============================] - 2s 149ms/step - factorized_top_k/top_1_categorical_accuracy: 7.5000e-04 - factorized_top_k/top_5_categorical_accuracy: 0.0099 - factorized_top_k/top_10_categorical_accuracy: 0.0226 - factorized_top_k/top_50_categorical_accuracy: 0.1245 - factorized_top_k/top_100_categorical_accuracy: 0.2324 - loss: 31079.0635 - regularization_loss: 0.0000e+00 - total_loss: 31079.0635
{'factorized_top_k/top_1_categorical_accuracy': 0.000750000006519258,
 'factorized_top_k/top_5_categorical_accuracy': 0.009850000031292439,
 'factorized_top_k/top_10_categorical_accuracy': 0.02264999970793724,
 'factorized_top_k/top_50_categorical_accuracy': 0.12449999898672104,
 'factorized_top_k/top_100_categorical_accuracy': 0.23235000669956207,
 'loss': 28244.771484375,
 'regularization_loss': 0,
 'total_loss': 28244.771484375}

टेस्ट सेट का प्रदर्शन प्रशिक्षण प्रदर्शन की तुलना में बहुत खराब है। यह दो कारकों के कारण है:

  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_from_dataset(
  tf.data.Dataset.zip((movies.batch(100), movies.batch(100).map(model.movie_model)))
)

# 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.
  tf.saved_model.save(index, path)

  # Load it back; can also be done in TensorFlow Serving.
  loaded = tf.saved_model.load(path)

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

  print(f"Recommendations: {titles[0][:3]}")
2021-10-02 11:05:54.109254: 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 query_with_exclusions while saving (showing 1 of 1). These functions will not be directly callable after loading.
INFO:tensorflow:Assets written to: /tmp/tmp7otg6id7/model/assets
INFO:tensorflow:Assets written to: /tmp/tmp7otg6id7/model/assets
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

एक बार स्थापित हम TFRS उपयोग कर सकते हैं ScaNN परत:

scann_index = tfrs.layers.factorized_top_k.ScaNN(model.user_model)
scann_index.index_from_dataset(
  tf.data.Dataset.zip((movies.batch(100), movies.batch(100).map(model.movie_model)))
)
<tensorflow_recommenders.layers.factorized_top_k.ScaNN at 0x7f560caffc10>

यह परत लगभग लुकअप प्रदर्शन करेंगे: इस बनाता है थोड़ा सा गलत पुनर्प्राप्ति, लेकिन बड़े उम्मीदवार सेट पर तेजी से परिमाण के आदेश।

# 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.
  tf.saved_model.save(
      index,
      path,
      options=tf.saved_model.SaveOptions(namespace_whitelist=["Scann"])
  )

  # Load it back; can also be done in TensorFlow Serving.
  loaded = tf.saved_model.load(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.
INFO:tensorflow:Assets written to: /tmp/tmp_rde8grm/model/assets
INFO:tensorflow:Assets written to: /tmp/tmp_rde8grm/model/assets
Recommendations: [b'Bridges of Madison County, The (1995)'
 b'Father of the Bride Part II (1995)' b'Rudy (1993)']

का उपयोग करते हुए और ट्यूनिंग तेजी से अनुमानित पुनर्प्राप्ति मॉडल के बारे में अधिक जानकारी के लिए हमारे पर एक नजर है कुशल सेवारत ट्यूटोरियल।

आइटम-टू-आइटम अनुशंसा

इस मॉडल में, हमने एक उपयोगकर्ता-मूवी मॉडल बनाया। हालांकि, कुछ एप्लिकेशन (उदाहरण के लिए, उत्पाद विवरण पृष्ठ) के लिए आइटम-से-आइटम (उदाहरण के लिए, मूवी-टू-मूवी या उत्पाद-से-उत्पाद) अनुशंसाएं निष्पादित करना आम बात है।

इस तरह के प्रशिक्षण मॉडल उसी पैटर्न का पालन करेंगे जैसा कि इस ट्यूटोरियल में दिखाया गया है, लेकिन विभिन्न प्रशिक्षण डेटा के साथ। यहां, हमारे पास एक उपयोगकर्ता और एक मूवी टॉवर था, और उन्हें प्रशिक्षित करने के लिए (उपयोगकर्ता, मूवी) जोड़े का इस्तेमाल किया। आइटम-टू-आइटम मॉडल में, हमारे पास दो आइटम टावर (क्वेरी और उम्मीदवार आइटम के लिए) होंगे, और (क्वेरी आइटम, उम्मीदवार आइटम) जोड़े का उपयोग करके मॉडल को प्रशिक्षित करेंगे। इनका निर्माण उत्पाद विवरण पृष्ठों पर क्लिक से किया जा सकता है।

अगले कदम

यह पुनर्प्राप्ति ट्यूटोरियल का समापन करता है।

यहाँ जो प्रस्तुत किया गया है उस पर विस्तार करने के लिए, इस पर एक नज़र डालें:

  1. बहु-कार्य मॉडल सीखना: रेटिंग और क्लिक के लिए संयुक्त रूप से अनुकूलित करना।
  2. मूवी मेटाडेटा का उपयोग करना: कोल्ड-स्टार्ट को कम करने के लिए अधिक जटिल मूवी मॉडल बनाना।