1. Présentation
Cet atelier vous présente les 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 ces instructions.
Étape 2: Activer 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 le nom par défaut. Nous allons ensuite explorer les options de personnalisation. Cliquez sur le bouton Customize (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 utiliserons les valeurs par défaut pour la région et l'environnement. Pour la configuration de la machine, nous utiliserons 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é d'elle 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". Voici le répertoire à partir duquel nous allons travailler tout au long de cet atelier:
Double-cliquez sur le répertoire codelab que vous venez de créer, puis sélectionnez le notebook Python 3 dans le lanceur:
Renommez le bloc-notes demo.ipynb ou donnez-lui un autre nom.
Étape 4: Importer des 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 données big data de Google Cloud, met à votre disposition de nombreux ensembles de données publics. AI Platform Notebooks permet une intégration directe à BigQuery sans 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 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 des données BigQuery dans notre notebook
Nous allons utiliser la bibliothèque cliente Python pour BigQuery pour 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 simplifier,nous n'utiliserons que 10 000 lignes de l'ensemble 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 prédira). L'ensemble de données remonte à plusieurs 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()
Il affiche la moyenne, l'écart type, la valeur minimale 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 genre.
Étape 2: Préparer 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 mélangeons 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. É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 notre ensemble de données en exécutant data.head(), vous devriez voir les quatre caractéristiques que nous utiliserons pour l'entraînement.
4. Initialiser Git
AI Platform Notebooks est intégré directement à Git. Vous pouvez ainsi gérer les versions directement dans votre environnement de notebook. Vous pouvez ainsi 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'UI.
Étape 1: Initialisez 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:
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 de vos 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 l'ajouter à l'étape de préparation du commit (vous pouvez ignorer le répertoire .ipynb_checkpoints/). Saisissez un message de validation 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 Historique pour voir 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éer et entraîner 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 capable de prédire le poids des bébés. Dans cet atelier, nous allons nous concentrer sur les outils de notebook plutôt que sur la justesse 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éer et entraîner 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. Tout le code dont nous avons besoin pour créer notre modèle est ici:
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 pour pouvoir l'entraîner. Ici, nous allons choisir l'optimiseur, la fonction de perte et les métriques que nous souhaitons que le modèle enregistre pendant l'entraînement. Comme il s'agit d'un modèle de régression (prédisant une valeur numérique), nous utilisons l'erreur quadratique moyenne plutôt que la justesse comme métrique:
model.compile(optimizer=tf.keras.optimizers.RMSprop(),
loss=tf.keras.losses.MeanSquaredError(),
metrics=['mae', 'mse'])
Vous pouvez utiliser la fonction model.summary() pratique de Keras pour afficher la forme et le nombre de paramètres enregistrables de votre modèle à chaque couche.
Nous sommes maintenant prêts à entraîner notre modèle. Il nous 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 validation_split facultatif, qui contiendra une partie de nos données d'entraînement pour valider le modèle à chaque étape. Dans l'idéal, la perte d'entraînement et de validation doit toujours 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érer des prédictions sur des exemples de test
Pour évaluer les performances de notre modèle, générons 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])
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 effectuez un commit de vos modifications
Maintenant que vous avez apporté des modifications au notebook, vous pouvez essayer la fonctionnalité de comparaison Git disponible dans l'interface utilisateur Git des notebooks. Le notebook demo.ipynb devrait maintenant figurer dans la section "Modifié" de l'interface utilisateur. Pointez sur le nom de fichier, puis cliquez sur l'icône de comparaison:
Vous devriez alors voir une comparaison de 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 la barre latérale de gauche est ouvert lorsque vous exécutez les commandes ci-dessous, vous verrez vos modifications reflétées dans l'interface utilisateur de git.
Dans votre nouvelle instance de terminal, exécutez la commande suivante pour préparer votre fichier notebook à être validé:
git add demo.ipynb
Exécutez ensuite 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 devrait alors s'afficher dans l'historique:
6. Utiliser l'outil de simulation What-If directement depuis votre notebook
L'outil 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, il dispose de certaines fonctionnalités conçues exclusivement pour Cloud AI Platform.
L'outil What-If est préinstallé dans les instances Cloud AI Platform Notebooks avec TensorFlow. Nous allons l'utiliser ici pour voir les performances globales de notre modèle et examiner son comportement sur les points de données de notre ensemble de test.
Étape 1: Préparer les données pour l'outil d'analyse des scénarios
Pour exploiter pleinement l'outil "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 libellés:
wit_data = pd.concat([x_test, y_test], axis=1)
Dans cet atelier, nous allons connecter l'outil 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: Instancier l'outil d'analyse des scénarios
Nous allons instancier l'outil "What-If" (Et si ?) en lui transmettant 500 exemples de l'ensemble de données de test concaténé et les é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, ainsi que notre cible (l'élément 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)
L'écran qui s'affiche devrait ressembler à celui-ci:
Sur l'axe X, vous pouvez voir vos points de données de test répartis en fonction de la valeur de poids prévue du modèle, weight_pounds.
Étape 3: Explorer le comportement du modèle avec l'outil What-If
L'outil de simulation What-If vous permet de faire de nombreuses choses intéressantes. Nous n'en explorerons que quelques-uns 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 leurs valeurs. Commencez par cliquer sur un point de données:
Sur la gauche, vous trouverez les valeurs des éléments géographiques 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 du modèle pour voir l'impact de cette modification sur votre modèle. Par exemple, nous pouvons remplacer la valeur "30" pour "weeks_gestation" pour ce point de données en double-cliquant dessus et en exécutant à nouveau la prédiction:
Les menus déroulants de la section "Graphique" de l'outil "Et si ?" vous permettent de créer toutes sortes de visualisations personnalisées. Par exemple, voici un graphique avec le poids prévu des modèles sur l'axe X, l'âge de la mère sur l'axe Y et des points de couleur selon leur erreur d'inférence (plus la couleur est foncée, plus la différence entre le poids prévu et le poids réel est importante). Ici, il semble que lorsque la pondération diminue, l'erreur du modèle augmente légèrement:
Ensuite, cochez le bouton Graphiques de dépendance partielle sur la gauche. Cela montre comment chaque caractéristique influence la prédiction du modèle. Par exemple, à mesure que la durée de gestation augmente, le poids du bébé prédit par notre modèle augmente également:
Pour plus d'idées d'exploration avec l'outil What-If, consultez les liens au début de cette section.
7. Facultatif: connecter 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. Pour effectuer cette étape, vous avez besoin d'un compte GitHub.
Étape 1: Créer 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 de l'initialiser avec un fichier README). Sur la page suivante, vous allez suivre les instructions pour pousser 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: S'authentifier auprès de GitHub dans votre instance Notebooks
Vous devez ensuite vous authentifier sur GitHub depuis votre instance de notebook. Cette procédure varie selon que vous avez activé l'authentification à deux facteurs 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 configuré correctement les éléments, exécutez git remote -v dans votre terminal. Votre nouveau dépôt doit apparaître en tant que dépôt à distance. Une fois que vous voyez l'URL de votre dépôt GitHub et que vous vous êtes authentifié sur GitHub depuis votre notebook, vous pouvez envoyer des modifications directement sur GitHub depuis votre instance de notebook.
Pour synchroniser votre dépôt Git de notebook local avec votre dépôt GitHub nouvellement créé, 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 avec 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 dans le nuage pour synchroniser ces modifications.
Dans l'onglet "Historique" de l'interface utilisateur Git des 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 un commit, il vous suffit de cliquer à nouveau sur le bouton d'importation dans le cloud pour envoyer ces modifications à votre dépôt GitHub.
8. Félicitations !
Vous avez accompli beaucoup de choses dans cet atelier 👏👏👏
Pour récapituler, vous avez appris à:
- Créer et personnaliser une instance de notebook AI Platform
- Initialisez un dépôt Git local dans cette instance, ajoutez des commits via l'interface utilisateur ou la ligne de commande Git, et affichez les différences Git dans l'interface utilisateur Git du notebook.
- Créer et entraîner un modèle TensorFlow 2 simple
- Utiliser l'outil 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. Dans l'interface utilisateur de Notebooks de la console Cloud, sélectionnez le notebook, puis cliquez sur Arrêter:
Si vous souhaitez supprimer toutes les ressources que vous avez créées dans cet atelier, il vous suffit de supprimer l'instance de notebook au lieu de l'arrêter.
Dans le menu de navigation de la console Cloud, accédez à "Stockage", puis supprimez les deux buckets que vous avez créés pour stocker les composants de votre modèle.