k-means-Clustering-Modell zur Marktsegmentierung mithilfe von BigQuery ML erstellen

Im Folgenden wird gezeigt, wie Sie Google Analytics 360-Zielgruppendaten für Marketingzwecke segmentieren und dafür k-means-Cluster mit BigQuery ML erstellen.

Übersicht

Eine gängige Problemstellung für Marketinganalysen besteht darin, Merkmale im Nutzerverhalten zu ermitteln, mit denen sich Kundenprofile oder -identitäten erstellen lassen. Mithilfe dieser Profile können Marketingkampagnen mit zusätzlichem Wissen über Kunden ausgestattet werden.

Um auf schnelle Weise anhand Ihrer Daten Kundensegmente zu entwickeln, steht eine Methode namens „Clustering“ zur Verfügung. Mithilfe von Clustering lassen sich Kunden mit ähnlichem Verhalten gruppieren und daraus unterschiedliche Zielgruppen für das Marketing ableiten. Sie können damit Ihre Aktivitäten zur Akquisition von Kunden stärker personalisieren und Anzeigen sowie andere Kommunikationsmaßnahmen gezielt an diesen ausrichten. Als Grundlage dienen dabei die Präferenzen und Verhaltensweisen, die den Cluster charakterisieren, zu dem die Kunden jeweils gehören.

In dieser Anleitung erfahren Sie, wie Sie Kundencluster mit einem k-means-Modell in BigQuery ML erstellen. Sie trainieren dafür das Modell mit Beispieldaten von Kunden, die aus Transaktions- und demografischen Informationen bestehen. Das Modell generiert dann Informationen zu den Kundenclustern, die es aus diesen Daten ermittelt. Anschließend rufen Sie aus dem Modell Vorhersagen ab, mit denen Sie jeden Kunden auf Basis seiner demografischen Daten und seines Transaktionsverlaufs seinem jeweiligen Cluster zuweisen können. Nachdem Sie die Kunden den jeweiligen Clustern zugewiesen haben, senden Sie die aktualisierten Kundendaten zurück zu Google Analytics 360, um sie für die Marketingaktivitäten zu verwenden.

Diese Anleitung zeigt, wie Sie eine nutzerverwaltete Notebookinstanz von Vertex AI Workbench erstellen, um diese Schritte auszuführen. Dazu wird eine präskriptive Schritt-für-Schritt-Vorgehensweise angegeben. Wenn Sie stattdessen mit einem vorhandenen Notebook starten möchten, können Sie dafür das Notebook How-y building k-means Clustering for market segmentation using BigQuery ML auf dem Notebookserver Ihrer Wahl verwenden.

Diese Anleitung richtet sich an Data Engineers, Data Scientists und Datenanalysten, die ML-Datasets und -Modelle zur Unterstützung von Geschäftsentscheidungen erstellen. Es wird dabei davon ausgegangen, dass Sie über Grundkenntnisse zu folgenden Themen verfügen:

  • Konzepte für maschinelles Lernen
  • Python
  • Standard-SQL

Wie funktionieren Clustering-Algorithmen?

Clustering ist eine Art nicht überwachtes maschinelles Lernen. Sie verwenden dafür einen Algorithmus, in diesem Fall für ein k-means-Clustering, um zu ermitteln, wie sich Daten logisch gruppieren lassen. Der Algorithmus wertet die Trainingsdaten auf Ähnlichkeiten aus und gruppiert sie auf dieser Basis, also nicht anhand eines von Menschen bereitgestellten Labels. Angenommen, Sie möchten Ihre Kunden nach Alter und geschätztem Einkommen gruppieren. Mithilfe des Clusterings können Sie ermitteln, wie viele Cluster innerhalb Ihrer Daten gemäß dieser Attribute vorhanden sind. Clustering ist auf den ersten Blick ein einfacher Vorgang, wenn man nur ein oder zwei Kundenattribute in Betracht zieht. Für eine manuelle Ausführung kann es aber zu komplex werden, wenn mehr Kundenattribute berücksichtigt werden müssen.

Ein wichtiger Aspekt beim Clustering ist die Ermittlung, ob die „richtige“ Anzahl an Clustern vorliegt. In dieser Anleitung erfahren Sie, wie Sie das Modell verbessern, nachdem Sie eine erste Version erstellt haben. Am Ende erhalten Sie ein Modell, mit dem eine geeignete Anzahl an Clustern für Ihren Anwendungsfall erstellt wird.

Dataset

In dieser Anleitung wird das Google Analytics-Beispiel-Dataset verwendet, das öffentlich in BigQuery gehostet wird. Dieses Dataset bietet verschleierte Analytics 360-Daten aus einem Zeitraum von zwölf Monaten (August 2016 bis August 2017). Die Daten stammen aus dem Google Merchandise Store, einem realen E-Commerce-Shop, in dem Merchandise-Artikel von Google verkauft werden.

Wenn Sie eigene Analytics 360-Daten haben, können Sie stattdessen auch diese verwenden. Die Anleitung enthält entsprechende Informationen, wenn für einen solchen Fall die Schritte abweichen.

