Modelle für maschinelles Lernen in BigQuery ML erstellen

Modelle für maschinelles Lernen in BigQuery ML erstellen

In dieser Anleitung erfahren Sie, wie Sie mithilfe von BigQuery ML in der Google Cloud Console ein logistisches Regressionsmodell erstellen.

Mit BigQuery ML können Sie mithilfe von SQL-Abfragen Modelle für maschinelles Lernen in BigQuery erstellen und trainieren. Dies trägt dazu bei, das maschinelle Lernen besser zugänglich zu machen, da Sie vertraute Tools wie den BigQuery-SQL-Editor verwenden können. Außerdem wird die Entwicklungsgeschwindigkeit erhöht, da Daten nicht in eine separate Umgebung für maschinelles Lernen verschoben werden müssen.

In dieser Anleitung verwenden Sie das Google Analytics-Beispiel-Dataset für BigQuery. Damit erstellen Sie ein Modell, das vorhersagt, ob ein Besucher Ihrer Website eine Transaktion vornehmen wird oder nicht. Informationen zum Schema des Analytics-Datasets finden Sie in der Analytics-Hilfe unter BigQuery-Exportschema.

Lernziele

In dieser Anleitung werden die folgenden Aufgaben erläutert:

• Mit der Anweisung CREATE MODEL ein binäres logistisches Regressionsmodell erstellen
• Die ML.EVALUATE-Funktion zum Bewerten des Modells verwenden.
• Funktion ML.PREDICT verwenden, um mithilfe des Modells Vorhersagen zu treffen.

Kosten

In dieser Anleitung werden kostenpflichtige Komponenten von Google Cloud verwendet, 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.

Hinweis

1. Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

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

   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

3. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

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

   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

5. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

6. BigQuery ist in neuen Projekten automatisch aktiviert. Zum Aktivieren von BigQuery in einem vorhandenen Projekt wechseln Sie zu

   BigQuery API aktivieren.

   Aktivieren Sie die API

   .

Dataset erstellen

Erstellen Sie ein BigQuery-Dataset, um Ihr ML-Modell zu speichern:

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

   Zur Seite „BigQuery“

2. Klicken Sie im Bereich Explorer auf den Namen Ihres Projekts.

3. Klicken Sie auf Aktionen ansehen > Dataset erstellen.

   

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

     Die öffentlichen Datasets sind am multiregionalen Standort US gespeichert. Der Einfachheit halber sollten Sie Ihr Dataset am selben Standort speichern.

   • Übernehmen Sie die verbleibenden Standardeinstellungen unverändert und klicken Sie auf Dataset erstellen.

     

Logistisches Regressionsmodell erstellen

Logistisches Regressionsmodell mit dem Analytics-Beispiel-Dataset für BigQuery erstellen

SQL

1. Öffnen Sie in der Google Cloud Console die Seite BigQuery.

   BigQuery aufrufen

2. Führen Sie im Abfrageeditor folgende Abfrage aus:

   CREATE OR REPLACE MODEL `bqml_tutorial.sample_model`
   OPTIONS(model_type='logistic_reg') AS
   SELECT
   IF(totals.transactions IS NULL, 0, 1) AS label,
   IFNULL(device.operatingSystem, "") AS os,
   device.isMobile AS is_mobile,
   IFNULL(geoNetwork.country, "") AS country,
   IFNULL(totals.pageviews, 0) AS pageviews
   FROM
   `bigquery-public-data.google_analytics_sample.ga_sessions_*`
   WHERE
   _TABLE_SUFFIX BETWEEN '20160801' AND '20170630'
   

   Die Abfrage kann mehrere Minuten dauern. Nachdem der erste Durchlauf abgeschlossen ist, wird das Modell (sample_model) im Navigationsbereich angezeigt. Da die Abfrage eine CREATE MODEL-Anweisung zum Erstellen einer Modells verwendet, werden keine Abfrageergebnisse angezeigt.

Abfragedetails

Die CREATE MODEL-Anweisung erstellt das Modell und trainiert dann das Modell anhand der Daten, die mit der SELECT-Anweisung Ihrer Abfrage abgerufen wurden.

