Please wait, while the deck is loading…
# {/no-status /keep-logo title-slide} // comment - - - *(**naviguer** pas-à-pas avec les flèches ←/→ **ou** slide par slide avec 'a'/'z'){dense}* ## Meta {libyli} - `$ whoami`
@svg: logos/affiliations.svg 400 100
- Objectifs - comprendre le « deep learning » pour l'image - pratiquer : numpy, scikit-learn, tensorflow - Déroulement du workshop // disclaimer: non-exhaustive - « cours » - pratique dans un « notebook » Jupyter - Ressources - slides et notebooks github.com/twitwi/2017-mixit-tensorflow - site Tensorflow - Attributions - wikipedia, [creative commons et autres media](#attrib) ## Menu du jour {#the-overview} - Apprentissage automatique {ml} - Frameworks et Graphes de Calculs {tfgraph} - Combinaison linéaire, Perceptron, Activation {percep} - Optimisation et Descente de Gradient (ou autre) {optim} - Perceptron Multicouches, Apprentissage Profond {deep} - Convolutions et Deep Learning {convnet} - Sur les Épaules des Géants {pretrain} # @copy: #the-overview: %+class:HERE: .ml # Machine Learning
Apprentissage Automatique ## Question : Quelle espèce d'Iris ? {image-full bottom-left darkened /black-bg /no-status}
- {notes} - you have to write a program or human procedure - that receives a flower - that should tell it's species among 3 possible ones (close ones) ## Extraction de Caractéristiques {custommap}
Sepal length: 5.1
Sepal width: 2.5
Petal length: 4.2
Petal width: 1.0
Expected Label: “Iris Setosa”
## Analyse et Écriture de Programme {image-full bottom-left darkened /black-bg /no-status}
- {notes} - looking at feature - starting to write the program - using "if" etc ## IFTTT... {image-full top-right darkened /black-bg /no-status}
- {notes} - a lot of if - a simple case - actually: more features, more classes, more intricated ## Machine Learning Prédictif - Au lieu d'écrire un programme pour résoudre une tâche, - Nous allons {slide} 1. collecter des données annotées : *paires entrée/sortie* 2. générer automatiquement un programme
qui calcule la *sortie* pour n'importe quelle *entrée* {step2} 3. « profit! » {slide} // actually fast to apply usually 2. @anim: .step2 La machine *apprend* à *généraliser*
à partir d'un nombre limité d'exemples,
à la manière des humains. {center slide bordered} ## Différentes Tâches - Apprentissage supervisé : des annotations sont données {slide} - classification : trouver l'étiquette (classe, ...) d'un exemple - régression : trouver une valeur cible (âge, prix, poids, ...) - Apprentissage non-supervisé : pas d'annotations {slide} - clustering : grouper les choses - pattern mining : trouver des structures récurrentes - détection d'anomalie: trouver des valeurs « aberrantes » ## Notations - En général : - $X$ : entrée (caractéristiques) - $Y$ : sortie (valeur ou classe) - $w$ : poids, paramètres qui seront appris - $b$ : biais, paramètres qui seront appris - $\theta$ : ensemble des paramètres ($w$, $b$, ...) - Ensembles de données // cf slide suivant - $train$ : ensemble d'apprentissage (pour entraîner le système) - $valid$ : ensemble de validation (pour éviter le sur-apprentissage) - $test$ : ensemble de test (pour évaluer le système) ## Le « sur-apprentissage » @svg: media/overfitting.svg 800px 500px - @anim: #points | #linear | #piecewise | #ok - {notes} - example: surface of a flat vs price - in the end, there is no best solution # Régression et Classification
avec Scikit Learn **01** {pratique} # @copy: #the-overview: %+class:HERE: .tfgraph # Frameworks,
Graphes de Calculs ## Frameworks de Machine Learning {libyli} - Généraux - scikit-learn - Weka - Hadoop, spark, MLlib, … - … - Orientés « deep learning » - Theano, Pylearn2, lasagne, … // Montréal - caffe // berkeley - Torch7 // F.A.I.R. - Tensorflow // Google (nov 2015) - Keras // wrapper over theano or tensorflow - MXnet // open community - … ## Graphes de Calculs - Calculs « classiques » (numpy, etc.) ```python N = 1000 # nombre de points D = 10 # nombre de caractéristiques x = np.random.randn(N, D) # données au hasard... w = np.random.randn(D) # poids au hasard b = np.random.randn(1) # biais au hasard # opérations élément par élément, avec broadcasting ypred = np.sum(w*x, axis=1) + b {dense slide} ``` - Graphes de calcul (theano, tensorflow, etc.) ```python x = tf.placeholder(tf.float32, shape=[None, D]) # entréees w = tf.Variable(tf.truncated_normal([D], stddev=0.05)) # poids b = tf.Variable(tf.constant(0.05, shape=[1])) # biais # opérations élément par élément, avec broadcasting ypred = tf.reduce_sum(x * w, axis=1) + b {dense slide} ``` ## Graphe de calcul en Tensorflow ```python x = tf.placeholder(tf.float32, shape=[None, D]) # entréees w = tf.Variable(tf.truncated_normal([D], stddev=0.05)) # poids b = tf.Variable(tf.constant(0.05, shape=[1])) # biais # opérations élément par élément, avec broadcasting ypred = tf.reduce_sum(x * w, axis=1) + b {dense} ``` - Le code ne fait que créer un graphe symbolique - @anim: - #y,#subsquared,#reduceprint,#intermediate + .grr + - @anim: #x | #w, #b | #mul | #sumadd | #ypred - *@svg: media/compute-graph.svg 800 230 {grr}* {no} - Évaluation du graphe {slide} ```python X = np.random.randn(N, D) # données au hasard... with tf.Session() as sess: res = sess.run(ypred, feed_dict={ x: X }) # calcule "ypred" sachant que "x" vaut "X" print(res) {dense slide} ``` ## Utilisation d'un graphe Tensorflow {pratique nobg} - @anim: #x,#w,#b,#mul,#sumadd,#ypred @svg: media/compute-graph.svg 800 230 {grr whitebg no} - $err = \sum_i (y^i - y_{pred}^i)^2$ {slide} - @anim: #y | #subsquared | #reduceprint | #intermediate - À vous ! **02** {slide} - calcul de l'erreur totale - évaluation du graphe - vérification des tailles (shape) # @copy: #the-overview: %+class:HERE: .percep # Combinaison linéaire, Perceptron, Activation ## Perceptron et fonction d'activation // à la base une machine physique
$\varphi$ « marche »
$\varphi$ « en S »
$\varphi$ « ReLU » (la plus utilisée)
- $o = \varphi\left(\sum_{i=0}^n w_i x_i\right)$     (avec $x_0 = 1$) {dense} - vu autrement :

