1. Présentation
Cet atelier vous présentera différents outils d'AI Platform Notebooks pour explorer vos données et prototyper des modèles de ML.
Objectifs de l'atelier
Vous allez apprendre à effectuer les opérations suivantes :
- Créer et personnaliser une instance AI Platform Notebooks
- Suivre le code de vos notebooks avec Git, directement intégré à AI Platform Notebooks
- Utiliser l'outil de simulation What-If dans votre notebook
Le coût total d'exécution de cet atelier sur Google Cloud est d'environ 1$. Pour en savoir plus sur les tarifs d'AI Platform Notebooks, cliquez ici.
2. Créer une instance AI Platform Notebooks
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 2 : Activez 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éez une instance de notebook
Accédez à la section AI Platform Notebooks de votre console Cloud, puis cliquez sur Nouvelle instance. Sélectionnez ensuite le dernier type d'instance TensorFlow 2 Enterprise sans GPU :
Attribuez un nom à votre instance ou utilisez le nom par défaut. Nous allons ensuite explorer les options de personnalisation. Cliquez sur le bouton Personnaliser :
AI Platform Notebooks propose de nombreuses options de personnalisation, y compris la région dans laquelle votre instance est déployée, le type d'image, la taille de la machine, le nombre de GPU, etc. Nous allons utiliser les valeurs par défaut pour la région et l'environnement. Pour la configuration de la machine, nous allons utiliser une machine n1-standard-8 :
Nous n'ajouterons aucun GPU et nous utiliserons les valeurs par défaut pour le disque de démarrage, la mise en réseau et les autorisations. Sélectionnez Créer pour créer votre instance. Cette opération prend quelques minutes.
Une fois l'instance créée, une coche verte s'affiche à côté dans l'interface utilisateur de Notebooks. Sélectionnez Ouvrir JupyterLab pour ouvrir votre instance et commencer le prototypage :
Lorsque vous ouvrez l'instance, créez un répertoire nommé "codelab". Il s'agit du répertoire à partir duquel nous allons travailler tout au long de cet atelier :
Cliquez sur le répertoire codelab que vous venez de créer en double-cliquant dessus, puis sélectionnez le notebook Python 3 dans le lanceur :
Remplacez le nom du notebook par demo.ipynb ou le nom de votre choix.
Étape 4 : Importez des packages Python
Créez une cellule dans le notebook et importez les bibliothèques que nous allons utiliser dans cet atelier de programmation :
import pandas as pd
import tensorflow as tf
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
import numpy as np
import json
from sklearn.model_selection import train_test_split
from sklearn.utils import shuffle
from google.cloud import bigquery
from witwidget.notebook.visualization import WitWidget, WitConfigBuilder
3. Connectez des données BigQuery à votre notebook
BigQuery, l'entrepôt de données volumineuses de Google Cloud, a rendu de nombreux ensembles de données publics pour que vous puissiez les explorer. AI Platform Notebooks est compatible avec l'intégration directe à BigQuery sans nécessiter d'authentification.
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 à la 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 à la naissance d'un bébé.
Étape 1 : Téléchargez des 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. 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 à 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é. 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 par sexe.
Étape 2 : Préparez l'ensemble de données pour l'entraînement
Maintenant que nous avons téléchargé l'ensemble de données dans notre notebook en tant que DataFrame Pandas, nous pouvons effectuer un prétraitement et le diviser en ensembles d'entraînement et de test.
Commençons par supprimer les lignes contenant des valeurs nulles de l'ensemble de données et mélangeons 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 contenant uniquement nos caractéristiques. Étant donné que is_male est une valeur booléenne, nous allons la convertir en entier afin que toutes les entrées de notre modèle soient numériques :
labels = df['weight_pounds']
data = df.drop(columns=['weight_pounds'])
data['is_male'] = data['is_male'].astype(int)
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.
4. Initialisez Git
AI Platform Notebooks est directement intégré à Git, ce qui vous permet d'effectuer le contrôle des versions directement dans votre environnement de notebook. Cela permet de valider le code directement dans l'interface utilisateur du notebook ou via le terminal disponible dans JupyterLab. Dans cette section, nous allons initialiser un dépôt Git dans notre notebook et effectuer notre premier commit via l'interface utilisateur.
Étape 1 : Initialisez un dépôt Git
Dans votre répertoire codelab, sélectionnez Git , puis Init dans la barre de menu supérieure de JupyterLab :
Lorsque vous êtes invité à faire de ce répertoire un dépôt Git, sélectionnez Oui. Sélectionnez ensuite l'icône Git dans la barre latérale de gauche pour afficher l'état de vos fichiers et commits :
Étape 2 : Effectuez votre premier commit
Dans cette interface utilisateur, vous pouvez ajouter des fichiers à un commit, afficher les différences entre les fichiers (nous y reviendrons plus tard) et valider vos modifications. Commençons par valider le fichier de notebook que nous venons d'ajouter.
Cochez la case à côté de votre fichier de notebook demo.ipynb pour le préparer au commit (vous pouvez ignorer le répertoire .ipynb_checkpoints/). Saisissez un message de commit dans la zone de texte, puis cliquez sur la coche pour valider vos modifications :
Lorsque vous y êtes invité, saisissez votre nom et votre adresse e-mail. Revenez ensuite à l'onglet Historique pour afficher votre premier commit :
Notez que les captures d'écran peuvent ne pas correspondre exactement à votre interface utilisateur, en raison des mises à jour effectuées depuis la publication de cet atelier.
5. Créez et entraînez un modèle TensorFlow
Nous allons utiliser l'ensemble de données sur la natalité BigQuery que nous avons téléchargé dans notre notebook pour créer un modèle qui prédit le poids du bébé. Dans cet atelier, nous allons nous concentrer sur les outils de notebook plutôt que sur la précision du modèle lui-même.
Étape 1 : Divisez vos données en ensembles d'entraînement et de test
Nous allons utiliser l'utilitaire train_test_split de Scikit Learn pour diviser nos données avant de créer notre modèle :
x,y = data,labels
x_train,x_test,y_train,y_test = train_test_split(x,y)
Nous sommes maintenant prêts à créer notre modèle TensorFlow.
Étape 2 : Créez et entraînez le modèle TensorFlow
Nous allons créer ce modèle à l'aide de l'API de modèle Sequential tf.keras, qui nous permet de définir notre modèle comme une pile de couches. Voici tout le code dont nous avons besoin pour créer notre modèle :
model = Sequential([
Dense(64, activation='relu', input_shape=(len(x_train.iloc[0]),)),
Dense(32, activation='relu'),
Dense(1)]
)
Nous allons ensuite compiler notre modèle afin de pouvoir l'entraîner. Nous allons choisir l'optimiseur, la fonction de perte et les métriques du modèle que nous souhaitons que le modèle enregistre pendant l'entraînement. Comme il s'agit d'un modèle de régression (prédiction d'une valeur numérique), nous utilisons l'erreur quadratique moyenne au lieu de la précision comme métrique :
model.compile(optimizer=tf.keras.optimizers.RMSprop(),
loss=tf.keras.losses.MeanSquaredError(),
metrics=['mae', 'mse'])
Vous pouvez utiliser la fonction pratique model.summary() de Keras pour afficher la forme et le nombre de paramètres entraînables de votre modèle à chaque couche.
Nous sommes maintenant prêts à entraîner notre modèle. Il suffit d'appeler la méthode fit(), en lui transmettant nos données et étiquettes d'entraînement. Nous allons utiliser le paramètre facultatif validation_split, qui contiendra une partie de nos données d'entraînement pour valider le modèle à chaque étape. Idéalement, vous souhaitez voir la perte d'entraînement et de validation diminuer. N'oubliez pas que dans cet exemple, nous nous concentrons davantage sur les outils de modèle et de notebook que sur la qualité du modèle :
model.fit(x_train, y_train, epochs=10, validation_split=0.1)
Étape 3 : Générez des prédictions sur des exemples de test
Pour voir les performances de notre modèle, générons quelques prédictions de test sur les 10 premiers exemples de notre ensemble de données de test.
num_examples = 10
predictions = model.predict(x_test[:num_examples])
Nous allons ensuite itérer sur les prédictions de notre modèle, en les comparant à la valeur réelle :
for i in range(num_examples):
print('Predicted val: ', predictions[i][0])
print('Actual val: ',y_test.iloc[i])
print()
Étape 4 : Utilisez git diff et validez vos modifications
Maintenant que vous avez apporté des modifications au notebook, vous pouvez essayer la fonctionnalité git diff disponible dans l'interface utilisateur Git de Notebooks. Le notebook demo.ipynb devrait maintenant se trouver dans la section "Modifié" de l'interface utilisateur. Pointez sur le nom de fichier, puis cliquez sur l'icône de différence :
Vous devriez alors voir une différence entre vos modifications, comme suit :
Cette fois, nous allons valider nos modifications via la ligne de commande à l'aide du terminal. Dans le menu Git de la barre de menu supérieure de JupyterLab, sélectionnez Commande Git dans le terminal. Si l'onglet Git de votre barre latérale gauche est ouvert lorsque vous exécutez les commandes ci-dessous, vous pourrez voir vos modifications reflétées dans l'interface utilisateur Git.
Dans votre nouvelle instance de terminal, exécutez la commande suivante pour préparer votre fichier de notebook au commit :
git add demo.ipynb
Exécutez ensuite la commande suivante pour valider vos modifications (vous pouvez utiliser le message de commit de votre choix) :
git commit -m "Build and train TF model"
Vous devriez alors voir votre dernier commit dans l'historique :
6. Utilisez l'outil de simulation What-If directement depuis votre notebook
L'outil de simulation What-If est une interface visuelle interactive conçue pour vous aider à visualiser vos ensembles de données et à mieux comprendre la sortie de vos modèles de ML. Il s'agit d'un outil Open Source créé par l'équipe PAIR de Google. Bien qu'il fonctionne avec n'importe quel type de modèle, certaines de ses fonctionnalités sont conçues exclusivement pour Cloud AI Platform.
L'outil de simulation What-If est préinstallé dans les instances Cloud AI Platform Notebooks avec TensorFlow. Nous allons l'utiliser pour voir les performances globales de notre modèle et inspecter son comportement sur les points de données de notre ensemble de test.
Étape 1 : Préparez les données pour l'outil de simulation What-If
Pour tirer le meilleur parti de l'outil de simulation What-If, nous allons lui envoyer des exemples de notre ensemble de test ainsi que les étiquettes de vérité terrain pour ces exemples (y_test). Nous pourrons ainsi comparer ce que notre modèle a prédit à la vérité terrain. Exécutez la ligne de code ci-dessous pour créer un DataFrame avec nos exemples de test et leurs étiquettes :
wit_data = pd.concat([x_test, y_test], axis=1)
Dans cet atelier, nous allons connecter l'outil de simulation What-If au modèle que nous venons d'entraîner dans notre notebook. Pour ce faire, nous devons écrire une fonction que l'outil utilisera pour exécuter ces points de données de test sur notre modèle :
def custom_predict(examples_to_infer):
preds = model.predict(examples_to_infer)
return preds
Étape 2 : Instanciez l'outil de simulation What-If
Nous allons instancier l'outil de simulation What-If en lui transmettant 500 exemples de l'ensemble de données de test concaténé + les étiquettes de vérité terrain que nous venons de créer. Nous allons créer une instance de WitConfigBuilder pour configurer l'outil, en lui transmettant nos données, la fonction de prédiction personnalisée que nous avons définie ci-dessus, ainsi que notre cible (ce que nous prédisons) et le type de modèle :
config_builder = (WitConfigBuilder(wit_data[:500].values.tolist(), data.columns.tolist() + ['weight_pounds'])
.set_custom_predict_fn(custom_predict)
.set_target_feature('weight_pounds')
.set_model_type('regression'))
WitWidget(config_builder, height=800)
Lorsque l'outil de simulation What-If se charge, vous devriez voir quelque chose comme ceci :
Sur l'axe des abscisses, vous pouvez voir vos points de données de test répartis par la valeur de poids prédite par le modèle, weight_pounds.
Étape 3 : Explorez le comportement du modèle avec l'outil de simulation What-If
Vous pouvez faire beaucoup de choses intéressantes avec l'outil de simulation What-If. Nous n'en examinerons que quelques-unes ici. Commençons par l'éditeur de points de données. Vous pouvez sélectionner n'importe quel point de données pour afficher ses caractéristiques et modifier les valeurs de caractéristiques. Commencez par cliquer sur un point de données :
Sur la gauche, vous verrez les valeurs de caractéristiques du point de données que vous avez sélectionné. Vous pouvez également comparer l'étiquette de vérité terrain de ce point de données avec la valeur prédite par le modèle. Dans la barre latérale de gauche, vous pouvez également modifier les valeurs de caractéristiques et réexécuter la prédiction du modèle pour voir l'effet de cette modification sur votre modèle. Par exemple, nous pouvons remplacer gestation_weeks par 30 pour ce point de données en double-cliquant dessus et en réexécutant la prédiction :
À l'aide des menus déroulants de la section de tracé de l'outil de simulation What-If, vous pouvez créer toutes sortes de visualisations personnalisées. Voici par exemple un graphique avec le poids prédit par les modèles sur l'axe des abscisses, l'âge de la mère sur l'axe des ordonnées et des points colorés par leur erreur d'inférence (plus la couleur est foncée, plus la différence entre le poids prédit et le poids réel est élevée). Il semble qu'à mesure que le poids diminue, l'erreur du modèle augmente légèrement :
Ensuite, cochez le bouton Tracés de dépendance partielle sur la gauche. Cela montre comment chaque caractéristique influence la prédiction du modèle. Par exemple, à mesure que le temps de gestation augmente, le poids du bébé prédit par notre modèle augmente également :
Pour obtenir d'autres idées d'exploration avec l'outil de simulation What-If, consultez les liens au début de cette section.
7. Facultatif : connectez votre dépôt Git local à GitHub
Enfin, nous allons apprendre à connecter le dépôt Git de notre instance de notebook à un dépôt de notre compte GitHub. Si vous souhaitez effectuer cette étape, vous aurez besoin d'un compte GitHub.
Étape 1 : Créez un dépôt sur GitHub
Dans votre compte GitHub, créez un dépôt. Attribuez-lui un nom et une description, indiquez si vous souhaitez qu'il soit public, puis sélectionnez Créer un dépôt (vous n'avez pas besoin d'initialiser avec un fichier README). Sur la page suivante, suivez les instructions pour envoyer un dépôt existant à partir de la ligne de commande.
Ouvrez une fenêtre de terminal et ajoutez votre nouveau dépôt en tant que dépôt distant. Remplacez username dans l'URL du dépôt ci-dessous par votre nom d'utilisateur GitHub et your-repo par le nom de celui que vous venez de créer :
git remote add origin git@github.com:username/your-repo.git
Étape 2 : Authentifiez-vous auprès de GitHub dans votre instance de notebooks
Vous devez ensuite vous authentifier auprès de GitHub à partir de votre instance de notebook. Ce processus varie selon que l'authentification à deux facteurs est activée ou non sur GitHub.
Si vous ne savez pas par où commencer, suivez les étapes de la documentation GitHub pour créer une clé SSH , puis ajouter la nouvelle clé à GitHub.
Étape 3 : Assurez-vous d'avoir correctement associé votre dépôt GitHub
Pour vous assurer que vous avez tout configuré correctement, exécutez git remote -v dans votre terminal. Votre nouveau dépôt devrait s'afficher en tant que dépôt distant. Une fois que vous voyez l'URL de votre dépôt GitHub et que vous vous êtes authentifié auprès de GitHub à partir de votre notebook, vous êtes prêt à envoyer directement des données vers GitHub à partir de votre instance de notebook.
Pour synchroniser votre dépôt Git de notebook local avec le dépôt GitHub que vous venez de créer, cliquez sur le bouton de chargement cloud en haut de la barre latérale Git :
Actualisez votre dépôt GitHub. Vous devriez voir le code de votre notebook avec vos commits précédents. Si d'autres personnes ont accès à votre dépôt GitHub et que vous souhaitez extraire les dernières modifications apportées à votre notebook, cliquez sur l'icône de téléchargement cloud pour synchroniser ces modifications.
Dans l'onglet "Historique" de l'interface utilisateur Git de Notebooks, vous pouvez voir si vos commits locaux sont synchronisés avec GitHub. Dans cet exemple, origin/master correspond à notre dépôt sur GitHub :
Chaque fois que vous effectuez de nouveaux commits, cliquez à nouveau sur le bouton de chargement cloud pour envoyer ces modifications vers votre dépôt GitHub.
8. Félicitations !
Vous avez fait beaucoup de choses dans cet atelier 👏👏👏
Pour récapituler, vous avez appris à effectuer les opérations suivantes :
- Créer et personnaliser une instance AI Platform Notebook
- Initialiser un dépôt Git local dans cette instance, ajouter des commits via l'interface utilisateur Git ou la ligne de commande, afficher les différences Git dans l'interface utilisateur Git de Notebooks
- Créer et entraîner un modèle TensorFlow 2 simple
- Utiliser l'outil de simulation What-If dans votre instance de notebook
- Connecter votre dépôt Git de notebook à un dépôt externe sur GitHub
9. 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, 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 votre console Cloud, accédez à "Stockage" et supprimez les deux buckets que vous avez créés pour stocker les éléments de votre modèle.