Die Klausel OPTIONS(model_type='logistic_reg') erstellt ein logistisches Regressionsmodell. Ein logistisches Regressionsmodell teilt Eingabedaten in zwei Klassen auf und schätzt dann die Wahrscheinlichkeit, dass die Daten in einer der beiden Klassen enthalten sind. Was Sie zu erkennen versuchen, z. B. ob es sich bei einer E-Mail um eine Spam-E-Mail handelt, wird durch 1 und andere Werte durch 0 dargestellt. Die Wahrscheinlichkeit, dass ein bestimmter Wert zu der Klasse gehört, die Sie erkennen möchten, wird durch einen Wert zwischen 0 und 1 angegeben. Wenn eine E-Mail beispielsweise eine Wahrscheinlichkeitsschätzung von 0,9 erhält, besteht eine Wahrscheinlichkeit von 90 %, dass die E-Mail Spam ist.

Die SELECT-Anweisung dieser Abfrage ruft die folgenden Spalten ab, die vom Modell zur Vorhersage der Wahrscheinlichkeit verwendet werden, mit der ein Kunde eine Transaktion abschließen wird:

• totals.transactions: Gesamtzahl der E-Commerce-Transaktionen während der Sitzung. Wenn die Anzahl der Transaktionen NULL ist, wird der Wert in der Spalte label auf 0 gesetzt. Ansonsten wird er auf 1 gesetzt. Diese Werte repräsentieren die möglichen Ergebnisse. Alternativ zum Festlegen der Option input_label_cols= in der Anweisung CREATE MODEL können Sie einen Alias namens label erstellen.
• device.operatingSystem: Betriebssystem des Geräts des Besuchers
• device.isMobile: Gibt an, ob das Gerät des Besuchers ein Mobilgerät ist.
• geoNetwork.country: Land, aus dem die Sitzungen stammen, basierend auf der IP-Adresse.
• totals.pageviews: Gesamtzahl der Seitenaufrufe innerhalb der Sitzung.

Die FROM-Klausel bewirkt, dass die Abfrage das Modell mithilfe der bigquery-public-data.google_analytics_sample.ga_sessions-Beispieltabellen trainiert. Diese Tabellen sind nach Datum fragmentiert. Sie müssen sie daher mithilfe eines Platzhalters im Tabellennamen aggregieren: google_analytics_sample.ga_sessions_*.

Die WHERE-Klausel (_TABLE_SUFFIX BETWEEN '20160801' AND '20170630') begrenzt die Anzahl der mit der Abfrage gescannten Tabellen. Der Scanzeitraum liegt zwischen dem 1. August 2016 und dem 30. Juni 2017.

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 Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

from bigframes.ml.linear_model import LogisticRegression
import bigframes.pandas as bpd

# Start by selecting the data you'll use for training. `read_gbq` accepts
# either a SQL query or a table ID. Since this example selects from multiple
# tables via a wildcard, use SQL to define this data. Watch issue
# https://github.com/googleapis/python-bigquery-dataframes/issues/169
# for updates to `read_gbq` to support wildcard tables.

df = bpd.read_gbq_table(
    "bigquery-public-data.google_analytics_sample.ga_sessions_*",
    filters=[
        ("_table_suffix", ">=", "20160801"),
        ("_table_suffix", "<=", "20170630"),
    ],
)

# Extract the total number of transactions within
# the Google Analytics session.
#
# Because the totals column is a STRUCT data type, call
# Series.struct.field("transactions") to extract the transactions field.
# See the reference documentation below:
# https://cloud.google.com/python/docs/reference/bigframes/latest/bigframes.operations.structs.StructAccessor#bigframes_operations_structs_StructAccessor_field
transactions = df["totals"].struct.field("transactions")

# The "label" values represent the outcome of the model's
# prediction. In this case, the model predicts if there are any
# ecommerce transactions within the Google Analytics session.
# If the number of transactions is NULL, the value in the label
# column is set to 0. Otherwise, it is set to 1.
label = transactions.notnull().map({True: 1, False: 0}).rename("label")

# Extract the operating system of the visitor's device.
operating_system = df["device"].struct.field("operatingSystem")
operating_system = operating_system.fillna("")

# Extract whether the visitor's device is a mobile device.
is_mobile = df["device"].struct.field("isMobile")

