Se usó la API de Cloud Translation para traducir esta página.

Crea recomendaciones basadas en comentarios explícitos con un modelo de factorización de matrices

En este instructivo, aprenderás a crear un modelo de factorización de matrices y a entrenarlo con las calificaciones de películas de los clientes en el conjunto de datos movielens1m. Luego, usa el modelo de factorización de matrices para generar recomendaciones de películas para los usuarios.

El uso de calificaciones proporcionadas por los clientes para entrenar el modelo se denomina entrenamiento con comentarios explícitos. Los modelos de factorización de matrices se entrenan con el algoritmo de mínimos cuadrados alternos cuando usas comentarios explícitos como datos de entrenamiento.

Objetivos

En este instructivo, se te guiará para completar las siguientes tareas:

Crear un modelo de factorización de matrices con la sentencia CREATE MODEL
Evalúa el modelo con la función ML.EVALUATE.
Generar recomendaciones de películas para los usuarios con el modelo con la función ML.RECOMMEND

Costos

En este instructivo, se usan los siguientes componentes facturables de Google Cloud:

BigQuery
BigQuery ML

Para obtener más información sobre los costos de BigQuery, consulta la página Precios de BigQuery.

Para obtener más información sobre los costos de BigQuery ML, consulta los precios de BigQuery ML.

Antes de comenzar

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

BigQuery se habilita automáticamente en proyectos nuevos. Para activar BigQuery en un proyecto existente, ve a
Enable the BigQuery API.
Enable the API

Permisos necesarios

Para crear el conjunto de datos, necesitas el permiso bigquery.datasets.create de IAM.
Para crear el modelo, necesitas los siguientes permisos:
- bigquery.jobs.create
- bigquery.models.create
- bigquery.models.getData
- bigquery.models.updateData
Para ejecutar inferencias, necesitas los siguientes permisos:
- bigquery.models.getData
- bigquery.jobs.create

Para obtener más información sobre los roles y permisos de IAM en BigQuery, consulta Introducción a IAM.

Crea un conjunto de datos

Crea un conjunto de datos de BigQuery para almacenar tu modelo de AA.

Console

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

Ir a la página de BigQuery
En el panel Explorador, haz clic en el nombre de tu proyecto.
Haz clic en Ver acciones > Crear conjunto de datos.
En la página Crear conjunto de datos, haz lo siguiente:
- En ID del conjunto de datos, ingresa bqml_tutorial.
- En Tipo de ubicación, selecciona Multirregión y, luego, EE.UU. (varias regiones en Estados Unidos).
- Deja la configuración predeterminada restante como está y haz clic en Crear conjunto de datos.

bq

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

Crea un conjunto de datos llamado bqml_tutorial con la ubicación de los datos establecida en US y una descripción de 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 omites -d y --dataset, el comando crea un conjunto de datos de manera predeterminada.
Confirma que se haya 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"
  }
}

Permite trabajar con BigQuery DataFrames.

Antes de probar este ejemplo, sigue las instrucciones de configuración de BigQuery DataFrames 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 BigQuery DataFrames.

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

import google.cloud.bigquery

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

Sube los datos de MovieLens

Sube los datos de movielens1m a BigQuery.

CLI

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

Abre Cloud Shell:

Activa Cloud Shell

Sube los datos de las calificaciones a la tabla ratings. En la línea de comandos, pega la siguiente consulta y presiona 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

Sube los datos de las películas a la tabla movies. En la línea de comandos, pega la siguiente consulta y presiona 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

Permite trabajar con BigQuery DataFrames.

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

Primero, crea un objeto Client con bqclient = google.cloud.bigquery.Client() y, luego, carga los datos movielens1m en el conjunto de datos que creaste 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()

Crea el modelo

Crea un modelo de factorización de matrices y entrena en los datos de la tabla ratings. El modelo se entrena para predecir una calificación para cada par de usuario y elemento, según las calificaciones de las películas que proporciona el cliente.

SQL

La siguiente sentencia CREATE MODEL usa estas columnas para generar recomendaciones:

user_id: El ID de usuario.
item_id: Es el ID de la película.
rating: Es la calificación explícita del 1 al 5 que el usuario otorgó al elemento.

Sigue estos pasos para crear el modelo:

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

Ir a BigQuery

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 de lo cual el modelo mf_explicit aparece en el panel Explorador. Debido a que en la consulta se usa una sentencia CREATE MODEL para crear un modelo, no se muestran los resultados.

Permite trabajar con BigQuery DataFrames.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura ADC para 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 de lo cual el modelo mf_explicit aparece en el panel Explorador.

Obtén estadísticas de entrenamiento

De manera opcional, puedes ver las estadísticas de entrenamiento del modelo en la consola deGoogle Cloud .

Para compilar un modelo, los algoritmos de aprendizaje automático crean muchas iteraciones del modelo con diferentes parámetros y, luego, seleccionan la versión del modelo que minimiza la pérdida. Este proceso se llama minimización del riesgo empírico. Las estadísticas de entrenamiento del modelo te permiten ver la pérdida asociada con cada iteración del modelo.

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

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

