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

Créer et utiliser un modèle de classification portant sur des données de recensement

Dans ce tutoriel, vous allez utiliser un modèle de régression logistique binaire dans BigQuery ML pour prédire la plage de revenus des personnes en fonction de leurs données démographiques. Un modèle de régression logistique binaire 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.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
Roles required to select or create a project
- Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
- Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
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
Verify that billing is enabled for your Google Cloud project.
Enable the BigQuery API.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.
Enable the API

Autorisations requises

Pour créer le modèle à l'aide de BigQuery ML, vous devez disposer des autorisations IAM suivantes :

bigquery.jobs.create
bigquery.models.create
bigquery.models.getData
bigquery.models.updateData
bigquery.models.updateMetadata

Pour exécuter une inférence, vous devez disposer des autorisations suivantes :

bigquery.models.getData sur le modèle
bigquery.jobs.create

Introduction

Dans le cadre du machine learning, il est souvent nécessaire de classer les données dans l'un des deux types possibles, aussi appelés libellés. Par exemple, un marchand peut souhaiter prédire si un client donné achètera un nouveau produit, en se basant sur d'autres informations concernant ce client. Dans ce cas, les deux libellés peuvent être will buy et won't buy. Le revendeur peut créer un ensemble de données de sorte qu'une colonne représente les deux libellés et contient également des informations sur le client, telles que son emplacement, ses achats précédents et ses préférences déclarées. Le marchand peut ensuite utiliser un modèle de régression logistique binaire qui exploite ces informations client pour prédire l'étiquette qui représente le mieux chaque client.

Dans ce tutoriel, vous allez créer un modèle de régression logistique binaire permettant de prédire si le revenu d'une personne interrogée lors du recensement se situe dans l'une des deux plages possibles en fonction des attributs démographiques de cette personne.

Créer un ensemble de données

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

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

Accéder à BigQuery
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, 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 census.
- Pour Type d'emplacement, sélectionnez Multirégional, puis sélectionnez US (plusieurs régions aux États-Unis).
  
  Les ensembles de données publics sont stockés dans l'emplacement multirégional US. Par souci de simplicité, stockez votre ensemble de données dans le même emplacement.
- Conservez les autres paramètres par défaut, puis cliquez sur Créer un ensemble de données.

Examiner les données

Examinez l'ensemble de données et identifier les colonnes à utiliser comme données d'entraînement pour le modèle de régression logistique. Sélectionnez 100 lignes dans la table census_adult_income :

SQL

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

Accéder à BigQuery

Dans l'éditeur de requête, exécutez la requête GoogleSQL suivante :

SELECT
age,
workclass,
marital_status,
education_num,
occupation,
hours_per_week,
income_bracket,
functional_weight
FROM
`bigquery-public-data.ml_datasets.census_adult_income`
LIMIT
100;

Les résultats ressemblent à ce qui suit :

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

df = 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",
    ),
    max_results=100,
)
df.peek()
# Output:
# age      workclass       marital_status  education_num          occupation  hours_per_week income_bracket  functional_weight
#  47      Local-gov   Married-civ-spouse             13      Prof-specialty              40           >50K             198660
#  56        Private        Never-married              9        Adm-clerical              40          <=50K              85018
#  40        Private   Married-civ-spouse             12        Tech-support              40           >50K             285787
#  34   Self-emp-inc   Married-civ-spouse              9        Craft-repair              54           >50K             207668
#  23        Private   Married-civ-spouse             10   Handlers-cleaners              40          <=50K              40060

Les résultats de la requête montrent que la colonne income_bracket de la table census_adult_income ne présente que l'une des deux valeurs suivantes : <=50K ou >50K.

Préparer les exemples de données

Dans ce tutoriel, vous allez prédire le revenu des personnes interrogées lors du recensement en fonction des valeurs des colonnes suivantes du tableau census_adult_income :

age : âge du répondant.
workclass : classe de travail effectué. Par exemple, une administration locale, une entreprise privée ou un travailleur indépendant.
marital_status
education_num : niveau d'études le plus élevé de la personne interrogée.
occupation
hours_per_week : heures travaillées par semaine.

Vous excluez les colonnes qui entraîneraient une duplication des données. Par exemple, la colonne education, car les valeurs des colonnes education et education_num expriment les mêmes données sous différents formats.

La colonne functional_weight correspond au nombre de personnes représentées par une ligne particulière selon l'organisation de recensement. Étant donné que la valeur de cette colonne n'a aucun lien avec la valeur de income_bracket pour une ligne donnée, vous utilisez la valeur de cette colonne pour séparer 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. Vous étiquetez 80 % des données pour l'entraînement du modèle, 10 % pour l'évaluation et 10 % pour la prédiction.

