Crear recomendaciones basadas en comentarios explícitos con un modelo de factorización de matriz

En este tutorial se explica cómo crear un modelo de factorización de matriz y entrenarlo con las valoraciones de películas de los clientes del conjunto de datos movielens1m. Después, usa el modelo de factorización de matriz para generar recomendaciones de películas para los usuarios.

Usar las valoraciones proporcionadas por los clientes para entrenar el modelo se denomina entrenamiento con feedback explícito. Los modelos de factorización de matrices se entrenan con el algoritmo de mínimos cuadrados alternantes cuando se usa feedback explícito como datos de entrenamiento.

Crear conjunto de datos

Crea un conjunto de datos de BigQuery para almacenar tu modelo de aprendizaje automático.

Consola

  1. En la Google Cloud consola, ve a la página BigQuery.

    Ir a la página de BigQuery

  2. En el panel Explorador, haz clic en el nombre de tu proyecto.

  3. Haga clic en Ver acciones > Crear conjunto de datos.

  4. En la página Crear conjunto de datos, haz lo siguiente:

    • En ID del conjunto de datos, introduce bqml_tutorial.

    • En Tipo de ubicación, selecciona Multirregión y, a continuación, EE. UU. (varias regiones de Estados Unidos).

    • Deje el resto de los ajustes predeterminados como están y haga clic en Crear conjunto de datos.

bq

Para crear un conjunto de datos, usa el comando bq mk con la marca --location. Para ver una lista completa de los parámetros posibles, consulta la referencia del comando bq mk --dataset.

  1. Crea un conjunto de datos llamado bqml_tutorial con la ubicación de los datos definida como US y la descripción BigQuery ML tutorial dataset:

    bq --location=US mk -d \
 --description "BigQuery ML tutorial dataset." \
 bqml_tutorial

    En lugar de usar la marca --dataset, el comando usa el acceso directo -d. Si omite -d y --dataset, el comando creará un conjunto de datos de forma predeterminada.

  2. Confirma que se ha creado el conjunto de datos:

    bq ls

API

Llama al método datasets.insert con un recurso de conjunto de datos definido.

{
  "datasetReference": {
     "datasetId": "bqml_tutorial"
  }
}

BigQuery DataFrames

Antes de probar este ejemplo, sigue las instrucciones de configuración de BigQuery DataFrames que se indican en la guía de inicio rápido de BigQuery con BigQuery DataFrames. Para obtener más información, consulta la documentación de referencia de los DataFrames de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configurar ADC en un entorno de desarrollo local. 

import google.cloud.bigquery

bqclient = google.cloud.bigquery.Client()
bqclient.create_dataset("bqml_tutorial", exists_ok=True)

Subir los datos de MovieLens

Sube los datos movielens1m a BigQuery.

CLI

Sigue estos pasos para subir los datos de movielens1m con la herramienta de línea de comandos bq:

  1. Abre Cloud Shell:

    Activar Cloud Shell

  2. Sube los datos de las valoraciones a la tabla ratings. En la línea de comandos, pega la siguiente consulta y pulsa Enter:

    curl -O 'http://files.grouplens.org/datasets/movielens/ml-1m.zip'
unzip ml-1m.zip
sed 's/::/,/g' ml-1m/ratings.dat > ratings.csv
bq load --source_format=CSV bqml_tutorial.ratings ratings.csv \
  user_id:INT64,item_id:INT64,rating:FLOAT64,timestamp:TIMESTAMP

  3. Sube los datos de la película a la tabla movies. En la línea de comandos, pega la siguiente consulta y pulsa Enter:

    sed 's/::/@/g' ml-1m/movies.dat > movie_titles.csv
bq load --source_format=CSV --field_delimiter=@ \
bqml_tutorial.movies movie_titles.csv \
movie_id:INT64,movie_title:STRING,genre:STRING

BigQuery DataFrames

Antes de probar este ejemplo, sigue las instrucciones de configuración de BigQuery DataFrames que se indican en la guía de inicio rápido de BigQuery con BigQuery DataFrames. Para obtener más información, consulta la documentación de referencia de los DataFrames de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configurar ADC en un entorno de desarrollo local.

