K-Means-Modell zum Clustern des Datasets "London Bicycle Hires" erstellen

---

In dieser Anleitung erfahren Sie, wie Sie mit einem k-means-Modell in BigQuery ML Cluster in einem Datensatz identifizieren.

Der k-Means-Algorithmus, mit dem Ihre Daten in Clustern gruppiert werden, ist eine Form des unüberwachten maschinellen Lernens. Anders als beim überwachten Lernen, bei dem es um vorhersagende Analysen geht, beschäftigt sich das unüberwachte Lernen mit beschreibenden Analysen. Mithilfe von nicht überwachtem maschinellem Lernen können Sie Ihre Daten besser verstehen und so fundierte Entscheidungen treffen.

Die Abfragen in dieser Anleitung verwenden geografische Funktionen, die für die raumbezogene Analyse verfügbar sind. Weitere Informationen finden Sie unter Einführung in raumbezogene Analysen.

In dieser Anleitung wird das öffentliche Dataset zum Fahrradverleih in London verwendet. Außerdem enthalten die Daten Zeitstempel zu Leihbeginn und -ende, Namen von Verleihstationen und Fahrtdauer.

Lernziele

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

• Prüfen Sie die Daten, die zum Trainieren des Modells verwendet wurden.
• Ein k-Means-Clustering-Modell erstellen
• Interpretieren Sie die erstellten Datencluster anhand der Visualisierung der Cluster in BigQuery ML.
• Führen Sie die Funktion ML.PREDICT auf dem K-Means-Modell aus, um den wahrscheinlichen Cluster für eine Reihe von Fahrradstationen vorherzusagen.

Kosten

In dieser Anleitung werden kostenpflichtige Komponenten von Google Cloud verwendet, darunter:

• BigQuery
• BigQuery ML

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

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. Make sure that billing is enabled for your Google Cloud project.

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. Make sure that billing is enabled for your Google Cloud project.

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

   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 der Verbindungsressource benötigen Sie die folgenden Berechtigungen:

  • bigquery.connections.create
  • bigquery.connections.get

• Zum Erstellen des Modells benötigen Sie die folgenden Berechtigungen:

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

• 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, um Ihr K-Means-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 Multiregional und dann EU (mehrere Regionen in der Europäischen Union) aus.

     Das öffentliche Dataset zum Fahrradverleih in London wird in der Multiregion EU gespeichert. Ihr Dataset muss sich am selben Speicherort befinden.

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

     

Trainingsdaten prüfen

Prüfen Sie die Daten, die Sie für das Training des k-means-Modells verwenden. In dieser Anleitung clustern Sie Radstationen anhand der folgenden Attribute:

• Dauer des Verleihs
• Anzahl der Fahrten pro Tag
• Entfernung zum Stadtzentrum

SQL

Diese Abfrage extrahiert Daten zum Fahrradverleih, einschließlich der Spalten start_station_name und duration, und verknüpft diese Daten mit Informationen zu Radstationen. Dazu gehört auch die Erstellung einer berechneten Spalte, die die Entfernung der Station vom Stadtzentrum enthält. Anschließend werden Attribute der Station in einer stationstats-Spalte berechnet, einschließlich der durchschnittlichen Fahrtdauer und der Anzahl der Fahrten, sowie die berechnete distance_from_city_center-Spalte.

So prüfen Sie die Trainingsdaten:

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

   BigQuery aufrufen

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

   WITH
   hs AS (
     SELECT
       h.start_station_name AS station_name,
       IF(
         EXTRACT(DAYOFWEEK FROM h.start_date) = 1
           OR EXTRACT(DAYOFWEEK FROM h.start_date) = 7,
         'weekend',
         'weekday') AS isweekday,
       h.duration,
       ST_DISTANCE(ST_GEOGPOINT(s.longitude, s.latitude), ST_GEOGPOINT(-0.1, 51.5)) / 1000
         AS distance_from_city_center
     FROM
       `bigquery-public-data.london_bicycles.cycle_hire` AS h
     JOIN
       `bigquery-public-data.london_bicycles.cycle_stations` AS s
       ON
         h.start_station_id = s.id
     WHERE
       h.start_date
       BETWEEN CAST('2015-01-01 00:00:00' AS TIMESTAMP)
       AND CAST('2016-01-01 00:00:00' AS TIMESTAMP)
   ),
   stationstats AS (
     SELECT
       station_name,
       isweekday,
       AVG(duration) AS duration,
       COUNT(duration) AS num_trips,
       MAX(distance_from_city_center) AS distance_from_city_center
     FROM
       hs
     GROUP BY
       station_name, isweekday
   )
   SELECT *
   FROM
   stationstats
   ORDER BY
   distance_from_city_center ASC;

