Créer des recommandations basées sur des commentaires explicites avec un modèle de factorisation matricielle

Ce tutoriel vous explique comment créer un modèle de factorisation matricielle et l'entraîner sur les notes de films des clients dans l'ensemble de données movielens1m. Vous utilisez ensuite le modèle de factorisation matricielle pour générer des recommandations de films pour les utilisateurs.

L'entraînement du modèle à l'aide des notes fournies par les clients est appelé entraînement avec commentaires explicites. Les modèles de factorisation matricielle sont entraînés à l'aide de l'algorithme des moindres carrés alternés lorsque vous utilisez des commentaires explicites comme données d'entraînement.

Important : Vous devez disposer d'une réservation pour utiliser un modèle de factorisation matricielle. Pour en savoir plus, reportez-vous à la page Tarification.

Objectifs

Ce tutoriel vous guide à travers les tâches suivantes :

• Créez un modèle de factorisation matricielle à l'aide de l'instruction CREATE MODEL.
• Évaluer le modèle à l'aide de la fonction ML.EVALUATE
• Générez des recommandations de films pour les utilisateurs à l'aide du modèle avec la fonction ML.RECOMMEND.

Coûts

Ce tutoriel fait appel à des composants payants de Google Cloud, y compris ceux-ci :

• BigQuery
• BigQuery ML

Pour en savoir plus sur le coût de BigQuery, consultez la page Tarifs de BigQuery.

Pour en savoir plus sur les coûts associés à BigQuery ML, consultez la page Tarifs de BigQuery ML.

Avant de commencer

Connectez-vous à votre compte Google Cloud . Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $de crédits sans frais pour exécuter, tester et déployer des charges de travail.

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

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

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

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

1. BigQuery est automatiquement activé dans les nouveaux projets. Pour activer BigQuery dans un projet préexistant, accédez à

   Activez l'API BigQuery.

   Rôles requis pour activer les API

   Pour activer les API, vous avez besoin du rôle IAM Administrateur Service Usage (roles/serviceusage.serviceUsageAdmin), qui contient l'autorisation serviceusage.services.enable. Découvrez comment attribuer des rôles.

   Activer l'API

Autorisations requises

• Pour créer l'ensemble de données, vous devez disposer de l'autorisation IAM bigquery.datasets.create.

• Pour créer le modèle, vous avez besoin des autorisations suivantes :

  • bigquery.jobs.create
  • bigquery.models.create
  • bigquery.models.getData
  • bigquery.models.updateData

• Pour exécuter une inférence, vous devez disposer des autorisations suivantes :

  • bigquery.models.getData
  • bigquery.jobs.create

Pour plus d'informations sur les rôles et les autorisations IAM dans BigQuery, consultez la page Présentation d'IAM.

Créer un ensemble de données

Créez un ensemble de données BigQuery pour stocker votre modèle de ML.

Console

1. Dans la console Google Cloud , accédez à la page BigQuery.

   Accéder à la page "BigQuery"

2. Dans le volet Explorateur, cliquez sur le nom de votre projet.

3. Cliquez sur Afficher les actions > Créer un ensemble de données.

4. Sur la page Créer un ensemble de données, procédez comme suit :

   • Dans le champ ID de l'ensemble de données, saisissez bqml_tutorial.

   • Pour Type d'emplacement, sélectionnez Multirégional, puis États-Unis.

   • Conservez les autres paramètres par défaut, puis cliquez sur Créer un ensemble de données.

bq

Pour créer un ensemble de données, utilisez la commande bq mk --dataset.

1. Créez un ensemble de données nommé bqml_tutorial et définissez l'emplacement des données sur US.

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

2. Vérifiez que l'ensemble de données a été créé :

   bq ls

API

Appelez la méthode datasets.insert avec une ressource d'ensemble de données définie.

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

BigQuery DataFrames

Avant d'essayer cet exemple, suivez les instructions de configuration pour BigQuery DataFrames du guide de démarrage rapide de BigQuery DataFrames. Pour en savoir plus, consultez la documentation de référence sur BigQuery DataFrames.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer les ADC pour un environnement de développement local.

import google.cloud.bigquery

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

Importer les données Movielens

Importez les données movielens1m dans BigQuery.

CLI

Suivez ces étapes pour importer les données movielens1m à l'aide de l'outil de ligne de commande bq :

1. Ouvrez Cloud Shell.

   Activer Cloud Shell

