Esta página foi traduzida pela API Cloud Translation.

Criar recomendações com base em feedback explícito usando um modelo de fatoração de matrizes

Neste tutorial, você vai aprender a criar um modelo de fatoração de matrizes e treiná-lo com as classificações de filmes dos clientes no conjunto de dados movielens1m. Em seguida, use o modelo de fatoração de matrizes para gerar recomendações de filmes para os usuários.

Usar as classificações fornecidas pelos clientes para treinar o modelo é chamado de treinamento com feedback explícito. Os modelos de fatoração de matrizes são treinados usando o algoritmo de mínimos quadrados alternados quando você usa feedback explícito como dados de treinamento.

Objetivos

Este tutorial vai orientar você nas tarefas a seguir:

Como criar um modelo de fatoração de matrizes usando a instrução CREATE MODEL.
Avalie o modelo usando a função ML.EVALUATE.
Gerar recomendações de filmes para usuários usando o modelo com a função ML.RECOMMEND.

Custos

Neste tutorial, usamos componentes faturáveis do Google Cloud, incluindo:

BigQuery
BigQuery ML

Para mais informações sobre os custos do BigQuery, consulte a página de preços do BigQuery.

Para mais informações sobre os custos do BigQuery ML, consulte os preços do BigQuery ML.

Antes de começar

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.

O BigQuery é ativado automaticamente em novos projetos. Para ativar o BigQuery em um projeto preexistente, acesse
Enable the BigQuery API.
Enable the API

Permissões exigidas

Para criar o conjunto de dados, é preciso ter a permissão de IAM bigquery.datasets.create.
Para criar o modelo, você precisa das seguintes permissões:
- bigquery.jobs.create
- bigquery.models.create
- bigquery.models.getData
- bigquery.models.updateData
Para executar a inferência, você precisa das seguintes permissões:
- bigquery.models.getData
- bigquery.jobs.create

Para mais informações sobre os papéis e as permissões do IAM no BigQuery, consulte Introdução ao IAM.

crie um conjunto de dados

Crie um conjunto de dados do BigQuery para armazenar seu modelo de ML.

Console

No console Google Cloud , acesse a página BigQuery.

Acessar a página do BigQuery
No painel Explorer, clique no nome do seu projeto.
Clique em Conferir ações > Criar conjunto de dados.
Na página Criar conjunto de dados, faça o seguinte:
- Para o código do conjunto de dados, insira bqml_tutorial.
- Em Tipo de local, selecione Multirregião e EUA (várias regiões nos Estados Unidos).
- Mantenha as configurações padrão restantes e clique em Criar conjunto de dados.

bq

Para criar um novo conjunto de dados, utilize o comando bq mk com a sinalização --location. Para obter uma lista completa de parâmetros, consulte a referência comando bq mk --dataset.

Crie um conjunto de dados chamado bqml_tutorial com o local dos dados definido como US e uma descrição de BigQuery ML tutorial dataset:
```
bq --location=US mk -d \
 --description "BigQuery ML tutorial dataset." \
 bqml_tutorial
```
Em vez de usar a flag --dataset, o comando usa o atalho -d. Se você omitir -d e --dataset, o comando vai criar um conjunto de dados por padrão.
Confirme se o conjunto de dados foi criado:
```
bq ls
```

API

Chame o método datasets.insert com um recurso de conjunto de dados definido.

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

BigQuery DataFrames

Antes de testar esta amostra, siga as instruções de configuração dos BigQuery DataFrames no Guia de início rápido do BigQuery: como usar os BigQuery DataFrames. Para mais informações, consulte a documentação de referência do BigQuery DataFrames.

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar o ADC para um ambiente de desenvolvimento local.

import google.cloud.bigquery

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

Fazer upload dos dados do MovieLens

Faça o upload dos dados de movielens1m no BigQuery.

CLI

Siga estas etapas para fazer upload dos dados de movielens1m usando a ferramenta de linha de comando bq:

Abra o Cloud Shell:

Ativar o Cloud Shell

Faça upload dos dados de classificação para a tabela ratings. Na linha de comando, cole a seguinte consulta e pressione 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

Faça upload dos dados de filmes para a tabela movies. Na linha de comando, cole a seguinte consulta e pressione 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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar o ADC para um ambiente de desenvolvimento local.

Primeiro, crie um objeto Client com bqclient = google.cloud.bigquery.Client() e carregue os dados movielens1m no conjunto de dados criado na etapa 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()

Criar o modelo

Crie um modelo de fatoração de matrizes e treine-o com os dados da tabela ratings. O modelo é treinado para prever uma classificação para cada par de usuário e item, com base nas classificações de filmes fornecidas pelo cliente.

SQL

A instrução CREATE MODEL a seguir usa essas colunas para gerar recomendações:

user_id: o ID do usuário.
item_id: o ID do filme.
rating: a classificação explícita de 1 a 5 que o usuário deu ao item.

Siga estas etapas para criar o modelo:

No console Google Cloud , acesse a página BigQuery.

Acessar o BigQuery

