Apprentissage profond

(1)

Apprentissage profond Fabien Teytaud

Apprentissage profond

Fabien Teytaud

Université du Littoral Cote d’Opale

26 août 2020

(2)

Sommaire

(3)

Quelques références

Livre

Bulco : 006.3 COR A

(4)

Quelques références

Vidéos en ligne

I 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 ligne

I Mon cours en Master 1

I Un tutorial rapide python pour le cours

(5)

L’apprentissage

On souhaite faire en sorte que le programme apprenne quelque chose à partir de données.

On distingue plusieurs familles d’apprentissage, et en particulier :

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.

(6)

Les types d’apprentissage

Supervisé Non-supervisé

(7)

Exemples d’apprentissage supervisé

Classification Régression

(8)

Un exemple simple

Ca devrait vous rappeler quelque chose ...

Régression linéaire, erreur quadratique moyenne

I 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 , y i , X i ) = 1

2 (y i − W ⁰ X i ) ²

On minimise la différence entre la sortie désirée et la sortie du système.

I Gradient du coût : ∂L(W , y i , X i )

∂W = −(y _i − W (t ) ⁰ X i )X i 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)(y _i − W (t) ⁰ X _i )X _i )

On soustrait au poids le gradient du coût.

−→

Convergence : minimisation de la moyenne de la fonction coût

(9)

Un exemple simple

Le perceptron

(10)

Un exemple simple

Le perceptron

(11)

Un exemple simple

... le perceptron

Machine linéaire, le perceptron

I Règle de décision : y = F (W ⁰ X )

F est la fonction seuil.

I Fonction de coût : L(W , y _i , X _i ) = (F (W ⁰ X _i ) − y _i )W ⁰ X _i

On minimise la différence entre la sortie désirée et la sortie du système.

I Gradient du coût : ∂L(W , y _i , X _i )

∂W = −(y _i − F (W (t) ⁰ X _i ))X _i

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)(y _i − F (W (t ) ⁰ X _i ))X _i )

On soustrait au poids le gradient du coût.

(12)

Un exemple simple

... le perceptron

Machine linéaire, le perceptron

I Règle de décision : y = F (W ⁰ X )

F est la fonction seuil.

I Fonction de coût : L(W , y i , X i ) = (F (W ⁰ X i ) − y i )W ⁰ X i On minimise la différence entre la sortie désirée et la sortie du système.

I Gradient du coût : ∂L(W , y _i , X _i )

∂W = −(y _i − F (W (t) ⁰ X _i ))X _i

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)(y _i − F (W (t ) ⁰ X _i ))X _i )

On soustrait au poids le gradient du coût.

Sans oublier le biais !

(13)

Rappels importants

Sur-apprentissage (variance) et sous-apprentissage (biais)

Regression

Classification

(14)

Problème des machines linéaires ?

(15)

Les réseaux de neurones

XOR Activation, fonction seuil :

Si > seuil alors 1 sinon 0

⇔

d

X

i=1

w _i x _i − seuil Seuil _N

₃

= 0, Seuil _N

₂

= 1

x ₀ x ₁ σ ₃ σ ₂ y ₃ y ₂ y

0 0 0 0 0 0 0

0 1 1 1 1 0 1

1 0 1 1 1 0 1

1 1 2 2 1 1 0

(16)

Les réseaux de neurones

XOR Activation, fonction seuil :

Si > seuil alors 1 sinon 0

⇔

d

X

i=1

w _i x _i − seuil Seuil _N

₃

= 0, Seuil _N

₂

= 1

x ₀ x ₁ σ ₃ σ ₂ y ₃ y ₂ y

0 0 0 0 0 0 0

0 1 1 1 1 0 1

1 0 1 1 1 0 1

1 1 2 2 1 1 0

(17)

Les réseaux de neurones

XOR Activation, fonction seuil :

Si > seuil alors 1 sinon 0

⇔

d

X

i=1

w _i x _i − seuil Seuil _N

₃

= 0, Seuil _N

₂

= 1

x ₀ x ₁ σ ₃ σ ₂ y ₃ y ₂ y