Ziele

  • Kundendaten verarbeiten, damit sie für das Erstellen eines k-means-Clustering-Modells im richtigen Format vorliegen
  • k-means-Modell mithilfe von BigQuery ML erstellen, trainieren und bereitstellen
  • Für das Modell Iterationen ausführen, um eine Version zu entwickeln, die die optimale Anzahl von Clustern erstellt
  • Die vom Modell generierten Cluster analysieren, um zu ermitteln, welche Art von Kundensegmenten damit erstellt werden
  • Vorhersagen aus dem bereitgestellten Modell abrufen, um Kunden den entsprechenden Clustern zuzuweisen
  • Aktualisierte Kundendaten aus BigQuery exportieren, damit Sie in Analytics 360 für Marketingaktivitäten verwenden werden können

Kosten

In dieser Anleitung werden die folgenden kostenpflichtigen Komponenten von Google Cloud verwendet:

  • AI Platform
  • BigQuery
  • BigQuery ML

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

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. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

  3. Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für ein Projekt aktiviert ist.

  4. Notebooks and Compute Engine APIs aktivieren.

    Aktivieren Sie die APIs

  5. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

  6. Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für ein Projekt aktiviert ist.

  7. Notebooks and Compute Engine APIs aktivieren.

    Aktivieren Sie die APIs

Nach Abschluss dieser Anleitung können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Notebook erstellen

  1. Rufen Sie in der Google Cloud Console die Seite Notebooks auf.

    Zu "Notebooks"

  2. Klicken Sie auf dem Tab Nutzerverwaltete Notebooks auf  Neues Notebook.

  3. Wählen Sie Python 3 aus.

  4. Geben Sie für Instanzname kmeans ein.

  5. Klicken Sie auf Erstellen. Das Anlegen der Notebook-Instanz dauert einige Minuten.

  6. Klicken Sie, sobald die Instanz verfügbar ist, auf JupyterLab öffnen.

  7. Klicken Sie in JupyterLab Launcher im Abschnitt Notebook auf Python 3.

Bibliotheken installieren

Installieren Sie die für diese Anleitung erforderlichen Bibliotheken.

  1. Kopieren Sie folgenden Code in die erste Zelle des Notebooks:

    # Install libraries.
    !pip install pandas-gbq
    !pip install google-cloud-bigquery
    !pip install google-cloud-bigquery-storage
    # Needed to setup flex slots for flat-rate pricing
    !pip install google-cloud-bigquery-reservation
    
    # Automatically restart kernel after installs
    import IPython
    app = IPython.Application.instance()
    app.kernel.do_shutdown(True)
    
  2. Klicken Sie in der Menüleiste auf Ausführen.

Pakete importieren

Installieren Sie die für diese Anleitung erforderlichen Pakete. Kopieren Sie dazu den folgenden Code in die nächste leere Zelle des Notebooks und führen Sie ihn aus:

from google.cloud import bigquery
import numpy as np
import pandas as pd
import pandas_gbq
import matplotlib.pyplot as plt

# used to display float format
pd.set_option('display.float_format', lambda x: '%.3f' % x)

BigQuery-Client erstellen

Erstellen Sie einen BigQuery-Client für die Python-Clientbibliothek für BigQuery. Kopieren Sie dazu den folgenden Code in die nächste leere Zelle des Notebooks und führen Sie ihn aus. Ersetzen Sie myProject durch die ID des Projekts, das Sie für diese Anleitung verwenden.

client = bigquery.Client(project="myProject")

Daten verarbeiten

In diesem Abschnitt bereiten Sie die Daten vor, die Sie zum Trainieren des k-means-Modells benötigen. Zur Vorbereitung der Daten gehören das Zusammenführen von Kundentransaktionsdaten aus Analytics 360, das Generieren von demografischen Beispielkundendaten sowie das Verknüpfen dieser beiden Datasets zum Erstellen des Trainings-Datasets.

In dieser Anleitung verwenden Sie die Google Analytics-Beispieldaten. In einer Produktionsumgebung können Sie dann Ihre eigenen Analytics 360-Daten nutzen.

BigQuery-Dataset erstellen

Erstellen Sie ein BigQuery-Dataset, das die Kundendaten und das k-means-Modell enthält. Kopieren Sie dazu den folgenden Code in die nächste leere Zelle des Notebooks und führen Sie ihn aus:

! bq mk myProject:kmeans

Aggregierte Transaktionsdaten

In diesem Abschnitt führen Sie Kundentransaktionsdaten aus dem Analytics 360-Beispiel-Dataset zusammen. Die aggregierten Daten ergeben ein klareres Bild davon, wie oft Kunden Artikel kaufen, welche Arten von Artikeln sie kaufen und wie viel sie dabei ausgeben.

In dieser Anleitung wird von einem Kauf ausgegangen, wenn für den Seitentyp (pagetype) „EVENT“ gilt. In einer Produktionsumgebung können Sie abhängig von Ihrer Analytics 360-Konfiguration Käufe auch auf andere Weise ermitteln.

