Upload
others
View
5
Download
0
Embed Size (px)
Citation preview
Apprentissage profond
Fabien Teytaud
Apprentissage profond
Fabien Teytaud
Université du Littoral Cote d’Opale
26 août 2020
1/1
Apprentissage profond
Fabien TeytaudSommaire
2/1
Apprentissage profond
Fabien TeytaudQuelques références
Livre
Bulco : 006.3 COR A
3/1
Apprentissage profond
Fabien TeytaudQuelques références
Vidéos en ligneI Tensorflow et l’apprentissage profond, sans les équations
différentielles (Martin Görner)I Cours de Yann Le Cun au collège de France
Cours en ligneI Mon cours en Master 1I Un tutorial rapide python pour le cours
4/1
Apprentissage profond
Fabien TeytaudL’apprentissage
On souhaite faire en sorte que le programme apprennequelque chose à partir de données.On distingue plusieurs familles d’apprentissage, et enparticulier :I L’apprentissage supervisé : des exemples étiquettés sont
connus afin de guider l’apprentissage.I L’apprentissage non supervisé : le programme doit
apprendre à extraire une information ou une structure àpartir des données seules.
I L’apprentissage par renforcement : apprentissage basésur un système d’observations et de récompenses.
5/1
Apprentissage profond
Fabien TeytaudLes types d’apprentissage
Supervisé Non-supervisé
6/1
Apprentissage profond
Fabien TeytaudExemples d’apprentissage supervisé
Classification Régression
7/1
Apprentissage profond
Fabien TeytaudUn exemple simpleCa devrait vous rappeler quelque chose ...
Régression linéaire, erreur quadratique moyenneI Règle de décision : y = W ′X
Si c’est supérieur à un seuil c’est une classe, sinon c’est une autre.
I Fonction de coût : L(W , yi ,Xi) =12(yi −W ′Xi)
2
On minimise la différence entre la sortie désirée et la sortie du système.
I Gradient du coût :∂L(W , yi ,Xi)
∂W= −(yi −W (t)′Xi)Xi
Si la sortie est plus petite que la sortie désirée alors on rajoute au vecteur de poids
le vecteur d’entrées multiplié par l’erreur.
I Mise à jour : W (t + 1) = W (t) + η(t)(yi −W (t)′Xi)Xi)On soustrait au poids le gradient du coût.
−→Convergence : minimisation de la moyenne de la fonction coût
sur tous les exemples d’apprentissage.
8/1
Apprentissage profond
Fabien TeytaudUn exemple simpleLe perceptron
9/1
Apprentissage profond
Fabien TeytaudUn exemple simpleLe perceptron
10/1
Apprentissage profond
Fabien TeytaudUn exemple simple... le perceptron
Machine linéaire, le perceptronI Règle de décision : y = F (W ′X )
F est la fonction seuil.
I Fonction de coût : L(W , yi ,Xi) = (F (W ′Xi)− yi)W ′XiOn minimise la différence entre la sortie désirée et la sortie du système.
I Gradient du coût :∂L(W , yi ,Xi)
∂W= −(yi − F (W (t)′Xi))Xi
Si la sortie est plus petite que la sortie désirée alors on rajoute au vecteur de poids
le vecteur d’entrées multiplié par l’erreur.
I Mise à jour : W (t + 1) = W (t) + η(t)(yi − F (W (t)′Xi))Xi)On soustrait au poids le gradient du coût.
11/1
Apprentissage profond
Fabien TeytaudUn exemple simple... le perceptron
Machine linéaire, le perceptronI Règle de décision : y = F (W ′X )
F est la fonction seuil.
I Fonction de coût : L(W , yi ,Xi) = (F (W ′Xi)− yi)W ′XiOn minimise la différence entre la sortie désirée et la sortie du système.
I Gradient du coût :∂L(W , yi ,Xi)
∂W= −(yi − F (W (t)′Xi))Xi
Si la sortie est plus petite que la sortie désirée alors on rajoute au vecteur de poids
le vecteur d’entrées multiplié par l’erreur.
I Mise à jour : W (t + 1) = W (t) + η(t)(yi − F (W (t)′Xi))Xi)On soustrait au poids le gradient du coût.
Sans oublier le biais !
11/1
Apprentissage profond
Fabien TeytaudRappels importantsSur-apprentissage (variance) et sous-apprentissage (biais)
Regression
Classification
12/1
Apprentissage profond
Fabien TeytaudProblème des machines linéaires?
13/1
Apprentissage profond
Fabien TeytaudLes réseaux de neurones
XORActivation, fonction seuil :Si > seuil alors 1 sinon 0
⇔d∑
i=1
wixi − seuil
SeuilN3 = 0,SeuilN2 = 1
x0 x1 σ3 σ2 y3 y2 y0 0 0 0 0 0 00 1 1 1 1 0 11 0 1 1 1 0 11 1 2 2 1 1 0
14/1
Apprentissage profond
Fabien TeytaudLes réseaux de neurones
XORActivation, fonction seuil :Si > seuil alors 1 sinon 0
⇔d∑
i=1
wixi − seuil
SeuilN3 = 0,SeuilN2 = 1
x0 x1 σ3 σ2 y3 y2 y0 0 0 0 0 0 00 1 1 1 1 0 11 0 1 1 1 0 11 1 2 2 1 1 0
14/1
Apprentissage profond
Fabien TeytaudLes réseaux de neurones
XORActivation, fonction seuil :Si > seuil alors 1 sinon 0
⇔d∑
i=1
wixi − seuil
SeuilN3 = 0,SeuilN2 = 1
x0 x1 σ3 σ2 y3 y2 y0 0 0 0 0 0 00 1 1 1 1 0 11 0 1 1 1 0 11 1 2 2 1 1 0
14/1
Apprentissage profond
Fabien TeytaudLes réseaux de neurones
XORActivation, fonction seuil :Si > seuil alors 1 sinon 0
⇔d∑
i=1
wixi − seuil
SeuilN3 = 0,SeuilN2 = 1
x0 x1 σ3 σ2 y3 y2 y0 0 0 0 0 0 00 1 1 1 1 0 11 0 1 1 1 0 11 1 2 2 1 1 0
14/1
Apprentissage profond
Fabien TeytaudLes réseaux de neurones
XORActivation, fonction seuil :Si > seuil alors 1 sinon 0
⇔d∑
i=1
wixi − seuil
SeuilN3 = 0,SeuilN2 = 1
y3 = w0,3x0+ w1,3x1− seuilN3
y2 = w0,2x0+ w1,2x1− seuilN2
y = w3,4y3+ w2,4y2
15/1
Apprentissage profond
Fabien TeytaudLes réseaux de neurones
XORActivation, fonction seuil :Si > seuil alors 1 sinon 0
⇔d∑
i=1
wixi − seuil
SeuilN3 = 0,SeuilN2 = 1
y3 = x0+ x1
y2 = x0+ x1− 1y = y3− y2
15/1
Apprentissage profond
Fabien TeytaudSommaire
16/1
Apprentissage profond
Fabien TeytaudApprentissage et test
Nous allons approfondir les notions développées lors du coursde l’an dernier.
17/1
Apprentissage profond
Fabien TeytaudApprentissage et test : limite
I Supposons que l’on a un modèle qui dépend d’unparamètre (comme le pas d’un réseau de neurones).
I On souhaite trouver le meilleur pas.I Un scénario possible :
I On créé 100 modèles avec 100 pas différents.I On apprend ces 100 modèles sur la base d’apprentissage,
et on teste ces 100 modèles sur la base de test(généralisation).
I Le meilleur paramètre/modèle obtient 5% d’erreur engénéralisation (sur la base de test).
I On choisit ce modèle pour la production, mais on s’aperçoitqu’on obtient 15% d’erreur.
I Problème : On a biaisé le modèle sur notre base de test.I Solution : utiliser une base de validation en plus.
18/1
Apprentissage profond
Fabien TeytaudLa validation croisée (k -fold cross validation)
I La base d’apprentissage est découpée en ksous-ensembles.
I On sélectionne un des k sous-ensembles commeensemble de validation.
I Le modèle est entrainé sur les k − 1 sous-ensemblesrestants.
I Le processus de validation croisée est donc répété k fois.I Les k résultats de validation sont ensuite moyennés.I Avantages :
I Toutes les observations sont utilisées pour l’apprentissageet la validation.
I Chaque observation est utilisée qu’une seule fois envalidation.
19/1
Apprentissage profond
Fabien TeytaudLa validation croisée (k -fold cross validation)
20/1
Apprentissage profond
Fabien TeytaudMesure de performance : sensibilité,spécificité et courbe ROC
I Supposons que nous ayons 2 classes A et B.I Nous avons une base d’apprentissage qui contient 900
exemples étiquetés A et 100 exemples étiquetés B.I Nous créons un classifieur qui fait 90% de précision.I Comment interpréter ce résultat.
I C’est pour cela que la précision seule n’est en général pasun bon critère de performance.
21/1
Apprentissage profond
Fabien TeytaudMesure de performance : sensibilité,spécificité et courbe ROC
Malade Non maladetest positif True Positive False Positivetest négatif False Negative True Negative
22/1
Apprentissage profond
Fabien TeytaudMesure de performance : sensibilité,spécificité et courbe ROC
I La sensibilité d’un test mesure sa capacité à donner unrésultat positif si l’hypothèse est vérifiée.
I La sensitivité d’un test mesure sa capacité à donner unrésultat négatif si l’hypothèse n’est pas vérifiée.
Quelques mesures
I Sensibilité :TN
TN + FP
I Sensitivité (recall) :TP
TP + FN
I Precision :TP
TP + FP
I Accuracy :TP + TN
TP + FP + TN + FN
23/1
Apprentissage profond
Fabien TeytaudMesure de performance : sensibilité,spécificité et courbe ROC
Score F1Afin de comparer deux classifieurs il est pratique de n’avoirqu’un seul score qui combine precision et recall.Le score F1 correspond à la moyenne harmonique :
F1 =2
1precision + 1
recall
= 2× precision × recallprecision + recall
=TP
TP + FN+FP2
Ce score favorise des classifieurs qui ont une précision et unrecall similaires.Pour certains problèmes il est plus intéressant de s’intéresserà une mesure plutôt qu’à une autre.
24/1
Apprentissage profond
Fabien TeytaudMesure de performance : sensibilité,spécificité et courbe ROC
Score F1
25/1
Apprentissage profond
Fabien TeytaudLa courbe ROC Receiver OperatingCharacteristic
Il s’agit d’une autre mesure de performance d’un classifieur.Cette mesure donne le taux de vrais positifs en fonction dutaux de faux positifs.
[Wikipedia]
26/1
Apprentissage profond
Fabien TeytaudSommaire
27/1
Apprentissage profond
Fabien TeytaudTensorFlow
TensorFlowI Bibliothèque d’apprentissage artificiel.I Développée par Google, 2015.I Interface en Python.
Il existe aussi ...I mxnet,I torch,I pytorch...
28/1
Apprentissage profond
Fabien TeytaudTensorFlow
I https://www.tensorflow.org/
I Python. Tutorial à python disponible ici.I Graphe de noeuds TensorFlow : série d’opérations.I Pour faire tourner un programme il faut :
I Construire le graphe.I Exécuter le graphe.
29/1
Apprentissage profond
Fabien TeytaudExemple de graphe
[Doc tensorFlow]30/1
Apprentissage profond
Fabien TeytaudExemple de code
Code :import tensorflow as tfa = tf.placeholder(tf.float32)b = tf.placeholder(tf.float32)adder_node = tf.add(a,b)
sess = tf.Session()print(sess.run(adder_node, {a:3, b:4.5}))print(sess.run(adder_node, {a:[1,3], b:[2,4]}))
Sortie :7.5[ 3. 7.]
[Doc tensorFlow]
31/1
Apprentissage profond
Fabien TeytaudAnalysons le code suivant [Doc tensorFlow]
# Model parametersW = tf.Variable([.3], dtype=tf.float32)b = tf.Variable([-.3], dtype=tf.float32)# Model input and outputx = tf.placeholder(tf.float32)linear_model = W * x + by = tf.placeholder(tf.float32)
# lossloss = tf.reduce_sum(tf.square(linear_model - y)) # sum of the squares# optimizeroptimizer = tf.train.GradientDescentOptimizer(0.01)train = optimizer.minimize(loss)
# training datax_train = [1, 2, 3, 4]y_train = [0, -1, -2, -3]# training loopinit = tf.global_variables_initializer()sess = tf.Session()sess.run(init)for i in range(1000):
sess.run(train, {x: x_train, y: y_train})
# evaluate training accuracycurr_W, curr_b, curr_loss = sess.run([W, b, loss], {x: x_train, y: y_train})print("W: %s b: %s loss: %s"%(curr_W, curr_b, curr_loss))
W: [-0.9999969] b: [ 0.99999082] loss: 5.69997e-11
32/1
Apprentissage profond
Fabien TeytaudAnalysons le code suivant [Doc tensorFlow]
# Model parametersW = tf.Variable([.3], dtype=tf.float32)b = tf.Variable([-.3], dtype=tf.float32)# Model input and outputx = tf.placeholder(tf.float32)linear_model = W * x + by = tf.placeholder(tf.float32)
# lossloss = tf.reduce_sum(tf.square(linear_model - y)) # sum of the squares# optimizeroptimizer = tf.train.GradientDescentOptimizer(0.01)train = optimizer.minimize(loss)
# training datax_train = [1, 2, 3, 4]y_train = [0, -1, -2, -3]# training loopinit = tf.global_variables_initializer()sess = tf.Session()sess.run(init)for i in range(1000):
sess.run(train, {x: x_train, y: y_train})
# evaluate training accuracycurr_W, curr_b, curr_loss = sess.run([W, b, loss], {x: x_train, y: y_train})print("W: %s b: %s loss: %s"%(curr_W, curr_b, curr_loss))
W: [-0.9999969] b: [ 0.99999082] loss: 5.69997e-11
32/1
Apprentissage profond
Fabien TeytaudSommaire
33/1
Apprentissage profond
Fabien TeytaudTout d’abord les données : MNIST
Le problème/les donnéesI Reconnaissance de chiffres manuscrits.I 60k images d’apprentissage, 10k de test.I Normalisées, centrées, 28x28 pixelsI http://yann.lecun.com/exdb/mnist
34/1
Apprentissage profond
Fabien TeytaudCharger les données avec TensorFlow
Code pour le chargement des donnéesfrom tensorflow.examples.tutorials.mnist import input_datamnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
one_hotCelà signifie que toutes les dimensions sont à 0 sauf une (qui est 1).Exemple :3 : [0,0,0,1,0,0,0,0,0,0]
I mnist.train.images : tensor [60000,784]I mnist.train.labels : tensor [60000,10]
'0 0.5 0.3 1 . . . 1 0.5 0.3 0
35/1
Apprentissage profond
Fabien TeytaudUn premier réseau
0
0.5
0.3
1
. . .
1
0.5
0.3
0
784 pixels
0
1
2
3
4
5
6
7
8
9
36/1
Apprentissage profond
Fabien TeytaudUn premier réseau
softmax(x) =exp(x)∑j exp(xj)
y = softmax(X .W + b)
Prédictions[nbimages,10]
Poids[784,10]
Images[nbimages,784]
Biais[10]
37/1
Apprentissage profond
Fabien TeytaudC’est parti .. [Doc tensorFlow]
import tensorflow as tf
x = tf.placeholder(tf.float32, [None, 784]) # None : n'importe quelle taillew = tf.Variable(tf.zeros([784, 10]))b = tf.Variable(tf.zeros([10])y = tf.nn.softmax(tf.matmul(x,w) + b)
38/1
Apprentissage profond
Fabien TeytaudC’est parti .. [Doc tensorFlow]
Mesure de l’erreurUtilisation de la cross-entropy :
−∑
y log(y ′)
I y ′ correspond aux valeurs prédites (probabilité entre 0 et1).
I y correspond correspond aux vraies étiquettes (vecteurone_hot).
39/1
Apprentissage profond
Fabien TeytaudC’est parti .. [Doc tensorFlow]
import tensorflow as tf
# Déclarationx = tf.placeholder(tf.float32, [None, 784]) # None : n'importe quelle taillew = tf.Variable(tf.zeros([784, 10]))b = tf.Variable(tf.zeros([10]))y = tf.nn.softmax(tf.matmul(x,w) + b)
y_et = tf.placeholder(tf.float32, [None, 10]) # Stockage des étiquettes one_hot
# Mesure de l'erreurcross_entropy = -tf.reduce_sum(y_et*tf.log(y))
# Entrainementtrain_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)
# Lancement de la sessionsess = tf.InteractiveSession()tf.global_variables_initializer().run()
for _ in range(1000):batch_xs, batch_ys = mnist.train.next_batch(1) # pour l'instant on prend les images une par unesess.run(train_step, feed_dict={x: batch_xs, y_et: batch_ys})
# Evaluation du modelest_correct = tf.equal(tf.argmax(y,1), tf.argmax(y_et, 1))precision = tf.reduce_mean(tf.cast(est_correct, tf.float32))
print(sess.run(precision, feed_dict={x: mnist.test.images, y_et: mnist.test.labels}))
40/1
Apprentissage profond
Fabien TeytaudEn prenant un batch de 100 images
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_datamnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
# Déclarationx = tf.placeholder(tf.float32, [None, 784]) # None : n'importe quelle taillew = tf.Variable(tf.zeros([784, 10]))b = tf.Variable(tf.zeros([10]))y = tf.nn.softmax(tf.matmul(x,w) + b)
y_et = tf.placeholder(tf.float32, [None, 10]) # Stockage des étiquettes one_hot
# Mesure de l'erreurcross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_et, logits=y))
# Entrainementtrain_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)
# Lancement de la sessionsess = tf.InteractiveSession()tf.global_variables_initializer().run()
# Evaluation du modelest_correct = tf.equal(tf.argmax(y,1), tf.argmax(y_et, 1))precision = tf.reduce_mean(tf.cast(est_correct, tf.float32))
for _ in range(1000):batch_xs, batch_ys = mnist.train.next_batch(100)train_data={x: batch_xs, y_et: batch_ys}
_,a,c = sess.run([train_step, precision, cross_entropy], feed_dict=train_data)print("Training : {} et {}".format(a,c))
test_data = {x:mnist.test.images, y_et: mnist.test.labels}a,c = sess.run([precision, cross_entropy], feed_dict=test_data)print("Test : {} et {}".format(a,c))
41/1
Apprentissage profond
Fabien TeytaudRésultat du réseau simple
I 92% de réussite en test.I Résultat satisfaisant vue la simplicité du modèle, mais on
doit pouvoir faire mieux.
=⇒I Complexifier le modèle?
I Rajouter des neurones en largeur?I Rajouter des couches?
42/1
Apprentissage profond
Fabien TeytaudPassons à 5 couches
0
0.5
. . .
0.3
0
0
1
2
3
4
5
6
7
8
9
784pixels
200
100
60
30
10
fonction sigmoid
43/1
Apprentissage profond
Fabien TeytaudEn tensorflow
C1 = 200C2 = 100C3 = 60C4 = 30
x = tf.placeholder(tf.float32, [None, 784])x = tf.reshape(x, [-1, 784])w1 = tf.Variable(tf.truncated_normal([784, C1], stddev=0.1))b1 = tf.Variable(tf.zeros([C1]))w2 = tf.Variable(tf.truncated_normal([C1, C2], stddev=0.1))b2 = tf.Variable(tf.zeros([C2]))w3 = tf.Variable(tf.truncated_normal([C2, C3], stddev=0.1))b3 = tf.Variable(tf.zeros([C3]))w4 = tf.Variable(tf.truncated_normal([C3, C4], stddev=0.1))b4 = tf.Variable(tf.zeros([C4]))w5 = tf.Variable(tf.truncated_normal([C4, 10], stddev=0.1))b5 = tf.Variable(tf.zeros([10]))
y1 = tf.nn.relu(tf.matmul(x,w1) + b1)y2 = tf.nn.relu(tf.matmul(y1,w2) + b2)y3 = tf.nn.relu(tf.matmul(y2,w3) + b3)y4 = tf.nn.relu(tf.matmul(y3,w4) + b4)y = tf.nn.softmax(tf.matmul(y4,w5) + b5)
44/1
Apprentissage profond
Fabien TeytaudRésultats?
Problème de la sigmoide?
La fonction reluI f (x) = max(0, x)
I Ré-essayez avec la fonction relu et 10k itérations.
45/1
Apprentissage profond
Fabien TeytaudAnalyse des résultats : tensorboard
46/1
Apprentissage profond
Fabien Teytaudtensorboard : les changements
Dans le code# On rajoute ce qu'on souhaite visualisertf.summary.scalar("Precision", precision)tf.summary.scalar("Cross_entropy", cross_entropy)merged_summary_op = tf.summary.merge_all()
# On créé un FileWriter pour les résultats en test et en apprentissagetrain_summary_writer = tf.summary.FileWriter('/tmp/tensorflow_logs/5couches/train/', graph=tf.get_default_graph())test_summary_writer = tf.summary.FileWriter('/tmp/tensorflow_logs/5couches/test/', graph=tf.get_default_graph())
# On transmet ce qu'on souhaite écrire_,a,c,summary = sess.run([train_step,precision, cross_entropy, merged_summary_op], feed_dict=train_data)train_summary_writer.add_summary(summary, i)
test_data = {x:mnist.test.images, y_et: mnist.test.labels}at,ct, summaryt = sess.run([precision, cross_entropy, merged_summary_op], feed_dict=test_data)test_summary_writer.add_summary(summaryt, i)
Dans une consoletensorboard --logdir=/tmp/tensorflow_logs/5couches/
47/1
Apprentissage profond
Fabien TeytaudRappel : jouer sur le pas d’apprentissage
I Pourquoi?I En tensorFlow :
starter_learning_rate = 0.5global_step = tf.Variable(0, trainable=True)learning_rate = tf.train.exponential_decay(starter_learning_rate, global_step, 1000, 0.96, staircase=False)train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(cross_entropy, global_step=global_step)
48/1
Apprentissage profond
Fabien TeytaudRappel : jouer sur le pas d’apprentissage
49/1
Apprentissage profond
Fabien TeytaudRappel : le sur-apprentissage
I Qu’est ce que le sur-apprentissage?I La solution :
I Dropout
keep_prob = tf.placeholder(tf.float32)y = tf.nn.dropout(yt, keep_prob)
50/1
Apprentissage profond
Fabien TeytaudLes réseaux convolutifs
I Les réseaux de neurones sont un outil puissant.I Il est difficile de calculer les millions de poids.I Création de réseau avec de nombreuses couches :
I Les premières couches extraient des caractéristiques basniveau.
I Ces caractéristiques sont similaires partout dans l’image.I Les dernières couches reconnaissent des formes haut
niveau.I Seule la dernière couche exploite les informations de sortie.
51/1
Apprentissage profond
Fabien TeytaudLes réseaux convolutifs
I Pavage : découpage de l’image en petites zonesI Chaque tuile correspond à un neurone.I Correspond à une convolution (même traitement pour
chaque recepteur) :I Réduit l’empreinte mémoire.I Invariance par translation.
I Subsampling (pooling, mise en commun) : on garde lemax de chaque zone (idée : ce que le neurone a le mieuxappris à reconnaitre).
52/1
Apprentissage profond
Fabien TeytaudLes réseaux convolutifs
53/1
Apprentissage profond
Fabien TeytaudLes réseaux convolutifs
[wikipedia]
54/1
Apprentissage profond
Fabien TeytaudLes réseaux convolutifs
Sans dropout
55/1
Apprentissage profond
Fabien TeytaudLes réseaux convolutifs
Avec dropout
56/1
Apprentissage profond
Fabien TeytaudLes réseaux convolutifs
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
x = tf.placeholder(tf.float32, shape=[None, 784])y_ = tf.placeholder(tf.float32, shape=[None, 10])
# initialisation : on évite les neurones initiaux morts avec des poids initiaux positifs (relu)def weight_variable(shape):
initial = tf.truncated_normal(shape, stddev=0.1)return tf.Variable(initial)
def bias_variable(shape):initial = tf.constant(0.1, shape=shape)return tf.Variable(initial)
# Convolutiondef conv2d(x, W):
return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
# Pooling : on prend le max d'un bloc 2x2def max_pool_2x2(x):
return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
57/1
Apprentissage profond
Fabien TeytaudLes réseaux convolutifs
# Première couche convolutionnelle# Les deux premières dimensions sont la taille du patch# La troisème est le nombre de canaux d'entrées# et la dernière est le nombre de sortiesW_conv1 = weight_variable([5, 5, 1, 32])b_conv1 = bias_variable([32])
# Largeur, hauteur et nombre de canaux couleursx_image = tf.reshape(x, [-1, 28, 28, 1])
# En sortie on a une image 14x14 avec le poolingh_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)h_pool1 = max_pool_2x2(h_conv1)
# Seconde couche convolutionnelleW_conv2 = weight_variable([5, 5, 32, 64])b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)h_pool2 = max_pool_2x2(h_conv2)
# On a un bloc de 7x7, on ajoute un réseau pleinement connecté de 1024 neuronesW_fc1 = weight_variable([7 * 7 * 64, 1024])b_fc1 = weight_variable([1024])
# On applatit le bloc 7x7 pour l'avoir en entrée du réseauh_pool2_flat = tf.reshape(h_pool2, [-1, 7 * 7 * 64])h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
58/1
Apprentissage profond
Fabien TeytaudLes réseaux convolutifs
# Dropoutkeep_prob = tf.placeholder(tf.float32)h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
# On finit de façon classique avec un softmaxW_fc2 = weight_variable([1024, 10])b_fc2 = bias_variable([10])
y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2
# Entrainement et évaluationcross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv))train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# Visualisation dans tensorboardtf.summary.scalar("Precision", accuracy)tf.summary.scalar("Cross_entropy", cross_entropy)merged_summary_op = tf.summary.merge_all()
59/1
Apprentissage profond
Fabien TeytaudLes réseaux convolutifs
with tf.Session() as sess:sess.run(tf.global_variables_initializer())
train_summary_writer = tf.summary.FileWriter('/tmp/conv/train', graph=tf.get_default_graph())test_summary_writer = tf.summary.FileWriter('/tmp/conv/test', graph=tf.get_default_graph())
for i in range(10000):batch = mnist.train.next_batch(50)if i % 100 == 0:
train_accuracy = accuracy.eval(feed_dict={x: batch[0], y_: batch[1], keep_prob: 1.0})print("Step %d, training accuracy %g" % (i, train_accuracy))
_, summary_train = sess.run([train_step, merged_summary_op],feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.75})
train_summary_writer.add_summary(summary_train, i)_, summary_test = sess.run([accuracy, merged_summary_op],
feed_dict={x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0})test_summary_writer.add_summary(summary_test, i)
print("Test accuracy %g" % accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))
train_summary_writer.close()test_summary_writer.close()
60/1
Apprentissage profond
Fabien TeytaudSommaire
61/1
Apprentissage profond
Fabien TeytaudRappel : classification de la base des Iris
La base des IrisI 4 caractéristiques :
I Largeur et longueur des pétales,I largeur et longueur des sépales.
I 3 classesI Settosa,I Virginica,I Versicolor.
I 150 exemples, 50 de chaque classe.
62/1
Apprentissage profond
Fabien TeytaudChargement des données
Les donnéesLe fichier de données est disponible ici : TODO
Chargement des données
# On utilise la librairie pandaimport pandas as pd
# Fonction de chargement des données dans un data framedef load_data(filename):
return pd.read_csv(filename)
# Appel à partir du fichier csv dans le maindata = load_data("../data/iris.csv")
63/1
Apprentissage profond
Fabien TeytaudAnalyse des données
# Fonction analysant les donnéesdef analyze_data(df):
# Shape de la base, ici (150,6)print(df.shape)# Détail de chaque colonnedf.info()# Résumé statistique de chaque caractéritiqueprint(df.describe())# Affichage des premières ligne de la baseprint(df.head())# Fréquence de chaque classeprint(df['Species'].value_counts())
# Appel de la fonction dans le mainanalyze_data(data)
64/1
Apprentissage profond
Fabien TeytaudEncodage des données
Après analyse des données, on se rend compte que la colonne“Species” est de type objet. Pour simplifier, nous allons travaillerqu’avec des données numériques.# import de la classe LabelEncoderfrom sklearn.preprocessing import LabelEncoder
# Transforme un type catégorie en entierdef label_encode(df):
le = LabelEncoder()# On récupère chaque nom de catégories possiblescol_values_unique = list(df['Species'].unique())le_fitted = le.fit(col_values_unique)# On liste l'ensemble des valeurscol_values = list(df['Species'].values)# On transforme les catégories en entiercol_values_transformed = le.transform(col_values)# On fait le remplacement de la colonne Species# dans le dataset d'originedf['Species'] = col_values_transformed
# Appel de la fonction dans le mainlabel_encode(data)
65/1
Apprentissage profond
Fabien TeytaudLa matrice de corrélation
Utile pour évaluer la dépendance entre des variables.# On utilise la bibilothèque seabornimport seaborn as sns
# Corrélation entre les caractéritiquesdef show_matrix(df):
plt.figure(figsize=(10, 8))sns.heatmap(df.corr(), vmax=1, annot=True)plt.title('Matrice de corrélation')plt.show()
# Appel dans le mainshow_matrix(data)
66/1
Apprentissage profond
Fabien TeytaudSéparation des données en deux bases,apprentissage et test
from sklearn.model_selection import train_test_split# Séparation des donnéesdef split_data(df, ratio):
# Séparation en apprentissage/testtrain, test = train_test_split(df, test_size=ratio)# Séparation des étiquettesx_train = trainy_train = train['Species']del x_train['Species']x_test = testy_test = test['Species']del x_test['Species']return x_train, y_train, x_test, y_test
# Appel dans le maintest_train_ratio = 0.3x_train, y_train, x_test, y_test =
split_data(data, test_train_ratio)
67/1
Apprentissage profond
Fabien TeytaudApprentissage et test
from sklearn.metrics import confusion_matrix# Apprentissage du modèledef create_model(classifier, x_train, y_train):
classifier.fit(x_train, y_train)return classifier
# Evaluation du modèledef display_score(classifier, x_train,
y_train, x_test, y_test):# Précision en apprentissage et testprint("Train score: {}, Test score {}"
.format(classifier.score(x_train, y_train),classifier.score(x_test, y_test)))
# Calcul de la matrice de confusiony_pred = classifier.predict(x_test)print(confusion_matrix(y_test, y_pred))
68/1
Apprentissage profond
Fabien TeytaudExemples de classifieurs
from sklearn import treefrom sklearn.neighbors import KNeighborsClassifier# K plus proches voisinsprint('K-plus proches voisins')classifier = KNeighborsClassifier()create_model(classifier, x_train, y_train)display_score(classifier, x_train, y_train, x_test, y_test)
# Arbre de décisionsprint('Arbre de décisions')classifier = tree.DecisionTreeClassifier()create_model(classifier, x_train, y_train)display_score(classifier, x_train, y_train, x_test, y_test)
69/1
Apprentissage profond
Fabien TeytaudExemples de classifieurs
from sklearn.ensemble import RandomForestClassifierfrom sklearn.neural_network import MLPClassifier# Random forestprint('Random forest')classifier = RandomForestClassifier(n_estimators=28)create_model(classifier, x_train, y_train)display_score(classifier, x_train, y_train, x_test, y_test)
# Réseau de neuronesprint('Réseau de neurones')classifier = MLPClassifier()create_model(classifier, x_train, y_train)display_score(classifier, x_train, y_train, x_test, y_test)
70/1
Apprentissage profond
Fabien TeytaudRésultats
K-plus proches voisinsTrain score: 1.0, Test score 1.0[[18 0 0][ 0 12 0][ 0 0 15]]
Arbre de décisionsTrain score: 1.0, Test score 0.9777777777777777[[18 0 0][ 0 12 0][ 0 1 14]]
Random forestTrain score: 1.0, Test score 0.9777777777777777[[18 0 0][ 0 12 0][ 0 1 14]]
Réseau de neuronesTrain score: 0.42857142857142855, Test score 0.3333333333333333[[ 3 15 0][ 0 12 0][ 0 15 0]]
71/1
Apprentissage profond
Fabien TeytaudSommaire
72/1
Apprentissage profond
Fabien TeytaudLa catégorisation de texte
La catégorisation de texte est un problème classique enapprentissage artificiel. Des exemples classiques sont :I Retrouver l’auteur d’un texte ou d’un document,I classer des critques selon qu’elles soient positives ou
négatives,I classer des mails,I etc.
73/1
Apprentissage profond
Fabien TeytaudLe modèle “sac de mots” (bag of words)
I Il s’agit de la représentation la plus classique.I Un ensemble encode les mots qui apparaissent dans le
texte.I Ils n’encodent pas la syntaxe, l’ordre des mots ou la
grammaire.I Chaque élément est une valeur binaire qui représente si
oui ou non le mot est présent dans le document.
74/1