# Extract the country from which the sessions originated, based on the IP address.
country = df["geoNetwork"].struct.field("country").fillna("")

# Extract the total number of page views within the session.
pageviews = df["totals"].struct.field("pageviews").fillna(0)

# Combine all the feature columns into a single DataFrame
# to use as training data.
features = bpd.DataFrame(
    {
        "os": operating_system,
        "is_mobile": is_mobile,
        "country": country,
        "pageviews": pageviews,
    }
)

# Logistic Regression model splits data into two classes, giving the
# a confidence score that the data is in one of the classes.
model = LogisticRegression()
model.fit(features, label)

# The model.fit() call above created a temporary model.
# Use the to_gbq() method to write to a permanent location.
model.to_gbq(
    your_model_id,  # For example: "bqml_tutorial.sample_model",
    replace=True,
)

Verluststatistiken des Modells ansehen

Beim maschinellen Lernen geht es darum, ein Modell zu erstellen, das mithilfe von Daten eine Vorhersage treffen kann. Bei dem Modell handelt es sich im Wesentlichen um eine Funktion, die mithilfe von Eingaben Berechnungen anstellt, um eine Ausgabe, d. h. eine Vorhersage, zu erzeugen.

Maschinelle Lernalgorithmen arbeiten mit mehreren Beispielen, bei denen die Vorhersage bereits bekannt ist (z. B. Verlaufsdaten von Nutzerkäufen). Es werden verschiedene Gewichtungen im Modell iterativ angepasst, sodass die Vorhersagen des Modells den wahren Werten entsprechen. Dies geschieht durch Minimieren der Fehlerwerte, die das Modell verwendet. Diese Werte werden auch als Verlust bezeichnet.

Erwartet wird, dass der Verlust für jeden Durchlauf weniger wird (idealerweise auf null sinkt). Ein Verlust von null bedeutet, dass das Modell zu 100 % genau ist.

Beim Training des Modells teilt BigQuery ML die Eingabedaten automatisch in Trainings- und Bewertungs-Datasets auf, um eine Überanpassung des Modell zu vermeiden. Dies ist erforderlich, damit der Trainingsalgorithmus nicht so genau an die Trainingsdaten angepasst wird. Nur so kann eine Verallgemeinerung neuer Beispiele vermieden werden.

Verwenden Sie die Google Cloud Console, um zu sehen, wie sich der Verlust des Modells während der Trainingsdurchläufe des Modells ändert:

1. Öffnen Sie in der Google Cloud Console die Seite BigQuery.

   BigQuery aufrufen

2. Maximieren Sie im Bereich Explorer bqml_tutorial > Modelle und klicken Sie dann auf sample_model.

3. Klicken Sie auf den Tab Training und sehen Sie sich die Grafik Verlust an. Das Verlustdiagramm zeigt die Änderung des Verlustmesswerts über die Iterationen im Trainings-Dataset hinweg. Wenn Sie den Mauszeiger über die Grafik halten, sehen Sie, dass es Linien für Trainingsverlust und Evaluationsverlust gibt. Da Sie eine logistische Regression durchgeführt haben, wird der Trainingsverlustwert unter Verwendung der Trainingsdaten als logarithmischer Verlust berechnet. Der Bewertungsverlust ist der Logverlust, der anhand der Bewertungsdaten berechnet wurde. Beide Verlusttypen stellen durchschnittliche Verlustwerte dar, die über alle Beispiele in den jeweiligen Datasets pro Iteration gemittelt werden.

Sie können die Ergebnisse des Modelltrainings auch mit der Funktion ML.TRAINING_INFO aufrufen.

Modell bewerten

Bewerten Sie die Leistung des Modells mit der Funktion ML.EVALUATE. Die Funktion ML.EVALUATE wertet die vom Modell generierten vorhergesagten Werte anhand der tatsächlichen Daten aus. Zur Berechnung spezieller Messwerte für logistische Regressionen können Sie Folgendes verwenden:ML.ROC_CURVE SQL-Funktion oderbigframes.ml.metrics.roc_curve BigQuery DataFrames-Funktion “

In dieser Anleitung verwenden Sie ein binäres Klassifizierungsmodell, das Transaktionen erkennt. Die Werte in der Spalte label sind die beiden vom Modell generierten Klassen: 0 (keine Transaktion) und 1 (Transaktion durchgeführt).

