Sentence / Maciej Kula Japonés James Chen, Google Brain
Los sistemas de recomendación son una aplicación importante del aprendizaje automático, que puede impulsar contenido relacionado según las preferencias del usuario, como recomendar películas, restaurantes, combinar joyas de moda o filtrar flujos de información multimedia.
Google ha estado explorando nuevas tecnologías de aprendizaje profundo en los últimos años, esforzándose por brindar mejores recomendaciones al combinar el aprendizaje de múltiples tareas, el aprendizaje por refuerzo, la extracción de mejores representaciones de usuarios y la construcción de indicadores de equidad. Estos esfuerzos y otros desarrollos han mejorado enormemente nuestras recomendaciones.
Hoy, estamos orgullosos de lanzar TensorFlow Recomenders (TFRS), un paquete de software TensorFlow de código abierto que simplifica la construcción, evaluación y aplicación de modelos de recomendación complejos.
Recomendados de TensorFlow (TFRS)
https://tensorflow.google.cn/recommenders
TFRS está construido con TensorFlow 2.xy ayuda a:
Construir y evaluar un modelo de nominación de candidatos flexible;
Integre libremente información contextual, de usuario y de artículo en el modelo de recomendación;
Entrene un modelo de tareas múltiples que pueda optimizar conjuntamente múltiples objetivos de recomendación;
Use TensorFlow Serving para usar de manera eficiente el modelo generado.
TFRS se basa en TensorFlow 2.xy Keras y es muy fácil de usar. Si bien adopta un diseño modular (puede personalizar cada capa y cada índice de evaluación), aún forma un todo sólido (cada componente puede funcionar bien en conjunto). En el proceso de diseño de TFRS, siempre hemos enfatizado la flexibilidad y la facilidad de uso: configuraciones predeterminadas razonables, tareas comunes intuitivas y fáciles y tareas recomendadas más complejas o personalizadas.
Los recomendadores de TensorFlow ahora son de código abierto en GitHub. Nuestro objetivo es permitir que continúe desarrollándose, poder realizar investigaciones académicas de manera flexible y construir un sistema de recomendación en toda la red de una manera altamente escalable. También planeamos expandir sus funciones en el aprendizaje multitarea, con modelado cruzado, aprendizaje auto-supervisado y el cálculo del vecino más cercano aproximado de vanguardia (SOTA) .
GitHub
https://github.com/tensorflow/recommenders
Ejemplo: creación de una herramienta de recomendación de películas
Usemos un ejemplo simple para mostrar cómo usar los recomendadores de TensorFlow. Primero, instale TFRS usando pip:
!pip install tensorflow_recommenders
Luego, podemos usar el conjunto de datos MovieLens para entrenar un modelo de recomendación de película simple. La información contenida en el conjunto de datos incluye qué películas ha visto el usuario y la calificación de la película por parte del usuario.
Usaremos este conjunto de datos para construir un modelo para predecir las películas que los usuarios vieron y no vieron. Este tipo de tarea suele optar por el modelo de torre gemela: una red neuronal con dos submodelos para aprender la representación de consulta y candidato respectivamente. La puntuación de un par de consulta-candidato dado es solo el producto escalar de las salidas de estas dos torres.
La arquitectura del modelo es bastante flexible. La entrada de la torre de consultas puede ser: ID de usuario, palabras clave de búsqueda o marca de tiempo; para el lado del candidato, hay: título de la película, descripción, resumen y lista de estrellas.
En este ejemplo, solo usamos el ID de usuario en la torre de consultas y solo el título de la película en la torre candidata.
Preparemos los datos primero. Los datos se pueden obtener de TensorFlow Datasets.
import tensorflow as tf
import tensorflow_datasets as tfds
import tensorflow_recommenders as tfrs
# Ratings data.
ratings = tfds.load("movie_lens/100k-ratings", split="train")
# Features of all the available movies.
movies = tfds.load("movie_lens/100k-movies", split="train")
De todas las funciones disponibles en el conjunto de datos, las más útiles son la identificación de usuario y el título de la película. Aunque TFRS tiene una variedad de características opcionales, por simplicidad, solo usamos estas dos.
ratings = ratings.map(lambda x: {
"movie_title": x["movie_title"],
"user_id": x["user_id"],
})
movies = movies.map(lambda x: x["movie_title"])
Cuando solo se utilizan el ID de usuario y el título de la película, nuestro modelo simple de torres gemelas es muy similar al modelo típico de factorización matricial. Necesitamos construir con lo siguiente:
Una torre de usuario convierte la identificación de usuario en un vector de incorporación de usuario (representado por un vector de alta dimensión).
Una torre de películas que convierte títulos de películas en vectores de incrustación de películas.
Una función de pérdida, para el comportamiento de visualización, maximiza la predicción de la coincidencia entre el usuario y la película y minimiza el comportamiento no visto.
TFRS y Keras proporcionan una gran cantidad de módulos básicos para lograr este objetivo. Podemos empezar creando una clase modelo. En el __init__método, establecemos algunos hiperparámetros y los componentes principales del modelo.
class TwoTowerMovielensModel(tfrs.Model):
"""MovieLens prediction model."""
def __init__(self):
# The `__init__` method sets up the model architecture.
super().__init__()
# How large the representation vectors are for inputs: larger vectors make
# for a more expressive model but may cause over-fitting.
embedding_dim = 32
num_unique_users = 1000
num_unique_movies = 1700
eval_batch_size = 128
El primer componente importante es el modelo de usuario: un conjunto de capas que describen cómo transformar las características originales del usuario en representaciones digitales del usuario. Aquí usamos la capa de preprocesamiento de Keras para convertir el ID de usuario en un índice entero y luego mapearlo al vector de incrustación aprendido:
# Set up user and movie representations.
self.user_model = tf.keras.Sequential([
# We first turn the raw user ids into contiguous integers by looking them
# up in a vocabulary.
tf.keras.layers.experimental.preprocessing.StringLookup(
max_tokens=num_unique_users),
# We then map the result into embedding vectors.
tf.keras.layers.Embedding(num_unique_users, embedding_dim)
])
El modelo de película es muy similar y puede convertir títulos de películas en vectores de incrustación:
self.movie_model = tf.keras.Sequential([
tf.keras.layers.experimental.preprocessing.StringLookup(
max_tokens=num_unique_movies),
tf.keras.layers.Embedding(num_unique_movies, embedding_dim)
])
Después de obtener los modelos de usuario y película, debemos definir nuestros objetivos y sus indicadores de evaluación. En TFRS, esto se puede lograr a través de Retrieval tareas (usando pérdida softmax en lote):
# The `Task` objects has two purposes: (1) it computes the loss and (2)
# keeps track of metrics.
self.task = tfrs.tasks.Retrieval(
# In this case, our metrics are top-k metrics: given a user and a known
# watched movie, how highly would the model rank the true movie out of
# all possible movies?
metrics=tfrs.metrics.FactorizedTopK(
candidates=movies.batch(eval_batch_size).map(self.movie_model)
)
)
Usamos el compute_loss método para ver el proceso de entrenamiento del modelo:
def compute_loss(self, features, training=False):
# The `compute_loss` method determines how loss is computed.
# Compute user and item embeddings.
user_embeddings = self.user_model(features["user_id"])
movie_embeddings = self.movie_model(features["movie_title"])
# Pass them into the task to get the resulting loss. The lower the loss is, the
# better the model is at telling apart true watches from watches that did
# not happen in the training data.
return self.task(user_embeddings, movie_embeddings)
Podemos llamar al ajuste de Keras para que se ajuste a este modelo:
model = MovielensModel()
model.compile(optimizer=tf.keras.optimizers.Adagrad(0.1))
model.fit(ratings.batch(4096), verbose=False)
Para realizar Sanity-Check en las recomendaciones del modelo, podemos usar la capa TFRS BruteForce. La capa BruteForce ordena las representaciones de candidatos precalculadas, lo que nos permite calcular las puntuaciones de los pares de candidatos de consulta para todos los candidatos posibles y devolver la película (consulta) con la clasificación más alta:
index = tfrs.layers.ann.BruteForce(model.user_model)
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]}")
Por supuesto, la capa BruteForce solo es adecuada para conjuntos de datos muy pequeños. Para ver un ejemplo del uso de TFRS con la biblioteca vecina más cercana, Annoy, consulte nuestro tutorial completo.
Tutorial completo
https://tensorflow.google.cn/recommenders/examples/basic_retrieval#building_a_candidate_ann_index
Esperamos que esto le dé una idea de las características de los recomendadores de TensorFlow. Para obtener más información, consulte nuestro tutorial o referencia de API. Si desea participar y promover el desarrollo del sistema de recomendación de TensorFlow juntos, ¡considere contribuir con su fortaleza! También anunciaremos el establecimiento del Grupo de Interés Especial de Recomendaciones (SIG) de TensorFlow en un futuro cercano. Invitamos a todos a cooperar y contribuir en temas como el aprendizaje de vectores integrado y la capacitación y las aplicaciones distribuidas. ¡Manténganse al tanto!
Tutorial
https://tensorflow.google.cn/recommenders/examples/quickstartReferencia de API
https://tensorflow.google.cn/recommenders/api_docs/python/tfrs/all_symbolsContribuya con su fuerza
https://github.com/tensorflow/recommenders/
Gracias
Los recomendadores de TensorFlow son el resultado de los esfuerzos conjuntos de Google y otras organizaciones. Nos gustaría agradecer a Tiansheng Yao, Xinyang Yi y Ji Yang por sus contribuciones fundamentales a la biblioteca, y agradecer a Lichan Hong y Ed Chi por su liderazgo y orientación. También nos gustaría agradecer a Zhe Zhao, Derek Cheng, Sagar Jain, Alexandre Passos, Francois Chollet, Sandeep Gupta, Eric Ni y otros por sus sugerencias y apoyo al proyecto.
Si desea obtener más información sobre el contenido relacionado mencionado en este documento , consulte los siguientes documentos. Estos documentos profundizan en muchos de los temas mencionados en este artículo:
Aprendizaje reforzado
https://research.google/pubs/pub47647/Mejor caracterización del usuario
https://research.google/pubs/pub47954/Indicador de equidad
https://research.google/pubs/pub48107/Modelo de nominación de candidatos
https://research.google/pubs/pub48840/Información
https://tensorflow.google.cn/recommenders/examples/featurizationModelo multitarea
https://tensorflow.google.cn/recommenders/examples/multitaskPublicación de TensorFlow
https://tensorflow.google.cn/tfx/guide/servingConjunto de datos MovieLens
https://grouplens.org/datasets/movielens/Modelo de torre gemela
https://research.google/pubs/pub48840/Conjuntos de datos de TensorFlow
https://tensorflow.google.cn/datasets/catalog/movielensCapa de preprocesamiento de Keras
https://keras.io/guides/preprocessing_layers/pérdida de softmax en lote
https://research.google/pubs/pub48840/
Para obtener más información, haga clic en "Leer el original" para visitar GitHub.