0 0 0 0 0 0 0

0 1 1 1 1 0 1

1 0 1 1 1 0 1

1 1 2 2 1 1 0

(18)

Les réseaux de neurones

XOR Activation, fonction seuil :

Si > seuil alors 1 sinon 0

⇔

d

X

i=1

w _i x _i − seuil Seuil _N

₃

= 0, Seuil _N

₂

= 1

x ₀ x ₁ σ ₃ σ ₂ y ₃ y ₂ y

0 0 0 0 0 0 0

0 1 1 1 1 0 1

1 0 1 1 1 0 1

1 1 2 2 1 1 0

(19)

Les réseaux de neurones

XOR Activation, fonction seuil :

Si > seuil alors 1 sinon 0

⇔

d

X

i=1

w _i x _i − seuil Seuil _N

₃

= 0, Seuil _N

₂

= 1



 

 

y 3 = w 0,3 x 0 + w 1,3 x 1 − seuil N

3

y ₂ = w _0,2 x ₀ + w _1,2 x ₁ − seuil _N

₂

y = w 3,4 y 3 + w 2,4 y 2

(20)

Les réseaux de neurones

XOR Activation, fonction seuil :

Si > seuil alors 1 sinon 0

⇔

d

X

i=1

w _i x _i − seuil Seuil _N

₃

= 0, Seuil _N

₂

= 1



 

 

y 3 = x 0 + x 1

y ₂ = x ₀ + x ₁ − 1

y = y 3 − y 2

(21)

Sommaire

(22)

Apprentissage et test

Nous allons approfondir les notions développées lors du cours

de l’an dernier.

(23)

Apprentissage et test : limite

I Supposons que l’on a un modèle qui dépend d’un paramè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 en généralisation (sur la base de test).

I On choisit ce modèle pour la production, mais on s’aperçoit qu’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.

(24)

La validation croisée (k-fold cross validation)

I La base d’apprentissage est découpée en k sous-ensembles.

I On sélectionne un des k sous-ensembles comme ensemble de validation.

I Le modèle est entrainé sur les k − 1 sous-ensembles restants.

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’apprentissage et la validation.

I Chaque observation est utilisée qu’une seule fois en

validation.

(25)

La validation croisée (k-fold cross validation)

(26)

Mesure 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 pas

un bon critère de performance.

(27)

Mesure de performance : sensibilité, spécificité et courbe ROC

Malade Non malade

test positif True Positive False Positive

test négatif False Negative True Negative

(28)

Mesure de performance : sensibilité, spécificité et courbe ROC

I La sensibilité d’un test mesure sa capacité à donner un résultat positif si l’hypothèse est vérifiée.

I La sensitivité d’un test mesure sa capacité à donner un ré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

(29)

Mesure de performance : sensibilité, spécificité et courbe ROC

Score F 1

Afin de comparer deux classifieurs il est pratique de n’avoir qu’un seul score qui combine precision et recall.

Le score F 1 correspond à la moyenne harmonique :

F 1 = 2

1 precision + _recall ¹ = 2 × precision × recall

precision + recall = TP TP + ^FN+FP ₂ Ce score favorise des classifieurs qui ont une précision et un recall similaires.

Pour certains problèmes il est plus intéressant de s’intéresser

à une mesure plutôt qu’à une autre.

(30)

Mesure de performance : sensibilité, spécificité et courbe ROC

Score F 1

(31)

La courbe ROC Receiver Operating Characteristic

Il s’agit d’une autre mesure de performance d’un classifieur.

Cette mesure donne le taux de vrais positifs en fonction du

taux de faux positifs.

(32)

Sommaire

(33)

TensorFlow

I 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...

(34)

TensorFlow

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.

(35)

Exemple de graphe

(36)

Exemple de code

Code :

import tensorflow as tf

a = 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]

(37)

Analysons le code suivant [Doc tensorFlow]

# Model parameters

W=tf.Variable([.3], dtype=tf.float32) b=tf.Variable([-.3], dtype=tf.float32)

# Model input and output x=tf.placeholder(tf.float32) linear_model=W*x+b y=tf.placeholder(tf.float32)

