Fabien Teytaud - LISIC

Apprentissage profond

Fabien Teytaud

Université du Littoral Cote d’Opale

26 août 2020

Fabien TeytaudSommaire

Fabien TeytaudQuelques références

Bulco : 006.3 COR A

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

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.

Fabien TeytaudLes types d’apprentissage

Supervisé Non-supervisé

Fabien TeytaudExemples d’apprentissage supervisé

Classification Régression

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)

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.

Fabien TeytaudUn exemple simpleLe perceptron

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.

∂W= −(yi − F (W (t)′Xi))Xi

I Mise à jour : W (t + 1) = W (t) + η(t)(yi − F (W (t)′Xi))Xi)On soustrait au poids le gradient du coût.

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.

∂W= −(yi − F (W (t)′Xi))Xi

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 !

Fabien TeytaudRappels importantsSur-apprentissage (variance) et sous-apprentissage (biais)

Regression

Classification

Fabien TeytaudProblème des machines linéaires?

Fabien TeytaudLes réseaux de neurones

XORActivation, fonction seuil :Si > seuil alors 1 sinon 0

⇔d∑

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

⇔d∑

wixi − seuil

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

⇔d∑

wixi − seuil

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

⇔d∑

wixi − seuil

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

⇔d∑

wixi − seuil

y3 = w0,3x0+ w1,3x1− seuilN3

y2 = w0,2x0+ w1,2x1− seuilN2

y = w3,4y3+ w2,4y2

⇔d∑

wixi − seuil

y3 = x0+ x1

y2 = x0+ x1− 1y = y3− y2

Fabien TeytaudApprentissage et test

Nous allons approfondir les notions développées lors du coursde l’an dernier.

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.

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.

Fabien TeytaudLa validation croisée (k -fold cross validation)

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.

Malade Non maladetest positif True Positive False Positivetest négatif False Negative True Negative

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

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 :

1precision + 1

recall

= 2× precision × recallprecision + recall

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.

Score F1

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]

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

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.

Fabien TeytaudExemple de graphe

[Doc tensorFlow]30/1

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]

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

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

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

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

Fabien TeytaudUn premier réseau

784 pixels

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]

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)

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

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

Fabien TeytaudEn prenant un batch de 100 images

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

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?

Fabien TeytaudPassons à 5 couches

784pixels

fonction sigmoid

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)

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.

Fabien TeytaudAnalyse des résultats : tensorboard

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/

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)

Fabien TeytaudRappel : jouer sur le pas d’apprentissage

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)

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.

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

[wikipedia]

Sans dropout

Avec dropout

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

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

# 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()

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

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.

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

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)

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)

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)

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)

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

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)

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)

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

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.

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.

Fabien Teytaud - LISIC

Documents

Accumulateur Hydraulique Fabien Manuel

Bases de données - LISIC

#PortraitDeStartuper #60 - Le Taximètre - Fabien Conreaux

portfolio fabien zocco · portfolio fabien zocco. fabien zocco 1980 vit et travaille à Lille diplômé du Fresnoy 2016, félicitations du jury « contribution majeure aux oeuvres

· BODART Olivier CAIRA Françoise CHABERT Jérôme CHAMBRES Patrick COLOMB Aurélie CONORD Fabien COUTAREL Fabien ... DEVOIZE …

Autoformation à JavaFX - LISIC

Fabien Gabel - Atma Classique

Product Design - Fabien Dupont

Nuages - Fabien Lévy | Composer

Symfony Fabien Potencier Symfony

PANCREATITE CHRONIQUE Professeur Fabien ZOULIM HOTEL DIEU

Présentation de Fabien Gandon

Book Fabien Flourens

Portfolio - Fabien Ropars Photographies N°1

FABIEN FABIEN CORRECH NATHALIE FERRON SANTÉ-DÉTOX DE …

L’INVITÉ DE CONJONCTURE FABIEN CAPARROS …

M2 AGEST - Fabien Raimbaud 2012-2013

Derrière l’appareil : Fabien Hobléa

TFE Myotest Fabien Culemme

de et avec Fabien Lalaux - theatredufiguier.com