Primero, crea un objeto Client con bqclient = google.cloud.bigquery.Client() y, a continuación, carga los datos movielens1m en el conjunto de datos que has creado en el paso anterior.

import io
import zipfile

import google.api_core.exceptions
import requests

try:
    # Check if you've already created the Movielens tables to avoid downloading
    # and uploading the dataset unnecessarily.
    bqclient.get_table("bqml_tutorial.ratings")
    bqclient.get_table("bqml_tutorial.movies")
except google.api_core.exceptions.NotFound:
    # Download the https://grouplens.org/datasets/movielens/1m/ dataset.
    ml1m = requests.get("http://files.grouplens.org/datasets/movielens/ml-1m.zip")
    ml1m_file = io.BytesIO(ml1m.content)
    ml1m_zip = zipfile.ZipFile(ml1m_file)

    # Upload the ratings data into the ratings table.
    with ml1m_zip.open("ml-1m/ratings.dat") as ratings_file:
        ratings_content = ratings_file.read()

    ratings_csv = io.BytesIO(ratings_content.replace(b"::", b","))
    ratings_config = google.cloud.bigquery.LoadJobConfig()
    ratings_config.source_format = "CSV"
    ratings_config.write_disposition = "WRITE_TRUNCATE"
    ratings_config.schema = [
        google.cloud.bigquery.SchemaField("user_id", "INT64"),
        google.cloud.bigquery.SchemaField("item_id", "INT64"),
        google.cloud.bigquery.SchemaField("rating", "FLOAT64"),
        google.cloud.bigquery.SchemaField("timestamp", "TIMESTAMP"),
    ]
    bqclient.load_table_from_file(
        ratings_csv, "bqml_tutorial.ratings", job_config=ratings_config
    ).result()

    # Upload the movie data into the movies table.
    with ml1m_zip.open("ml-1m/movies.dat") as movies_file:
        movies_content = movies_file.read()

    movies_csv = io.BytesIO(movies_content.replace(b"::", b"@"))
    movies_config = google.cloud.bigquery.LoadJobConfig()
    movies_config.source_format = "CSV"
    movies_config.field_delimiter = "@"
    movies_config.write_disposition = "WRITE_TRUNCATE"
    movies_config.schema = [
        google.cloud.bigquery.SchemaField("movie_id", "INT64"),
        google.cloud.bigquery.SchemaField("movie_title", "STRING"),
        google.cloud.bigquery.SchemaField("genre", "STRING"),
    ]
    bqclient.load_table_from_file(
        movies_csv, "bqml_tutorial.movies", job_config=movies_config
    ).result()

Crear el modelo

Crea un modelo de factorización de matriz y entrénalo con los datos de la ratingstabla. El modelo se entrena para predecir una valoración de cada par usuario-elemento, en función de las valoraciones de películas proporcionadas por los clientes.

SQL

La siguiente instrucción CREATE MODEL usa estas columnas para generar recomendaciones:

  • user_id— El ID de usuario.
  • item_id: el ID de la película.
  • rating: la valoración explícita del 1 al 5 que el usuario ha dado al elemento.

Sigue estos pasos para crear el modelo:

  1. En la Google Cloud consola, ve a la página BigQuery.

    Ir a BigQuery

  2. En el editor de consultas, pega la siguiente consulta y haz clic en Ejecutar:

    CREATE OR REPLACE MODEL `bqml_tutorial.mf_explicit`
OPTIONS (
  MODEL_TYPE = 'matrix_factorization',
  FEEDBACK_TYPE = 'explicit',
  USER_COL = 'user_id',
  ITEM_COL = 'item_id',
  L2_REG = 9.83,
  NUM_FACTORS = 34)
AS
SELECT
user_id,
item_id,
rating
FROM `bqml_tutorial.ratings`;

    La consulta tarda unos 10 minutos en completarse. Después, el modelo mf_explicit aparece en el panel Explorador. Como la consulta usa una instrucción CREATE MODEL para crear un modelo, no se muestran resultados.

BigQuery DataFrames