In der Anleitung wird außerdem fullVisitorID als Schlüssel für die Kundendaten verwendet. In einer Produktionsumgebung müssen Sie in dieser und in nachfolgenden Abfragen für die Instanzen fullVisitorID durch clientId ersetzen. Das liegt daran, dass Sie beim Importieren von Zielgruppendaten in Analytics 360 clientId als Schlüsselfeld verwenden müssen. clientId ist normalerweise eine Hash-Version von fullVisitorId. Diese Spalte enthält aber im Google Analytics-Beispiel-Dataset keine Daten. Zum Verwenden von clientId in Ihren eigenen Analytics 360-Daten müssen Sie eine benutzerdefinierte Dimension erstellen und Daten hinzufügen.

  1. Erstellen Sie eine Ansicht mit aggregierten Kundentransaktionsdaten. Kopieren Sie dazu den folgenden Code in die nächste leere Zelle des Notebooks und führen Sie ihn aus:

    ga360_only_view = 'GA360_View'
    shared_dataset_ref = client.dataset('kmeans')
    ga360_view_ref = shared_dataset_ref.table(ga360_only_view)
    ga360_view = bigquery.Table(ga360_view_ref)
    
    ga360_query = '''
    SELECT
      fullVisitorID,
      # This will be used to generate random data.
      ABS(farm_fingerprint(fullVisitorID)) AS Hashed_fullVisitorID,
      # You can aggregate this because an
      # operating system is tied to a fullVisitorID.
      MAX(device.operatingSystem) AS OS,
      SUM (CASE
           WHEN REGEXP_EXTRACT (v2ProductCategory,
                               r'^(?:(?:.*?)Home/)(.*?)/')
                               = 'Apparel' THEN 1 ELSE 0 END) AS Apparel,
      SUM (CASE
           WHEN REGEXP_EXTRACT (v2ProductCategory,
                               r'^(?:(?:.*?)Home/)(.*?)/')
                               = 'Office' THEN 1 ELSE 0 END) AS Office,
      SUM (CASE
           WHEN REGEXP_EXTRACT (v2ProductCategory,
                               r'^(?:(?:.*?)Home/)(.*?)/')
                               = 'Electronics' THEN 1 ELSE 0 END) AS Electronics,
      SUM (CASE
           WHEN REGEXP_EXTRACT (v2ProductCategory,
                               r'^(?:(?:.*?)Home/)(.*?)/')
                               = 'Limited Supply' THEN 1 ELSE 0 END) AS LimitedSupply,
      SUM (CASE
           WHEN REGEXP_EXTRACT (v2ProductCategory,
                               r'^(?:(?:.*?)Home/)(.*?)/')
                               = 'Accessories' THEN 1 ELSE 0 END) AS Accessories,
      SUM (CASE
           WHEN REGEXP_EXTRACT (v2ProductCategory,
                               r'^(?:(?:.*?)Home/)(.*?)/')
                               = 'Shop by Brand' THEN 1 ELSE 0 END) AS ShopByBrand,
      SUM (CASE
           WHEN REGEXP_EXTRACT (v2ProductCategory,
                               r'^(?:(?:.*?)Home/)(.*?)/')
                               = 'Bags' THEN 1 ELSE 0 END) AS Bags,
      ROUND (SUM (productPrice/1000000),2) AS totalSpent_USD
      FROM
      `bigquery-public-data.google_analytics_sample.ga_sessions_*`,
      UNNEST(hits) AS hits,
      UNNEST(hits.product) AS hits_product
    WHERE
      _TABLE_SUFFIX BETWEEN '20160801'
      AND '20160831'
      AND geoNetwork.country = 'United States'
      AND type = 'EVENT'
    GROUP BY
      1,
      2
    '''
    
    ga360_view.view_query = ga360_query.format('myProject')
    ga360_view = client.create_table(ga360_view)
    
    
  2. Prüfen Sie das Beispiel für die aggregierten Kundentransaktionsdaten. Kopieren Sie dazu den folgenden Code in die nächste leere Zelle des Notebooks und führen Sie ihn aus:

    # Show a sample of GA360 data
    
    ga360_query_df = f'''
    SELECT * FROM {ga360_view.full_table_id.replace(":", ".")}
    ORDER BY fullVisitorID
    LIMIT 5
    '''
    
    job_config = bigquery.QueryJobConfig()
    
    # Start the query
    query_job = client.query(ga360_query_df, job_config=job_config) #API Request
    df_ga360 = query_job.result()
    df_ga360 = df_ga360.to_dataframe()
    
    df_ga360
    

    Das Ergebnis sollte in etwa so aussehen:

    Die ersten fünf Zeilen der aggregierten Transaktionsdaten

Demografische Daten generieren

Gehen Sie wie unten beschrieben vor, um zusammengefasste demografische Kundendaten zu generieren.