2. Importez les données de notation dans la table ratings. Dans la ligne de commande, collez la requête suivante et appuyez sur 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. Importez les données de films dans la table movies. Dans la ligne de commande, collez la requête suivante et appuyez sur 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

Avant d'essayer cet exemple, suivez les instructions de configuration pour BigQuery DataFrames du guide de démarrage rapide de BigQuery DataFrames. Pour en savoir plus, consultez la documentation de référence sur BigQuery DataFrames.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer les ADC pour un environnement de développement local.

Tout d'abord, créez un objet Client avec bqclient = google.cloud.bigquery.Client(), puis chargez les données movielens1m dans l'ensemble de données que vous avez créé à l'étape précédente.

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

Créer le modèle

Créez un modèle de factorisation matricielle et entraînez-le sur les données de la table ratings. Le modèle est entraîné à prédire une note pour chaque paire utilisateur-élément, en fonction des notes de films fournies par les clients.

SQL

L'instruction CREATE MODEL suivante utilise ces colonnes pour générer des recommandations :

• user_id : ID utilisateur.
• item_id : ID du film
• rating : note explicite de 1 à 5 attribuée par l'utilisateur à l'élément.

Pour créer le modèle, procédez comme suit :

1. Dans la console Google Cloud , accédez à la page BigQuery.

   Accéder à BigQuery

2. Dans l'éditeur de requête, collez la requête suivante, puis cliquez sur Exécuter :

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

   L'exécution de la requête prend environ 10 minutes, après quoi le modèle mf_explicit apparaît dans le volet Explorateur. Étant donné que la requête utilise une instruction CREATE MODEL pour créer un modèle, les résultats de la requête ne sont pas affichés.

BigQuery DataFrames

Avant d'essayer cet exemple, suivez les instructions de configuration pour BigQuery DataFrames du guide de démarrage rapide de BigQuery DataFrames. Pour en savoir plus, consultez la documentation de référence sur BigQuery DataFrames.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer les ADC pour un environnement de développement 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"
)

L'exécution du code prend environ 10 minutes, après quoi le modèle mf_explicit apparaît dans le volet Explorateur.

Obtenir des statistiques d'entraînement

Si vous le souhaitez, vous pouvez afficher les statistiques d'entraînement du modèle dans la consoleGoogle Cloud .

Pour créer un modèle, un algorithme de machine learning crée de nombreuses itérations du modèle à l'aide de différents paramètres, puis sélectionne la version du modèle qui minimise la perte. Ce processus est appelé minimisation du risque empirique. Les statistiques d'entraînement du modèle vous permettent de voir la perte associée à chaque itération du modèle.

Pour afficher les statistiques d'entraînement du modèle, procédez comme suit :

1. Dans la console Google Cloud , accédez à la page BigQuery.

   Accéder à BigQuery

2. Dans le volet de gauche, cliquez sur Explorateur :

   

   Si le volet de gauche n'apparaît pas, cliquez sur Développer le volet de gauche pour l'ouvrir.

3. Dans le volet Explorateur, développez votre projet, cliquez sur Ensembles de données, puis sur l'ensemble de données bqml_tutorial.

4. Cliquez sur l'onglet Modèles.

5. Cliquez sur le modèle mf_explicit, puis sur l'onglet Entraînement.

