Cette page a été traduite par l'API Cloud Translation.

Effectuer une classification avec un modèle d'arbres de décision à boosting

Ce tutoriel explique comment utiliser un modèle de classification d'arbre de décision à boosting pour prédire la tranche de revenus des personnes en fonction de leurs données démographiques. Le modèle permet de prédire si une valeur tombe dans l'une des deux catégories, soit dans le cas présent prédire si le revenu annuel d'une personne est supérieur ou inférieur à 50 000 $.

Ce tutoriel utilise l'ensemble de données bigquery-public-data.ml_datasets.census_adult_income. Cet ensemble de données contient les informations relatives à la démographie et aux revenus des résidents américains à partir de 2000 et de 2010.

Créer un ensemble de données

Créez un ensemble de données BigQuery pour stocker votre modèle de ML.

Console

Dans la console Google Cloud , accédez à la page BigQuery.

Accéder à la page "BigQuery"
Dans le volet Explorateur, cliquez sur le nom de votre projet.
Cliquez sur Afficher les actions > Créer un ensemble de données.
Sur la page Créer un ensemble de données, procédez comme suit :
- Dans le champ ID de l'ensemble de données, saisissez bqml_tutorial.
- Pour Type d'emplacement, sélectionnez Multirégional, puis sélectionnez US (plusieurs régions aux États-Unis).
- Conservez les autres paramètres par défaut, puis cliquez sur Créer un ensemble de données.

bq

Pour créer un ensemble de données, exécutez la commande bq mk en spécifiant l'option --location. Pour obtenir la liste complète des paramètres possibles, consultez la documentation de référence sur la commande bq mk --dataset.

Créez un ensemble de données nommé bqml_tutorial avec l'emplacement des données défini sur US et une description de BigQuery ML tutorial dataset :
```
bq --location=US mk -d \
 --description "BigQuery ML tutorial dataset." \
 bqml_tutorial
```
Au lieu d'utiliser l'option --dataset, la commande utilise le raccourci -d. Si vous omettez -d et --dataset, la commande crée un ensemble de données par défaut.
Vérifiez que l'ensemble de données a été créé :
```
bq ls
```

API

Appelez la méthode datasets.insert avec une ressource d'ensemble de données définie.

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

BigQuery DataFrames

Avant d'essayer cet exemple, suivez les instructions de configuration pour BigQuery DataFrames du guide de démarrage rapide de BigQuery DataFrames. Pour en savoir plus, consultez la documentation de référence sur BigQuery DataFrames.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer les ADC pour un environnement de développement local.

import google.cloud.bigquery

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

Préparer les exemples de données

Le modèle que vous allez créer dans ce tutoriel prédit la tranche de revenus des personnes interrogées lors du recensement, en fonction des caractéristiques suivantes :

Âge
Type de travail réalisé
Statut marital
Niveau d'études
Profession
Heures travaillées par semaine

La colonne education n'est pas incluse dans les données d'entraînement, car les colonnes education et education_num expriment toutes les deux le niveau d'études de la personne interrogée sous différents formats.

Séparez les données en ensembles d'entraînement, d'évaluation et de prédiction en créant une colonne dataframe dérivée de la colonne functional_weight. 80 % des données sont utilisées pour entraîner le modèle, et les 20 % restants sont utilisés pour l'évaluation et la prédiction.

SQL

Pour préparer vos exemples de données, créez une vue contenant les données d'entraînement. Cette vue est utilisée par l'instruction CREATE MODEL plus loin dans ce tutoriel.

Exécutez la requête qui prépare les exemples de données :

Dans la console Google Cloud , accédez à la page BigQuery.

Accéder à BigQuery

Dans l'éditeur de requête, saisissez la requête suivante :

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

Dans le panneau de gauche, cliquez sur Explorer :

Si le volet de gauche n'apparaît pas, cliquez sur Développer le volet de gauche pour l'ouvrir.
Dans le volet Explorateur, recherchez l'ensemble de données bqml_tutorial.
Cliquez sur l'ensemble de données, puis sur Présentation > Tables.
Cliquez sur la vue input_data pour ouvrir le volet d'informations. Le schéma de la vue s'affiche dans l'onglet Schéma.

BigQuery DataFrames

Créez un DataFrame appelé input_data. Vous utiliserez input_data plus loin dans ce tutoriel pour entraîner le modèle, l'évaluer et effectuer des prédictions.

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

Créer le modèle d'arbre de décision boosté

Créez un modèle d'arbres boostés pour prédire la tranche de revenus des personnes interrogées lors du recensement et entraînez-le sur les données de recensement. L'exécution de la requête prend environ 30 minutes.

SQL

Pour créer le modèle, procédez comme suit :

Dans la console Google Cloud , accédez à la page BigQuery.

Accéder à BigQuery

Dans l'éditeur de requête, collez la requête suivante, puis cliquez sur Exécuter :

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

Une fois la requête terminée, vous pouvez accéder au modèle tree_model dans le volet Explorateur. Étant donné que la requête utilise une instruction CREATE MODEL pour créer un modèle, les résultats de la requête ne sont pas affichés.

BigQuery DataFrames

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

Évaluer le modèle

SQL

Pour évaluer le modèle, procédez comme suit :

Dans la console Google Cloud , accédez à la page BigQuery.

Accéder à BigQuery

Dans l'éditeur de requête, collez la requête suivante, puis cliquez sur Exécuter :

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

Le résultat doit ressembler à ce qui suit :

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

BigQuery DataFrames

# 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

Les métriques d'évaluation indiquent de bonnes performances du modèle, en particulier le fait que le score roc_auc est supérieur à 0.8.

Pour en savoir plus sur les métriques d'évaluation, consultez Sortie.

Utiliser le modèle pour prédire des classifications

SQL

Pour prévoir des données avec le modèle, procédez comme suit :

Dans la console Google Cloud , accédez à la page BigQuery.

Accéder à BigQuery

Dans l'éditeur de requête, collez la requête suivante, puis cliquez sur Exécuter :

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

Les premières colonnes des résultats doivent ressembler à ce qui suit :

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

# 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 contient la valeur prédite par le modèle. predicted_income_bracket_probs.label indique les deux libellés entre lesquels le modèle a dû choisir, et la colonne predicted_income_bracket_probs.prob indique la probabilité que le libellé donné soit le bon.

Pour en savoir plus sur les colonnes de sortie, consultez Modèles de classification.

Effectuer une classification avec un modèle d'arbres de décision à boosting Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Créer un ensemble de données

Console

bq

API

BigQuery DataFrames

Préparer les exemples de données

SQL

BigQuery DataFrames

Créer le modèle d'arbre de décision boosté

SQL

BigQuery DataFrames

Évaluer le modèle

SQL

BigQuery DataFrames

Utiliser le modèle pour prédire des classifications

SQL

BigQuery DataFrames

Effectuer une classification avec un modèle d'arbres de décision à boosting