SQL

1. Öffnen Sie in der Google Cloud Console die Seite BigQuery.

   BigQuery aufrufen

2. Führen Sie im Abfrageeditor folgende Abfrage aus:

   SELECT
   *
   FROM
   ML.EVALUATE(MODEL `bqml_tutorial.sample_model`, (
   SELECT
   IF(totals.transactions IS NULL, 0, 1) AS label,
   IFNULL(device.operatingSystem, "") AS os,
   device.isMobile AS is_mobile,
   IFNULL(geoNetwork.country, "") AS country,
   IFNULL(totals.pageviews, 0) AS pageviews
   FROM
   `bigquery-public-data.google_analytics_sample.ga_sessions_*`
   WHERE
   _TABLE_SUFFIX BETWEEN '20170701' AND '20170801'))
   

   Die Ergebnisse sollten so aussehen:

     +--------------------+---------------------+---------------------+---------------------+---------------------+--------------------+
     |     precision      |       recall        |      accuracy       |      f1_score       |      log_loss       | roc_auc                   |
     +--------------------+---------------------+---------------------+---------------------+---------------------+--------------------+
     | 0.468503937007874  | 0.11080074487895716 | 0.98534315834767638 | 0.17921686746987953 | 0.04624221101176898    | 0.98174125874125873 |
     +--------------------+---------------------+---------------------+---------------------+---------------------+--------------------+
     

   Da Sie eine logistische Regression durchgeführt haben, enthalten die Ergebnisse die folgenden Spalten:

   • precision: Messwert für Klassifikationsmodelle. Gibt präzise die Häufigkeit an, mit der ein Modell die positive Klasse richtig vorhergesagt hat.

   • recall: Messwert für Klassifizierungsmodelle, der folgende Frage beantwortet: Wie viele der möglichen positiven Labels konnte das Modell richtig identifizieren?

   • accuracy: Anteil der Vorhersagen, die ein Klassifizierungsmodell richtig getroffen hat.

   • f1_score: Maß für die Accuracy des Modells. Der f1-Wert ist der harmonische Mittelwert von Precision und Trefferquote. 1 ist der beste und 0 der schlechteste f1-Wert.

   • log_loss: Die in einer logistischen Regression verwendete Verlustfunktion. Gibt an, wie weit auseinander die Vorhersagen des Modells und die richtigen Labels liegen.

   • roc_auc: Fläche unterhalb der ROC. Gibt an, mit welcher Wahrscheinlichkeit ein Klassifikator davon ausgeht, dass ein zufällig ausgewähltes positives Beispiel tatsächlich positiv ist und ein zufällig ausgewähltes negatives Beispiel positiv ist. Weitere Informationen finden Sie im Machine Learning Crash Course unter Classification.

Abfragedetails

Die anfängliche SELECT-Anweisung ruft die Spalten aus Ihrem Modell ab.

In der FROM-Klausel wird die Funktion ML.EVALUATE für das Modell verwendet.

Die verschachtelte SELECT-Anweisung und die FROM-Klausel sind mit denen in der Abfrage CREATE MODEL identisch.

Die WHERE-Klausel (_TABLE_SUFFIX BETWEEN '20170701' AND '20170801') begrenzt die Anzahl der mit der Abfrage gescannten Tabellen. Der Scanzeitraum liegt zwischen dem 1. Juli 2017 und dem 1. August 2017. Dies sind die Daten, die Sie zum Bewerten der Vorhersageleistung des Modells verwenden. Sie wurden in dem Monat erhoben, der unmittelbar auf den Zeitraum folgte, der durch die Trainingsdaten vorgegeben wurde.

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 Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

import bigframes.pandas as bpd

# Select model you'll use for evaluating. `read_gbq_model` loads model data from a
# BigQuery, but you could also use the `model` object from the previous steps.
model = bpd.read_gbq_model(
    your_model_id,  # For example: "bqml_tutorial.sample_model",
)

# The filters parameter limits the number of tables scanned by the query.
# The date range scanned is July 1, 2017 to August 1, 2017. This is the
# data you're using to evaluate the predictive performance of the model.
# It was collected in the month immediately following the time period
# spanned by the training data.
df = bpd.read_gbq_table(
    "bigquery-public-data.google_analytics_sample.ga_sessions_*",
    filters=[
        ("_table_suffix", ">=", "20170701"),
        ("_table_suffix", "<=", "20170801"),
    ],
)

