1. Présentation
Dans cet atelier, vous allez découvrir un workflow de ML complet sur GCP. Dans un environnement Cloud AI Platform Notebooks, vous ingérerez des données à partir d'un ensemble de données public BigQuery, créerez et entraînerez un modèle XGBoost, puis déploierez le modèle sur AI Platform pour la prédiction.
Objectifs de l'atelier
Vous allez apprendre à effectuer les opérations suivantes :
- Ingérer et analyser un ensemble de données BigQuery dans AI Platform Notebooks
- Créer un modèle XGBoost
- Déployer le modèle XGBoost sur AI Platform et obtenir des prédictions
Le coût total d'exécution de cet atelier sur Google Cloud est d'environ 1 $.
2. Configurez votre environnement.
Pour suivre cet atelier de programmation, vous aurez besoin d'un projet Google Cloud Platform dans lequel la facturation est activée. Pour créer un projet, suivez ces instructions.
Étape 1 : Activez l'API Cloud AI Platform Models
Accédez à la section "Modèles AI Platform" de la console Cloud, puis cliquez sur "Activer" si elle n'est pas déjà activée.
Étape 2 : Activez l'API Compute Engine
Accédez à Compute Engine et cliquez sur Activer si ce n'est pas déjà fait. Vous en aurez besoin pour créer votre instance de notebook.
Étape 3 : Créez une instance AI Platform Notebooks.
Accédez à la section AI Platform Notebooks de la console Cloud, puis cliquez sur Nouvelle instance. Sélectionnez ensuite le dernier type d'instance Python :
Utilisez les options par défaut, puis cliquez sur Créer. Une fois l'instance créée, sélectionnez Ouvrir JupyterLab :
Étape 4 : Installez XGBoost
Une fois votre instance JupyterLab ouverte, vous devez ajouter le package XGBoost.
Pour ce faire, sélectionnez "Terminal" dans le lanceur d'applications :
Exécutez ensuite la commande suivante pour installer la dernière version de XGBoost compatible avec AI Platform :
pip3 install xgboost==0.82
Une fois cette opération terminée, ouvrez une instance de notebook Python 3 à partir du lanceur. Vous pouvez maintenant commencer à utiliser votre notebook.
Étape 5 : Importer des packages Python
Dans la première cellule de votre notebook, ajoutez les importations suivantes et exécutez la cellule. Pour l'exécuter, appuyez sur le bouton en forme de flèche vers la droite dans le menu du haut ou appuyez sur Cmd+Entrée :
import pandas as pd
import xgboost as xgb
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.utils import shuffle
from google.cloud import bigquery
3. Explorer l'ensemble de données BigQuery
BigQuery a rendu de nombreux ensembles de données publics pour que vous puissiez les explorer. Pour cet atelier, nous allons utiliser l'ensemble de données sur la natalité. Il contient des données sur presque toutes les naissances aux États-Unis sur une période de 40 ans, y compris le poids de naissance de l'enfant et des informations démographiques sur ses parents. Nous allons utiliser un sous-ensemble des caractéristiques pour prédire le poids d'un bébé à la naissance.
Étape 1 : Téléchargez les données BigQuery dans notre notebook.
Nous utiliserons la bibliothèque cliente Python pour BigQuery afin de télécharger les données dans un DataFrame Pandas. Le jeu de données d'origine fait 21 Go et contient 123 millions de lignes. Pour plus de simplicité,nous n'utiliserons que 10 000 lignes de l'ensemble de données.
Construisez la requête et prévisualisez le DataFrame obtenu avec le code suivant. Ici, nous obtenons quatre caractéristiques de l'ensemble de données d'origine, ainsi que le poids du bébé (ce que notre modèle va prédire). L'ensemble de données remonte à de nombreuses années, mais pour ce modèle, nous n'utiliserons que les données postérieures à l'an 2000 :
query="""
SELECT
weight_pounds,
is_male,
mother_age,
plurality,
gestation_weeks
FROM
publicdata.samples.natality
WHERE year > 2000
LIMIT 10000
"""
df = bigquery.Client().query(query).to_dataframe()
df.head()
Pour obtenir un récapitulatif des caractéristiques numériques de notre ensemble de données, exécutez la commande suivante :
df.describe()
Il indique la moyenne, l'écart-type, le minimum et d'autres métriques pour nos colonnes numériques. Enfin, obtenons des données sur notre colonne booléenne indiquant le sexe du bébé. Pour ce faire, nous pouvons utiliser la méthode value_counts de Pandas :
df['is_male'].value_counts()
Il semble que l'ensemble de données soit presque équilibré (50/50) en termes de genre.
4. Préparer les données pour l'entraînement
Dans cette section, nous allons diviser les données en ensembles d'entraînement et de test pour les préparer à l'entraînement de notre modèle.
Étape 1 : Extrayez la colonne de libellés.
Commencez par supprimer les lignes contenant des valeurs nulles de l'ensemble de données, puis mélangez les données :
df = df.dropna()
df = shuffle(df, random_state=2)
Ensuite, extrayez la colonne d'étiquettes dans une variable distincte et créez un DataFrame avec uniquement nos caractéristiques :
labels = df['weight_pounds']
data = df.drop(columns=['weight_pounds'])
Si vous prévisualisez maintenant notre ensemble de données en exécutant data.head(), vous devriez voir les quatre caractéristiques que nous utiliserons pour l'entraînement.
Étape 2 : Convertissez les caractéristiques catégorielles en entiers.
Étant donné qu'XGBoost exige que toutes les données soient numériques, nous devrons modifier la façon dont nous représentons les données dans la colonne is_male, qui contient actuellement des chaînes "True" (Vrai) et "False" (Faux). Pour ce faire, il suffit de modifier le type de cette colonne :
data['is_male'] = data['is_male'].astype(int)
Étape 3 : Divisez les données en ensembles d'entraînement et de test
Nous allons utiliser l'utilitaire train_test_split de Scikit-Learn, que nous avons importé au début du notebook, pour diviser nos données en ensembles d'entraînement et de test :
x,y = data,labels
x_train,x_test,y_train,y_test = train_test_split(x,y)
Nous sommes maintenant prêts à créer et à entraîner notre modèle.
5. Présentation rapide de XGBoost
XGBoost est un framework de machine learning qui utilise des arbres de décision et le boosting de gradient pour créer des modèles prédictifs. Il fonctionne en assemblant plusieurs arbres de décision en fonction du score associé aux différents nœuds feuilles d'un arbre.
Le diagramme ci-dessous est une visualisation simplifiée d'un réseau d'arbres d'ensemble pour un modèle qui évalue si une personne aimera ou non un jeu vidéo spécifique (extrait de la documentation XGBoost) :
Pourquoi utilisons-nous XGBoost pour ce modèle ? Alors que les réseaux de neurones traditionnels se sont avérés les plus performants sur les données non structurées comme les images et le texte, les arbres de décision sont souvent extrêmement performants sur les données structurées comme l'ensemble de données hypothécaires que nous utiliserons dans cet atelier de programmation.
6. Créer, entraîner et évaluer un modèle XGBoost
Étape 1 : Définir et entraîner le modèle XGBoost
Créer un modèle dans XGBoost est simple. Nous utiliserons la classe XGBRegressor pour créer le modèle. Il nous suffit de transmettre le bon paramètre objective pour notre tâche spécifique. Ici, nous utilisons un modèle de régression, car nous prédisons une valeur numérique (le poids du bébé). Si nous devions plutôt regrouper nos données dans des buckets pour déterminer si un bébé pesait plus ou moins de 2,7 kg, nous utiliserions un modèle de classification.
Dans ce cas, nous utiliserons reg:squarederror comme objectif de notre modèle.
Le code suivant crée un modèle XGBoost :
model = xgb.XGBRegressor(
objective='reg:linear'
)
Vous pouvez entraîner le modèle avec une ligne de code, en appelant la méthode fit() et en lui transmettant les données et les libellés d'entraînement.
model.fit(x_train, y_train)
Étape 2 : Évaluer votre modèle sur des données de test
Nous pouvons maintenant utiliser notre modèle entraîné pour générer des prédictions sur nos données de test avec la fonction predict() :
y_pred = model.predict(x_test)
Voyons comment le modèle s'est comporté sur les 20 premières valeurs de notre ensemble de test. Nous allons maintenant afficher le poids du bébé prédit ainsi que le poids réel pour chaque exemple de test :
for i in range(20):
print('Predicted weight: ', y_pred[i])
print('Actual weight: ', y_test.iloc[i])
print()
Étape 3 : Enregistrez votre modèle
Pour déployer le modèle, exécutez le code suivant pour l'enregistrer dans un fichier local :
model.save_model('model.bst')
7. Déployer le modèle sur Cloud AI Platform
Notre modèle fonctionne en local, mais il serait intéressant de pouvoir faire des prédictions à partir de n'importe où (et pas seulement dans ce notebook). Au cours de cette étape, nous allons le déployer dans le cloud.
Étape 1 : Créez un bucket Cloud Storage pour notre modèle
Commençons par définir des variables d'environnement que nous utiliserons tout au long de l'atelier de programmation. Renseignez les valeurs ci-dessous avec le nom de votre projet Google Cloud, le nom du bucket Cloud Storage que vous souhaitez créer (il doit être unique au niveau mondial) et le nom de la première version de votre modèle :
# Update these to your own GCP project, model, and version names
GCP_PROJECT = 'your-gcp-project'
MODEL_BUCKET = 'gs://storage_bucket_name'
VERSION_NAME = 'v1'
MODEL_NAME = 'baby_weight'
Nous sommes maintenant prêts à créer un bucket de stockage pour stocker notre fichier de modèle XGBoost. Nous indiquerons ce fichier à Cloud AI Platform lors du déploiement.
Exécutez cette commande gsutil depuis votre notebook pour créer un bucket :
!gsutil mb $MODEL_BUCKET
Étape 2 : Copiez le fichier de modèle dans Cloud Storage
Ensuite, nous allons copier le fichier de modèle XGBoost enregistré dans Cloud Storage. Exécutez la commande gsutil suivante :
!gsutil cp ./model.bst $MODEL_BUCKET
Accédez au navigateur de stockage dans la console Cloud pour vérifier que le fichier a été copié :
Étape 3 : Créez et déployez le modèle
La commande gcloud ai-platform suivante crée un modèle dans votre projet. Nous l'appellerons xgb_mortgage :
!gcloud ai-platform models create $MODEL_NAME
Il est maintenant temps de déployer le modèle. Pour ce faire, utilisez la commande gcloud suivante :
!gcloud ai-platform versions create $VERSION_NAME \
--model=$MODEL_NAME \
--framework='XGBOOST' \
--runtime-version=1.15 \
--origin=$MODEL_BUCKET \
--python-version=3.7 \
--project=$GCP_PROJECT
Pendant l'exécution, consultez la section "Modèles" de votre console AI Platform. La nouvelle version devrait s'y déployer :
Une fois le déploiement terminé, une coche verte s'affiche à la place de l'icône de chargement. Le déploiement devrait prendre deux à trois minutes.
Étape 4 : Testez le modèle déployé
Pour vous assurer que votre modèle déployé fonctionne, testez-le à l'aide de gcloud pour effectuer une prédiction. Tout d'abord, enregistrez un fichier JSON avec deux exemples de notre ensemble de test :
%%writefile predictions.json
[0.0, 33.0, 1.0, 27.0]
[1.0, 26.0, 1.0, 40.0]
Testez votre modèle en enregistrant la sortie de la commande gcloud suivante dans une variable et en l'imprimant :
prediction = !gcloud ai-platform predict --model=$MODEL_NAME --json-instances=predictions.json --version=$VERSION_NAME
print(prediction.s)
La prédiction de votre modèle devrait s'afficher dans le résultat. Le poids réel du bébé pour ces deux exemples est respectivement de 1,9 livre et 8,1 livres.
8. Nettoyage
Si vous souhaitez continuer à utiliser ce notebook, nous vous recommandons de le désactiver quand vous ne vous en servez pas. À partir de l'interface utilisateur de Notebooks dans la console Cloud, sélectionnez le notebook et cliquez sur Arrêter :
Si vous souhaitez supprimer toutes les ressources que vous avez créées dans cet atelier, supprimez simplement l'instance de notebook au lieu de l'arrêter.
À l'aide du menu de navigation de la console Cloud, accédez à "Stockage" et supprimez les deux buckets que vous avez créés pour stocker les composants de votre modèle.