1. Présentation
Dans cet atelier, vous allez suivre un workflow de ML complet sur GCP. À partir d'un environnement Cloud AI Platform Notebooks, vous ingérerez les données d'un ensemble de données public BigQuery, vous créerez et entraînerez un modèle XGBoost, puis vous déploierez le modèle sur AI Platform à des fins de 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 ces instructions.
Étape 1: Activez l'API Cloud AI Platform Models
Accédez à la section Modèles AI Platform de Cloud Console, 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 l'opération terminée, ouvrez une instance de notebook Python 3 à partir du lanceur. Vous êtes prêt à commencer dans votre notebook !
Étape 5: Importez les packages Python
Dans la première cellule de votre notebook, ajoutez les importations suivantes et exécutez la cellule. Vous pouvez l'exécuter en appuyant sur la flèche vers la droite dans le menu supérieur ou en appuyant 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 mis de nombreux ensembles de données à la disposition du public pour que vous puissiez les explorer. Dans 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 de caractéristiques pour prédire le poids de naissance d'un bébé.
Étape 1: Téléchargez les données BigQuery dans notre notebook
Pour télécharger les données dans un DataFrame Pandas, nous allons utiliser la bibliothèque cliente Python pour BigQuery. 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 du jeu de données.
Créez 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 des 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 montre 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 Pandas, Méthode value_counts:
df['is_male'].value_counts()
Il semble que l'ensemble de données est presque équilibré à 50/50 par 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 en ensembles de test afin de les préparer à l'entraînement de notre modèle.
Étape 1: Extrayez la colonne d'étiquette
Commencez par supprimer les lignes contenant des valeurs nulles de l'ensemble de données et brassez les données:
df = df.dropna()
df = shuffle(df, random_state=2)
Ensuite, extrayez la colonne d'étiquette 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 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: Convertissez les caractéristiques catégorielles en entiers
Étant donné que XGBoost nécessite que toutes les données soient numériques, nous devons modifier la façon dont les données sont représentées dans la colonne is_male, qui correspond actuellement à des chaînes vrai / faux. Pour ce faire, il suffit de modifier le type de cette colonne:
data['is_male'] = data['is_male'].astype(int)
Étape 3: Répartissez 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 l'optimisation de gradient pour créer des modèles prédictifs. Il assemble plusieurs arbres de décision ensemble 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'arborescence d'ensembles pour un modèle qui évalue si quelqu'un aimera un jeu informatique spécifique (à partir de la documentation XGBoost):
Pourquoi utilisons-nous XGBoost pour ce modèle ? Bien qu'il s'avère que les réseaux de neurones traditionnels fonctionnent mieux sur des données non structurées comme les images et le texte, les arbres de décision sont souvent très performants sur les données structurées, comme l'ensemble de données hypothécaire que nous utiliserons dans cet atelier de programmation.
6. Créer, entraîner et évaluer un modèle XGBoost
Étape 1: Définissez et entraînez le modèle XGBoost
Dans XGBoost, la création d'un modèle est simple. Nous allons utiliser la classe XGBRegressor pour créer le modèle. Il nous suffit de transmettre le paramètre objective approprié 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 procédions plutôt au binning de nos données pour déterminer si un bébé pesait plus ou moins de 6 livres, nous utiliserions un modèle de classification.
Dans ce cas, nous utiliserons reg:squarederror comme objectif du 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 d'entraînement et les étiquettes.
model.fit(x_train, y_train)
Étape 2: Évaluer votre modèle sur les 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 les performances du modèle pour les 20 premières valeurs de notre ensemble de test. Nous affichons ci-dessous le poids estimé d'un bébé ainsi que son 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, enregistrez-le dans un fichier local en exécutant le code suivant:
model.save_model('model.bst')
7. Déployer le modèle sur Cloud AI Platform
Notre modèle fonctionne en local, mais il serait utile que nous puissions faire des prédictions depuis n'importe où (pas seulement depuis 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 certaines variables d'environnement que nous utiliserons 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 (il doit être unique) et le nom de la version 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 la commande gsutil suivante depuis votre notebook pour créer un bucket:
!gsutil mb $MODEL_BUCKET
Étape 2: Copiez le fichier de modèle dans Cloud Storage
Nous allons maintenant copier notre fichier de modèle enregistré XGBoost dans Cloud Storage. Exécutez la commande gsutil suivante:
!gsutil cp ./model.bst $MODEL_BUCKET
Accédez au navigateur de stockage de votre console Cloud pour vérifier que le fichier a bien é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 appellerons celui-ci xgb_mortgage:
!gcloud ai-platform models create $MODEL_NAME
Il est maintenant temps de déployer le modèle. Pour ce faire, exécutez 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 la console AI Platform. Votre nouvelle version devrait s'y déployer:
Une fois le déploiement terminé, une coche verte s'affiche à l'emplacement 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. Commencez par enregistrer un fichier JSON avec deux exemples tirés 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 le résultat 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 doit s'afficher dans le résultat. Pour ces deux exemples, le poids réel du bébé est de 7,5 kg et 8,1 livres, respectivement.
8. Nettoyage
Si vous souhaitez continuer à utiliser cet ordinateur portable, nous vous recommandons de le désactiver lorsqu'il n'est pas utilisé. À partir de l'interface utilisateur de Notebooks dans Cloud Console, sélectionnez le notebook, puis cliquez sur Arrêter:
Si vous souhaitez supprimer toutes les ressources que vous avez créées au cours de cet atelier, il vous suffit de supprimer l'instance de notebook au lieu de l'arrêter.
À l'aide du menu de navigation de Cloud Console, accédez à "Storage" (Stockage) et supprimez les deux buckets que vous avez créés pour stocker les ressources de votre modèle.