Klassifizierung mit einem Boosted Tree-Modell durchführen


In dieser Anleitung erfahren Sie, wie Sie ein Boosted Tree-Klassifikationsmodell verwenden, um den Einkommensbereich von Personen anhand ihrer demografischen Daten vorherzusagen. Das Modell sagt vorher, ob ein Wert in eine von zwei Kategorien fällt. In diesem Fall,ob das jährliche Einkommen einer Person über oder unter 50.000 $fällt.

In dieser Anleitung wird das Dataset bigquery-public-data.ml_datasets.census_adult_income verwendet. Dieses Dataset enthält demografische und einkommensbezogene Informationen von US-Bürgern aus den Jahren 2000 und 2010.

Lernziele

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

Kosten

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

  • BigQuery
  • BigQuery ML

Weitere Informationen zu den Kosten von BigQuery finden Sie auf der Seite BigQuery-Preise.

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

Hinweise

  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.

    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.

    Go to project selector

  5. Make sure that billing is enabled for your Google Cloud project.

  6. BigQuery ist in neuen Projekten automatisch aktiviert. So aktivieren Sie BigQuery in einem vorhandenen Projekt:

    Enable the BigQuery API.

    Enable the API

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

  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.

    Die Menüoption „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.

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

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

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

Beispieldaten vorbereiten

Das Modell, das Sie in dieser Anleitung erstellen, sagt die Einkommensgruppe für Befragte bei der Volkszählung anhand der folgenden Features vorher:

  • Alter
  • Art der Tätigkeit
  • Familienstand
  • Bildungsniveau
  • Beruf
  • Arbeitsstunden pro Woche

Die Spalte education ist nicht in den Trainingsdaten enthalten, da die Spalten education und education_num das Bildungsniveau des Befragten in unterschiedlichen Formaten ausdrücken.

Sie trennen die Daten in Trainings-, Auswertungs- und Vorhersage-Sets, indem Sie eine neue dataframe-Spalte erstellen, die von der functional_weight-Spalte abgeleitet wird. 80 % der Daten werden zum Trainieren des Modells verwendet und die verbleibenden 20 % für die Bewertung und Vorhersage.

SQL

Erstellen Sie zum Vorbereiten Ihrer Beispieldaten eine Ansicht, die die Trainingsdaten enthält. Diese Ansicht wird später in dieser Anleitung von der CREATE MODEL-Anweisung verwendet.

Führen Sie die Abfrage aus, mit der die Beispieldaten vorbereitet werden:

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

    BigQuery aufrufen

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

    CREATE OR REPLACE VIEW
      `bqml_tutorial.input_data` AS
    SELECT
      age,
      workclass,
      marital_status,
      education_num,
      occupation,
      hours_per_week,
      income_bracket,
      CASE
        WHEN MOD(functional_weight, 10) < 8 THEN 'training'
        WHEN MOD(functional_weight, 10) = 8 THEN 'evaluation'
        WHEN MOD(functional_weight, 10) = 9 THEN 'prediction'
      END AS dataframe
    FROM
      `bigquery-public-data.ml_datasets.census_adult_income`;
  3. Maximieren Sie im Bereich Explorer das Dataset bqml_tutorial und suchen Sie die Ansicht input_data.

  4. Klicken Sie auf den Namen der Ansicht, um den Informationsbereich zu öffnen. Das Ansichtsschema wird auf dem Tab Schema angezeigt.

BigQuery DataFrames

Erstellen Sie einen DataFrame mit dem Namen input_data. input_data wird später in dieser Anleitung verwendet, um das Modell zu trainieren, zu bewerten und Vorhersagen zu treffen.

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 bigframes.pandas as bpd

input_data = bpd.read_gbq(
    "bigquery-public-data.ml_datasets.census_adult_income",
    columns=(
        "age",
        "workclass",
        "marital_status",
        "education_num",
        "occupation",
        "hours_per_week",
        "income_bracket",
        "functional_weight",
    ),
)
input_data["dataframe"] = bpd.Series("training", index=input_data.index,).case_when(
    [
        (((input_data["functional_weight"] % 10) == 8), "evaluation"),
        (((input_data["functional_weight"] % 10) == 9), "prediction"),
    ]
)
del input_data["functional_weight"]

Boosted Tree-Modell erstellen

Erstellen Sie ein Boosted Tree-Modell, um die Einkommensklasse der Befragten der Volkszählung vorherzusagen, und trainieren Sie es mit den Volkszählungsdaten. Die Abfrage dauert etwa 30 Minuten.

SQL

So erstellen Sie das Modell:

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

    BigQuery aufrufen

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

    CREATE MODEL `bqml_tutorial.tree_model`
    OPTIONS(MODEL_TYPE='BOOSTED_TREE_CLASSIFIER',
            BOOSTER_TYPE = 'GBTREE',
            NUM_PARALLEL_TREE = 1,
            MAX_ITERATIONS = 50,
            TREE_METHOD = 'HIST',
            EARLY_STOP = FALSE,
            SUBSAMPLE = 0.85,
            INPUT_LABEL_COLS = ['income_bracket'])
    AS SELECT * EXCEPT(dataframe)
    FROM `bqml_tutorial.input_data`
    WHERE dataframe = 'training';

    Nach Abschluss der Abfrage wird das Modell tree_model im Bereich Explorer angezeigt. Da die Abfrage eine CREATE MODEL-Anweisung zum Erstellen eines Modells verwendet, werden keine Abfrageergebnisse ausgegeben.

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.