# loss

loss=tf.reduce_sum(tf.square(linear_model-y))# sum of the squares

# optimizer

optimizer=tf.train.GradientDescentOptimizer(0.01) train=optimizer.minimize(loss)

# training data x_train=[1,2,3,4]

y_train=[0,-1,-2,-3]

# training loop

init=tf.global_variables_initializer() sess=tf.Session()

sess.run(init) foriinrange(1000):

sess.run(train, {x: x_train, y: y_train})

# evaluate training accuracy

curr_W, curr_b, curr_loss=sess.run([W, b, loss], {x: x_train, y: y_train}) print("W:%sb:%sloss:%s"%(curr_W, curr_b, curr_loss))

(38)

Analysons le code suivant [Doc tensorFlow]

# Model parameters

W=tf.Variable([.3], dtype=tf.float32) b=tf.Variable([-.3], dtype=tf.float32)

# Model input and output x=tf.placeholder(tf.float32) linear_model=W*x+b y=tf.placeholder(tf.float32)

# loss

loss=tf.reduce_sum(tf.square(linear_model-y))# sum of the squares

# optimizer

optimizer=tf.train.GradientDescentOptimizer(0.01) train=optimizer.minimize(loss)

# training data x_train=[1,2,3,4]

y_train=[0,-1,-2,-3]

# training loop

init=tf.global_variables_initializer() sess=tf.Session()

sess.run(init) foriinrange(1000):

sess.run(train, {x: x_train, y: y_train})

# evaluate training accuracy

curr_W, curr_b, curr_loss=sess.run([W, b, loss], {x: x_train, y: y_train}) print("W:%sb:%sloss:%s"%(curr_W, curr_b, curr_loss))

(39)

Sommaire

(40)

Tout d’abord les données : MNIST

Le problème/les données

I Reconnaissance de chiffres manuscrits.

I 60k images d’apprentissage, 10k de test.

I Normalisées, centrées, 28x28 pixels

I http://yann.lecun.com/exdb/mnist

(41)

Charger les données avec TensorFlow

Code pour le chargement des données

fromtensorflow.examples.tutorials.mnistimportinput_data mnist=input_data.read_data_sets("MNIST_data/", one_hot=True)

one_hot

Celà 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

(42)

Un 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

(43)

Un premier réseau

softmax(x ) = exp(x ) P

j exp(x _j )

y = softmax(X.W + b)

Prédictions [nbimages, 10]

Poids [784, 10]

Images

[nbimages, 784]

Biais

[10]

(44)

C’est parti .. [Doc tensorFlow]

importtensorflowastf

x=tf.placeholder(tf.float32, [None,784])# None : n'importe quelle taille w=tf.Variable(tf.zeros([784,10]))

b=tf.Variable(tf.zeros([10]) y=tf.nn.softmax(tf.matmul(x,w)+b)

(45)

C’est parti .. [Doc tensorFlow]

Mesure de l’erreur

Utilisation de la cross-entropy :

− X

y log(y ⁰ )

I y ⁰ correspond aux valeurs prédites (probabilité entre 0 et 1).

I y correspond correspond aux vraies étiquettes (vecteur

one_hot).

(46)

C’est parti .. [Doc tensorFlow]

# Déclaration

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'erreur

cross_entropy= -tf.reduce_sum(y_et*tf.log(y))

# Entrainement

train_step=tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

# Lancement de la session sess=tf.InteractiveSession() tf.global_variables_initializer().run()

for_inrange(1000):

batch_xs, batch_ys=mnist.train.next_batch(1)# pour l'instant on prend les images une par une sess.run(train_step, feed_dict={x: batch_xs, y_et: batch_ys})

# Evaluation du model

est_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}))

(47)

En prenant un batch de 100 images

fromtensorflow.examples.tutorials.mnistimportinput_data mnist=input_data.read_data_sets("MNIST_data/", one_hot=True)

# Déclaration

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'erreur

cross_entropy=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_et, logits=y))

# Entrainement

train_step=tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