« $o = seuil(a.x + b) = seuil(w_1 x_1 + w_2 x_2 + \cdots + b)$ »{dense} # @copy: #the-overview: %+class:HERE: .optim # Optimisation,
Descente de Gradient ## Apprentissage = Optimisation {libyli} - $o = f(x, w)$ - $x, y$ est un exemple d'entrainement - $o$ est la sortie obtenue, avec les paramètres $w$ - Objectif de l'apprentissage - à partir d'exemples annotés, $x$ et $y$ correspondant - minimiser la somme des erreurs $err(y, o) = dist(y, f(x, w))$ - **trouver les meilleurs paramètres $w$**
*(NB: attention quand même au sur-apprentissage) {dense}* @svg: media/gradient-empty.svg 800 180 {grad} @anim: .grad ## Descente de Gradient *(suivre la pente){dense}*
@svg: media/gradient.svg 390 250 {grad}
@svg: media/wikipedia/Gradient_descent.svg 300 250 {grad2d}

- « which optimizer to use? » {ref dense} - @anim: .grad - @anim: #cat | #w0 | #j1, #w1 | #j2, #w2 | #j3, #w3 | #j4, #w4 | #j5, #w5 + #j6, #w6 - @anim: .grad2d | .ref | .opt1 | .opt2 # Optimiseur en Tensorflow
(plus tard) {pratique} # @copy: #the-overview: %+class:HERE: .deep # Perceptron Multicouches,
*Deep Learning*,
Apprentissage de Représentation ## Perceptron Multicouches @svg: media/mlp.svg 800 450 - $o = \varphi(W^4 \times \varphi(W^3 \times \varphi(W^2 \times \varphi(W^1 \times X))))$ {eqs} - @anim: #percep | #per1 | #per2 | #per3 | #one2 | #l3 | #one3,#l4 | #one4,#o | .eqs ## Apprentissage de Représentation @svg: media/mlp-long.svg 800 150 - Deep Learning / Representation Learning {libyli} - au lieu - d'extraire des caractéristiques « à la main » - d'apprendre le classifieur - on va - donner à l'algorithme l'entrée brute (ex: les pixels) - laisser l'algorithme trouver les caractéristiques pertinentes - apprendre de bout en bout - il faut avoir compris son problème (architecture), et avoir - des données - de la puissance de calcul (CPU, GPU) - un framework (optimiseur, dérivation, …) - des fonctions dérivables pour le gradient de la composition : $(f \circ g)'(x) = f'(g(x)) . f(g'(x))$ # Un MLP en Tensorflow **03** {pratique} // combien de paramètres # @copy: #the-overview: %+class:HERE: .convnet # Convolutions et Deep Learning ## Particularité des images {libyli} - Exemple : ségmentation sémantique - pour chaque pixel, une des 30 classes - entrée/sortie en 2000x1000 = 2MPixels = 2 million de dimensions - @anim: %+class:FS:video | %play:video | %pause:video | %-class:FS:video - Perceptron simple couche - nombre de paramètres ? - Malédiction de la dimension - explosion du nombre de paramètres - apprentissage impossible - risque de sur-apprentissage - {no noslide} - Particularité des images - invariance en translation - dépendances locales ## Convolutions et Couche de Convolution {libyli} - Convolution - opération entre 2 fonctions : $(f * g )(t) = \int_{-\infty}^{\infty} f(\tau) g(t - \tau) d\tau {dense}$ - application d'un filtre à une image (comme dans Photoshop / gimp) - corrélation entre un motif et une image, essayer - Couche de convolution : on apprends les filtres ! - entrée : $k$ « feature maps » (ex, les 3 canaux d'une image couleur) - sortie : $l$ « features maps » de même taille (ex, image filtrée) - paramètres, dans le cas de filtres $3\times 3$ - nombre filtres : $k.l$ ⇒ $9.k.l$ (poids) - nombres de biais : $l$ ⇒ $l$ paramètres en plus - @anim: .typical # Un « Convnet » en Tensorflow **04** {pratique} ## Comprendre ce qui est Appris - Travail à la maison - reconnaissance de chiffres - http://scs.ryerson.ca/~aharley/vis/ - http://scs.ryerson.ca/~aharley/vis/conv/ - deepvis - http://yosinski.com/deepvis - https://www.youtube.com/watch?v=AgkfIQ4IGaM
# @copy: #the-overview: %+class:HERE: .pretrain # Sur les Épaules des Géants ## Les réseaux d'aujourd'hui {libyli} - {no} - Architectures - réseaux convolutionnels - parfois un MLP à la fin - de ~ 20 à 1000 couches - millions de paramètres - des fermes de GPU (carte graphiques) à 1500€ - des semaines d'entraînement (sur ImageNet) - Éléments - convolutions $3\times 3$ et $1\times 1$ - activation ReLU - max-pooling - dropout - batch-normalization - connections résiduelles - Optimiseur : Adam, rmsprop, SGD ## Réutilisation des réseaux {libyli} - Step 1 : récupérer le code ⇒ github - Step 2 : récupérer le modèle (les poids appris) ⇒ github - Step 3 : le code, selon les cas : - utiliser le modèle tel quel - le « fine-tuner » sur nos données - utiliser le modèle pour extraire des caractéristiques - faire de « l'adaptation de domaine » - Extraction de caractéristiques - charger le modèle - couper les dernières couches (spécifiques) - utiliser les activations comme caractéristiques # Classification et Extraction de Caractéristiques avec le Réseau InceptionV3 **05** {pratique} # @copy: #the-overview ## Conclusions {image-full bottom-left darkened /black-bg /no-status}
# Merci de votre participation ! {/no-status /keep-logo title-slide deck-status-fake-end} - - - http://home.heeere.com/ {dense} - twitter: @remiemonet {dense} # Attributions {#attrib} ## -Porsupah- {image-full bottom-left darkened /black-bg /no-status}
## Asa-moya {image-full bottom-left darkened /black-bg /no-status}
## Chris R McFarland {image-full bottom-left darkened /black-bg /no-status}
## startup_mena {image-full bottom-left darkened /black-bg /no-status}
## Post: which optimizer to use?
## Wikipedia - Pour toutes les images se trouvant dans le sous-dossier `wikipedia` ## supplementary slides ## END image {/no-status /blackbg image-full bottom-right darkened no-print}

/ automatically replaced by the authorautomatically replaced by the title