SQL

Créez une vue avec les exemples de données. 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
`census.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`;

Affichez les exemples de données :
```
SELECT * FROM `census.input_data`;
```

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 un modèle de régression logistique

Vous allez créer un modèle de régression logistique avec les données d'entraînement que vous avez étiquetées dans la section précédente.

SQL

Utilisez l'instruction CREATE MODEL et spécifiez LOGISTIC_REG pour le type de modèle.

Voici quelques points utiles à connaître concernant l'instruction CREATE MODEL :

L'option input_label_cols spécifie la colonne de l'instruction SELECT à utiliser comme colonne d'étiquette. Ici, la colonne d'étiquette indique income_bracket. Le modèle détermine donc laquelle des deux valeurs de income_bracket est la plus probable pour cette ligne en fonction des autres valeurs présentes dans cette ligne.
Il n'est pas nécessaire de spécifier si un modèle de régression logistique est binaire ou multiclasse. BigQuery ML détermine le type de modèle à entraîner en fonction du nombre de valeurs uniques dans la colonne de libellé.
L'option auto_class_weights est définie sur TRUE afin d'équilibrer les libellés de classe dans les données d'entraînement. Par défaut, les données d'entraînement ne sont pas pondérées. Si les étiquettes des données d'entraînement sont déséquilibrées, le modèle peut apprendre à prédire en priorité la classe d'étiquettes la plus populaire. Dans ce cas, la plupart des personnes interrogées de l'ensemble de données se situent dans la tranche de revenu inférieure. Cela peut conduire à un modèle qui favorise trop la tranche de revenu inférieure. Les pondérations des classes équilibrent les étiquettes de classe en calculant des pondérations pour chaque classe de manière inversement proportionnelle à la fréquence de celle-ci.
L'option enable_global_explain est définie sur TRUE pour vous permettre d'utiliser la fonction ML.GLOBAL_EXPLAIN sur le modèle plus loin dans le tutoriel.
L'instruction SELECT interroge la vue input_data qui contient les exemples de données. La clause WHERE filtre les lignes afin que seules celles libellées en tant que données d'entraînement soient utilisées pour entraîner le modèle.

Exécutez la requête permettant de créer le modèle de régression logistique :

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 MODEL
`census.census_model`
OPTIONS
( model_type='LOGISTIC_REG',
  auto_class_weights=TRUE,
  enable_global_explain=TRUE,
  data_split_method='NO_SPLIT',
  input_label_cols=['income_bracket'],
  max_iterations=15) AS
SELECT * EXCEPT(dataframe)
FROM
`census.input_data`
WHERE
dataframe = 'training'

Dans le panneau de gauche, cliquez sur Explorer :
Dans le volet Explorateur, cliquez sur Ensembles de données.
Dans le volet Ensembles de données, cliquez sur census.
Cliquez sur l'onglet Modèles.
Cliquez sur census_model.
L'onglet Détails liste les attributs que BigQuery ML a utilisés pour effectuer une régression logistique.

BigQuery DataFrames

Utilisez la méthode fit pour entraîner le modèle et la méthode to_gbq pour l'enregistrer dans votre ensemble de données.

import bigframes.ml.linear_model

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

census_model = bigframes.ml.linear_model.LogisticRegression(
    # Balance the class labels in the training data by setting
    # class_weight="balanced".
    #
    # By default, the training data is unweighted. If the labels
    # in the training data are imbalanced, the model may learn to
    # predict the most popular class of labels more heavily. In
    # this case, most of the respondents in the dataset are in the
    # lower income bracket. This may lead to a model that predicts
    # the lower income bracket too heavily. Class weights balance
    # the class labels by calculating the weights for each class in
    # inverse proportion to the frequency of that class.
    class_weight="balanced",
    max_iterations=15,
)
census_model.fit(X, y)

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

Évaluer les performances du modèle

Après avoir créé le modèle, évaluez ses performances par rapport aux données d'évaluation.

SQL

La fonction ML.EVALUATE compare les valeurs de prédiction générées par le modèle aux données d'évaluation.

En entrée, la fonction ML.EVALUATE prend le modèle entraîné et les lignes de la vue input_data qui ont evaluation comme valeur pour la colonne dataframe. La fonction renvoie une seule ligne de statistiques concernant le modèle.

Exécutez la requête ML.EVALUATE :

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

