Diese Seite wurde von der Cloud Translation API übersetzt.

Empfehlungen basierend auf explizitem Feedback mit einem Matrixfaktorisierungsmodell erstellen

In dieser Anleitung erfahren Sie, wie Sie ein Matrixfaktorisierungsmodell erstellen und es mit den Filmrezensionen der Kunden im Dataset movielens1m trainieren. Anschließend verwenden Sie das Matrixfaktorisierungsmodell, um Filmempfehlungen für Nutzer zu generieren.

Die Verwendung von Kundenbewertungen zum Trainieren des Modells wird als Training mit explizitem Feedback bezeichnet. Matrixfaktorisierungsmodelle werden mit dem Algorithmus der alternierenden kleinsten Quadrate trainiert, wenn Sie explizites Feedback als Trainingsdaten verwenden.

Lernziele

In dieser Anleitung werden Sie durch die folgenden Aufgaben geführt:

Ein Matrixfaktorisierungsmodell mit der CREATE MODEL-Anweisung erstellen.
Bewerten Sie das Modell mit der Funktion ML.EVALUATE.
Generieren von Filmempfehlungen für Nutzer mithilfe des Modells mit der Funktion ML.RECOMMEND.

Kosten

In dieser Anleitung werden kostenpflichtige Komponenten von Google Cloudverwendet, darunter:

BigQuery
BigQuery ML

Weitere Informationen zu den Kosten für BigQuery finden Sie auf der Seite BigQuery-Preise.

Weitere Informationen zu den Kosten für BigQuery ML finden Sie unter BigQuery ML-Preise.

Hinweise

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 ist in neuen Projekten automatisch aktiviert. So aktivieren Sie BigQuery in einem vorhandenen Projekt:
Enable the BigQuery API.
Enable the API

Erforderliche Berechtigungen

Sie benötigen die IAM-Berechtigung bigquery.datasets.create, um das Dataset zu erstellen.
Zum Erstellen des Modells benötigen Sie die folgenden Berechtigungen:
- bigquery.jobs.create
- bigquery.models.create
- bigquery.models.getData
- bigquery.models.updateData
Zum Ausführen von Inferenzen benötigen Sie die folgenden Berechtigungen:
- bigquery.models.getData
- bigquery.jobs.create

Weitere Informationen zu IAM-Rollen und Berechtigungen in BigQuery finden Sie unter Einführung in IAM.

Dataset erstellen

Erstellen Sie ein BigQuery-Dataset zum Speichern Ihres ML-Modells.

Console

Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

Zur Seite "BigQuery"
Klicken Sie im Bereich Explorer auf den Namen Ihres Projekts.
Klicken Sie auf Aktionen ansehen > Dataset erstellen.
Führen Sie auf der Seite Dataset erstellen die folgenden Schritte aus:
- Geben Sie unter Dataset-ID bqml_tutorial ein.
- Wählen Sie als Standorttyp die Option Mehrere Regionen und dann USA (mehrere Regionen in den USA) aus.
- Übernehmen Sie die verbleibenden Standardeinstellungen unverändert und klicken Sie auf Dataset erstellen.

bq

Wenn Sie ein neues Dataset erstellen möchten, verwenden Sie den Befehl bq mk mit dem Flag --location. Eine vollständige Liste der möglichen Parameter finden Sie in der bq mk --dataset-Befehlsreferenz.

Erstellen Sie ein Dataset mit dem Namen bqml_tutorial, wobei der Datenspeicherort auf US und die Beschreibung auf BigQuery ML tutorial dataset festgelegt ist:
```
bq --location=US mk -d \
 --description "BigQuery ML tutorial dataset." \
 bqml_tutorial
```
Anstelle des Flags --dataset verwendet der Befehl die verkürzte Form -d. Wenn Sie -d und --dataset auslassen, wird standardmäßig ein Dataset erstellt.
Prüfen Sie, ob das Dataset erstellt wurde:
```
bq ls
```

API

Rufen Sie die Methode datasets.insert mit einer definierten Dataset-Ressource auf.

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

BigQuery DataFrames

Bevor Sie dieses Beispiel ausprobieren, folgen Sie den Schritten zur Einrichtung von BigQuery DataFrames in der BigQuery-Kurzanleitung: BigQuery DataFrames verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu BigQuery DataFrames.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

import google.cloud.bigquery

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

Movielens-Daten hochladen

Laden Sie die movielens1m-Daten in BigQuery hoch.

Befehlszeile

So laden Sie die movielens1m-Daten mit dem bq-Befehlszeilentool hoch:

Öffnen Sie Cloud Shell:

Cloud Shell aktivieren

Laden Sie die Daten zu den Bewertungen in die Tabelle ratings hoch. Fügen Sie in der Befehlszeile die folgende Abfrage ein und drücken Sie die Enter-Taste:

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

Laden Sie die Filmdaten in die Tabelle movies hoch. Fügen Sie in der Befehlszeile die folgende Abfrage ein und drücken Sie die Enter-Taste:

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

Erstellen Sie zuerst ein Client-Objekt mit bqclient = google.cloud.bigquery.Client() und laden Sie dann die movielens1m-Daten in das Dataset, das Sie im vorherigen Schritt erstellt haben.

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

Modell erstellen

Erstellen Sie ein Matrixfaktorisierungsmodell und trainieren Sie es mit den Daten in der Tabelle ratings. Das Modell wird trainiert, um eine Bewertung für jedes Nutzer/Artikel-Paar auf Grundlage der vom Kunden bereitgestellten Filmbewertungen vorherzusagen.

SQL

Die folgende CREATE MODEL-Anweisung verwendet diese Spalten, um Empfehlungen zu generieren:

user_id: Die Nutzer-ID.
item_id: Die Film-ID.
rating: Die explizite Bewertung von 1 bis 5, die der Nutzer für den Artikel abgegeben hat.

So erstellen Sie das Modell:

Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

BigQuery aufrufen

Fügen Sie die folgende Abfrage in den Abfrageeditor ein und klicken Sie auf Ausführen:

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

Die Abfrage dauert etwa 10 Minuten. Anschließend wird das Modell mf_explicit im Bereich Explorer angezeigt. Da die Abfrage eine CREATE MODEL-Anweisung zum Erstellen eines Modells verwendet, werden keine Abfrageergebnisse ausgegeben.

BigQuery DataFrames

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

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

Die Ausführung des Codes dauert etwa 10 Minuten. Anschließend wird das Modell mf_explicit im Bereich Explorer angezeigt.

Trainingsstatistiken abrufen

Optional können Sie die Trainingsstatistiken des Modells in derGoogle Cloud Console ansehen.

Ein Algorithmus für maschinelles Lernen erstellt ein Modell, indem er viele Iterationen des Modells mit unterschiedlichen Parametern erstellt und dann die Version des Modells auswählt, die den Verlust minimiert. Dieser Vorgang wird als empirische Risikominimierung bezeichnet. Anhand der Trainingsstatistiken des Modells können Sie den Verlust sehen, der mit jeder Iteration des Modells verbunden ist.

So rufen Sie die Trainingsstatistiken des Modells auf:

Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

BigQuery aufrufen
Maximieren Sie im Bereich Explorer Ihr Projekt, maximieren Sie das Dataset bqml_tutorial und maximieren Sie dann den Ordner Modelle.
Klicken Sie auf das mf_explicit-Modell und dann auf den Tab Training.

Klicken Sie im Bereich Anzeigen als auf Tabelle. Die Antwort sollte in etwa so aussehen:

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

Die Spalte Trainingsdatenverlust enthält den Verlustmesswert, der berechnet wird, nachdem das Modell trainiert wurde. Da es sich um ein Matrixfaktorisierungsmodell handelt, wird in dieser Spalte die mittlere quadratische Abweichung angezeigt.

Mit der Funktion ML.TRAINING_INFO können Sie auch Statistiken zum Modelltraining aufrufen.

Modell bewerten

Bewerten Sie die Leistung des Modells, indem Sie die vom Modell zurückgegebenen vorhergesagten Filmbewertungen mit den tatsächlichen Filmbewertungen der Nutzer aus den Trainingsdaten vergleichen.

SQL

Mit der ML.EVALUATE-Funktion das Modell bewerten:

Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

BigQuery aufrufen

Fügen Sie die folgende Abfrage in den Abfrageeditor ein und klicken Sie auf Ausführen:

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

Die Antwort sollte in etwa so aussehen:

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

Ein wichtiger Messwert in den Bewertungsergebnissen ist der R²-Wert. Der R²-Wert ist ein statistisches Maß dafür, ob sich die Vorhersagen der linearen Regression den tatsächlichen Daten annähern. Der Wert 0 gibt an, dass das Modell keine der Abweichungen der Antwortdaten um den Mittelwert erklärt. Der Wert 1 gibt an, dass das Modell alle Abweichungen der Antwortdaten um den Mittelwert erklärt.

Weitere Informationen zur Ausgabe der ML.EVALUATE-Funktion finden Sie unter Matrixfaktorisierungsmodelle.

