Google Colab : Le guide Ultime

C’est quoi Google Colab ?

Google Colab  ou Colaboratory est un service cloud, offert par Google (gratuit), basé sur Jupyter Notebook et destiné à la formation et à la recherche dans l’apprentissage automatique. Cette plateforme permet d’entraîner des modèles de Machine Learning directement dans le cloud. Sans donc avoir besoin d’installer quoi que ce soit sur notre ordinateur à l’exception d’un navigateur. Cool, n’est ce pas ? Avant de présenter ce magnifique service, nous rappellerons ce qu’est un Jupyter Notebook.

Jupyter Notebook: l’outil incontournable du data scientist

Jupyter Notebook est une application Web Open Source permettant de créer et de partager des documents contenant du code (exécutable directement dans le document), des équations, des images et du texte. Avec cette application il est possible de faire du traitement de données, de la modélisation statistique, de la visualisation de données, du Machine Learning, etc. Elle est disponible par défaut dans la distribution Anaconda (suivre ce lien pour savoir comment l’installer).
Dans un terminal après installation il vous suffit d’entrer la commande suivante :

jupyter notebook

L’interface se présentera ainsi :

Ainsi, c’est sur cet outil qu’est basé Google Colaboratory.

Google Colab, La version cloud de Jupyter Notebook

Pour utiliser Google colab il suffit d’aller sur google drive ensuite cliquer sur nouveau ensuite sur « plus » et choisissez « Colaboratory ».

🔴 Si vous n’avez pas l’option « Colaboratory » cliquez sur « Associer plus d’applications » puis rechercher « Colaboratory » et cliquez sur connecter.

Vous pouvez aussi accéder directement à  l’interface de google colab en cliquant ici. La fenêtre se présentera comme suit:

Comment Manipuler les fichiers ?

• Pour importer des fichiers depuis votre ordinateur

files.upload renvoie un dictionnaire des fichiers qui ont été importés.
La clé du dictionnaire est  le nom du fichier importé, la valeur correspond aux données des fichiers importés.

from google.colab import files
uploaded = files.upload()
for fn in uploaded.keys():
  print('Vous avez importé le fichier "{name}" qui a une taille de {length} bytes'.format(name=fn, length=len(uploaded[fn])))

• Pour télécharger des fichiers sur votre ordinateur

files.download fait une requête à votre navigateur pour qu’il télécharge un fichier.
Exemple :

from google.colab import files
with open('example.txt', 'w') as f:
  f.write('exemple de contenu')
files.download('example.txt'))

• Utiliser les fichiers depuis google drive

from google.colab import drive
drive.mount('/content/gdrive')

Exécutez la commande ci-dessus et suivez-les instructions afin de connecter votre google drive à votre noteboook.

Ensuite vous pouvez voir vos fichiers dans google colab avec :

!ls "/content/gdrive/My Drive/"

Pour ajouter des fichiers directement sur votre drive il faut  :

with open('/content/gdrive/My Drive/example.txt', 'w') as f:
  f.write('Test fichier Google Drive!')
#on vérifie ensuite si le fichier est bien créé
!cat /content/gdrive/My\ Drive/example.txt

Importer les librairies

L’import des librairies se fait de la même manière que sur un jupyter notebook.

import pandas as pd

Cependant si une librairie ne semble pas être installée sur votre environnement google colab vous suffit de l’installer avec !pip install ou !apt-get install. Par exemple :

!pip install -q matplotlib-venn

!apt-get -qq install -y libfluidsynth1

Réduire le temps d’apprentissage de vos modèles avec google colab !

Nous allons entrainer un modèle sur CPU, GPU et TPU  afin de mesurer les différentes durées d’apprentissage. Ainsi nous aurons besoin d’un jeu de données afin de créer un modèle d’apprentissage. Nous choisissons le MNIST fashion 👚 👕 👖 qui est un jeu de données créé par Zalando qui contient des images de tee-shirts, chaussures, sacs…

Le lien du notebook se trouve ici (MNIST CPU vs GPU vs TPU).

On importe les données déjà disponibles sous ‘tf.keras.datasests’ et on les prépare pour notre modèle

import tensorflow as tf
import numpy as np
import os
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.fashion_mnist.load_data()
# add empty color dimension
x_train = np.expand_dims(x_train, -1)
x_test = np.expand_dims(x_test, -1)

Le modèle par défaut que nous allons utiliser est le suivant (Qui nous permet d’atteindre 90% d’accuracy):

