1. Présentation
Dans cet atelier, vous allez découvrir divers outils disponibles dans 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
- Suivez 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 ces instructions.
É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 de notebook
Accédez à la section AI Platform Notebooks de la 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 la valeur par défaut. Ensuite, nous examinerons les options de personnalisation. Cliquez sur le bouton Customize (Personnaliser) :
AI Platform Notebooks propose de nombreuses options de personnalisation différentes, 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 utiliserons les valeurs par défaut pour la région et l'environnement. Pour configurer 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é de celle-ci 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é "atelier de programmation". Voici le répertoire à partir duquel nous allons travailler tout au long de cet atelier:
Double-cliquez sur le répertoire de l'atelier de programmation que vous venez de créer, puis sélectionnez le notebook Python 3 dans le lanceur:
Renommez le notebook demo.ipynb ou donnez-lui le nom de votre choix.
Étape 4: Importez les packages Python
Créez une cellule dans le notebook et importez les bibliothèques que nous utiliserons 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. Connecter des données BigQuery à votre notebook
BigQuery, l'entrepôt de big data de Google Cloud, met à votre disposition de nombreux ensembles de données publics pour que vous puissiez les explorer. AI Platform Notebooks permet l'intégration directe à BigQuery sans authentification.
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é. 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 est presque équilibré à 50/50 par genre.
É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.
Tout d'abord, supprimons les lignes contenant des valeurs nulles de l'ensemble de données et brassons 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 ne contenant que nos caractéristiques. Comme is_male est une valeur booléenne, nous la convertirons 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 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. Initialiser git
AI Platform Notebooks s'intègre directement à Git, ce qui vous permet d'effectuer un contrôle des versions directement dans votre environnement de notebook. Cela permet de valider du 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: Initialiser un dépôt Git
Dans le répertoire de votre atelier de programmation, sélectionnez Git, puis Init dans la barre de menu supérieure de JupyterLab:
Lorsqu'il vous demande si vous souhaitez transformer ce répertoire en dépôt Git, sélectionnez Yes (Oui). Sélectionnez ensuite l'icône Git dans la barre latérale 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, voir les différences entre les fichiers (nous y reviendrons plus tard) et valider vos modifications. Commençons par valider le fichier notebook que nous venons d'ajouter.
Cochez la case à côté de votre fichier notebook demo.ipynb afin de le préparer pour le 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:
Saisissez votre nom et votre adresse e-mail lorsque vous y êtes invité. Revenez ensuite à l'onglet History (Historique) pour voir votre premier commit:
Notez qu'il est possible que les captures d'écran ne correspondent pas exactement à votre interface utilisateur en raison de modifications apportées depuis la publication de cet atelier.
5. Créer et entraîner un modèle TensorFlow
Nous allons utiliser l'ensemble de données BigQuery sur la natalité que nous avons téléchargé dans notre notebook pour créer un modèle capable de prédire le poids des bébés. Dans cet atelier, nous allons nous concentrer sur les outils du notebook, plutôt que sur la précision du modèle lui-même.
Étape 1: Répartir vos données en ensembles d'entraînement et de test
Nous allons nous servir de l'utilitaire scikit-learn train_test_split pour diviser les données avant de créer le 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 en tant que pile de couches. Tout le code dont nous avons besoin pour créer notre modèle se trouve ici:
model = Sequential([
Dense(64, activation='relu', input_shape=(len(x_train.iloc[0]),)),
Dense(32, activation='relu'),
Dense(1)]
)
Ensuite, nous compilons notre modèle pour l'entraîner. Nous allons choisir l'optimiseur, la fonction de perte et les métriques du modèle que le modèle doit enregistrer 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 justesse comme métrique:
model.compile(optimizer=tf.keras.optimizers.RMSprop(),
loss=tf.keras.losses.MeanSquaredError(),
metrics=['mae', 'mse'])
La fonction pratique model.summary() de Keras vous permet d'afficher la forme et le nombre de paramètres pouvant être entraînés de votre modèle au niveau de 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 d'entraînement et nos étiquettes. Ici, nous allons utiliser le paramètre facultatif validation_split, qui contiendra une partie des données d'entraînement permettant de valider le modèle à chaque étape. Dans l'idéal, la perte d'entraînement et de validation doit toutes les deux diminuer. N'oubliez pas que, dans cet exemple, nous nous concentrons davantage sur les outils des modèles et des notebooks plutôt 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 à partir d'exemples de test
Pour connaître les performances de notre modèle, nous allons générer des 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])
Ensuite, nous itérerons 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 la commande 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'UI Git de Notebooks. Le notebook demo.ipynb devrait maintenant se trouver sous le libellé "Modifié" de l'interface utilisateur. Passez la souris sur le nom du fichier et 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 de 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 la barre latérale gauche est ouvert pendant que vous exécutez les commandes ci-dessous, vos modifications sont répercutées dans l'interface utilisateur Git.
Dans votre nouvelle instance de terminal, exécutez la commande suivante pour préparer votre fichier notebook pour le commit:
git add demo.ipynb
Ensuite, exécutez la commande suivante pour valider vos modifications (vous pouvez utiliser le message de validation de votre choix):
git commit -m "Build and train TF model"
Votre dernier commit doit s'afficher dans l'historique:
6. Utiliser 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 les résultats 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 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 évaluer les performances globales de notre modèle et inspecter son comportement sur des 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 lui enverrons des exemples issus de notre ensemble de test, ainsi que les étiquettes de vérité terrain associées à ces exemples (y_test). Nous pouvons ainsi comparer les prédictions du modèle à la vérité terrain. Exécutez la ligne de code ci-dessous pour créer un DataFrame contenant 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é et des étiquettes de vérité terrain que nous venons de créer. Nous créons 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, 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)
Une page de ce type devrait s'afficher lorsque l'outil de simulation What-If se charge:
Sur l'axe des abscisses, les points de données de test sont répartis selon la valeur de pondération prédite du modèle, weight_pounds.
Étape 3: Examinez le comportement du modèle avec l'outil de simulation What-If
L'outil de simulation What-If offre de nombreuses possibilités intéressantes. Nous n'en explorerons que quelques-unes ici. Commençons par examiner 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 des caractéristiques. Commencez par cliquer sur un point de données:
Sur la gauche s'affichent les valeurs des caractéristiques pour le 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 à la valeur prédite par le modèle. Dans la barre latérale de gauche, vous pouvez également modifier les valeurs des caractéristiques et réexécuter la prédiction pour observer 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 Tracé de l'outil de simulation What-If, vous pouvez créer toutes sortes de visualisations personnalisées. Par exemple, voici un graphique avec les données le poids prédit sur l'axe des x, l'âge de la mère sur l'axe des y et les points colorés par l'erreur d'inférence (plus le fond est foncé, plus l'écart entre le poids prédit et le poids réel est élevé). Dans cet exemple, lorsque le poids diminue, l'erreur du modèle augmente légèrement:
Cochez ensuite le bouton Partial dépendant plots (Graphiques de dépendance partielle) à gauche. Cela montre comment chaque caractéristique influence la prédiction du modèle. Par exemple, plus la durée de la grossesse augmente, le poids estimé du bébé par notre modèle augmente également:
Pour découvrir d'autres idées d'exploration avec l'outil de simulation What-If, consultez les liens au début de cette section.
7. Facultatif: connecter votre dépôt Git local à GitHub
Enfin, nous apprendrons à 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 devez disposer d'un compte GitHub.
Étape 1: Créez un dépôt sur GitHub
Dans votre compte GitHub, créez un dépôt. Donnez-lui un nom et une description, décidez si vous souhaitez qu'il soit public, puis sélectionnez Créer un dépôt (vous n'avez pas besoin de l'initialiser avec un fichier README). Sur la page suivante, vous allez suivre les instructions pour transférer 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 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 notebook
Vous devez ensuite vous authentifier auprès de GitHub depuis 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 la procédure décrite dans la documentation GitHub pour créer une clé SSH, puis ajoutez la nouvelle clé à GitHub.
Étape 3: Assurez-vous d'avoir correctement associé votre dépôt GitHub
Pour vous assurer que la configuration est correcte, exécutez git remote -v dans votre terminal. Votre nouveau dépôt devrait apparaître dans la liste des dépôts distants. Une fois que vous avez vu l'URL de votre dépôt GitHub et que vous vous êtes authentifié auprès de GitHub depuis votre notebook, vous pouvez transférer directement les données vers GitHub depuis votre instance de notebook.
Pour synchroniser le dépôt git de votre notebook local avec le dépôt GitHub que vous venez de créer, cliquez sur le bouton d'importation dans le cloud en haut de la barre latérale Git:
Actualisez votre dépôt GitHub. Vous devriez voir le code de votre notebook contenant vos commits précédents. Si d'autres utilisateurs ont accès à votre dépôt GitHub et que vous souhaitez récupérer 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 "History" (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, il vous suffit de cliquer à nouveau sur le bouton d'importation dans le cloud pour appliquer ces modifications à votre dépôt GitHub.
8. Félicitations !
Vous avez fait beaucoup de choses dans cet atelier 👏👏👏
Pour récapituler, vous avez appris à:
- Créer une instance AI Platform Notebook personnalisée
- Initialiser un dépôt Git local dans cette instance, ajouter des commits via l'UI ou la ligne de commande Git, afficher les différences git dans l'UI git du notebook
- Créer et entraîner un modèle TensorFlow 2 simple
- Utiliser l'outil de simulation What-If dans votre instance de notebook
- Connecter le dépôt Git de votre notebook à un dépôt externe sur GitHub
9. 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.