Ir a BigQuery
En el panel Explorador, expande tu proyecto, expande el conjunto de datos bqml_tutorial y, luego, expande la carpeta Modelos.
Haz clic en el modelo mf_explicit y, luego, en la pestaña Entrenamiento.

En la sección Ver como, haz clic en Tabla. Los resultados debería ser similares al siguiente:

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

La columna Training Data Loss (Pérdida de datos de entrenamiento) representa la métrica de pérdida calculada después de que se entrena el modelo. Debido a que este es 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 de modelos.

Evalúa el modelo

Para evaluar el rendimiento del modelo, compara las calificaciones de películas previstas que muestra el modelo con las calificaciones reales de las películas de los usuarios de los datos de entrenamiento.

SQL

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

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

Ir a BigQuery

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ía ser similar al siguiente:

+---------------------+---------------------+------------------------+-----------------------+--------------------+--------------------+
| 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 R² es una medida estadística que determina si las predicciones de regresión lineal se aproximan a los datos reales. Un valor 0 indica que el modelo no explica nada de la variabilidad de los datos de respuesta alrededor de la media. Un valor 1 indica que el modelo explica toda la variabilidad de los datos de respuesta alrededor de la media.

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

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

Permite trabajar con BigQuery DataFrames.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura ADC para 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

Obtén las calificaciones previstas de un subconjunto de pares de usuario y elemento

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

SQL

Usa la función ML.RECOMMEND para obtener calificaciones previstas:

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

Ir a BigQuery

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ía ser similar al siguiente:

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

Permite trabajar con BigQuery DataFrames.

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

Llama a model.predict() para obtener las calificaciones previstas.

# 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

Genera recomendaciones

Usa las calificaciones previstas para generar las cinco películas recomendadas más populares para cada usuario.

SQL

Sigue estos pasos para generar recomendaciones:

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

Ir a BigQuery
Escribe las calificaciones previstas 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`);
```
Une las calificaciones previstas con la información de la película y selecciona los cinco resultados más populares 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ía ser similar al siguiente:

  +---------+-------------------------------------+------------------------+--------------------+
  | 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  |
  +---------+-------------------------------------+------------------------+--------------------+
  | ...     | ...                                 | ...                    | ...                |
  +---------+-------------------------------------+------------------------+--------------------+

Permite trabajar con BigQuery DataFrames.

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

Llama a model.predict() para obtener las calificaciones previstas.

# 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

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

Puedes borrar el proyecto que creaste.
De lo contrario, puedes mantener el proyecto y borrar el conjunto de datos.

Borra tu conjunto de datos

Borrar tu proyecto quita todos sus conjuntos de datos y tablas. Si prefieres volver a usar el proyecto, puedes borrar el conjunto de datos que creaste en este instructivo:

Si es necesario, abre la página de BigQuery en la consola de Google Cloud .

Ir a la página de BigQuery
En el panel de navegación, haz clic en el conjunto de datos bqml_tutorial que creaste.
Haz clic en Borrar conjunto de datos en el lado derecho de la ventana. Esta acción borra el conjunto de datos, la tabla y todos los datos.
En el cuadro de diálogo Borrar conjunto de datos, escribe el nombre del conjunto de datos (bqml_tutorial) para confirmar el comando de borrado y, luego, haz clic en Borrar.

Borra tu proyecto

Para borrar el proyecto, haz lo siguiente:

Precaución: Borrar un proyecto tiene las siguientes consecuencias:

Se borra todo en el proyecto. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.

Si planeas explorar varias infraestructuras, instructivos y guías de inicio rápido la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

¿Qué sigue?

Intenta crear un modelo de factorización de matrices basado en comentarios implícitos.
Para obtener una descripción general de BigQuery ML, consulta Introducción a BigQuery ML.
Para obtener más información sobre el aprendizaje automático, consulta el Curso intensivo de aprendizaje automático.

Crea recomendaciones basadas en comentarios explícitos con un modelo de factorización de matrices Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Objetivos

Costos

Antes de comenzar

Permisos necesarios

Crea un conjunto de datos

Console

bq

API

Permite trabajar con BigQuery DataFrames.

Sube los datos de MovieLens

CLI

Permite trabajar con BigQuery DataFrames.

Crea el modelo

SQL

Permite trabajar con BigQuery DataFrames.

Obtén estadísticas de entrenamiento

Evalúa el modelo

SQL

Permite trabajar con BigQuery DataFrames.

Obtén las calificaciones previstas de un subconjunto de pares de usuario y elemento

SQL

Permite trabajar con BigQuery DataFrames.

Genera recomendaciones

SQL

Permite trabajar con BigQuery DataFrames.

Limpia

Borra tu conjunto de datos

Borra tu proyecto

¿Qué sigue?

Crea recomendaciones basadas en comentarios explícitos con un modelo de factorización de matrices