# Lancement de la session sess=tf.InteractiveSession() tf.global_variables_initializer().run()

# Evaluation du model

est_correct=tf.equal(tf.argmax(y,1), tf.argmax(y_et,1)) precision=tf.reduce_mean(tf.cast(est_correct, tf.float32)) for_inrange(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))

(48)

Ré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 ?

(49)

Passons à 5 couches

0 0.5 . . . 0.3 0

1 2 3 4 5 6 7 8 9

784 pixels

200

100 60 30

10

(50)

En tensorflow

C1= 200 C2= 100 C3= 60 C4= 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]))

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)

(51)

Résultats ?

Problème de la sigmoide ?

La fonction relu

I f (x ) = max(0, x)

I Ré-essayez avec la fonction relu et 10k itérations.

(52)

Analyse des résultats : tensorboard

(53)

tensorboard : les changements

Dans le code

# On rajoute ce qu'on souhaite visualiser tf.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 apprentissage

train_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 console

tensorboard --logdir=/tmp/tensorflow_logs/5couches/

(54)

Rappel : jouer sur le pas d’apprentissage

I Pourquoi ? I En tensorFlow :

starter_learning_rate= 0.5

global_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)

(55)

Rappel : jouer sur le pas d’apprentissage

(56)

Rappel : le sur-apprentissage

I Qu’est ce que le sur-apprentissage ? I La solution :

I Dropout

keep_prob=tf.placeholder(tf.float32)

(57)

Les 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 bas

niveau.

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.

(58)

Les réseaux convolutifs

I Pavage : découpage de l’image en petites zones I 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 le

max de chaque zone (idée : ce que le neurone a le mieux

appris à reconnaitre).

(59)

Les réseaux convolutifs

(60)

Les réseaux convolutifs

[wikipedia]

(61)

Les réseaux convolutifs

Sans dropout

(62)

Les réseaux convolutifs

Avec dropout

(63)

Les réseaux convolutifs

fromtensorflow.examples.tutorials.mnistimportinput_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) defweight_variable(shape):

initial=tf.truncated_normal(shape, stddev=0.1) returntf.Variable(initial)

defbias_variable(shape):

initial=tf.constant(0.1, shape=shape) returntf.Variable(initial)

# Convolution defconv2d(x, W):

returntf.nn.conv2d(x, W, strides=[1,1,1,1], padding='SAME')

# Pooling : on prend le max d'un bloc 2x2 defmax_pool_2x2(x):

returntf.nn.max_pool(x, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')

(64)

Les 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 sorties W_conv1=weight_variable([5,5,1,32]) b_conv1=bias_variable([32])

# Largeur, hauteur et nombre de canaux couleurs x_image=tf.reshape(x, [-1,28,28,1])

# En sortie on a une image 14x14 avec le pooling h_conv1=tf.nn.relu(conv2d(x_image, W_conv1)+b_conv1) h_pool1=max_pool_2x2(h_conv1)

# Seconde couche convolutionnelle W_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 neurones W_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éseau h_pool2_flat=tf.reshape(h_pool2, [-1,7 * 7 * 64]) h_fc1=tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1)+b_fc1)

(65)

Les réseaux convolutifs

# Dropout

keep_prob=tf.placeholder(tf.float32) h_fc1_drop=tf.nn.dropout(h_fc1, keep_prob)

# On finit de façon classique avec un softmax W_fc2=weight_variable([1024,10]) b_fc2=bias_variable([10])

y_conv=tf.matmul(h_fc1_drop, W_fc2)+b_fc2

# Entrainement et évaluation

cross_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 tensorboard tf.summary.scalar("Precision", accuracy) tf.summary.scalar("Cross_entropy", cross_entropy) merged_summary_op=tf.summary.merge_all()

(66)

Les réseaux convolutifs

withtf.Session()assess:

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()) foriinrange(10000):

batch=mnist.train.next_batch(50) ifi% 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()

(67)

Sommaire

(68)

Rappel : classification de la base des Iris

La base des Iris

I 4 caractéristiques :

I Largeur et longueur des pétales, I largeur et longueur des sépales.