Antes de probar este ejemplo, sigue las instrucciones de configuración de BigQuery DataFrames que se indican en la guía de inicio rápido de BigQuery con BigQuery DataFrames. Para obtener más información, consulta la documentación de referencia de los DataFrames de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configurar ADC en un entorno de desarrollo local. 

from bigframes.ml import decomposition
import bigframes.pandas as bpd

# Load data from BigQuery
bq_df = bpd.read_gbq(
    "bqml_tutorial.ratings", columns=("user_id", "item_id", "rating")
)

# Create the Matrix Factorization model
model = decomposition.MatrixFactorization(
    num_factors=34,
    feedback_type="explicit",
    user_col="user_id",
    item_col="item_id",
    rating_col="rating",
    l2_reg=9.83,
)
model.fit(bq_df)
model.to_gbq(
    your_model_id, replace=True  # For example: "bqml_tutorial.mf_explicit"
)

El código tarda unos 10 minutos en completarse. Después, el modelo mf_explicit aparece en el panel Explorador.

Obtener estadísticas de formación

Si quiere, puede ver las estadísticas de entrenamiento del modelo en laGoogle Cloud consola.

Un algoritmo de aprendizaje automático crea un modelo generando muchas iteraciones del modelo con diferentes parámetros y, a continuación, selecciona la versión del modelo que minimiza la pérdida. Este proceso se denomina minimización del riesgo empírico. Las estadísticas de entrenamiento del modelo te permiten ver la pérdida asociada a cada iteración del modelo.

Siga estos pasos para ver las estadísticas de entrenamiento del modelo:

  1. En la Google Cloud consola, ve a la página BigQuery.

    Ir a BigQuery

  2. En el panel de la izquierda, haz clic en Explorador:

    Botón destacado del panel Explorador.

    Si no ves el panel de la izquierda, haz clic en Ampliar panel de la izquierda para abrirlo.

  3. En el panel Explorador, despliega tu proyecto, haz clic en Conjuntos de datos y, a continuación, en el conjunto de datos bqml_tutorial.

  4. Haz clic en la pestaña Modelos.

  5. Haga clic en el modelo mf_explicit y, a continuación, en la pestaña Entrenamiento.

  6. En la sección Ver como, haga clic en Tabla. Los resultados deberían ser similares a los siguientes:

    +-----------+--------------------+--------------------+
| Iteration | Training Data Loss | Duration (seconds) |
+-----------+--------------------+--------------------+
|  11       | 0.3943             | 42.59              |
+-----------+--------------------+--------------------+
|  10       | 0.3979             | 27.37              |
+-----------+--------------------+--------------------+
|   9       | 0.4038             | 40.79              |
+-----------+--------------------+--------------------+
|  ...      | ...                | ...                |
+-----------+--------------------+--------------------+

    La columna Pérdida de datos de entrenamiento representa la métrica de pérdida calculada después de entrenar el modelo. Como se trata de un modelo de factorización de matrices, esta columna muestra el error cuadrático medio.

También puedes usar la función ML.TRAINING_INFO para ver las estadísticas de entrenamiento del modelo.

Evaluar el modelo

Evalúa el rendimiento del modelo comparando las valoraciones de películas predichas que devuelve el modelo con las valoraciones de películas reales de los usuarios de los datos de entrenamiento.

SQL

Usa la función ML.EVALUATE para evaluar el modelo:

  1. En la Google Cloud consola, ve a la página BigQuery.

    Ir a BigQuery

  2. En el editor de consultas, pega la siguiente consulta y haz clic en Ejecutar:

    SELECT
*
FROM
ML.EVALUATE(
  MODEL `bqml_tutorial.mf_explicit`,
  (
    SELECT
      user_id,
      item_id,
      rating
    FROM
      `bqml_tutorial.ratings`
  ));

    Los resultados deberían ser similares a los siguientes:

    +---------------------+---------------------+------------------------+-----------------------+--------------------+--------------------+
