Questa pagina è stata tradotta dall'API Cloud Translation.

Creare consigli basati su feedback espliciti con un modello di fattorizzazione matriciale

Questo tutorial ti insegna a creare un modello di fattorizzazione matriciale e ad addestrarlo in base alle valutazioni dei film dei clienti nel set di dati movielens1m. Quindi, utilizzi il modello di fattorizzazione matriciale per generare suggerimenti sui film per gli utenti.

L'utilizzo delle valutazioni fornite dai clienti per addestrare il modello è chiamato addestramento con feedback esplicito. I modelli di fattorizzazione della matrice vengono addestrati utilizzando l'algoritmo dei minimi quadrati alternati quando utilizzi il feedback esplicito come dati di addestramento.

Obiettivi

Questo tutorial ti guida nel completamento delle seguenti attività:

Creazione di un modello di fattorizzazione matriciale utilizzando l'istruzione CREATE MODEL.
Valutazione del modello utilizzando la funzione ML.EVALUATE.
Generare consigli sui film per gli utenti utilizzando il modello con la funzione ML.RECOMMEND.

Costi

Questo tutorial utilizza componenti fatturabili di Google Cloud, tra cui:

BigQuery
BigQuery ML

Per ulteriori informazioni sui costi di BigQuery, consulta la pagina Prezzi di BigQuery.

Per ulteriori informazioni sui costi di BigQuery ML, vedi Prezzi di BigQuery ML.

Prima di iniziare

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 viene attivato automaticamente nei nuovi progetti. Per attivare BigQuery in un progetto preesistente, vai a
Enable the BigQuery API.
Enable the API

Autorizzazioni richieste

Per creare il set di dati, devi disporre dell'autorizzazione IAM bigquery.datasets.create.
Per creare il modello, devi disporre delle seguenti autorizzazioni:
- bigquery.jobs.create
- bigquery.models.create
- bigquery.models.getData
- bigquery.models.updateData
Per eseguire l'inferenza, devi disporre delle seguenti autorizzazioni:
- bigquery.models.getData
- bigquery.jobs.create

Per saperne di più sui ruoli e sulle autorizzazioni IAM in BigQuery, consulta Introduzione a IAM.

Crea un set di dati

Crea un set di dati BigQuery per archiviare il tuo modello ML.

Console

Nella console Google Cloud , vai alla pagina BigQuery.

Vai alla pagina BigQuery
Nel riquadro Explorer, fai clic sul nome del progetto.
Fai clic su Visualizza azioni > Crea set di dati.
Nella pagina Crea set di dati:
- In ID set di dati, inserisci bqml_tutorial.
- Per Tipo di località, seleziona Più regioni e poi Stati Uniti (più regioni negli Stati Uniti).
- Lascia invariate le restanti impostazioni predefinite e fai clic su Crea set di dati.

bq

Per creare un nuovo set di dati, utilizza il comando bq mk con il flag --location. Per un elenco completo dei possibili parametri, consulta la documentazione di riferimento del comando bq mk --dataset.

Crea un set di dati denominato bqml_tutorial con la località dei dati impostata su US e una descrizione di BigQuery ML tutorial dataset:
```
bq --location=US mk -d \
 --description "BigQuery ML tutorial dataset." \
 bqml_tutorial
```
Anziché utilizzare il flag --dataset, il comando utilizza la scorciatoia -d. Se ometti -d e --dataset, il comando crea un set di dati per impostazione predefinita.
Verifica che il set di dati sia stato creato:
```
bq ls
```

API

Chiama il metodo datasets.insert con una risorsa dataset definita.

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

BigQuery DataFrames

Prima di provare questo esempio, segui le istruzioni di configurazione di BigQuery DataFrames nella guida rapida di BigQuery che utilizza BigQuery DataFrames. Per ulteriori informazioni, consulta la documentazione di riferimento di BigQuery DataFrames.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, vedi Configurare ADC per un ambiente di sviluppo locale.

import google.cloud.bigquery

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

Carica i dati di MovieLens

Carica i dati movielens1m in BigQuery.