In einer Produktionsumgebung können Sie Ihre eigenen Daten aus einem CRM-System (Customer-Relationship-Management) verwenden. In einem solchen Fall überspringen Sie diesen Schritt und fahren mit dem nächsten fort, dem Verknüpfen der CRM-Daten mit den aggregierten Kundentransaktionsdaten.

  1. Erstellen Sie eine Ansicht mit generierten Kundendaten. Kopieren Sie dazu den folgenden Code in die nächste leere Zelle des Notebooks und führen Sie ihn aus:

    CRM_only_view = 'CRM_View'
    shared_dataset_ref = client.dataset('kmeans')
    CRM_view_ref = shared_dataset_ref.table(CRM_only_view)
    CRM_view = bigquery.Table(CRM_view_ref)
    
    # The query below works by hashing the fullVisitorID, which creates a
    # random distribution. It uses modulo to artificially split gender and
    # household income distribution.
    CRM_query = '''
    SELECT
      fullVisitorID,
    IF
      (MOD(Hashed_fullVisitorID,2) = 0,
        "M",
        "F") AS gender,
      # Generate household income
      CASE
        WHEN MOD(Hashed_fullVisitorID,10) = 0 THEN 55000
        WHEN MOD(Hashed_fullVisitorID,10) < 3 THEN 65000
        WHEN MOD(Hashed_fullVisitorID,10) < 7 THEN 75000
        WHEN MOD(Hashed_fullVisitorID,10) < 9 THEN 85000
        WHEN MOD(Hashed_fullVisitorID,10) = 9 THEN 95000
      ELSE
      Hashed_fullVisitorID
    END
      AS hhi
    FROM (
      SELECT
        fullVisitorID,
        ABS(farm_fingerprint(fullVisitorID)) AS Hashed_fullVisitorID,
      FROM
        `bigquery-public-data.google_analytics_sample.ga_sessions_*`,
        UNNEST(hits) AS hits,
        UNNEST(hits.product) AS hits_product
          WHERE
        _TABLE_SUFFIX BETWEEN '20160801'
        AND '20160831'
        AND geoNetwork.country = 'United States'
        AND type = 'EVENT'
      GROUP BY
        1,
        2)
    '''
    
    CRM_view.view_query = CRM_query.format('myProject')
    CRM_view = client.create_table(CRM_view)
    
  2. Prüfen Sie das Beispiel für die generierten Kundendaten. Kopieren Sie dazu den folgenden Code in die nächste leere Zelle des Notebooks und führen Sie ihn aus:

    # See an output of the synthetic CRM data
    
    CRM_query_df = f'''
    SELECT * FROM {CRM_view.full_table_id.replace(":", ".")}
    ORDER BY fullVisitorID
    LIMIT 5
    '''
    
    job_config = bigquery.QueryJobConfig()
    
    # Start the query
    query_job = client.query(CRM_query_df, job_config=job_config)
    df_CRM = query_job.result()
    df_CRM = df_CRM.to_dataframe()
    
    df_CRM
    

    Das Ergebnis sollte in etwa so aussehen:

    Die ersten fünf Zeilen generierter Kundendaten

Trainings-Dataset erstellen

Erstellen Sie mit den folgenden Schritten das Trainings-Dataset. Dazu verknüpfen Sie die aggregierten Kundentransaktionsdaten mit den generierten demografischen Kundendaten.

  1. Erstellen Sie eine Ansicht mit verknüpften Kunden- und Transaktionsdaten. Kopieren Sie dazu den folgenden Code in die nächste leere Zelle des Notebooks und führen Sie ihn aus:

    # Build a final view, which joins GA360 data with CRM data
    
    final_data_view = 'Final_View'
    shared_dataset_ref = client.dataset('kmeans')
    final_view_ref = shared_dataset_ref.table(final_data_view)
    final_view = bigquery.Table(final_view_ref)
    
    final_data_query = f'''
    SELECT
        g.*,
        c.* EXCEPT(fullVisitorId)
    FROM {ga360_view.full_table_id.replace(":", ".")} g
    JOIN {CRM_view.full_table_id.replace(":", ".")} c
    ON g.fullVisitorId = c.fullVisitorId
    '''
    
    final_view.view_query = final_data_query.format('myProject')
    final_view = client.create_table(final_view)
    
    print(f"Successfully created view at {final_view.full_table_id}")
    
  2. Prüfen Sie das Beispiel für die verknüpften Daten. Kopieren Sie dazu den folgenden Code in die nächste leere Zelle des Notebooks und führen Sie ihn aus:

    # Show final data used before modeling
    
    sql_demo = f'''
    SELECT * FROM {final_view.full_table_id.replace(":", ".")}
    ORDER BY fullVisitorID
    LIMIT 5
    '''
    
    job_config = bigquery.QueryJobConfig()
    
    # Start the query
    query_job = client.query(sql_demo, job_config=job_config)
    df_demo = query_job.result()
    df_demo = df_demo.to_dataframe()
    
    df_demo
    

    Das Ergebnis sollte in etwa so aussehen:

    Die ersten fünf Zeilen verknüpfter Kunden- und Transaktionsdaten

Erstes Modell erstellen, trainieren und bereitstellen

In diesem Abschnitt erstellen Sie eine Python-Funktion, die das k-means-Modell erstellt. Durch Anlegen einer Funktion anstelle der Verwendung von SQL können Sie mehrere Modelle definieren und von BigQuery parallel erstellen lassen. Sie verwenden diese Funktion noch einmal im Abschnitt Modell verbessern, um mehrere Versionen des Modells für einen Vergleich zu erstellen.