| mean_absolute_error | mean_squared_error  | mean_squared_log_error | median_absolute_error |      r2_score      | explained_variance |
+---------------------+---------------------+------------------------+-----------------------+--------------------+--------------------+
| 0.48494444327829156 | 0.39433706592870565 |   0.025437895793637522 |   0.39017059802629905 | 0.6840033369412044 | 0.6840033369412264 |
+---------------------+---------------------+------------------------+-----------------------+--------------------+--------------------+

    Una métrica importante en los resultados de la evaluación es la puntuación R. La puntuación R2 es una medida estadística que determina si las predicciones de regresión lineal se aproximan a los datos reales. El valor 0 indica que el modelo no explica ninguna de las variabilidades de los datos de respuesta en torno a la media. El valor 1 indica que el modelo explica toda la variabilidad de los datos de respuesta en torno a la media.

    Para obtener más información sobre el resultado de la función ML.EVALUATE, consulta Resultado.

También puedes llamar a ML.EVALUATE sin proporcionar los datos de entrada. Usará las métricas de evaluación calculadas durante el entrenamiento.

BigQuery DataFrames

Antes de probar este ejemplo, sigue las instrucciones de configuración de BigQuery DataFrames que se indican en la guía de inicio rápido de BigQuery con BigQuery DataFrames. Para obtener más información, consulta la documentación de referencia de los DataFrames de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configurar ADC en un entorno de desarrollo local.

Llama a model.score() para evaluar el modelo.

# Evaluate the model using the score() function
model.score(bq_df)
# Output:
# mean_absolute_error	mean_squared_error	mean_squared_log_error	median_absolute_error	r2_score	explained_variance
# 0.485403	                0.395052	        0.025515	            0.390573	        0.68343	        0.68343

Obtener las valoraciones predichas de un subconjunto de pares usuario-elemento

Obtén la valoración prevista de cada película para cinco usuarios.

SQL

Usa la función ML.RECOMMEND para obtener las valoraciones predichas:

  1. En la Google Cloud consola, ve a la página BigQuery.

    Ir a BigQuery

  2. En el editor de consultas, pega la siguiente consulta y haz clic en Ejecutar:

    SELECT
*
FROM
ML.RECOMMEND(
  MODEL `bqml_tutorial.mf_explicit`,
  (
    SELECT
      user_id
    FROM
      `bqml_tutorial.ratings`
    LIMIT 5
  ));

    Los resultados deberían ser similares a los siguientes:

    +--------------------+---------+---------+
| predicted_rating   | user_id | item_id |
+--------------------+---------+---------+
| 4.2125303962491873 | 4       | 3169    |
+--------------------+---------+---------+
| 4.8068920531981263 | 4       | 3739    |
+--------------------+---------+---------+
| 3.8742203494732403 | 4       | 3574    |
+--------------------+---------+---------+
| ...                | ...     | ...     |
+--------------------+---------+---------+

BigQuery DataFrames

Antes de probar este ejemplo, sigue las instrucciones de configuración de BigQuery DataFrames que se indican en la guía de inicio rápido de BigQuery con BigQuery DataFrames. Para obtener más información, consulta la documentación de referencia de los DataFrames de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configurar ADC en un entorno de desarrollo local.

Llama al model.predict() para obtener las valoraciones predichas.

# Use predict() to get the predicted rating for each movie for 5 users
subset = bq_df[["user_id"]].head(5)
predicted = model.predict(subset)
print(predicted)
# Output:
#   predicted_rating	user_id	 item_id	rating
# 0	    4.206146	     4354	  968	     4.0
# 1	    4.853099	     3622	  3521	     5.0
# 2	    2.679067	     5543	  920	     2.0
# 3	    4.323458	     445	  3175	     5.0
# 4	    3.476911	     5535	  235	     4.0

Generar recomendaciones

Usa las valoraciones predichas para generar las cinco películas recomendadas principales para cada usuario.

SQL

Sigue estos pasos para generar recomendaciones:

  1. En la Google Cloud consola, ve a la página BigQuery.

    Ir a BigQuery

  2. Escribe las valoraciones predichas en una tabla. En el editor de consultas, pega la siguiente consulta y haz clic en Ejecutar:

    CREATE OR REPLACE TABLE `bqml_tutorial.recommend`
