Google I / O 18-20 मई को लौटता है! जगह आरक्षित करें और अपना शेड्यूल बनाएं अभी रजिस्टर करें

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

TensorFlow.org पर देखें 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

डेटासेट तैयार करना

आइए सबसे पहले डेटा पर एक नजर डालते हैं।

हम Tensorflow डेटासेट से MovieLens डेटासेट का उपयोग करते हैं। लोड हो रहा है movielens/100k_ratings एक 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 फ़ील्ड 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

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

दूसरा मॉडल को स्वयं परिभाषित करना है। यहाँ, हम पहले उपयोगकर्ता आईडी को पूर्णांक में बदलने के लिए केरस प्रीप्रोसेसिंग लेयर्स का उपयोग करने जा रहे हैं, और फिर एक 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 एक उपवर्ग को परिभाषित करते समय 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)
)

हानि

अगला घटक हमारे मॉडल को प्रशिक्षित करने के लिए उपयोग किया जाने वाला नुकसान है। 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 से प्राप्त 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 [==============================] - 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>

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

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

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

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 परत बहुत धीमी होने जा रही है। निम्न अनुभाग दिखाता है कि अनुमानित अनुमानित सूचकांक का उपयोग करके इसे कैसे गति दें।

मॉडल सेवारत

मॉडल प्रशिक्षित होने के बाद, हमें इसे तैनात करने का एक तरीका चाहिए।

दो-टॉवर पुनर्प्राप्ति मॉडल में, सेवारत के दो घटक हैं:

  • एक सेवारत क्वेरी मॉडल, क्वेरी की सुविधाओं में ले जा रहा है और उन्हें एक क्वेरी एम्बेडिंग में परिवर्तित कर रहा है, और
  • एक सेवारत उम्मीदवार मॉडल। यह अक्सर एक निकटतम निकटतम पड़ोसी (एएनएन) सूचकांक का रूप ले लेता है, जो क्वेरी मॉडल द्वारा निर्मित क्वेरी के जवाब में उम्मीदवारों के तेजी से अनुमानित लुकअप की अनुमति देता है।

TFRS में, दोनों घटकों को एक एकल निर्यात योग्य मॉडल में पैक किया जा सकता है, जो हमें एक मॉडल देता है जो कच्चे उपयोगकर्ता आईडी लेता है और उस उपयोगकर्ता के लिए शीर्ष फिल्मों के शीर्षक देता है। यह मॉडल को एक SavedModel प्रारूप में निर्यात करने के माध्यम से किया जाता है, जो TensorFlow सर्विंग का उपयोग करके सेवा करना संभव बनाता है।

इस तरह से एक मॉडल को तैनात करने के लिए, हम बस ऊपर बनाई गई BruteForce परत को निर्यात करते हैं:

0518abb80
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

एक बार स्थापित होने के बाद हम TFRS 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. मूवी मेटाडेटा का उपयोग करना: कोल्ड-स्टार्ट को कम करने के लिए एक अधिक जटिल मूवी मॉडल का निर्माण।