Lien de la note Hackmd

Un reseau de neurones convolutif

Le but est d'extraire les caracteristiques

Les formules de convolution

Continue 1D:

$$(f\ast g)(x)={\int }_{-\mathrm{\infty }}^{+\mathrm{\infty }}f(x-t)g(t)dt={\int }_{-\mathrm{\infty }}^{+\mathrm{\infty }}f(t)g(x-t)dt$$

Discrete 2D:

$$(f\ast \omega )(x,y)=\sum _{dx=-a}^a\sum _{dy=-b}^b\omega (a+dx,b+dy)f(x+dx,y+dy)$$

$f$ est l'aimeg,

$\omega$ le noyau, son support est

$[-a,a]\times [-b,b]$

Exemple de noyaux

$\omega$ (WP Noyau_(traitement_d'image)):

Conv2D

x = kl.Conv2D(filters = 4, kernel_size=(5, 5))(x)

L'image d'entree a 3 canaux -> chaque filtre a

$5\times 5\times 3+1$ poids
L'image de sortie a 4 canaux, elle pert 4 pixels dans chaque direction

En details + stride + padding = 'same'

Conv2D(filters = 2, kernel_size = (3, 3), stride = (2, 2), padding = 'same')

• Stride: une facon de reduire la taille d'une image
• padding = 'same': la sortie a la meme taille

Convolution a trous

En anglais: atrous convolution

Conv2D(32, kernel_size=3, dilatation_rate=(2, 2))

Couvre la meme surface qu'un noyau

$5\times 5$, ou que

$2$ convolutions

$3\times 3$ a la suite, mais pour un cout moins cher (en poids)

Ne reduit pas la taille de l'image (padding = same)

Convolution separee

• spatiale: une conv
  $2D\to 1$ conv.
  $1D$
• profondeur:
  $N$ conv
  $2D$ sur
  $M$ couches
  $\to$
  $M$ conv
  $2D$ puis
  $N$ conv
  $1D$

Convolution separeee spatiale

En pratique on fait:

Conv separee en profondeur

kl.SeparableConv2D

Ici 3 couches:

• $3$ conv
  $2D$ +
  $4$ conv
  $1D$
• $4$ couches en sortie

Gain de calcul important
perte de representation

$\to$ utilise

MobileNet

La convolution transposee (ou deconvolution)

Convolution: concentre en un pixel un bloc de pixel (fois un noyau)

Conv transposee: distribue un pixel (fois un noyau) a un bloc de pixel

Mathematiquement les deux sont des convolutions mais la conv. transposee a pour but de simuler l'operation inverse de la conv

$$\begin{array}{rl}\text{propagation conv transposee}& \leftrightarrow \text{retro-propagation conv}\\ \text{retro-propagation conv. transposee}& \leftrightarrow \text{propagation conv.}\end{array}$$

Trucs d'architecture

Pooling

kl.MaxPooling2d(pool_size = (2, 2))

Si on veut augmenter le nombre de couches il faut diminuer la taille de l'image sinon BOOM

On veut une vision multi-echelle il faut diminuer la taille de l'image + ponts.

L'inverse du pooling est kl

Ponts

La grande astuce de ResNet qui leur a permis de tout gagner

• vert
  $\to$
• rouge
  $\leftarrow$

Prog. et retro-prog.

Lors de la retropropagation l'erreur prend le pont et les convolutions

$\to$ les premieres couches sont corrigees

Dropout ou BatchNormalization

Pas besoin de dropout si BatchNormalization

Evite que les poids importants en bloquent d'autres

Apres convolution
Avant fonction d'activation
Reduit le besoin de normaliser les donnees

Types de problemes en vision

Semantic segmentation

• Classification
• Classification + localisation
• Object detection
• Instance segmentation
  • Celle qu'on va faire

U-net (2015)

Separation semantique d'images medicales

Multi-echelle

Notre projet aujourd'hui !

Copy & crops: ce sont des PONTS

• Ca sert a faire des concatenations

Fonctions d'erreur pour la segmentation

Si chaque image de sortie represente les pixels appartenant a la classe

$k$, alors on peut finir avec un softmax:

$y+k=e^{z_k}/\sum _i{e}^{z_i}$

• Erreur quadratique mse: pente douce, pas d'information d'exclusion
• Entropie croisee:
  $E=-\sum _{k}t\log y_k+(1-t_k)\log (1-y_k)$
  • binary_crossentropy avec
    $t_k=0$ ou
    $1$
  • categorical_crossentropy avec resultats sous la forme
    $[0,0,..,1,..,0]$ pour indiquer la classe
    $k$
  • sparse_categorical_crossentropy avec les classes indiques par des entier

y_true = [[1, 2], [0, 2]] #image 2x2 with 3 categories
y_pred = [[0.05, 0.95, 0], [0.1, .01, 0.8], #proba for each category
         [0.7, 0.2, 0.1], [0.2, 0.2, 0.6]] #for each pixel
loss = keras.losses.SparseCategoricalCrossentropy()
loss(y_true, y_pred).numpy()

Focal loss

$$E_{FL}=-\sum _k{t}_k(1-y_k{)}^{\gamma }+(1-t_k)(1-y_k{)}^{\gamma }\log (1-y_k)$$

Comme la pente du log est forte, elle favorise les cas simples a detecter. On peut ecraser la courbe de

$(1-{\gamma }_k)$ pour aider à trouver les cas difficiles.

Augmenter le nombre de donnees

Souvent c'est bien utile, en particulier lorsqu'on manque de donnees.

Parfois ca rend la tache plus difficile et ca ne marche pas.

ImageDataGenerator