Die Antwort sollte in etwa so aussehen:

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 datetime

import pandas as pd

import bigframes
import bigframes.pandas as bpd

bigframes.options.bigquery.project = your_gcp_project_id
# Compute in the EU multi-region to query the London bicycles dataset.
bigframes.options.bigquery.location = "EU"

# Extract the information you'll need to train the k-means model in this
# tutorial. Use the read_gbq function to represent cycle hires
# data as a DataFrame.
h = bpd.read_gbq(
    "bigquery-public-data.london_bicycles.cycle_hire",
    col_order=["start_station_name", "start_station_id", "start_date", "duration"],
).rename(
    columns={
        "start_station_name": "station_name",
        "start_station_id": "station_id",
    }
)

s = bpd.read_gbq(
    # Use ST_GEOPOINT and ST_DISTANCE to analyze geographical
    # data. These functions determine spatial relationships between
    # geographical features.
    """
    SELECT
    id,
    ST_DISTANCE(
        ST_GEOGPOINT(s.longitude, s.latitude),
        ST_GEOGPOINT(-0.1, 51.5)
    ) / 1000 AS distance_from_city_center
    FROM
    `bigquery-public-data.london_bicycles.cycle_stations` s
    """
)

# Define Python datetime objects in the UTC timezone for range comparison,
# because BigQuery stores timestamp data in the UTC timezone.
sample_time = datetime.datetime(2015, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc)
sample_time2 = datetime.datetime(2016, 1, 1, 0, 0, 0, tzinfo=datetime.timezone.utc)

h = h.loc[(h["start_date"] >= sample_time) & (h["start_date"] <= sample_time2)]

# Replace each day-of-the-week number with the corresponding "weekday" or
# "weekend" label by using the Series.map method.
h = h.assign(
    isweekday=h.start_date.dt.dayofweek.map(
        {
            0: "weekday",
            1: "weekday",
            2: "weekday",
            3: "weekday",
            4: "weekday",
            5: "weekend",
            6: "weekend",
        }
    )
)

# Supplement each trip in "h" with the station distance information from
# "s" by merging the two DataFrames by station ID.
merged_df = h.merge(
    right=s,
    how="inner",
    left_on="station_id",
    right_on="id",
)

# Engineer features to cluster the stations. For each station, find the
# average trip duration, number of trips, and distance from city center.
stationstats = merged_df.groupby(["station_name", "isweekday"]).agg(
    {"duration": ["mean", "count"], "distance_from_city_center": "max"}
)
stationstats.columns = pd.Index(
    ["duration", "num_trips", "distance_from_city_center"]
)
stationstats = stationstats.sort_values(
    by="distance_from_city_center", ascending=True
).reset_index()

# Expected output results: >>> stationstats.head(3)
# station_name	isweekday duration  num_trips	distance_from_city_center
# Borough Road...	weekday	    1110	    5749	    0.12624
# Borough Road...	weekend	    2125	    1774	    0.12624
# Webber Street...	weekday	    795	        6517	    0.164021
#   3 rows × 5 columns

k-means-Modell erstellen

Erstellen Sie ein K-Means-Modell mit den Trainingsdaten des Datasets „London Bicycle Hires“.

SQL

In der folgenden Abfrage gibt die CREATE MODEL-Anweisung die Anzahl der Cluster an, die verwendet werden sollen, nämlich vier. In der SELECT-Anweisung schließt die Klausel EXCEPT die Spalte station_name aus, da diese Spalte kein Feature enthält. Mit der Abfrage wird pro „station_name“ eine eindeutige Zeile erstellt und in der SELECT-Anweisung werden nur die Features genannt.