Beachten Sie, dass fullVisitorId nicht als Eingabe für das Modell genutzt wird, da Sie die entsprechenden Daten nicht zum Erstellen eines Features für das Clustering benötigen. Im Allgemeinen sind sehr spezifische oder ungewöhnliche Daten für diesen Zweck nicht hilfreich.

Normalerweise müssen Sie auch numerische Features normalisieren. Dieser Schritt kann jedoch übersprungen werden, da BigQuery ML diesen Schritt automatisch ausführt.

  1. Definieren Sie die Funktion makeModel. Kopieren Sie dazu den folgenden Code in die nächste leere Zelle des Notebooks und führen Sie ihn aus.

    PROJECT_ID = "myProject"
    
    def makeModel (n_Clusters, Model_Name):
        sql =f'''
        CREATE OR REPLACE MODEL `{PROJECT_ID}.kmeans.{Model_Name}`
        OPTIONS(model_type='kmeans',
        kmeans_init_method = 'KMEANS++',
        num_clusters={n_Clusters}) AS
        SELECT * except(fullVisitorID, Hashed_fullVisitorID) FROM `{final_view.full_table_id.replace(":", ".")}`
        '''
        job_config = bigquery.QueryJobConfig()
        client.query(sql, job_config=job_config)
    
  2. Testen Sie die Funktion und erstellen Sie dafür das Modell test, das die Daten in drei Cluster segmentiert. Das Erstellen des Modells dauert ungefähr fünf Minuten.

    Kopieren Sie den folgenden Code in die nächste leere Zelle des Notebooks und führen Sie ihn aus:

    model_test_name = "test"
    makeModel(3, model_test_name)
    
  3. Prüfen Sie, ob das Modell erstellt wurde. Kopieren Sie dazu den folgenden Code in die nächste leere Zelle des Notebooks und führen Sie ihn aus:

    for model in client.list_models('kmeans'):
      print(model)
    

    Das Ergebnis sollte in etwa so aussehen:

    Model(reference=ModelReference(project_id='myProject', dataset_id='kmeans', model_id='test'))
    
  4. Löschen Sie das Modell test. Kopieren Sie dazu den folgenden Code in die nächste leere Zelle des Notebooks und führen Sie ihn aus:

    model_id = "kmeans."+model_test_name
    client.delete_model(model_id)
    print(f"Deleted model '{model_id}'")
    

Modell verbessern

In diesem Abschnitt wird gezeigt, wie Sie das Modell verbessern und die optimale Anzahl an Clustern für Ihren Anwendungsfall ermitteln.

Die Ermittlung der richtigen Anzahl an Clustern – des k-Werts in „k-means“ – hängt vom jeweiligen Anwendungsfall ab. Manchmal lässt sich sehr einfach feststellen, wie viele Cluster Sie benötigen. Wenn Sie beispielsweise Bilder von handschriftlichen einstelligen Ziffern verarbeiten, benötigen Sie 10 Cluster, jeweils einen für die Ziffern 0–9. Für Anwendungsfälle, die weniger eindeutig sind, können Sie mit mehreren Versionen des Modells experimentieren, die jeweils eine unterschiedliche Anzahl an Clustern nutzen. Durch Vergleich verschiedener Versionen des Modells können Sie ermitteln, welche Version im Hinblick auf die Gruppierung Ihrer Daten die beste Leistung erzielt, und gleichzeitig die Fehler in jedem Cluster minimieren.

Mit der Ellbogenmethode lässt sich bestimmen, welche Modellversion die beste Gruppierung bietet. Dies ist eine Möglichkeit, Verluste im Verhältnis zur Anzahl an Clustern im Modell in Kombination mit der Davies-Bouldin-Bewertung des Modells grafisch dazustellen. Diese Bewertung gibt an, wie sich die Datenpunkte eines Clusters voneinander unterscheiden. Sie ist als Verhältnis zwischen der Streuung der Datenpunkte in einem bestimmten Cluster und der Streuung der Cluster insgesamt definiert. Je niedrigerer dieser Wert ist, desto besser ist das Clustering.

Mehrere Modelle zum Vergleich erstellen

Generieren Sie mehrere Versionen des k-means-Modells, von einer Version, die drei Cluster erstellt, bis zu einer Version mit fünfzehn Clustern.

  1. Generieren Sie mehrere Versionen des k-means-Modells. Die Erstellung der Modelle dauert ungefähr sieben Minuten.

    Kopieren Sie den folgenden Code in die nächste leere Zelle des Notebooks und führen Sie ihn aus:

    low_k = 3
    high_k = 15
    model_prefix_name = 'kmeans_clusters_'
    
    lst = list(range (low_k, high_k+1)) #build list to iterate through k values
    
    for k in lst:
        model_name = model_prefix_name + str(k)
        makeModel(k, model_name)
    
  2. Rufen Sie eine Liste der generierten Modelle ab. Kopieren Sie dazu den folgenden Code in die nächste leere Zelle des Notebooks und führen Sie ihn aus.

    models = client.list_models('kmeans')
    print("Listing current models:")
    for model in models:
        full_model_id = f"{model.dataset_id}.{model.model_id}"
        print(full_model_id)
    

    Das Ergebnis sollte in etwa so aussehen:

    Liste der verschiedenen Modellversionen