Interfaccia a riga di comando

Segui questi passaggi per caricare i dati movielens1m utilizzando lo strumento a riga di comando bq:

Apri Cloud Shell:

Attiva Cloud Shell

Carica i dati delle valutazioni nella tabella ratings. Nella riga di comando, incolla la seguente query e premi 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

Carica i dati del film nella tabella movies. Nella riga di comando, incolla la seguente query e premi 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

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, vedi Configurare ADC per un ambiente di sviluppo locale.

Innanzitutto, crea un oggetto Client con bqclient = google.cloud.bigquery.Client(), poi carica i dati movielens1m nel set di dati che hai creato nel passaggio precedente.

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 il modello

Crea un modello di fattorizzazione matriciale e addestralo sui dati nella tabella ratings. Il modello viene addestrato per prevedere una valutazione per ogni coppia utente-elemento, in base alle valutazioni dei film fornite dai clienti.

SQL

La seguente istruzione CREATE MODEL utilizza queste colonne per generare consigli:

user_id: l'ID utente.
item_id: l'ID del film.
rating: la valutazione esplicita da 1 a 5 che l'utente ha assegnato all'elemento.

Per creare il modello:

Nella console Google Cloud , vai alla pagina BigQuery.

Vai a BigQuery

Nell'editor di query, incolla la seguente query e fai clic su Esegui:

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

Il completamento della query richiede circa 10 minuti, dopodiché il modello mf_explicit viene visualizzato nel riquadro Explorer. Poiché la query utilizza un'istruzione CREATE MODEL per creare un modello, non vengono visualizzati i risultati della query.

BigQuery DataFrames

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, vedi Configurare ADC per un ambiente di sviluppo locale.

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"
)

Il completamento del codice richiede circa 10 minuti, dopodiché il modello mf_explicit viene visualizzato nel riquadro Explorer.

Visualizzare le statistiche di addestramento

Facoltativamente, puoi visualizzare le statistiche di addestramento del modello nella consoleGoogle Cloud .

Un algoritmo di machine learning crea un modello creando molte iterazioni del modello utilizzando parametri diversi e poi selezionando la versione del modello che riduce al minimo la perdita. Questo processo è chiamato minimizzazione empirica del rischio. Le statistiche di addestramento del modello ti consentono di visualizzare la perdita associata a ogni iterazione del modello.

Per visualizzare le statistiche di addestramento del modello:

Nella console Google Cloud , vai alla pagina BigQuery.

Vai a BigQuery
Nel riquadro Explorer, espandi il progetto, il set di dati bqml_tutorial e la cartella Modelli.
Fai clic sul modello mf_explicit e poi sulla scheda Addestramento.

Nella sezione Visualizza come, fai clic su Tabella. I risultati dovrebbero essere simili ai seguenti:

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

La colonna Perdita di dati di addestramento rappresenta la metrica di perdita calcolata dopo l'addestramento del modello. Poiché si tratta di un modello di fattorizzazione della matrice, questa colonna mostra l'errore quadratico medio.

Puoi anche utilizzare la funzione ML.TRAINING_INFO per visualizzare le statistiche di addestramento del modello.

Valuta il modello

Valuta le prestazioni del modello confrontando le valutazioni dei film previste restituite dal modello con le valutazioni dei film effettive degli utenti provenienti dai dati di addestramento.

SQL

Utilizza la funzione ML.EVALUATE per valutare il modello:

Nella console Google Cloud , vai alla pagina BigQuery.

Vai a BigQuery

Nell'editor di query, incolla la seguente query e fai clic su Esegui:

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

I risultati dovrebbero essere simili ai seguenti:

+---------------------+---------------------+------------------------+-----------------------+--------------------+--------------------+
| 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 metrica importante nei risultati della valutazione è il coefficiente R². Il coefficiente R² è una misura statistica che determina se le previsioni della regressione lineare si avvicinano ai dati effettivi. Un valore pari a 0 indica che il modello non spiega nessuna delle variabilità dei dati di risposta attorno alla media. Un valore di 1 indica che il modello spiega tutte le variabilità dei dati di risposta attorno alla media.