Accéder à BigQuery

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

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

Les résultats ressemblent à ce qui suit :

BigQuery DataFrames

Vous allez utiliser la méthode score pour évaluer le modèle par rapport aux données réelles.

# Select model you'll use for predictions. `read_gbq_model` loads model
# data from BigQuery, but you could also use the `census_model` object
# from previous steps.
census_model = bpd.read_gbq_model(
    your_model_id,  # For example: "your-project.census.census_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 = census_model.score(X, y)
score.peek()
# Output:
#    precision    recall  accuracy  f1_score  log_loss   roc_auc
# 0   0.685764  0.536685   0.83819  0.602134  0.350417  0.882953

Vous pouvez également consulter le volet Évaluation du modèle dans la console Google Cloud pour afficher les métriques d'évaluation calculées pendant l'entraînement :

Résultat de ML.EVALUATE

Prédire la tranche de revenu

Utilisez le modèle pour prédire la tranche de revenu la plus probable pour chaque répondant.

SQL

Utilisez la fonction ML.PREDICT pour effectuer des prédictions sur la tranche de revenu probable. En entrée, la fonction ML.PREDICT prend le modèle entraîné et les lignes de la vue input_data qui ont prediction comme valeur pour la colonne dataframe.

Exécutez la requête ML.PREDICT :

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

Accéder à BigQuery

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

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

Les résultats ressemblent à ce qui suit :

La colonne predicted_income_bracket contient la tranche de revenus prévue pour le répondant.

BigQuery DataFrames

Utilisez la méthode predict pour effectuer des prédictions sur la tranche de revenu probable.

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

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

predictions = census_model.predict(prediction_data)
predictions.peek()
# Output:
#           predicted_income_bracket                     predicted_income_bracket_probs  age workclass  ... occupation  hours_per_week income_bracket   dataframe
# 18004                    <=50K  [{'label': ' >50K', 'prob': 0.0763305999358786...   75         ?  ...          ?               6          <=50K  prediction
# 18886                    <=50K  [{'label': ' >50K', 'prob': 0.0448866871906495...   73         ?  ...          ?              22           >50K  prediction
# 31024                    <=50K  [{'label': ' >50K', 'prob': 0.0362982319421936...   69         ?  ...          ?               1          <=50K  prediction
# 31022                    <=50K  [{'label': ' >50K', 'prob': 0.0787836112058324...   75         ?  ...          ?               5          <=50K  prediction
# 23295                    <=50K  [{'label': ' >50K', 'prob': 0.3385373037905673...   78         ?  ...          ?              32          <=50K  prediction

Expliquer les résultats des prédictions

Pour comprendre pourquoi votre modèle génère ces résultats de prédiction, vous pouvez utiliser la fonction ML.EXPLAIN_PREDICT.

ML.EXPLAIN_PREDICT est une version étendue de la fonction ML.PREDICT. La fonction ML.EXPLAIN_PREDICT génère non seulement des résultats de prédiction, mais elle produit également des colonnes supplémentaires servant à expliquer ces résultats. Pour en savoir plus sur l'explicabilité, consultez la présentation d'Explainable AI dans BigQuery ML.

Exécutez la requête ML.EXPLAIN_PREDICT :

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

Accéder à BigQuery

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

SELECT
*
FROM
ML.EXPLAIN_PREDICT(MODEL `census.census_model`,
  (
  SELECT
    *
  FROM
    `census.input_data`
  WHERE
    dataframe = 'evaluation'),
  STRUCT(3 as top_k_features));

Les résultats ressemblent à ce qui suit :

Pour les modèles de régression logistique, les valeurs de Shapley sont utilisées pour déterminer l'attribution relative des caractéristiques pour chaque caractéristique du modèle. Étant donné que l'option top_k_features a été définie sur 3 dans la requête, ML.EXPLAIN_PREDICT génère les trois premières attributions de caractéristiques pour chaque ligne de la vue input_data. Ces attributions sont affichées par ordre décroissant de la valeur absolue de l'attribution.

Expliquer globalement le modèle

Pour identifier les caractéristiques les plus importantes pour déterminer la tranche de revenu, utilisez la fonction ML.GLOBAL_EXPLAIN.

Obtenez des explications globales pour le modèle :

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

Accéder à BigQuery
Dans l'éditeur de requête, exécutez la requête suivante pour obtenir des explications globales :
```
SELECT
  *
FROM
  ML.GLOBAL_EXPLAIN(MODEL `census.census_model`)
```
Les résultats ressemblent à ce qui suit :