Modellleistung vergleichen

Verwenden Sie die folgenden Schritte, um die Leistung der verschiedenen Modelle zu vergleichen. Prüfen Sie dazu die mittlere quadratische Abweichung, die den Verlust für ein Modell angibt, sowie die Davies-Bouldin-Bewertung für jedes Modell.

  1. Verwenden Sie die SQL-Anweisung ML.EVALUATE, um die mittlere quadratische Abweichung sowie die Davies-Bouldin-Werte für jedes Modell zu generieren. Dies kann etwa eine Minute dauern.

    Kopieren Sie den folgenden Code in die nächste leere Zelle des Notebooks und führen Sie ihn aus:

    # This creates a dataframe with each model name, the Davies Bouldin Index, and Loss.
    
    df = pd.DataFrame(columns=['davies_bouldin_index', 'mean_squared_distance'])
    models = client.list_models('kmeans')
    for model in models:
        full_model_id = f"{model.dataset_id}.{model.model_id}"
        sql =f'''
            SELECT
                davies_bouldin_index,
                mean_squared_distance
            FROM ML.EVALUATE(MODEL `{full_model_id}`)
        '''
    
        job_config = bigquery.QueryJobConfig()
    
        # Start the query, passing in the extra configuration.
        query_job = client.query(sql, job_config=job_config)
        df_temp = query_job.to_dataframe()  # Wait for the job to complete.
        df_temp['model_name'] = model.model_id
        df =  pd.concat([df, df_temp], axis=0)
    
  2. Aktualisieren Sie den DataFrame und fügen Sie eine Spalte hinzu, die die Anzahl der vom Modell verwendeten Cluster angibt und die Daten für die grafische Darstellung sortiert. Kopieren Sie dazu den folgenden Code in die nächste leere Zelle des Notebooks und führen Sie ihn aus:

    df['n_clusters'] = df['model_name'].str.split('_').map(lambda x: x[2])
    df['n_clusters'] = df['n_clusters'].apply(pd.to_numeric)
    df = df.sort_values(by='n_clusters', ascending=True)
    df
    

    Die Ausgabe sollte dieser Tabelle entsprechen:

    Mittlere quadratische Abweichung und Davies-Bouldin-Bewertungsinformationen für jedes Modell

  3. Erstellen Sie ein Diagramm der Daten. Kopieren Sie dazu den folgenden Code in die nächste leere Zelle des Notebooks und führen Sie ihn aus:

    df.plot.line(x='n_clusters', y=['davies_bouldin_index', 'mean_squared_distance'])
    

    Die Ausgabe sollte diesem Diagramm entsprechen:

    Diagramm mit der mittleren quadratischen Abweichung und der Davies-Bouldin-Bewertung im Verhältnis zur Anzahl der Cluster für jedes Modell

    Für die Ermittlung der optimalen Anzahl an Clustern für einen Anwendungsfall gibt es keinen perfekten Ansatz. Wir empfehlen dafür die folgende Vorgehensweise:

    1. Prüfen Sie mit der Ellbogenmethode, ob deutlich die Stelle erkennbar ist, an der der Verlust ausgeglichen wird.
    2. Prüfen Sie die Davies-Bouldin-Bewertung für die Modelle.
    3. Berücksichtigen Sie geschäftliche Regeln oder Anforderungen, die Einfluss darauf haben können, mit wie vielen Clustern Sie gearbeitet werden soll.
    4. Wählen Sie das Modell aus, das Ihren geschäftlichen Anforderungen entspricht und die beste Kombination aus niedrigem Verlust sowie niedriger Davies-Bouldin-Bewertung darstellt.

    Im obigen Diagramm steht die orange Linie für den Verlust jedes Modells, angegeben durch die mittlere quadratische Abweichung. Dieser wird anhand der Anzahl der Cluster im Modell grafisch dargestellt. Der Trend dieser Linie zeigt, dass eine Reduzierung der Anzahl der Cluster den Verlust wie erwartet verringert. Außerdem reduziert sich die Steigung der Linie stetig, anstatt einen Punkt zu erreichen, an dem sich der Verlust ausgleicht. Dadurch entsteht eine Ellbogenform. Das bedeutet, dass für dieses Dataset die Ellbogenmethode allein nicht zur Bestimmung der optimalen Anzahl an Clustern ausreicht.

    Die blaue Linie stellt die Davies-Bouldin-Bewertung jedes Modells im Verhältnis zur Anzahl der Cluster im Modell grafisch dar. Da die Ellbogenmethode das Modell mit der besten Leistung nicht eindeutig festgestellt hat, können Sie dieses Modell alternativ durch Auswahl eines Modells mit einer niedrigen Davies-Bouldin-Bewertung ermitteln.

    Beim Modell mit 11 Clustern ist der Verlust relativ niedrig und die Davies-Bouldin-Bewertung am besten. Sollten Ihre geschäftlichen Regeln nicht für die Anwendung weniger Cluster sprechen, ist dieses Modell die beste Wahl. Wenn Ihre Geschäftsregeln weniger Clustern erfordern, bietet sich das Modell mit vier Clustern an, das die zweitbeste Davies-Bouldin-Bewertung hat. Zur Vereinfachung wird in dieser Anleitung dieses Modell mit vier Clustern verwendet.