transactions = df["totals"].struct.field("transactions")
label = transactions.notnull().map({True: 1, False: 0}).rename("label")
operating_system = df["device"].struct.field("operatingSystem")
operating_system = operating_system.fillna("")
is_mobile = df["device"].struct.field("isMobile")
country = df["geoNetwork"].struct.field("country").fillna("")
pageviews = df["totals"].struct.field("pageviews").fillna(0)
features = bpd.DataFrame(
    {
        "os": operating_system,
        "is_mobile": is_mobile,
        "country": country,
        "pageviews": pageviews,
    }
)

# Some models include a convenient .score(X, y) method for evaluation with a preset accuracy metric:

# Because you performed a logistic regression, the results include the following columns:

# - precision — A metric for classification models. Precision identifies the frequency with
# which a model was correct when predicting the positive class.

# - recall — A metric for classification models that answers the following question:
# Out of all the possible positive labels, how many did the model correctly identify?

# - accuracy — Accuracy is the fraction of predictions that a classification model got right.

# - f1_score — A measure of the accuracy of the model. The f1 score is the harmonic average of
# the precision and recall. An f1 score's best value is 1. The worst value is 0.

# - log_loss — The loss function used in a logistic regression. This is the measure of how far the
# model's predictions are from the correct labels.

# - roc_auc — The area under the ROC curve. This is the probability that a classifier is more confident that
# a randomly chosen positive example
# is actually positive than that a randomly chosen negative example is positive. For more information,
# see ['Classification']('https://developers.google.com/machine-learning/crash-course/classification/video-lecture')
# in the Machine Learning Crash Course.

model.score(features, label)
#    precision    recall  accuracy  f1_score  log_loss   roc_auc
# 0   0.412621  0.079143  0.985074  0.132812  0.049764  0.974285
# [1 rows x 6 columns]

Modell verwenden, um Ergebnisse vorherzusagen

Verwenden Sie das Modell, um die Anzahl der Transaktionen von Websitebesuchern je nach Land vorherzusagen.

SQL

1. Öffnen Sie in der Google Cloud Console die Seite BigQuery.

   BigQuery aufrufen

2. Führen Sie im Abfrageeditor folgende Abfrage aus:

   SELECT
   country,
   SUM(predicted_label) as total_predicted_purchases
   FROM
   ML.PREDICT(MODEL `bqml_tutorial.sample_model`, (
   SELECT
   IFNULL(device.operatingSystem, "") AS os,
   device.isMobile AS is_mobile,
   IFNULL(totals.pageviews, 0) AS pageviews,
   IFNULL(geoNetwork.country, "") AS country
   FROM
   `bigquery-public-data.google_analytics_sample.ga_sessions_*`
   WHERE
   _TABLE_SUFFIX BETWEEN '20170701' AND '20170801'))
   GROUP BY country
   ORDER BY total_predicted_purchases DESC
   LIMIT 10
   

   Die Ergebnisse sollten so aussehen:

   +----------------+---------------------------+
   |    country     | total_predicted_purchases |
   +----------------+---------------------------+
   | United States  |                       220 |
   | Taiwan         |                         8 |
   | Canada         |                         7 |
   | India          |                         2 |
   | Turkey         |                         2 |
   | Japan          |                         2 |
   | Italy          |                         1 |
   | Brazil         |                         1 |
   | Singapore      |                         1 |
   | Australia      |                         1 |
   +----------------+---------------------------+
   

Abfragedetails

Die anfängliche SELECT-Anweisung ruft die Spalte country ab und summiert die Spalte predicted_label. Die predicted_label Spalte wird von der ML.PREDICT-Funktion generiert. Wenn Sie die Funktion ML.PREDICT verwenden, lautet der Ausgabespaltenname für das Modell predicted_<label_column_name>. Bei linearen Regressionsmodellen ist predicted_label der geschätzte Wert von label. Bei logistischen Regressionsmodellen ist predicted_label das Label, das den angegebenen Eingabedatenwert am besten beschreibt, entweder 0 oder 1.