Per saperne di più sull'output della funzione ML.EVALUATE, consulta Modelli di fattorizzazione della matrice.

Puoi anche chiamare ML.EVALUATE senza fornire dati di input. Utilizzerà le metriche di valutazione calcolate durante l'addestramento.

BigQuery DataFrames

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, vedi Configurare ADC per un ambiente di sviluppo locale.

Chiama model.score() per valutare il modello.

# 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

Recuperare le valutazioni previste per un sottoinsieme di coppie utente-articolo

Ottieni la valutazione prevista per ogni film per cinque utenti.

SQL

Utilizza la funzione ML.RECOMMEND per ottenere le valutazioni previste:

Nella console Google Cloud , vai alla pagina BigQuery.

Vai a BigQuery

Nell'editor di query, incolla la seguente query e fai clic su Esegui:

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

I risultati dovrebbero essere simili ai seguenti:

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

BigQuery DataFrames

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, vedi Configurare ADC per un ambiente di sviluppo locale.

Chiama model.predict() per ottenere le valutazioni previste.

# 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 suggerimenti

Utilizza le valutazioni previste per generare i primi cinque film consigliati per ogni utente.

SQL

Per generare i consigli:

Nella console Google Cloud , vai alla pagina BigQuery.

Vai a BigQuery

Scrivi le valutazioni previste in una tabella. Nell'editor di query, incolla la query seguente e fai clic su Esegui:

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

Unisci le valutazioni previste alle informazioni sui film e seleziona i primi cinque risultati per utente. Nell'editor di query, incolla la query seguente e fai clic su Esegui:

  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;

I risultati dovrebbero essere simili ai seguenti:

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

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, vedi Configurare ADC per un ambiente di sviluppo locale.

Chiama model.predict() per ottenere le valutazioni previste.

# 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

Esegui la pulizia

Per evitare che al tuo Account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Puoi eliminare il progetto che hai creato.
In alternativa, puoi conservare il progetto ed eliminare il set di dati.

Eliminare il set di dati

L'eliminazione del progetto rimuove tutti i set di dati e tutte le tabelle nel progetto. Se preferisci riutilizzare il progetto, puoi eliminare il set di dati creato in questo tutorial:

Se necessario, apri la pagina BigQuery nella console Google Cloud .

Vai alla pagina BigQuery
Nella navigazione, fai clic sul set di dati bqml_tutorial che hai creato.
Fai clic su Elimina set di dati sul lato destro della finestra. Questa azione elimina il set di dati, la tabella e tutti i dati.
Nella finestra di dialogo Elimina set di dati, conferma il comando di eliminazione digitando il nome del set di dati (bqml_tutorial) e poi fai clic su Elimina.

Elimina il progetto

Per eliminare il progetto:

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività descritte in questo documento, quando lo elimini, elimini anche tutto il lavoro che hai svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

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.

Passaggi successivi

Prova a creare un modello di fattorizzazione matriciale basato sul feedback implicito.
Per una panoramica di BigQuery ML, consulta Introduzione a BigQuery ML.
Per saperne di più sul machine learning, consulta Machine Learning Crash Course.

Creare consigli basati su feedback espliciti con un modello di fattorizzazione matriciale Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Obiettivi

Costi

Prima di iniziare

Autorizzazioni richieste

Crea un set di dati

Console

bq

API

BigQuery DataFrames

Carica i dati di MovieLens

Interfaccia a riga di comando

BigQuery DataFrames

Crea il modello

SQL

BigQuery DataFrames

Visualizzare le statistiche di addestramento

Valuta il modello

SQL

BigQuery DataFrames

Recuperare le valutazioni previste per un sottoinsieme di coppie utente-articolo

SQL

BigQuery DataFrames

Genera suggerimenti

SQL

BigQuery DataFrames

Esegui la pulizia

Eliminare il set di dati

Elimina il progetto

Passaggi successivi

Creare consigli basati su feedback espliciti con un modello di fattorizzazione matriciale