Estás leyendo la publicación: ¿Cómo construir un sistema de recomendación usando TensorFlow Ranking?
La clasificación de aprendizaje automático es un enfoque para construir sistemas escalables de recuperación de información, especialmente cuando la tarea es encontrar elementos similares para un valor de entrada dado. Los sistemas de recomendación también encuentran y presentan elementos similares en función de varias características. TensorFlow Ranking es una biblioteca de Python que ayuda a desarrollar el aprendizaje para clasificar los modelos de aprendizaje automático. En este artículo, analizaremos cómo podemos usar la clasificación de TensorFlow para crear un sistema de recomendación basado en el concepto de aprender a clasificar. La demostración aquí está inspirada en los tutoriales de TensorFlow en TensorFlow Ranking. Los puntos principales que se discutirán en el artículo se enumeran a continuación.
Tabla de contenido
- ¿Qué es la clasificación de TensorFlow?
- Sistema de recomendación de edificios
- Importación y preprocesamiento de datos
- Definición de modelo
- Modelo de compilación
- modelo apropiado
- Generando predicción
¿Qué es la clasificación de TensorFlow?
TensorFlow Ranking es una implementación de TensorFlow que nos ayuda a crear modelos de aprendizaje para clasificar (LTR). Los modelos de aprendizaje de clasificación (LTR) son modelos que nos ayudan a construir los modelos de clasificación para cualquier sistema de recuperación de información. En el modelado LTR usamos datos de entrenamiento con una lista de artículos y estos artículos están conectados con algunos pedidos parciales. La representación del orden parcial puede ser una puntuación numérica o un juicio binario.
El objetivo principal de este tipo de modelo es predecir el rango de nuevos elementos similares a los datos de entrenamiento. Usando la clasificación de TensorFlow podemos producir tales modelos. Además, estos modelos encuentran su uso en diversas tareas, como el filtrado colaborativo, el análisis de sentimientos y la publicidad personalizada. Una posible arquitectura de tales modelos puede ser explicada por la siguiente figura.
Fuente de imagen
Esta implementación también proporciona varios módulos para acelerar la creación de modelos LTR en los que estos módulos funcionan en segundo plano en la API de Keras. Dado que los modelos LTR tienen sus aplicaciones en la generación de sistemas de recomendación, en este artículo vamos a utilizar la clasificación de flujo de tensor para hacer un sistema de recomendación. Antes de iniciar el procedimiento, se requiere que instalemos esta implementación que se puede hacer usando las siguientes líneas de códigos.
!pip install -q tensorflow-ranking
Después de la instalación, estamos listos para implementarlo en nuestro trabajo.
Sistema de recomendación de edificios
En este artículo, vamos a crear un sistema de recomendación utilizando los paquetes de clasificación de TensorFlow, de modo que podamos utilizar el modelo para clasificar las películas y luego recomendarlas al usuario.
Importación y preprocesamiento de datos
En este artículo, vamos a utilizar el conjunto de datos movielens para crear sistemas de recomendación a los que se pueda llamar desde el módulo tensorflow_dataset.
importar tensorflow_datasets como tfds ratings_data = tfds.load(‘movielens/100k-ratings’, split=”train”) fetures_data = tfds.load(‘movielens/100k-movies’, split=”train”)
Producción:
Selección de las características de los datos de calificación.
ratings_data = ratings_data.map(lambda x: { “movie_title”: x[“movie_title”]”id_usuario”: x[“user_id”]”calificación_usuario”: x[“user_rating”]
})
Conversión de iser_ids y movie_title en índices enteros.
importar tensorflow como tf de tensorflow.keras importar capas feature_data = fetures_data.map(lambda x: x[“movie_title”]) usuarios = ratings_data.map(lambda x: x[“user_id”]) user_ids_vocabulary = capas.experimental.preprocesamiento.StringLookup( mask_token=Ninguno) user_ids_vocabulary.adapt(users.batch(1000)) movie_titles_vocabulary = capas.experimental.preprocesamiento.StringLookup( mask_token=Ninguno) movie_titles_vocabulary.adapt(feature_data.batch(1000) )
Agrupar por user_id.
key_func = lambda x: user_ids_vocabulary(x[“user_id”]) reduce_func = clave lambda, conjunto de datos: dataset.batch(100) tren = ratings_data.group_by_window(key_func=key_func, reduce_func=reduce_func, window_size=100)
Aquí podemos comprobar la forma de nuestros datos.
print(train) for x in train.take(1): for key, value in x.items(): print(f”Forma de {key}: {value.shape}”) print(f”Valores de ejemplo de { valor clave[:5].numpy()}”) imprimir()
Producción:
Generación de lotes de etiquetas y características
de escribir import Dict, Tuple def _features_and_labels( x: Dict[str, tf.Tensor]) -> Tupla[Dict[str, tf.Tensor]tf.Tensor]: etiquetas = x.pop(“calificación_usuario”) devuelve x, etiquetas tren = tren.map(_características_y_etiquetas) tren = tren.aplicar( tf.data.experimental.dense_to_ragged_batch(batch_size=32))
Aquí, en los códigos anteriores, tenemos tensor de identificación de usuario y títulos de películas en el tren de forma [32, none]. Definamos el modelo.
Definición de modelo
from tensorflow.keras import Model class RankingModel(Model): def __init__(self, user_vocab, movie_vocab): super().__init__() self.user_vocab = user_vocab self.movie_vocab = movie_vocab self.user_embed = layers.Embedding(user_vocab.vocabulary_size (), 64) self.movie_embed = capas.Embedding(movie_vocab.vocabulary_size(), 64) def call(self, características: Dict[str, tf.Tensor]) -> tf.Tensor: embeddings_user= self.user_embed(self.user_vocab(features[“user_id”])) incrustaciones_película = self.movie_embed( self.movie_vocab(características[“movie_title”])) devuelve tf.reduce_sum(incrustaciones_usuario * incrustaciones_película, eje=2)
Aquí, en los códigos anteriores, hemos definido una clase en la que definimos una función para configurar el vocabulario y las incrustaciones del usuario y la película y una función de llamada para definir cómo se calculará la clasificación. Como resultado, tendremos productos punto de incrustaciones de usuarios e incrustaciones de películas.
Compilación de modelos
importar tensorflow_ranking como tfr de tensorflow.keras importar modelo de optimizadores = RankingModel(user_ids_vocabulary, movie_titles_vocabulary) Optimizer = Optimizers.Adagrad(0.5) loss = tfr.keras.losses.get(loss=tfr.keras.losses.RankingLossKey.SOFTMAX_LOSS, ragged= Verdadero) eval_metrics = [
tfr.keras.metrics.get(key=”ndcg”, name=”metric/ndcg”, ragged=True),
tfr.keras.metrics.get(key=”mrr”, name=”metric/mrr”, ragged=True)
]
model.compile(optimizer=optimizer, loss=loss, metrics=eval_metrics
En lo anterior, hemos utilizado la pérdida de clasificación para el entrenamiento del modelo y las métricas de clasificación para la evaluación del modelo del paquete de clasificación de TensorFlow. También a partir de las métricas de clasificación, especificamos la ganancia acumulada descontada normalizada y la clasificación recíproca media.
Ajuste del modelo
history = model.fit(tren, epochs=9)
Producción:
En lo anterior, hemos entrenado nuestro modelo compilado en los datos usando 9 épocas. Veamos el historial del modelo.
historia.historia
En la historia, podemos ver que la pérdida del modelo es tan alta porque estamos usando la pérdida softmax específica de la clasificación que es diferente de la pérdida softmax en los problemas de clasificación. Esta pérdida promueve todos los elementos relevantes en la lista de clasificación que tienen mejores posibilidades que los elementos irrelevantes.
Generando predicción
para movie_titles en feature_data.batch(2000): romper entradas = { “user_id”: tf.expand_dims(tf.repeat(“26”, repeats=movie_titles.shape[0]), eje=0), “título_película”: tf.expand_dims(títulos_película, eje=0) } puntuaciones = modelo(entradas) títulos = tfr.utils.sort_by_scores(puntuaciones,
[tf.expand_dims(movie_titles, axis=0)])[0]
print(f”Las 10 mejores recomendaciones para el usuario 26: {titles[0, :10]}”)
Producción:
Aquí, en los códigos anteriores, hemos creado una lista de usuarios y películas a partir de la cual hemos generado una entrada como el usuario número 26. El uso del modelo de entrada y puntaje ha recomendado 10 nombres de películas para el usuario 26.
Ultimas palabras
En este artículo, analizamos la clasificación de TensorFlow, que es una implementación de TensorFlow para aprender a clasificar el modelado. Usando este módulo, hemos generado un sistema de recomendación sobre el conjunto de datos de lentes de película.
Referencias