Sie können ML.EVALUATE auch aufrufen, ohne die Eingabedaten anzugeben. Es werden dann die Bewertungsmesswerte verwendet, die während des Trainings berechnet wurden.

BigQuery DataFrames

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

Rufen Sie model.score() auf, um das Modell zu bewerten.

# 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

Vorhergesagte Bewertungen für eine Teilmenge von Nutzer/Artikel-Paaren abrufen

Die vorhergesagte Bewertung für jeden Film für fünf Nutzer abrufen.

SQL

Mit der ML.RECOMMEND-Funktion lassen sich vorhergesagte Bewertungen abrufen:

Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

BigQuery aufrufen

Fügen Sie die folgende Abfrage in den Abfrageeditor ein und klicken Sie auf Ausführen:

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

Die Antwort sollte in etwa so aussehen:

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

BigQuery DataFrames

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

Rufen Sie model.predict() auf, um die vorhergesagten Bewertungen abzurufen.

# 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

Empfehlungen generieren

Verwenden Sie die vorhergesagten Bewertungen, um die fünf am häufigsten empfohlenen Filme für jeden Nutzer zu generieren.

SQL

So generieren Sie Empfehlungen:

Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

BigQuery aufrufen
Schreiben Sie die vorhergesagten Bewertungen in eine Tabelle. Fügen Sie die folgende Abfrage in den Abfrageeditor ein und klicken Sie auf Ausführen:
```
CREATE OR REPLACE TABLE `bqml_tutorial.recommend`
AS
SELECT
*
FROM
ML.RECOMMEND(MODEL `bqml_tutorial.mf_explicit`);
```
Verknüpfen Sie die vorhergesagten Bewertungen mit den Filminformationen und wählen Sie die fünf besten Ergebnisse pro Nutzer aus. Fügen Sie die folgende Abfrage in den Abfrageeditor ein und klicken Sie auf Ausführen:

  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;

Die Antwort sollte in etwa so aussehen:

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter ADC für eine lokale Entwicklungsumgebung einrichten.

Rufen Sie model.predict() auf, um die vorhergesagten Bewertungen abzurufen.

# 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

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

Sie können das von Ihnen erstellte Projekt löschen.
Sie können das Projekt aber auch behalten und das Dataset löschen.

Dataset löschen

Wenn Sie Ihr Projekt löschen, werden alle Datasets und Tabellen entfernt. Wenn Sie das Projekt wieder verwenden möchten, können Sie das in dieser Anleitung erstellte Dataset löschen:

Rufen Sie, falls erforderlich, die Seite „BigQuery“ in der Google Cloud Console auf.

Zur Seite "BigQuery"
Wählen Sie im Navigationsbereich das Dataset bqml_tutorial aus, das Sie erstellt haben.
Klicken Sie rechts im Fenster auf Delete dataset (Dataset löschen). Dadurch werden das Dataset, die Tabelle und alle Daten gelöscht.
Bestätigen Sie im Dialogfeld Dataset löschen den Löschbefehl. Geben Sie dazu den Namen des Datasets (bqml_tutorial) ein und klicken Sie auf Löschen.

Projekt löschen

So löschen Sie das Projekt:

Achtung: Das Löschen von Projekten hat folgende Auswirkungen:

Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, z. B. eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, statt das gesamte Projekt.

Wenn Sie mehrere Architekturen, Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, indem Sie Projekte wiederverwenden.

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.

Nächste Schritte

Erstellen Sie ein Matrixfaktorisierungsmodell basierend auf implizitem Feedback.
Einführung in BigQuery ML
Mehr über maschinelles Lernen im Machine Learning Crash Course erfahren

Empfehlungen basierend auf explizitem Feedback mit einem Matrixfaktorisierungsmodell erstellen Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Lernziele

Kosten

Hinweise

Erforderliche Berechtigungen

Dataset erstellen

Console

bq

API

BigQuery DataFrames

Movielens-Daten hochladen

Befehlszeile

BigQuery DataFrames

Modell erstellen

SQL

BigQuery DataFrames

Trainingsstatistiken abrufen

Modell bewerten

SQL

BigQuery DataFrames

Vorhergesagte Bewertungen für eine Teilmenge von Nutzer/Artikel-Paaren abrufen

SQL

BigQuery DataFrames

Empfehlungen generieren

SQL

BigQuery DataFrames

Bereinigen

Dataset löschen

Projekt löschen

Nächste Schritte

Empfehlungen basierend auf explizitem Feedback mit einem Matrixfaktorisierungsmodell erstellen