AS
SELECT
*
FROM
ML.RECOMMEND(MODEL `bqml_tutorial.mf_explicit`);

  3. Combina las valoraciones predichas con la información de las películas y selecciona los cinco resultados principales por usuario. En el editor de consultas, pega la siguiente consulta y haz clic en Ejecutar:

  SELECT
    user_id,
    ARRAY_AGG(STRUCT(movie_title, genre, predicted_rating) ORDER BY predicted_rating DESC LIMIT 5)
  FROM
    (
      SELECT
        user_id,
        item_id,
        predicted_rating,
        movie_title,
        genre
      FROM
        `bqml_tutorial.recommend`
      JOIN
        `bqml_tutorial.movies`
        ON
          item_id = movie_id
    )
  GROUP BY
    user_id;

Los resultados deberían ser similares a los siguientes:

  +---------+-------------------------------------+------------------------+--------------------+
  | user_id | f0_movie_title                      | f0_genre               | predicted_rating   |
  +---------+-------------------------------------+------------------------+--------------------+
  | 4597    | Song of Freedom (1936)              | Drama                  | 6.8495752907364009 |
  |         | I Went Down (1997)                  | Action/Comedy/Crime    | 6.7203235758772877 |
  |         | Men With Guns (1997)                | Action/Drama           | 6.399407352232001  |
  |         | Kid, The (1921)                     | Action                 | 6.1952890198126731 |
  |         | Hype! (1996)                        | Documentary            | 6.1895766097451475 |
  +---------+-------------------------------------+------------------------+--------------------+
  | 5349    | Fandango (1985)                     | Comedy                 | 9.944574012151549  |
  |         | Breakfast of Champions (1999)       | Comedy                 | 9.55661860430112   |
  |         | Funny Bones (1995)                  | Comedy                 | 9.52778917835076   |
  |         | Paradise Road (1997)                | Drama/War              | 9.1643621767929133 |
  |         | Surviving Picasso (1996)            | Drama                  | 8.807353289233772  |
  +---------+-------------------------------------+------------------------+--------------------+
  | ...     | ...                                 | ...                    | ...                |
  +---------+-------------------------------------+------------------------+--------------------+

BigQuery DataFrames

Antes de probar este ejemplo, sigue las instrucciones de configuración de BigQuery DataFrames que se indican en la guía de inicio rápido de BigQuery con BigQuery DataFrames. Para obtener más información, consulta la documentación de referencia de los DataFrames de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configurar ADC en un entorno de desarrollo local.

Llama al model.predict() para obtener las valoraciones predichas.

# import bigframes.bigquery as bbq

# Load movies
movies = bpd.read_gbq("bqml_tutorial.movies")

# Merge the movies df with the previously created predicted df
merged_df = bpd.merge(predicted, movies, left_on="item_id", right_on="movie_id")

# Separate users and predicted data, setting the index to 'movie_id'
users = merged_df[["user_id", "movie_id"]].set_index("movie_id")

# Take the predicted data and sort it in descending order by 'predicted_rating', setting the index to 'movie_id'
sort_data = (
    merged_df[["movie_title", "genre", "predicted_rating", "movie_id"]]
    .sort_values(by="predicted_rating", ascending=False)
    .set_index("movie_id")
)

# re-merge the separated dfs by index
merged_user = sort_data.join(users, how="outer")

# group the users and set the user_id as the index
merged_user.groupby("user_id").head(5).set_index("user_id").sort_index()
print(merged_user)
# Output:
# 	            movie_title	                genre	        predicted_rating
# user_id
#   1	    Saving Private Ryan (1998)	Action|Drama|War	    5.19326
#   1	        Fargo (1996)	       Crime|Drama|Thriller	    4.996954
#   1	    Driving Miss Daisy (1989)	    Drama	            4.983671
#   1	        Ben-Hur (1959)	       Action|Adventure|Drama	4.877622
#   1	     Schindler's List (1993)	   Drama|War	        4.802336
#   2	    Saving Private Ryan (1998)	Action|Drama|War	    5.19326
#   2	        Braveheart (1995)	    Action|Drama|War	    5.174145
#   2	        Gladiator (2000)	      Action|Drama	        5.066372
#   2	        On Golden Pond (1981)	     Drama	            5.01198
#   2	    Driving Miss Daisy (1989)	     Drama	            4.983671