Introduction au Deep Learning

Ecole Nationale Supérieure de Cognitique

Baptiste Pesquet

Diaporama : http://www.bpesquet.fr/presentations/intro-deep-learning/

Exemples de code : https://github.com/bpesquet/intro-deep-learning

Activités : https://github.com/ensc-ia/intro-deep-learning (accès restreint)

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
  • Les réseaux de neurones en pratique

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

Python For Data Science

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 0 au lieu de 1, diminuer les poids ayant 1 comme valeur d'entrée
      • Si 1 au lieu de 0, augmenter les poids ayant 1 comme valeur d'entrée

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 (Y. LeCun, Y. 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

Initialisation des poids

  • Aléatoires
  • Non nuls
  • Valeurs faibles

Les 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

$$\frac{dy}{dx} = \frac{dy}{du} \cdot \frac{du}{dx}$$

Optimisation de la descente de gradient

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

Quelques méthodes d'optimisation

  • Stochastic Gradient Descent
  • Mini-batch Gradient Descent (entre 50 et 512 samples)
  • Momentum
  • RMSProp
  • Adam

Mesure de performance

Accuracy: % de réussite des prévisions sur un jeu de données

En pratique

Shallow Neural Networks With Python

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

Un premier exemple


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(train_X, train_y, epochs=5, batch_size=64)

loss, acc = model.evaluate(test_X, test_y, verbose=0)
					

Définition du 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(train_X, train_y, epochs=5, batch_size=64)
					

Evaluation


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

Le "Hello World" du Deep Learning : MNIST

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

Réseau utilisé

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 entrées


from keras.datasets import mnist
from keras.utils import to_categorical
			
# Load MNIST digits dataset
(train_images, train_targets), (test_images, test_targets) = mnist.load_data()

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

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

# Convert targets from vectors to binary matrixes
train_targets = to_categorical(train_targets_orig)
test_targets = to_categorical(test_targets_orig)
					

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


# Output: 5 
print(train_targets[0])  

# Convert targets from vectors to binary matrixes
train_targets = to_categorical(train_targets)

# Output: [ 0.  0.  0.  0.  0.  1.  0.  0.  0.  0.]
print(train_targets[0])  
					

En pratique

First Steps With Keras

Les réseaux de neurones en pratique

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 95% des données)
  • 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
				

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

Neural Networks In Practice