I 3 classes I Settosa, I Virginica, I Versicolor.

I 150 exemples, 50 de chaque classe.

(69)

Chargement des données

Les données

Le fichier de données est disponible ici : TODO

Chargement des données

# On utilise la librairie panda import pandas as pd

# Fonction de chargement des données dans un data frame def load_data(filename):

return pd.read_csv(filename)

# Appel à partir du fichier csv dans le main

data = load_data("../data/iris.csv")

(70)

Analyse des données

# Fonction analysant les données def analyze_data(df):

# Shape de la base, ici (150,6) print(df.shape)

# Détail de chaque colonne df.info()

# Résumé statistique de chaque caractéritique print(df.describe())

# Affichage des premières ligne de la base print(df.head())

# Fréquence de chaque classe

print(df['Species'].value_counts())

# Appel de la fonction dans le main

analyze_data(data)

(71)

Encodage 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 travailler qu’avec des données numériques.

# import de la classe LabelEncoder

from sklearn.preprocessing import LabelEncoder

# Transforme un type catégorie en entier def label_encode(df):

le = LabelEncoder()

# On récupère chaque nom de catégories possibles col_values_unique = list(df['Species'].unique()) le_fitted = le.fit(col_values_unique)

# On liste l'ensemble des valeurs col_values = list(df['Species'].values)

# On transforme les catégories en entier

col_values_transformed = le.transform(col_values)

# On fait le remplacement de la colonne Species

# dans le dataset d'origine

df['Species'] = col_values_transformed

# Appel de la fonction dans le main

label_encode(data)

(72)

La matrice de corrélation

Utile pour évaluer la dépendance entre des variables.

# On utilise la bibilothèque seaborn import seaborn as sns

# Corrélation entre les caractéritiques def 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 main

show_matrix(data)

(73)

Séparation des données en deux bases, apprentissage et test

from sklearn.model_selection import train_test_split

# Séparation des données def split_data(df, ratio):

# Séparation en apprentissage/test

train, test = train_test_split(df, test_size=ratio)

# Séparation des étiquettes x_train = train

y_train = train['Species']

del x_train['Species']

x_test = test

y_test = test['Species']

del x_test['Species']

return x_train, y_train, x_test, y_test

# Appel dans le main test_train_ratio = 0.3

x_train, y_train, x_test, y_test =

(74)

Apprentissage et test

from sklearn.metrics import confusion_matrix

# Apprentissage du modèle

def create_model(classifier, x_train, y_train):

classifier.fit(x_train, y_train) return classifier

# Evaluation du modèle

def display_score(classifier, x_train, y_train, x_test, y_test):

# Précision en apprentissage et test print("Train score: {}, Test score {}"

.format(classifier.score(x_train, y_train), classifier.score(x_test, y_test)))

# Calcul de la matrice de confusion

y_pred = classifier.predict(x_test)

print(confusion_matrix(y_test, y_pred))

(75)

Exemples de classifieurs

from sklearn import tree

from sklearn.neighbors import KNeighborsClassifier

# K plus proches voisins

print('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écisions

print('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)

(76)

Exemples de classifieurs

from sklearn.ensemble import RandomForestClassifier from sklearn.neural_network import MLPClassifier

# Random forest

print('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 neurones

print('Réseau de neurones') classifier = MLPClassifier()

create_model(classifier, x_train, y_train)

display_score(classifier, x_train, y_train, x_test, y_test)

(77)

Résultats

K-plus proches voisins

Train score: 1.0, Test score 1.0 [[18 0 0]

[ 0 12 0]

[ 0 0 15]]

Arbre de décisions

Train score: 1.0, Test score 0.9777777777777777 [[18 0 0]

[ 0 12 0]

[ 0 1 14]]

Random forest

Train score: 1.0, Test score 0.9777777777777777 [[18 0 0]

[ 0 12 0]

[ 0 1 14]]

Réseau de neurones

Train score: 0.42857142857142855, Test score 0.3333333333333333 [[ 3 15 0]

[ 0 12 0]

[ 0 15 0]]

(78)

Sommaire

(79)

Apprentissage profond