So erstellen Sie ein k-Means-Modell:

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

   BigQuery aufrufen

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

   CREATE OR REPLACE MODEL `bqml_tutorial.london_station_clusters`
   OPTIONS (
     model_type = 'kmeans',
     num_clusters = 4)
   AS
   WITH
   hs AS (
     SELECT
       h.start_station_name AS station_name,
       IF(
         EXTRACT(DAYOFWEEK FROM h.start_date) = 1
           OR EXTRACT(DAYOFWEEK FROM h.start_date) = 7,
         'weekend',
         'weekday') AS isweekday,
       h.duration,
       ST_DISTANCE(ST_GEOGPOINT(s.longitude, s.latitude), ST_GEOGPOINT(-0.1, 51.5)) / 1000
         AS distance_from_city_center
     FROM
       `bigquery-public-data.london_bicycles.cycle_hire` AS h
     JOIN
       `bigquery-public-data.london_bicycles.cycle_stations` AS s
       ON
         h.start_station_id = s.id
     WHERE
       h.start_date
       BETWEEN CAST('2015-01-01 00:00:00' AS TIMESTAMP)
       AND CAST('2016-01-01 00:00:00' AS TIMESTAMP)
   ),
   stationstats AS (
     SELECT
       station_name,
       isweekday,
       AVG(duration) AS duration,
       COUNT(duration) AS num_trips,
       MAX(distance_from_city_center) AS distance_from_city_center
     FROM
       hs
     GROUP BY
       station_name, isweekday
   )
   SELECT *
   EXCEPT (station_name, isweekday)
   FROM
   stationstats;

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.cluster import KMeans

# To determine an optimal number of clusters, construct and fit several
# K-Means objects with different values of num_clusters, find the error
# measure, and pick the point at which the error measure is at its minimum
# value.
cluster_model = KMeans(n_clusters=4)
cluster_model.fit(stationstats)
cluster_model.to_gbq(
    your_model_id,  # For example: "bqml_tutorial.london_station_clusters"
    replace=True,
)

Datencluster interpretieren

Anhand der Informationen auf dem Tab Bewertung des Modells können Sie die vom Modell erstellten Cluster interpretieren.

So rufen Sie die Bewertungsinformationen des Modells auf:

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

   BigQuery aufrufen

2. Maximieren Sie im Bereich Explorer Ihr Projekt, maximieren Sie das Dataset bqml_tutorial und maximieren Sie dann den Ordner Modelle.

3. Wählen Sie das london_station_clusters-Modell aus.

4. Wählen Sie den Tab Bewertung aus. In diesem Tab werden Visualisierungen der durch das k-Means-Modell identifizierten Cluster angezeigt. Im Bereich Numerische Features werden in Balkendiagrammen die wichtigsten numerischen Featurewerte für jeden Schwerpunkt angezeigt. Jeder Centroid steht für einen bestimmten Datencluster. Im Drop-down-Menü können Sie auswählen, welche Features angezeigt werden sollen.

   

   Mit diesem Modell werden die folgenden Centroide erstellt:

   • Centroid 1 ist die weniger ausgelastete Station in der Stadt, mit kürzerer Mietdauer.
   • Centerid 2 zeigt die zweite Station, die weniger ausgelastet ist und für längere Mietzeiten genutzt wird.
   • Centroid 3 zeigt eine belebte Radstation in der Nähe des Stadtzentrums.
   • Centerid 4 zeigt eine Vorstadtstation, deren Fahrten länger sind.

   Wenn Sie ein Fahrradverleihunternehmen leiten würden, könnten Sie diese Informationen für Geschäftsentscheidungen nutzen. Beispiel:

   • Angenommen, Sie müssen eine neue Art Schloss ausprobieren. Welchen Radstations-Cluster sollten Sie für dieses Experiment wählen? Die Stationen in Centroid 1, Centroid 2 oder Centroid 4 scheinen die logische Wahl zu sein, weil sie nicht die am stärksten frequentierten Stationen sind.

   • In einer weiteren Annahme möchten Sie in einigen Radstationen Rennräder bereitstellen. Welche Stationen wären hierfür die richtige Wahl? Centroid 4 ist die Station, die weit vom Stadtzentrum entfernt ist und an der die längsten Fahrten verzeichnet werden. Hier haben Sie Ihre Kandidaten für Rennräder.