Die Funktion ML.PREDICT wird verwendet, um Ergebnisse anhand des Modells vorherzusagen.

Die verschachtelte SELECT-Anweisung und die FROM-Klausel sind mit denen in der Abfrage CREATE MODEL identisch.

Die WHERE-Klausel (_TABLE_SUFFIX BETWEEN '20170701' AND '20170801') begrenzt die Anzahl der mit der Abfrage gescannten Tabellen. Der Scanzeitraum liegt zwischen dem 1. Juli 2017 und dem 1. August 2017. Dies sind die Daten, für die Sie Vorhersagen treffen. Sie wurden in dem Monat erhoben, der unmittelbar auf den Zeitraum folgte, der durch die Trainingsdaten vorgegeben wurde.

Die Klauseln GROUP BY und ORDER BY gruppieren die Ergebnisse nach Land und sortieren sie nach der Summe der vorhergesagten Käufe in absteigender Reihenfolge.

Hier wird die LIMIT-Klausel verwendet, um nur die oberen 10 Ergebnisse darzustellen.

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 Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

import bigframes.pandas as bpd

# Select model you'll use for predicting.
# `read_gbq_model` loads model data from
# BigQuery, but you could also use the `model`
# object from the previous steps.
model = bpd.read_gbq_model(
    your_model_id,  # For example: "bqml_tutorial.sample_model",
)

# The filters parameter limits the number of tables scanned by the query.
# The date range scanned is July 1, 2017 to August 1, 2017. This is the
# data you're using to make the prediction.
# It was collected in the month immediately following the time period
# spanned by the training data.
df = bpd.read_gbq_table(
    "bigquery-public-data.google_analytics_sample.ga_sessions_*",
    filters=[
        ("_table_suffix", ">=", "20170701"),
        ("_table_suffix", "<=", "20170801"),
    ],
)

operating_system = df["device"].struct.field("operatingSystem")
operating_system = operating_system.fillna("")
is_mobile = df["device"].struct.field("isMobile")
country = df["geoNetwork"].struct.field("country").fillna("")
pageviews = df["totals"].struct.field("pageviews").fillna(0)
features = bpd.DataFrame(
    {
        "os": operating_system,
        "is_mobile": is_mobile,
        "country": country,
        "pageviews": pageviews,
    }
)
# Use Logistic Regression predict method to predict results
# using your model.
# Find more information here in
# [BigFrames](https://cloud.google.com/python/docs/reference/bigframes/latest/bigframes.ml.linear_model.LogisticRegression#bigframes_ml_linear_model_LogisticRegression_predict)

predictions = model.predict(features)

# Call groupby method to group predicted_label by country.
# Call sum method to get the total_predicted_label by country.
total_predicted_purchases = predictions.groupby(["country"])[
    ["predicted_label"]
].sum()

# Call the sort_values method with the parameter
# ascending = False to get the highest values.
# Call head method to limit to the 10 highest values.
total_predicted_purchases.sort_values(ascending=False).head(10)

# country
# United States    220
# Taiwan             8
# Canada             7
# India              2
# Japan              2
# Turkey             2
# Australia          1
# Brazil             1
# Germany            1
# Guyana             1
# Name: predicted_label, dtype: Int64

Käufe pro Nutzer vorhersagen

die Anzahl der Transaktionen jedes Websitebesuchers vorhersagen

SQL

Diese Abfrage ist bis auf die Klausel GROUP BY mit der Abfrage im vorherigen Abschnitt identisch. Hier wird die GROUP BY-Klausel (GROUP BY fullVisitorId) verwendet, um die Ergebnisse nach Besucher-ID zu gruppieren.

1. Öffnen Sie in der Google Cloud Console die Seite BigQuery.

   BigQuery aufrufen