from bigframes.ml import ensemble

# input_data is defined in an earlier step.
training_data = input_data[input_data["dataframe"] == "training"]
X = training_data.drop(columns=["income_bracket", "dataframe"])
y = training_data["income_bracket"]

# create and train the model
tree_model = ensemble.XGBClassifier(
    n_estimators=1,
    booster="gbtree",
    tree_method="hist",
    max_iterations=1,  # For a more accurate model, try 50 iterations.
    subsample=0.85,
)
tree_model.fit(X, y)

tree_model.to_gbq(
    your_model_id,  # For example: "your-project.bqml_tutorial.tree_model"
    replace=True,
)

Modell bewerten

SQL

So bewerten Sie das Modell:

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

    BigQuery aufrufen

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

      SELECT
        *
      FROM
        ML.EVALUATE (MODEL `bqml_tutorial.tree_model`,
          (
          SELECT
            *
          FROM
            `bqml_tutorial.input_data`
          WHERE
            dataframe = 'evaluation'
          )
        );

    Die Antwort sollte in etwa so aussehen:

    +---------------------+---------------------+---------------------+-------------------+---------------------+---------------------+
    | precision           | recall              | accuracy            | f1_score          | log_loss            | roc_auc             |
    +---------------------+---------------------+---------------------+-------------------+-------------------------------------------+
    | 0.67192429022082023 | 0.57880434782608692 | 0.83942963422194672 | 0.621897810218978 | 0.34405456040833338 | 0.88733566433566435 |
    +---------------------+---------------------+ --------------------+-------------------+---------------------+---------------------+
    

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.

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

# input_data is defined in an earlier step.
evaluation_data = input_data[input_data["dataframe"] == "evaluation"]
X = evaluation_data.drop(columns=["income_bracket", "dataframe"])
y = evaluation_data["income_bracket"]

# The score() method evaluates how the model performs compared to the
# actual data. Output DataFrame matches that of ML.EVALUATE().
score = tree_model.score(X, y)
score.peek()
# Output:
#    precision    recall  accuracy  f1_score  log_loss   roc_auc
# 0   0.671924  0.578804  0.839429  0.621897  0.344054  0.887335

Die Bewertungsstatistiken deuten auf eine gute Modellleistung hin, insbesondere der roc_auc-Wert, der größer als 0.8 ist.

Weitere Informationen zu den Bewertungsstatistiken finden Sie unter Klassifikationsmodelle.

Modell zum Vorhersagen von Klassifizierungen verwenden

SQL

So prognostizieren Sie Daten mit dem Modell:

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

    BigQuery aufrufen

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

      SELECT
        *
      FROM
        ML.PREDICT (MODEL `bqml_tutorial.tree_model`,
          (
          SELECT
            *
          FROM
            `bqml_tutorial.input_data`
          WHERE
            dataframe = 'prediction'
          )
        );

Die ersten Spalten der Ergebnisse sollten in etwa so aussehen:

  +---------------------------+--------------------------------------+-------------------------------------+
  | predicted_income_bracket  | predicted_income_bracket_probs.label | predicted_income_bracket_probs.prob |
  +---------------------------+--------------------------------------+-------------------------------------+
  |  <=50K                    |  >50K                                | 0.05183430016040802                 |
  +---------------------------+--------------------------------------+-------------------------------------+
  |                           |  <50K                                | 0.94816571474075317                 |
  +---------------------------+--------------------------------------+-------------------------------------+
  |  <=50K                    |  >50K                                | 0.00365859130397439                 |
  +---------------------------+--------------------------------------+-------------------------------------+
  |                           |  <50K                                | 0.99634140729904175                 |
  +---------------------------+--------------------------------------+-------------------------------------+
  |  <=50K                    |  >50K                                | 0.037775970995426178                |
  +---------------------------+--------------------------------------+-------------------------------------+
  |                           |  <50K                                | 0.96222406625747681                 |
  +---------------------------+--------------------------------------+-------------------------------------+
  

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.

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

# input_data is defined in an earlier step.
prediction_data = input_data[input_data["dataframe"] == "prediction"]

predictions = tree_model.predict(prediction_data)
predictions.peek()
# Output:
# predicted_income_bracket   predicted_income_bracket_probs.label  predicted_income_bracket_probs.prob
#                   <=50K                                   >50K                   0.05183430016040802
#                                                           <50K                   0.94816571474075317
#                   <=50K                                   >50K                   0.00365859130397439
#                                                           <50K                   0.99634140729904175
#                   <=50K                                   >50K                   0.037775970995426178
#                                                           <50K                   0.96222406625747681

predicted_income_bracket enthält den vom Modell vorhergesagten Wert. Im predicted_income_bracket_probs.label sind die beiden Labels zu sehen, zwischen denen das Modell wählen musste, und in der Spalte predicted_income_bracket_probs.prob wird die Wahrscheinlichkeit angezeigt, dass das jeweilige Label das richtige ist.

Weitere Informationen zu den Ausgabespalten finden Sie unter Klassifizierungsmodelle.

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 derGoogle 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, die Tabelle und alle Daten 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:

  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