Datencluster im ausgewählten Modell analysieren

Anhand der Schwerpunkte des Modells können Sie feststellen, wie die Daten in diesem Modell geclustert wurden. Analysieren Sie dann die Daten in den einzelnen Clustern, um ermitteln, wie viele Nutzer darin enthalten sind und was das Clustering zum Kundenverhalten aussagt.

  1. Verwenden Sie die SQL-Anweisung ML.CENTROIDS zum Abrufen von Informationen zu den Schwerpunkten in jedem Cluster für das gender-Feature. Kopieren Sie dazu den folgenden Code in die nächste leere Zelle des Notebooks kopieren und führen Sie ihn aus:

    model_to_use = 'kmeans_clusters_4' # Edit this to use a different model
    final_model = 'kmeans.'+model_to_use
    
    pd.set_option('max_colwidth', 400)
    
    sql_get_attributes = f'''
    SELECT
      centroid_id,
      feature,
      categorical_value
    FROM
      ML.CENTROIDS(MODEL {final_model})
    WHERE
      feature IN ('gender')
    '''
    
    job_config = bigquery.QueryJobConfig()
    
    # Start the query
    query_job = client.query(sql_get_attributes, job_config=job_config)
    df_attributes = query_job.result()
    df_attributes = df_attributes.to_dataframe()
    df_attributes
    

    Das Ergebnis sollte in etwa so aussehen:

    Schwerpunkte für das Geschlechts-Feature des kMeans-Modells

  2. Berechnen Sie eine zusammenfassende Statistik zu den Clusterdaten mithilfe von Informationen aus ML.PREDICT und ML.CENTROIDS. Kopieren Sie dazu den folgenden Code in die nächste leere Zelle des Notebooks und führen Sie ihn aus:

    sql_get_numerical_attributes = f'''
    WITH T AS (
    SELECT
      centroid_id,
      ARRAY_AGG(STRUCT(feature AS name,
                       ROUND(numerical_value,1) AS value)
                       ORDER BY centroid_id)
                       AS cluster
    FROM ML.CENTROIDS(MODEL {final_model})
    GROUP BY centroid_id
    ),
    
    Users AS(
    SELECT
      centroid_id,
      COUNT(*) AS Total_Users
    FROM(
    SELECT
      * EXCEPT(nearest_centroids_distance)
    FROM
      ML.PREDICT(MODEL {final_model},
        (
        SELECT
          *
        FROM
          {final_view.full_table_id.replace(":", ".")}
          )))
    GROUP BY centroid_id
    )
    
    SELECT
      centroid_id,
      Total_Users,
      (SELECT value from unnest(cluster) WHERE name = 'Apparel') AS Apparel,
      (SELECT value from unnest(cluster) WHERE name = 'Office') AS Office,
      (SELECT value from unnest(cluster) WHERE name = 'Electronics') AS Electronics,
      (SELECT value from unnest(cluster) WHERE name = 'LimitedSupply') AS LimitedSupply,
      (SELECT value from unnest(cluster) WHERE name = 'Accessories') AS Accessories,
      (SELECT value from unnest(cluster) WHERE name = 'Bags') AS Bags,
      (SELECT value from unnest(cluster) WHERE name = 'ShopByBrand') AS ShopByBrand,
      (SELECT value from unnest(cluster) WHERE name = 'totalSpent_USD') AS totalSpent_USD,
      (SELECT value from unnest(cluster) WHERE name = 'hhi') AS HouseholdIncome
    
    FROM T LEFT JOIN Users USING(centroid_id)
    ORDER BY centroid_id ASC
    '''
    
    job_config = bigquery.QueryJobConfig()
    
    # Start the query
    query_job = client.query(sql_get_numerical_attributes, job_config=job_config)
    df_numerical_attributes = query_job.result()
    df_numerical_attributes = df_numerical_attributes.to_dataframe()
    df_numerical_attributes.head()
    

    Das Ergebnis sollte in etwa so aussehen:

    Zusammenfassende Statistik für Clusterdaten