model = tf.keras.models.Sequential()
model.add(tf.keras.layers.BatchNormalization(input_shape=x_train.shape[1:]))
model.add(tf.keras.layers.Conv2D(64, (5, 5), padding='same', activation='elu'))
model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2), strides=(2,2)))
model.add(tf.keras.layers.Dropout(0.25))

model.add(tf.keras.layers.BatchNormalization(input_shape=x_train.shape[1:]))
model.add(tf.keras.layers.Conv2D(128, (5, 5), padding='same', activation='elu'))
model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2)))
model.add(tf.keras.layers.Dropout(0.25))

model.add(tf.keras.layers.BatchNormalization(input_shape=x_train.shape[1:]))
model.add(tf.keras.layers.Conv2D(256, (5, 5), padding='same', activation='elu'))
model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2), strides=(2,2)))
model.add(tf.keras.layers.Dropout(0.25))

model.add(tf.keras.layers.Flatten())
model.add(tf.keras.layers.Dense(256))
model.add(tf.keras.layers.Activation('elu'))
model.add(tf.keras.layers.Dropout(0.5))
model.add(tf.keras.layers.Dense(10))
model.add(tf.keras.layers.Activation('softmax'))
model.summary()

Si on n’utilise pas de GPU ou de TPU pour accélérer nos calculs on aura un code d’entrainement qui sera le suivant :

cpumodel = model
cpumodel.compile(  optimizer=tf.train.AdamOptimizer(learning_rate=1e-3, ),
    loss=tf.keras.losses.sparse_categorical_crossentropy,
    metrics=['sparse_categorical_accuracy'])

def train_gen(batch_size):
  while True:
    offset = np.random.randint(0, x_train.shape[0] - batch_size)
    yield x_train[offset:offset+batch_size], y_train[offset:offset + batch_size]

cpumodel.fit_generator(
    train_gen(1024),
    epochs=1,
    steps_per_epoch=1000,
    validation_data=(x_test, y_test),
)

l’exécution de ce code prend environ 4h 🥵 .

entrainer sur GPU

Pour passer en mode GPU, dans la barre des options choisir « exécution » puis « modifier le type d’exécution » et mettre l’option accélérateur matériel en mode GPU.

Vous serez obligé de re-exécuter tout le notebook. Cette fois ci l’exécution du précédent prendra environ 4minutes 🤗. Pour cet exemple l’entrainement sur un GPU est 60 fois plus rapide qu’un entrainement classique sur un CPU.

entrainer sur TPU

Pour la petite histoire le TPU (Tensor Processing Unit) est un circuit intégré, développé par Google spécifiquement pour accélérer les systèmes d’intelligence artificielle (wikipédia). Du coup cette architecture est faite pour optimiser les calculs d’entrainement d’un réseau de neurones. Alors comment utiliser le « TPU » sur google colab ? 😉

il suffit de suivre les instructions précédentes pour l’activation du GPU mais choisir TPU comme Accélérateur matériel.

Notre code d’entrainement sera légèrement altéré et se présentera comme suit :

import os
tpu_model = tf.contrib.tpu.keras_to_tpu_model(
    model,
    strategy=tf.contrib.tpu.TPUDistributionStrategy(
        tf.contrib.cluster_resolver.TPUClusterResolver(tpu='grpc://' + os.environ['COLAB_TPU_ADDR'])
    )
)
tpu_model.compile(
    optimizer=tf.train.AdamOptimizer(learning_rate=1e-3, ),
    loss=tf.keras.losses.sparse_categorical_crossentropy,
    metrics=['sparse_categorical_accuracy']
)

def train_gen(batch_size):
  while True:
    offset = np.random.randint(0, x_train.shape[0] - batch_size)
    yield x_train[offset:offset+batch_size], y_train[offset:offset + batch_size]
    

tpu_model.fit_generator(
    train_gen(1024),
    epochs=1,
    steps_per_epoch=1000,
    validation_data=(x_test, y_test),
)

En mode TPU l’exécution du passe passe d’environ 4h à 90s soit 160 fois plus rapide !  😎 Pour en savoir plus voir le notebook qui se trouve ici (MNIST CPU vs GPU vs TPU).

Conclusion

Google colab est un outil complet pour entraîner rapidement et tester rapidement des modèles d’apprentissage automatique sans avoir de contrainte matérielle. Sa particularité est que tout le monde peut l’utiliser (gratuit aussi !)