2. Führen Sie im Abfrageeditor folgende Abfrage aus:

   SELECT
   fullVisitorId,
   SUM(predicted_label) as total_predicted_purchases
   FROM
   ML.PREDICT(MODEL `bqml_tutorial.sample_model`, (
   SELECT
   IFNULL(device.operatingSystem, "") AS os,
   device.isMobile AS is_mobile,
   IFNULL(totals.pageviews, 0) AS pageviews,
   IFNULL(geoNetwork.country, "") AS country,
   fullVisitorId
   FROM
   `bigquery-public-data.google_analytics_sample.ga_sessions_*`
   WHERE
   _TABLE_SUFFIX BETWEEN '20170701' AND '20170801'))
   GROUP BY fullVisitorId
   ORDER BY total_predicted_purchases DESC
   LIMIT 10
   

   Die Ergebnisse sollten so aussehen:

     +---------------------+---------------------------+
     |    fullVisitorId    | total_predicted_purchases |
     +---------------------+---------------------------+
     | 9417857471295131045 |                         4 |
     | 112288330928895942  |                         2 |
     | 2158257269735455737 |                         2 |
     | 489038402765684003  |                         2 |
     | 057693500927581077  |                         2 |
     | 2969418676126258798 |                         2 |
     | 5073919761051630191 |                         2 |
     | 7420300501523012460 |                         2 |
     | 0456807427403774085 |                         2 |
     | 2105122376016897629 |                         2 |
     +---------------------+---------------------------+
     

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 Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

import bigframes.pandas as bpd

# Select model you'll use for predicting.
# `read_gbq_model` loads model data from
# BigQuery, but you could also use the `model`
# object from the previous steps.
model = bpd.read_gbq_model(
    your_model_id,  # For example: "bqml_tutorial.sample_model",
)

# The filters parameter limits the number of tables scanned by the query.
# The date range scanned is July 1, 2017 to August 1, 2017. This is the
# data you're using to make the prediction.
# It was collected in the month immediately following the time period
# spanned by the training data.
df = bpd.read_gbq_table(
    "bigquery-public-data.google_analytics_sample.ga_sessions_*",
    filters=[
        ("_table_suffix", ">=", "20170701"),
        ("_table_suffix", "<=", "20170801"),
    ],
)

operating_system = df["device"].struct.field("operatingSystem")
operating_system = operating_system.fillna("")
is_mobile = df["device"].struct.field("isMobile")
country = df["geoNetwork"].struct.field("country").fillna("")
pageviews = df["totals"].struct.field("pageviews").fillna(0)
full_visitor_id = df["fullVisitorId"]

features = bpd.DataFrame(
    {
        "os": operating_system,
        "is_mobile": is_mobile,
        "country": country,
        "pageviews": pageviews,
        "fullVisitorId": full_visitor_id,
    }
)

predictions = model.predict(features)

# Call groupby method to group predicted_label by visitor.
# Call sum method to get the total_predicted_label by visitor.
total_predicted_purchases = predictions.groupby(["fullVisitorId"])[
    ["predicted_label"]
].sum()

# Call the sort_values method with the parameter
# ascending = False to get the highest values.
# Call head method to limit to the 10 highest values.
total_predicted_purchases.sort_values(ascending=False).head(10)

# fullVisitorId
# 9417857471295131045    4
# 0376394056092189113    2
# 0456807427403774085    2
# 057693500927581077     2
# 112288330928895942     2
# 1280993661204347450    2
# 2105122376016897629    2
# 2158257269735455737    2
# 2969418676126258798    2
# 489038402765684003     2
# Name: predicted_label, dtype: Int64

Bereinigen

Mit den folgenden Schritten vermeiden Sie, dass Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen in Rechnung gestellt werden:

Sie können das von Ihnen erstellte Projekt löschen oder das Projekt beibehalten 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:

1. Öffnen Sie in der Google Cloud Console die Seite BigQuery.

   BigQuery aufrufen

2. Wählen Sie im Bereich Explorer das von Ihnen erstellte Dataset bqml_tutorial aus.

3. Klicken Sie auf Aktionen > Löschen.

4. Bestätigen Sie im Dialogfeld Dataset löschen den Löschbefehl. Geben Sie dazu delete ein.

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

1. Wechseln Sie in der Google Cloud Console zur Seite Ressourcen verwalten.

   Zur Seite „Ressourcen verwalten“

2. Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
3. Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

Nächste Schritte

• Weitere Informationen über das maschinelle Lernen im Machine Learning Crash Course lesen
• Eine Übersicht über BigQuery ML finden Sie unter Einführung in BigQuery ML.
• Weitere Informationen zur Google Cloud Console finden Sie unter Google Cloud Console verwenden.