1. Présentation
Dans cet atelier, vous allez découvrir un workflow de ML complet sur GCP. À partir d'un environnement Cloud AI Platform Notebooks, vous allez ingérer des données à partir d'un ensemble de données public BigQuery, créer et entraîner un modèle XGBoost, puis le déployer 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. Configurer 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 les instructions ici.
Étape 1 : Activer l'API Cloud AI Platform Models
Accédez à la section AI Platform Models de la console Cloud et cliquez sur "Activer" si elle n'est pas déjà activée.
Étape 2 : Activer l'API Compute Engine
Accédez à Compute Engine et sélectionnez Activer si elle n'est pas déjà activée. Vous en aurez besoin pour créer votre instance de notebook.
Étape 3 : Créer une instance AI Platform Notebooks
Accédez à la section AI Platform Notebooks de la console Cloud et 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 : Installer XGBoost
Une fois votre instance JupyterLab ouverte, vous devez ajouter le package XGBoost.
Pour ce faire, sélectionnez "Terminal" dans le lanceur :
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 l'opération terminée, ouvrez une instance de notebook Python 3 à partir du lanceur. Vous êtes prêt à 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 flèche vers la droite dans le menu supérieur ou sur Commande+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 disponibles pour votre exploration. 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 les parents du bébé. Nous allons utiliser un sous-ensemble des caractéristiques pour prédire le poids de naissance d'un bébé.
Étape 1 : Télécharger les données BigQuery dans notre notebook
Nous allons utiliser la bibliothèque cliente Python pour BigQuery afin de télécharger les données dans un DataFrame Pandas. L'ensemble de données d'origine fait 21 Go et contient 123 millions de lignes. Pour simplifier,nous n'utiliserons que 10 000 lignes de l'ensemble de données.
Créez la requête et prévisualisez le DataFrame résultant avec le code suivant. Nous obtenons ici 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 à 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ésumé des caractéristiques numériques de notre ensemble de données, exécutez la commande suivante :
df.describe()
Cela affiche 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é. Nous pouvons le faire avec 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 par sexe.
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 : Extraire la colonne d'étiquettes
Commencez par supprimer les lignes contenant des valeurs nulles de l'ensemble de données et mélangez les données :
df = df.dropna()
df = shuffle(df, random_state=2)
Extrayez ensuite la colonne d'étiquettes dans une variable distincte et créez un DataFrame contenant 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 allons utiliser pour l'entraînement.
Étape 2 : Convertir les caractéristiques catégorielles en entiers
Étant donné que XGBoost exige que toutes les données soient numériques, nous devons modifier la façon dont nous représentons les données dans la colonne is_male, qui contient actuellement des chaînes True / False. Pour ce faire, il suffit de modifier le type de cette colonne :
data['is_male'] = data['is_male'].astype(int)
Étape 3 : Diviser 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. Introduction rapide à XGBoost
XGBoost est un framework de machine learning qui utilise des arbres de décision et un 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 schéma 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 neuronaux traditionnels se sont avérés les plus performants sur des données non structurées telles que des images et du texte, les arbres de décision sont souvent extrêmement performants sur des données structurées telles que l'ensemble de données sur les prêts immobiliers que nous allons utiliser 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 allons utiliser la classe XGBRegressor pour créer le modèle, et nous n'avons qu'à transmettre le bon paramètre objective pour notre tâche spécifique. Nous utilisons ici 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 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 allons utiliser 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 seule ligne de code, en appelant la méthode fit() et en lui transmettant les données et les étiquettes 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 imprimer ci-dessous le poids prédit du bébé ainsi que le poids réel du bébé 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 : Enregistrer 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 effectuer des prédictions à partir de n'importe où (et pas seulement de ce notebook). Dans cette étape, nous allons le déployer dans le cloud.
Étape 1 : Créer un bucket Cloud Storage pour notre modèle
Commençons par définir des variables d'environnement que nous allons utiliser tout au long de cet 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 (doit être globalement unique) 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 allons pointer Cloud AI Platform vers ce fichier lors du déploiement.
Exécutez cette commande gsutil depuis votre notebook pour créer un bucket :
!gsutil mb $MODEL_BUCKET
Étape 2 : Copier le fichier de modèle dans Cloud Storage
Nous allons ensuite copier notre 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éer et déployer le modèle
La commande gcloud ai-platform suivante crée un modèle dans votre projet. Nous allons l'appeler xgb_mortgage :
!gcloud ai-platform models create $MODEL_NAME
Il est maintenant temps de déployer le modèle. Nous pouvons le faire avec cette commande gcloud :
!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. Vous devriez voir votre nouvelle version en cours de déploiement :
Une fois le déploiement terminé, une coche verte s'affiche à l'emplacement de l'icône de chargement. Le déploiement devrait prendre 2 à 3 minutes.
Étape 4 : Tester 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. Commencez par enregistrer un fichier JSON contenant 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)
Vous devriez voir la prédiction de votre modèle dans la sortie. Le poids réel du bébé pour ces deux exemples est respectivement de 0,86 kg et 3,67 kg.
8. Nettoyage
Si vous souhaitez continuer à utiliser ce notebook, nous vous recommandons de le désactiver lorsque vous ne l'utilisez pas. À partir de l'interface utilisateur de Notebooks dans la console Cloud, sélectionnez le notebook, puis sélectionnez 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.
Dans le menu de navigation de la console Cloud, accédez à "Stockage" et supprimez les deux buckets que vous avez créés pour stocker les éléments de votre modèle.