6. Dans la section Afficher sous la forme, cliquez sur Tableau. Le résultat doit ressembler à ce qui suit :

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

   La colonne Training Data Loss (Perte de données d'entraînement) représente la métrique de perte calculée après entraînement du modèle. Étant donné qu'il s'agit d'un modèle de factorisation matricielle, cette colonne affiche l'erreur quadratique moyenne.

Vous pouvez également utiliser la fonction ML.TRAINING_INFO pour afficher les statistiques d'entraînement du modèle.

Évaluer le modèle

Évaluez les performances du modèle en comparant les notes de films prédites renvoyées par le modèle aux notes de films réelles des utilisateurs issues des données d'entraînement.

SQL

Utilisez la fonction ML.EVALUATE pour évaluer le modèle :

1. Dans la console Google Cloud , accédez à la page BigQuery.

   Accéder à BigQuery

2. Dans l'éditeur de requête, collez la requête suivante, puis cliquez sur Exécuter :

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

   Le résultat doit ressembler à ce qui suit :

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

   Le score R² est une métrique importante dans les résultats de l'évaluation. Le score R² est une mesure statistique qui détermine si les prédictions de régression linéaire se rapprochent des données réelles. Une valeur 0 indique que le modèle n'apporte aucune explication sur la variabilité des données de réponse autour de la moyenne. Une valeur 1 indique que le modèle explique toute la variabilité des données de réponse autour de la moyenne.

   Pour en savoir plus sur la sortie de la fonction ML.EVALUATE, consultez Sortie.

Vous pouvez également appeler ML.EVALUATE sans fournir de données d'entrée. Les métriques d'évaluation calculées au cours de l'entraînement seront alors utilisées.

BigQuery DataFrames

Avant d'essayer cet exemple, suivez les instructions de configuration pour BigQuery DataFrames du guide de démarrage rapide de BigQuery DataFrames. Pour en savoir plus, consultez la documentation de référence sur BigQuery DataFrames.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer les ADC pour un environnement de développement local.

Appelez model.score() pour évaluer le modèle.

# 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

Obtenir les notes prédites pour un sous-ensemble de paires utilisateur-élément

Obtenez la note prédite pour chaque film pour cinq utilisateurs.

SQL

Utilisez la fonction ML.RECOMMEND pour obtenir les notes prédites :

1. Dans la console Google Cloud , accédez à la page BigQuery.

   Accéder à BigQuery

2. Dans l'éditeur de requête, collez la requête suivante, puis cliquez sur Exécuter :

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

   Le résultat doit ressembler à ce qui suit :

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

BigQuery DataFrames

Avant d'essayer cet exemple, suivez les instructions de configuration pour BigQuery DataFrames du guide de démarrage rapide de BigQuery DataFrames. Pour en savoir plus, consultez la documentation de référence sur BigQuery DataFrames.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer les ADC pour un environnement de développement local.

Appelez model.predict() pour obtenir les notes prédites.

# 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

Générer des recommandations

Utilisez les notes prédites pour générer les cinq films les plus recommandés pour chaque utilisateur.

SQL

Pour générer des recommandations, procédez comme suit :

1. Dans la console Google Cloud , accédez à la page BigQuery.

   Accéder à BigQuery

2. Écrivez les notes prédites dans un tableau. Dans l'éditeur de requête, collez la requête suivante, puis cliquez sur Exécuter :

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

3. Associez les notes prédites aux informations sur les films, puis sélectionnez les cinq meilleurs résultats par utilisateur. Dans l'éditeur de requête, collez la requête suivante, puis cliquez sur Exécuter :

  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;

Le résultat doit ressembler à ce qui suit :

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

Avant d'essayer cet exemple, suivez les instructions de configuration pour BigQuery DataFrames du guide de démarrage rapide de BigQuery DataFrames. Pour en savoir plus, consultez la documentation de référence sur BigQuery DataFrames.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer les ADC pour un environnement de développement local.

Appelez model.predict() pour obtenir les notes prédites.

# 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

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

• Supprimez le projet que vous avez créé.
• Ou conservez le projet et supprimez l'ensemble de données.

Supprimer l'ensemble de données

Si vous supprimez votre projet, tous les ensembles de données et toutes les tables qui lui sont associés sont également supprimés. Si vous préférez réutiliser le projet, vous pouvez supprimer l'ensemble de données que vous avez créé dans ce tutoriel :

1. Si nécessaire, ouvrez la page BigQuery dans la console Google Cloud .

   Accéder à la page "BigQuery"

2. Dans le panneau de navigation, cliquez sur l'ensemble de données bqml_tutorial que vous avez créé.

3. Cliquez sur Delete dataset (Supprimer l'ensemble de données) dans la partie droite de la fenêtre. Cette action supprime l'ensemble de données, la table et toutes les données.

4. Dans la boîte de dialogue Supprimer l'ensemble de données, confirmez la commande de suppression en saisissant le nom de votre ensemble de données (bqml_tutorial), puis cliquez sur Supprimer.

Supprimer votre projet

Pour supprimer le projet :

Attention : La suppression d'un projet aura les effets suivants :

• Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
• Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

1. Dans la console Google Cloud , accédez à la page Gérer les ressources.

   Accéder à la page "Gérer les ressources"

2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Étapes suivantes

• Essayez de créer un modèle de factorisation matricielle basé sur des commentaires implicites.
• Pour obtenir plus d'informations sur BigQuery ML, consultez la page Présentation de BigQuery ML.
• Pour en savoir plus sur le machine learning, consultez le Cours d'initiation au Machine Learning.