Mit der Funktion ML.PREDICT den Cluster einer Radstation vorhersagen

Verwenden Sie die SQL-Funktion ML.PREDICT oder die BigQuery DataFrames-Funktion predict, um den Cluster zu ermitteln, zu dem eine bestimmte Station gehört.

SQL

In der folgenden Abfrage wird die Funktion REGEXP_CONTAINS verwendet, um in der Spalte station_name alle Einträge zu finden, die den String Kennington enthalten. Anhand dieser Werte prognostiziert die Funktion ML.PREDICT, welche Cluster diese Stationen enthalten könnten.

So prognostizieren Sie den Cluster jeder Station, deren Name den String Kennington enthält:

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

   BigQuery aufrufen

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

   WITH
   hs AS (
     SELECT
       h.start_station_name AS station_name,
       IF(
         EXTRACT(DAYOFWEEK FROM h.start_date) = 1
           OR EXTRACT(DAYOFWEEK FROM h.start_date) = 7,
         'weekend',
         'weekday') AS isweekday,
       h.duration,
       ST_DISTANCE(ST_GEOGPOINT(s.longitude, s.latitude), ST_GEOGPOINT(-0.1, 51.5)) / 1000
         AS distance_from_city_center
     FROM
       `bigquery-public-data.london_bicycles.cycle_hire` AS h
     JOIN
       `bigquery-public-data.london_bicycles.cycle_stations` AS s
       ON
         h.start_station_id = s.id
     WHERE
       h.start_date
       BETWEEN CAST('2015-01-01 00:00:00' AS TIMESTAMP)
       AND CAST('2016-01-01 00:00:00' AS TIMESTAMP)
   ),
   stationstats AS (
     SELECT
       station_name,
       isweekday,
       AVG(duration) AS duration,
       COUNT(duration) AS num_trips,
       MAX(distance_from_city_center) AS distance_from_city_center
     FROM
       hs
     GROUP BY
       station_name, isweekday
   )
   SELECT *
   EXCEPT (nearest_centroids_distance)
   FROM
   ML.PREDICT(
     MODEL `bqml_tutorial.london_station_clusters`,
     (
       SELECT *
       FROM
         stationstats
       WHERE
         REGEXP_CONTAINS(station_name, 'Kennington')
     ));

Die Ergebnisse sollten in etwa so aussehen:

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.

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

# Use 'contains' function to filter by stations containing the string
# "Kennington".
stationstats = stationstats.loc[
    stationstats["station_name"].str.contains("Kennington")
]

result = cluster_model.predict(stationstats)

# Expected output results:   >>>results.peek(3)
# CENTROID...	NEAREST...	station_name  isweekday	 duration num_trips dist...
# 	1	[{'CENTROID_ID'...	Borough...	  weekday	  1110	    5749	0.13
# 	2	[{'CENTROID_ID'...	Borough...	  weekend	  2125      1774	0.13
# 	1	[{'CENTROID_ID'...	Webber...	  weekday	  795	    6517	0.16
#   3 rows × 7 columns

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:

1. Rufen Sie, falls erforderlich, die Seite "BigQuery" in der Google Cloud Console auf.

   Zur Seite "BigQuery"

2. Wählen Sie im Navigationsbereich das Dataset bqml_tutorial aus, das Sie erstellt haben.

3. Klicken Sie rechts im Fenster auf Delete dataset (Dataset löschen). Dadurch werden das Dataset und das Modell gelöscht.

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

1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

Nächste Schritte

• Einführung in BigQuery ML
• Weitere Informationen zum Erstellen von Modellen finden Sie auf der Seite zur CREATE MODEL-Syntax