Introduction au Deep Learning

Ecole Nationale Supérieure de Cognitique

Baptiste Pesquet

Ressources documentaires

Sommaire

  • IA, Machine Learning et Deep Learning
  • Python et la Data Science
  • A la découverte des réseaux de neurones
  • Premiers pas avec Keras
  • Optimisation et tuning d'un réseau

IA, Machine Learning et Deep Learning

Intelligence artificielle

"L'IA consiste à parvenir à faire faire aux machines ce que l’homme fait aujourd’hui mieux qu’elles, notamment s’adapter, apprendre, communiquer et interagir d’une manière riche et variée avec leur environnement."
(Source : #FranceIA)

De nombreux domaines d'étude

  • Logique et raisonnement
  • Bases de connaissances, Web sémantique
  • Apprentissage automatique
  • Traitement du langage naturel
  • Robotique
  • Sciences cognitives
  • Aide à la décision
  • ...

(Source : INRIA)

Une histoire jeune et mouvementée

L'été, jusqu'à quand ?

Machine Learning

(Apprentissage automatique)

Ensemble de techniques permettant à des machines de s’entraîner sur des bases d’exemples, d’en faire émerger des traits, de généraliser sur des exemples non encore rencontrés et de s'améliorer continuellement avec l’expérience.

Un nouveau paradigme

Apprentissage supervisé

Les résultats à obtenir sont fournis avec les données d'entraînement.

Ces données sont dites structurées (étiquetées).

Régression

Le système prédit des valeurs continues.

Classification

Le système prédit des valeurs discrètes : il catégorise les entrées.

Apprentissage non supervisé

Le système doit découvrir par lui-même une éventuelle structure dans les données fournies.

Apprentissage par renforcement

Les décisions du système lui procurent une récompense qu'il cherche à maximiser.

Deep Learning

(Appprentissage profond)

Ensemble de techniques d’apprentissage automatique dans lesquels de vastes réseaux de neurones artificiels exploitent de grandes quantités de données.

A l'origine de la majorité des avancées récentes en IA.

Reconnaissance visuelle

Compréhension de la parole

Véhicules autonomes

Algorithmes de recommandation

Jeux complexes

Les clés du succès

  • L'optimisation d'algorithmes connus depuis les années 1980
  • L'augmentation de la puissance de calcul des machines
  • L'explosion du volume de données disponibles

L'état de l'art au début des années 1990

http://yann.lecun.com/exdb/lenet/

Python et la Data Science

Le langage Python

Langage de programmation sous licence libre créé en 1989 par Guido van Rossum.

  • Multi-paradigmes (procédural, fonctionnel, objet)
  • Typage dynamique
  • Gestion automatique de la mémoire

Python, le standard pour la Data Science

  • Qualités du langage (logique, simplicité, souplesse)
  • Implication de la communauté scientifique et universitaire
  • Existence de nombreuses bibliothèques dédiées

Quelques outils essentiels

  • NumPy : librairie de calcul mathématique
  • Matplotlib : création de graphiques
  • Anaconda : distribution scientifique incluant de nombreux packages
  • Jupyter Notebook : application web pour créer et exécuter interactivement du code

La notion de tenseur

Un tenseur est un ensemble de valeurs (très souvent numériques) stockées dans un tableau multidimensionnel
  • Vecteur = tenseur à une dimension
  • Matrice = tenseur à deux dimensions

En pratique

Tensors

A la découverte des réseaux de neurones

Les origines

  • 1943 : premier modèle mathématique du neurone biologique (McCulloch et Pitts)
  • 1949 : règle de Hebb
  • 1958 : le perceptron (F. Rosenblatt)
  • 1969 : limites des perceptrons (M. Minsky)

L'inspiration biologique

Le neurone formel de McCulloch et Pitts

La règle de Hebb

Postulat sur l'importance des synapses entre neurones pour l'apprentissage.

Quand un axone d'une cellule A est assez proche pour exciter une cellule B de manière répétée et persistante, une croissance ou des changements métaboliques prennent place dans l'une ou les deux cellules ce qui entraîne une augmentation de l'efficacité de A comme cellule stimulant B.

Le perceptron de Franck Rosenblatt

Algorithme d'apprentissage du perceptron

  1. Initialiser aléatoirement les poids des connexions
  2. Pour chaque donnée de test :
    1. Calculer la sortie du perceptron
    2. Si la sortie calculée diffère de celle attendue :
      • Si sortie = 0, augmenter les poids
      • Si sortie = 1, diminuer les poids

Multi Layer Perceptron (MLP)

La critique de Minsky

  • Un seul perceptron ne peut pas apprendre une fonction non séparable linéairement
  • Aucun algorithme d'apprentissage ne fonctionne pour les couches cachées d'un MLP

Des progrès décisifs

  • 1974 : technique de la rétropropagation (P. Werbos)
  • 1986 : apprentissage par rétropropagation (Rumelhart, Hinton, Williams)
  • 1989 : preuve mathématique de la capacité des réseaux de neurones à approximer toute fonction mesurable (Hornik, Stinchcombe, White)
  • 1989 : début des travaux sur les réseaux convolutifs profonds (LeCun, Bengio)

Les prémisses de la reconnaissance visuelle

L'avènement du Deep Learning

  • 2012 : AlexNet (Krizhevsky, Sutskever, Hinton) remporte la compétition ImageNet
  • 2016 : AlphaGo (DeepMind) bat le champion de Go Lee Sedol par 4 victoires à 1
  • 2017 : AlphaZero atteint en 24h un niveau surhumain au Go et aux échecs

Apprentissage supervisé

  • Classification binaire (0 ou 1)
    Chat/non chat, spam/non spam, maligne/bénigne
  • Classification multiclasses
    Chat/chien/autre animal, reconnaissance de chiffres, catégorisation de tweets
  • Régression
    Prix d'un bien immobilier, prévision de températures, âge d'une personne

Anatomie d'un réseau

Algorithme d'apprentissage

Entrainement et inférence

Format des données d'entrée

  • Cas général : matrice de la forme (samples, features)
  • Images : tenseur 4D de la forme (samples, height, width, color_channels)
  • Vidéos : tenseur 5D de la forme (samples, frames, height, width, color_channels)

Exemple : prix immobiliers

Surface (m2) Nombre chambres Age (années) Code Postal Prix (k€)
145 6 32 33600 380
85 3 45 33700 290
210 7 12 33400 740
... ... ... ... ...
110 4 22 33000 410

Exemple : prix immobiliers

Exemple : image RGB

Sortie pour un neurone

Fonctions d'activation

Vectorisation des calculs

Sortie de la couche 1

Sortie de la couche 2

Sortie de la couche 3

La fonction de coût (loss)

  • Mesure l'écart entre les résultats attendus et calculés
  • Paramètres : les poids du réseau
  • Dépend du type d'apprentissage

Exemples de fonctions

  • Binary crossentropy
    \(\mathcal{J}(\theta)= -\frac{1}{m}\sum_{i=1}^m \left[y_i \log(y'_i) + (1-y_i) \log(1-y'_i)\right]\)
  • Categorical crossentropy
    \(\mathcal{J}(\theta)= -\frac{1}{m}\sum_{i=1}^m\sum_{j=1}^n y_{ij} \log(y'_{ij})\)
  • Mean Squared Error
    \(\mathcal{J}(\theta)= \frac{1}{m}\sum_{i=1}^m (y'_{i} - y_{i})^2\)

Ajustement des poids du réseau

Objectif : minimiser la fonction de coût

Principe : mettre à jour les poids par petites étapes dans la direction inverse du gradient de la fonction de coût

La notion de gradient

Variation d'une fonction par rapport à la variation de ses différents paramètres

Vecteur dont les composantes sont les dérivées partielles de la fonction

Descente de gradient

Gradient 2D

Descente de gradient 2D

La rétropropagation

Objectif : calculer le gradient de la fonction de coût par rapport à ses paramètres (les poids du réseau)

Principe : appliquer la règle des dérivations en chaîne ou chain rule pour calculer les dérivées partielles de la fonction de coût

Démonstration visuelle

Mise à jour des poids du réseau

Learning rate \(\alpha\) : facteur d'ajustement des poids en fonction du gradient du coût

$$\theta_{i+1} = \theta_i - \alpha \frac{\partial}{\partial \theta} \mathcal{J}(\theta_i)$$

Importance du learning rate

Le problème des minima locaux

Mesures de performance pour la classification

Justesse (accuracy) : % de prédictions exactes.

Insuffisante si les classes ne sont pas distribuées équitablement parmi les données : explication.

Mesures complémentaires

  • Précision : nombre de prédictions exactes rapporté au nombre obtenu de prédictions pour une classe.
  • Rappel (recall) : nombre de prédictions exactes rapporté au nombre attendu de prédictions pour une classe.

Premiers pas avec Keras

Présentation de Keras

Librairie Python de création de réseaux de neurones conçue par François Chollet

Fournit une API de haut niveau au-dessus de TensorFlow, Theano ou CNTK

L'API de Keras


from keras.models import Sequential
from keras.layers import Dense

model = Sequential()
model.add(Dense(4, activation='tanh', input_shape=(3,)))
model.add(Dense(4, activation='tanh'))
model.add(Dense(1, activation='sigmoid'))

model.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
              metrics=['accuracy'])
history = model.fit(x_train, y_train, epochs=5, batch_size=64)

loss, acc = model.evaluate(x_test, y_test, verbose=0)
					

Définition d'un réseau


# Sequential defines a linear stack of layers
from keras.models import Sequential
# Dense defines a fully connected layer
from keras.layers import Dense

model = Sequential() # Create a new network
# Add a 4-neurons layer using tanh as activation function
# Input shape corresponds to the input layer (no of features)
model.add(Dense(4, activation='tanh'), input_shape=(3,))
# Add a 4-neurons layer using tanh
# Input shape is infered from previous layer
model.add(Dense(4, activation='tanh'))
# Add a 1-neuron output layer using sigmoid
model.add(Dense(1, activation='sigmoid'))
					

Réseau obtenu

Compilation du réseau


# Configuration of the training process
# optimizer: gradient descent optimization method
# loss: loss function
# metrics: list of metrics monitored during training and testing
model.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
              metrics=['accuracy'])
					

Apprentissage


# Launch the training of the network on the data
# epochs: number of epochs to train the model
#  (An epoch is an iteration over the entire training dataset)
# batch_size: number of samples used at each training iteration
# The returned history object contains the monitored metrics
history = model.fit(x_train, y_train, epochs=5, batch_size=64)
					

Evaluation


# Returns the loss value & metrics values for the network in test mode
loss, acc = model.evaluate(x_test, y_test, verbose=0)
					

Encodage one-hot

Permet de transformer un vecteur de valeurs numériques discrètes en une matrice associant un vecteur binaire à chaque valeur.

from keras.utils import to_categorical

x = np.array([1, 2, 0, 2, 1])
print(x.shape) # (5,)

# One-hot encoding
x = to_categorical(x)

print(x.shape) # (5, 3): 5 elements and 3 possible values for each one
print(x[0]) # [0. 1. 0.], corresponding to 1
print(x[1]) # [0. 0. 1.], corresponding to 2
print(x[2]) # [1. 0. 0.], corresponding to 0
print(x[3]) # [0. 0. 1.], corresponding to 2
print(x[4]) # [0. 1. 0.], corresponding to 1
				

Le "Hello World" du Deep Learning : MNIST digits

Jeu de 70 000 chiffres manuscrits stockés sous forme d'images 28x28 en niveau de gris (0 à 255)

Préparation des entrées


from keras.datasets import mnist
			
# Load MNIST digits dataset: 60,000 for training and 10,000 for test
(train_images, train_targets), (test_images, test_targets) = mnist.load_data()

# Reshape images data into a (number of samples, 28x28) matrix
x_train = train_images.reshape((60000, 28 * 28))
x_test = test_images.reshape((10000, 28 * 28))

# Change pixel values from (0, 255) to (0, 1)
x_train = x_train.astype('float32') / 255
x_test = x_test.astype('float32') / 255
				

Réseau utilisé


# Create a (784, 15, 10) model
model = Sequential()

# Use ReLU for hidden layer
model.add(Dense(15, activation='relu', input_shape=(28 * 28,)))

# Use softmax for output layer
model.add(Dense(10, activation='softmax'))
					

La fonction Softmax

$$\sigma(z)_j = \frac{e^{z_j}}{\sum_{k=1}^K {e^{z_k}}}$$

Représente une distribution de probabilités sur K catégories

Fonction d'activation de la couche de sortie pour la classification multiclasses

Préparation des résultats attendus

Softmax renvoie un vecteur de probabilités

Les résultats attendus doivent également être fournis sous forme de vecteurs


# Expected results are vectors of values between 0 and 9
print(train_targets.shape) # (60000,)
print(test_targets.shape) # (10000,)

# One-hot encoding of expected results
y_train = to_categorical(train_targets)
y_test = to_categorical(test_targets)

# Encoded expected results are binary matrixes
print(y_train.shape) # (60000, 10)
print(y_test.shape) # (10000, 10)
				

En pratique

Shallow Neural Networks

Optimisation et tuning d'un réseau

Choix des hyperparamètres

  • Nombre de couches
  • Nombre de neurones sur chaque couche cachée
  • Fonctions d'activation
  • Learning rate
  • Taille des mini-batchs
  • ...

Le processus de choix est itératif

Entrainement, validation et test

Les données d'entrée sont fréquemment séparées en 2 ou 3 groupes :
  • Entrainement (entre 60 et 98% des données selon leur nombre)
  • Validation : évaluation et tuning
  • Test : vérification des performances

Exemples de découpages


# Assuming x is a (1000, features) matrix

# Randomize samples order
np.random.shuffle(x) 

training_x, val_x, test_x = x[:800, :], x[800:900, :], x[900:, :]
# training_x is a (800, features) matrix
# val_x and test_x both are (100, features) matrices
					

from sklearn.model_selection import train_test_split

# Using sk-learn's predefined function train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25)
					

Normalisation des entrées

Afin de faciliter l'apprentissage, les données d'entrée doivent :
  • Etre homogènes
  • Avoir de faibles valeurs (souvent entre 0 et 1)

# Assuming x is a (samples, features) matrix
x -= x.mean(axis=0)  # center data
x /= x.std(axis=0)  # reduce data
# x now has a mean of 0 and a standard deviation of 1
				

Initialisation des poids du réseau

Afin d'optimiser l'apprentissage, ils doivent :
  • Etre non nuls
  • Etre aléatoires
  • Prendre des valeurs faibles

Méthodes d'initialisation des poids

Optimisation de la descente de gradient

  • Batch Gradient Descent
  • Stochastic Gradient Descent
  • Mini-batch SGD
  • Momentum
  • RMSprop
  • Adam

Batch Gradient Descent

Gradient calculé sur l'ensemble des données avant mise à jour des poids.

  • Simple et sûr
  • Lent voire inutilisable pour de gros volumes de données

Stochastic Gradient Descent

Gradient calculé sur une seule donnée prise au hasard avant mise à jour des poids.

  • Rapide
  • Autorise l'apprentissage à partir de nouveaux exemples ou online learning
  • Risque de ne pas converger
  • Pas de vectorisation des calculs

Mini-batch SGD

Gradient calculé sur une petite quantité de données prise au hasard avant mise à jour des poids.

  • Combine les avantages des deux précédents
  • Méthode par défaut pour de nombreuses librairies de DL, dont Keras

Quelle taille pour le mini-batch ?

  • Petit jeu de données (moins de 2000 examples) => batch gradient descent
  • Sinon : généralement entre 32 et 512 examples

Momentum

Accélère la descente de gradient dans la direction du minimum

Analogie : une boule qui prend de la vitesse dans le sens de la pente

RMSprop

Root Mean Square prop

Utilise les gradients précédents pour adapter le learning rate

Adam

Adaptive Moment Estimation

Combine Momentum et RMSprop

Plus d'informations

An overview of gradient descent optimization algorithms

Optimisation/généralisation

Underfitting (bias)

Indicateur : sous-performance sur les données d'entrainement

  • Augmenter la taille du réseau
  • Entrainer le réseau plus longtemps

Overfitting (variance)

Indicateur : écart entre les performances sur les données d'entrainement et de validation

  • Utiliser plus de données pour l'entrainement
  • Limiter la taille du réseau
  • Ajouter une régularisation
  • Introduire le dropout

Régularisation des poids

Principe : forcer les poids à prendre de faibles valeurs en ajoutant un surcoût lié aux grandes valeurs :
  • L1 : surcoût proportionnel à la valeur absolue des poids
  • L2 : surcoût proportionnel au carré de la valeur absolue des poids

# Add L2 regularization to a layer
model.add(Dense(16, kernel_regularizer=regularizers.l2(0.001),
                activation='relu', input_shape=(10000,)))
				

Dropout

Principe : supprimer aléatoirement certaines connexions (poids = 0) uniquement pendant l'apprentissage


# Add a layer with 50% dropout during training
model.add(Dense(16, activation='relu', input_shape=(10000,)))
model.add(Dropout(0.5))
				

En pratique

Optimization And Tuning