No Editor de consultas, cole a consulta a seguir e clique em Executar:

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`;

A consulta leva cerca de 10 minutos para ser concluída. Depois disso, o modelo mf_explicit aparece no painel Explorer. Como a consulta usa uma instrução CREATE MODEL para criar um modelo, não é possível ver os resultados dela.

BigQuery DataFrames

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar o ADC para um ambiente de desenvolvimento 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"
)

O código leva cerca de 10 minutos para ser concluído. Depois disso, o modelo mf_explicit aparece no painel Explorer.

Ver estatísticas de treinamento

Se quiser, confira as estatísticas de treinamento do modelo no consoleGoogle Cloud .

Para criar um modelo, um algoritmo de machine learning cria várias iterações dele usando parâmetros diferentes e seleciona a versão que minimiza a perda. Esse processo é chamado de minimização do risco empírico. As estatísticas de treinamento do modelo permitem que você veja a perda associada a cada iteração.

Siga estas etapas para conferir as estatísticas de treinamento do modelo:

No console Google Cloud , acesse a página BigQuery.

Acessar o BigQuery
No painel Explorer, expanda o projeto, o conjunto de dados bqml_tutorial e a pasta Modelos.
Clique no modelo mf_explicit e na guia Treinamento.

Na seção Visualizar como, clique em Tabela. Os resultados devem ficar assim:

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

A coluna Perda de dados de treinamento representa a métrica de perda calculada após o treinamento do modelo. Como esse é um modelo de fatoração de matrizes, essa coluna mostra o erro quadrático médio.

Também é possível usar a função ML.TRAINING_INFO para conferir as estatísticas treinamento de modelo.

Avaliar o modelo

Avalie o desempenho do modelo comparando as classificações de filmes previstas retornadas pelo modelo com as classificações reais de filmes do usuário nos dados de treinamento.

SQL

Use a função ML.EVALUATE para avaliar o modelo:

No console Google Cloud , acesse a página BigQuery.

Acessar o BigQuery

No Editor de consultas, cole a consulta a seguir e clique em Executar:

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

A resposta deve ficar assim:

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

Uma métrica importante nos resultados da avaliação é a pontuação R². A pontuação R² é uma medida estatística que determina se as previsões de regressão linear se aproximam dos dados reais. Um valor 0 indica que o modelo não explica a variabilidade dos dados de resposta em torno da média. Um valor 1 indica que o modelo explica toda a variabilidade dos dados de resposta em torno da média.

Para mais informações sobre a saída da função ML.EVALUATE, consulte Modelos de fatoração de matrizes.

Também é possível chamar ML.EVALUATE sem fornecer os dados de entrada. Ela usará as métricas de avaliação calculadas durante o treinamento.

BigQuery DataFrames

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar o ADC para um ambiente de desenvolvimento local.

Chame model.score() para avaliar o 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

Receber as classificações previstas para um subconjunto de pares de usuário e item

Receba a classificação prevista de cada filme para cinco usuários.

SQL

Use a função ML.RECOMMEND para receber classificações previstas:

No console Google Cloud , acesse a página BigQuery.

Acessar o BigQuery

No Editor de consultas, cole a consulta a seguir e clique em Executar:

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

A resposta deve ficar assim:

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

BigQuery DataFrames

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar o ADC para um ambiente de desenvolvimento local.

Chame model.predict() para receber classificações 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

Gerar recomendações

Use as classificações previstas para gerar os cinco principais filmes recomendados para cada usuário.

SQL

Siga estas etapas para gerar recomendações:

No console Google Cloud , acesse a página BigQuery.

Acessar o BigQuery

Grave as classificações previstas em uma tabela. No editor de consultas, cole a consulta a seguir e clique em Executar:

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

Una as classificações previstas às informações do filme e selecione os cinco principais resultados por usuário. No editor de consultas, cole a consulta a seguir e clique em Executar:

  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;

A resposta deve ficar assim:

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar o ADC para um ambiente de desenvolvimento local.

Chame model.predict() para receber classificações 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

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

exclua o projeto que você criou; ou
Mantenha o projeto e exclua o conjunto de dados.

Excluir o conjunto de dados

A exclusão do seu projeto removerá todos os conjuntos de dados e tabelas no projeto. Caso prefira reutilizá-lo, exclua o conjunto de dados criado neste tutorial:

Se necessário, abra a página do BigQuery no console do Google Cloud .

Acessar a página do BigQuery
Na navegação, clique no conjunto de dados bqml_tutorial criado.
Clique em Excluir conjunto de dados no lado direito da janela. Essa ação exclui o conjunto, a tabela e todos os dados.
Na caixa de diálogo Excluir conjunto de dados, confirme o comando de exclusão digitando o nome do seu conjunto de dados (bqml_tutorial). Em seguida, clique em Excluir.

Excluir o projeto

Para excluir o projeto:

Cuidado: excluir um projeto tem os seguintes efeitos:

Tudo no projeto é excluído. Se você tiver usado um projeto existente para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos no projeto.
Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja passar por várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

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.

A seguir

Tente criar um modelo de fatoração de matrizes com base no feedback implícito.
Para uma visão geral sobre ML do BigQuery, consulte Introdução ao ML do BigQuery.
Para saber mais sobre machine learning, consulte o Curso intensivo de machine learning.

Criar recomendações com base em feedback explícito usando um modelo de fatoração de matrizes Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Objetivos

Custos

Antes de começar

Permissões exigidas

crie um conjunto de dados

Console

bq

API

BigQuery DataFrames

Fazer upload dos dados do MovieLens

CLI

BigQuery DataFrames

Criar o modelo

SQL

BigQuery DataFrames

Ver estatísticas de treinamento

Avaliar o modelo

SQL

BigQuery DataFrames

Receber as classificações previstas para um subconjunto de pares de usuário e item

SQL

BigQuery DataFrames

Gerar recomendações

SQL

BigQuery DataFrames

Limpar

Excluir o conjunto de dados

Excluir o projeto

A seguir

Criar recomendações com base em feedback explícito usando um modelo de fatoração de matrizes