Mithilfe des Schwerpunkts und der zusammenfassenden Statistikdaten können Sie die folgenden Merkmale für die Cluster des Modells bestimmen:

  • Cluster 1: Kunden in diesem Cluster kaufen viel Bekleidung. Sie kaufen die meisten Artikel und haben die zweithöchsten Ausgaben pro Artikel. Sie sind wenig markenorientiert. Der Cluster tendiert leicht zu mehr weiblichen Kunden.
  • Cluster 2: Kunden in diesem Cluster kaufen in allen Kategorien, aber am meisten in der Kategorie Bekleidung. Sie kaufen weniger Artikel als die Kunden in Cluster 1, geben aber wesentlich mehr pro Artikel aus. Es ist sehr wahrscheinlich, dass sie markenorientiert einkaufen. Dieser Cluster tendiert stärker zu weiblichen Kunden.
  • Cluster 3: Dieser Cluster ist ein Ausreißer mit nur einer Person.
  • Cluster 4: Dies ist der umfangreichste Cluster. Kunden in diesem Cluster kaufen wenig und geben durchschnittlich weniger aus. Sie sind typischerweise Einmalkäufer und nicht markenloyal. Die Geschlechterverzerrung ist gering.

Vorhersagen abrufen

Verwenden Sie das ausgewählte Modell, um die Nutzer zu Clustern zuzuweisen, die Sie dann für die Marketingsegmentierung verwenden können.

  1. Erstellen Sie eine Tabelle mit aggregierten Kundentransaktionsdaten. Kopieren Sie dazu den folgenden Code in die nächste leere Zelle des Notebooks und führen Sie ihn aus:

    sql_score = f'''
    SELECT * EXCEPT(nearest_centroids_distance)
    FROM
      ML.PREDICT(MODEL {final_model},
        (
        SELECT
          *
        FROM
          {final_view.full_table_id.replace(":", ".")}
          LIMIT 10))
    '''
    
    job_config = bigquery.QueryJobConfig()
    
    # Start the query
    query_job = client.query(sql_score, job_config=job_config)
    df_score = query_job.result()
    df_score = df_score.to_dataframe()
    
    df_score
    

    Das Ergebnis sollte in etwa so aussehen:

    Die ersten zehn Zeilen der verarbeiteten Trainingsdaten

Daten nach Analytics 360 exportieren

Nachdem Sie aus dem k-means-Modell Clusterinformationen für Ihre Kunden generiert haben, können Sie diese zur Verwendung für Marketingkampagnen nach Analytics 360 exportieren.

Führen Sie dazu mit der BigQuery-Konsole eine Abfrage aus, mit der die Daten zurückgegeben werden, die exportiert werden sollen, wie im folgenden SQL-Pseudocode gezeigt:

CREATE OR REPLACE TABLE myDataset.myCustomerDataTable AS (
    SELECT * EXCEPT(nearest_centroids_distance)
    FROM
      ML.PREDICT(MODEL myDataset.myModel,
        (
        SELECT
          *
        FROM
          myDataset.myTable)))

Speichern Sie die Abfrageergebnisse als CSV-Datei und importieren Sie die Daten mit dem Datenimport in Analytics 360. Beachten Sie, dass die Spaltennamen in den exportierten Empfehlungsdaten dem Analytics 360-Datenimportschema entsprechen müssen. Wenn das Schema für den Datenimport beispielsweise ga:clientId, ga:dimension1, ga:dimension2 lautet, sollten die Spaltennamen in Ihren Daten ga:clientId, ga:dimension1, ga:dimension2 heißen. Die Verwendung von Doppelpunkten in Spaltennamen ist in BigQuery nicht zulässig. Sie müssen daher die Spaltennamen in der exportierten CSV-Datei ändern, bevor Sie sie importieren.

Auf Wunsch können Sie die Referenzimplementierung MoDeM (Model Deployment for Marketing) für BigQuery ML-Modelle verwenden, um das Laden von Daten in Analytics 360 zu vereinfachen. Verwenden Sie als Einstieg die interaktive Anleitung im Notebook für die BQML-Bereitstellungsvorlage.

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 behalten Sie das Projekt bei und löschen Sie nur diese Ressourcen.

In beiden Fällen sollten Sie diese Ressourcen entfernen, damit sie Ihnen nicht weiter in Rechnung gestellt werden. In den folgenden Abschnitten erfahren Sie, wie Sie diese Ressourcen löschen.

Projekt löschen

Am einfachsten vermeiden Sie weitere Kosten, wenn Sie das für die Anleitung erstellte Projekt löschen.

  1. Wechseln Sie in der 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.

Komponenten löschen

Wenn Sie das Projekt nicht löschen möchten, verwenden Sie die folgenden Abschnitte, um die abrechenbaren Komponenten dieser Anleitung zu löschen.

BigQuery-Dataset löschen

  1. Öffnen Sie die BigQuery Console.
  2. Maximieren Sie im Abschnitt Ressourcen das Projekt, in dem Sie diese Anleitung ausführen, und wählen Sie das Dataset kmeans aus.
  3. Klicken Sie im Header-Bereich des Datasets auf Dataset löschen.
  4. Geben Sie im eingeblendeten Fenster kmeans ein und klicken Sie dann auf Löschen.

Nutzerverwaltete Notebook-Instanz löschen

  1. Öffnen Sie den Tab „Nutzerverwaltete Notebooks“.
  2. Klicken Sie auf das Kästchen für die Notebook-Instanz kmeans.
  3. Klicken Sie auf Löschen.
  4. Klicken Sie im eingeblendeten Fenster auf Löschen.

Nächste Schritte