Deep Learning · les CNN

📐 L'essentiel à connaître

Toutes les formules et réflexes pour les annales, regroupés ici. Convention : image d'entrée $n \times n$, filtre $m \times m$ ($m \le n$), $c$ canaux d'entrée, $K$ filtres. C'est exactement ce qui tombe : analyse de code Keras, calcul de la taille de sortie et du nombre de paramètres couche par couche (façon model.summary()).

① Dimensionnement — taille de sortie

$$\text{Conv (sans padding, } s=1\text{)} : \quad (n - m + 1) \times (n - m + 1)$$

Forme générale (padding $p$ zéros de chaque côté, stride $s$) :

$$\text{taille de sortie} = \left\lfloor \frac{n + 2p - m}{s} \right\rfloor + 1$$

Cas usuels : valid ($p=0,\,s=1$) $\Rightarrow (n-m+1)$ · same ($s=1$, filtre impair) $\Rightarrow n$ (taille préservée) · $s=2 \Rightarrow$ environ $n/2$.

$$\text{MaxPooling}(p, p) : \quad \text{chaque dimension spatiale} \div p$$

Le pooling ne touche pas la profondeur (nombre de filtres). $p = 2$ presque toujours.

Mini-exemples chiffrés

Entrée $28 \times 28$, filtre $3 \times 3$, valid $\Rightarrow (28-3+1) = 26 \Rightarrow$ sortie $26 \times 26$.
Entrée $64 \times 64$, filtre $3 \times 3 \Rightarrow$ sortie $62 \times 62$.
$\text{Conv2D}(32, 5\times5, \texttt{padding='same'})$ sur $28 \times 28 \Rightarrow$ sortie $28 \times 28$ (préservée).
MaxPooling $2 \times 2$ sur $26 \times 26 \times 32 \Rightarrow$ $13 \times 13 \times 32$.

② Comptage des paramètres

$$\boxed{\;\text{Conv2D} : \quad K \times (m \times m \times c + 1)\;}$$

$K$ filtres ; chaque filtre a $m \times m \times c$ poids + 1 biais. Le « $+1$ » = un biais par filtre. Le partage des poids fait que ce nombre ne dépend pas de la taille de l'image : le même filtre est réutilisé partout.

$$\boxed{\;\text{Dense} : \quad \text{nb}_{\text{out}} \times (\text{nb}_{\text{in}} + 1)\;}$$

Chaque neurone de sortie est connecté à toutes les entrées ($\text{nb}_{\text{in}}$ poids) + 1 biais.

0 paramètre — à savoir par cœur : MaxPooling, Flatten, Dropout n'ont aucun paramètre appris (ce sont des opérations fixes, pas des poids).

Exemples chiffrés (tombés en annale)

$\text{Conv2D}(32, 3\times3)$, entrée RGB ($c=3$) : $32 \times (3 \times 3 \times 3 + 1) = 32 \times 28 = \mathbf{896}$.
$\text{Conv2D}(32, 3\times3)$, entrée 1 canal ($c=1$) : $32 \times (3 \times 3 \times 1 + 1) = 32 \times 10 = \mathbf{320}$.
$\text{Conv2D}(64, 5\times5)$ sur 32 canaux : $64 \times (5 \times 5 \times 32 + 1) = \mathbf{51\,264}$.
Dense de $5\,408$ entrées vers $10$ sorties : $10 \times (5\,408 + 1) = \mathbf{54\,090}$.

Nombre de neurones d'une couche conv $= (\text{taille de sortie})^2 \times (\text{nb de filtres})$.
Ex. : sortie $26 \times 26$ avec $32$ filtres $\Rightarrow 26^2 \times 32 = 21\,632$ neurones (mais seulement $320$ paramètres, grâce au partage des poids).

③ Exemple complet déroulé — un `model.summary()`

Architecture type des annales (MNIST / Fashion MNIST, entrée $28 \times 28 \times 1$) :

Input → Conv(32) → Pool → Conv(64) → Pool → Flatten → Dense(128) → Dense(10, softmax)

On calcule, couche par couche, la taille de sortie (formules ①) et le nombre de paramètres (formules ②). Astuce annale : la taille de sortie d'une couche devient le $\text{nb}_{\text{in}}$ de la suivante.

Couche	Sortie	Params
`Input`	28 × 28 × 1	0
`Conv2D(32, 3×3)` relu	26 × 26 × 32	$32(3{\cdot}3{\cdot}1{+}1) = 320$
`MaxPooling2D(2×2)`	13 × 13 × 32	0
`Conv2D(64, 3×3)` relu	11 × 11 × 64	$64(3{\cdot}3{\cdot}32{+}1) = 18\,496$
`MaxPooling2D(2×2)`	5 × 5 × 64	0
`Flatten`	1 600	0
`Dense(128)` relu	128	$128(1\,600{+}1) = 204\,928$
`Dense(10)` softmax	10	$10(128{+}1) = 1\,290$
Total	—	225 034

Détails de calcul à recopier le jour J

Conv1 : $28 - 3 + 1 = 26$. Params $= 32 \times (3 \times 3 \times 1 + 1) = 32 \times 10 = 320$.
Pool1 : $26 \div 2 = 13$. La profondeur reste $32$. 0 param.
Conv2 : $13 - 3 + 1 = 11$. Entrée = 32 canaux (sortie du pool) : $64 \times (3 \times 3 \times 32 + 1) = 64 \times 289 = 18\,496$.
Pool2 : $11 \div 2 = 5$ (partie entière). Profondeur $64$. 0 param.
Flatten : $5 \times 5 \times 64 = 1\,600$. 0 param.
Dense(128) : $128 \times (1\,600 + 1) = 204\,928$.
Dense(10) : $10 \times (128 + 1) = 1\,290$. Sortie = 10 classes → softmax.

À retenir : les couches Dense concentrent l'essentiel des paramètres (ici $204\,928 + 1\,290$ sur $225\,034$, soit $\approx 92\,\%$), alors que les convolutions n'en ont presque pas — c'est tout l'intérêt du partage des poids.

④ Réflexes & notions clés

Hyperparamètres vs paramètres

Hyperparamètres (choisis avant l'entraînement) : nb de filtres $K$, taille du filtre $m$, stride, padding, fonction d'activation, nb de couches, taux de Dropout, epochs, batch_size, learning rate.
Paramètres (appris pendant l'entraînement, par rétropropagation) : les poids des filtres + 1 biais par filtre (Conv), les poids + biais des couches Dense.

Conv2D : détecte des motifs locaux (contours, textures) via un filtre qui glisse
Pooling : sous-échantillonne (max), réduit la dimension, robustesse aux décalages, 0 param
Dropout(p) : met $\approx p \times 100\,\%$ des neurones à 0 → anti sur-apprentissage, 0 param
Flatten : tenseur → vecteur 1D avant le Dense, 0 param
Dense : entièrement connectée, fait la classification
Softmax en sortie : nb de neurones = nb de classes, donne des probabilités ($\sum = 1$)
ReLU : $\max(0, x)$ — activation des couches conv/dense, apprentissage rapide
Taille conv = $(n - m + 1)$ · same préserve la taille
Params Conv = $K(m \cdot m \cdot c + 1)$ · Params Dense = $\text{out}(\text{in}+1)$
Pool / Flatten / Dropout = 0 paramètre
Partage des poids ⇒ nb de params indépendant de la taille de l'image
CNN > Dense sur images : connexion locale, partage de poids, invariance par translation
Multi-classe : categorical_crossentropy + softmax · binaire : binary_crossentropy

📄 Ressources du cours

📥 Télécharger les slides · 🔗 Ouvrir dans un nouvel onglet · 📝 Ouvrir le TD/TP

🎥 Vidéos recommandées

🇫🇷 CNN1/ Réseaux convolutifs (CNN)
CNRS - Formation FIDLE · 27:27 · 49k vues — Principes et concepts des réseaux convolutifs, convolutions et paramètres associés.Toutes nos vidéos : https://fidle.cnrs.fr/youtubeLe site de notre format
🇫🇷 Les réseaux de convolution (CNN) | Intelligence artificielle 47
Science4All · 12:53 · 31k vues — Les réseaux de convolution sont des réseaux de neurones artificiels inspirés du cortex visuel des humains. Facebook : https://www.facebook.com/Science4Allorg
🇬🇧 Simple explanation of convolutional neural network | Deep Learning Tutorial 23 (Tensorflow & Python)
codebasics · 23:54 · 949k vues — A very simple explanation of convolutional neural network or CNN or ConvNet such that even a high school student can understand it easily. This video involve...

1. L'idée derrière le Deep Learning

Définition Le Deep Learning désigne des réseaux de neurones avec un grand nombre de couches. La profondeur correspond donc au nombre de couches du réseau.

L'intérêt d'un réseau profond est de représenter les données à plusieurs niveaux d'abstraction. Par exemple, pour une image :

🔍 Bas niveau
Pixels — la donnée brute.

📐 Intermédiaire
Formes, contours.

🎯 Haut niveau
Objet complet reconnu.

Un réseau profond apprend progressivement des représentations de plus en plus complexes : pixels → formes simples → … → image complète.

2. Principe d'un CNN (Convnet)

Un CNN (Convolutional Neural Network) est un réseau de neurones convolutif. Il est adapté aux images car une image n'est pas juste une liste de pixels — c'est un tableau avec une structure spatiale.

Représentation d'une image

Image en niveaux de gris → matrice 2D
Image en couleur RGB → tableau 3D avec 3 canaux (Rouge, Vert, Bleu)

Dans un CNN, un neurone de convolution est connecté à une petite zone locale de la couche précédente. C'est ce qu'on appelle une connexion locale.

Pourquoi pas un réseau dense ?

Un réseau entièrement connecté n'est pas viable sur les images : le nombre de paramètres explose dès qu'on dépasse de toutes petites résolutions.

Entrée	Couche dense de 1 000 neurones	Paramètres
MNIST 28 × 28	$784 \times 1\,000 + 1\,000$	≈ 785 k
Image SD 640 × 480	$307\,200 \times 1\,000 + 1\,000$	≈ 307 M
Photo HD couleur 1920 × 1080 × 3	$6\,220\,800 \times 1\,000 + 1\,000$	≈ 6 milliards

Conséquence Sur une image réelle, un dense demanderait des milliards de paramètres pour une seule couche cachée — impossible à entraîner. La convolution règle ce problème via deux mécanismes :

Connexion locale : chaque neurone ne regarde qu'une petite fenêtre, pas toute l'image.
Partage des poids : un seul filtre est réutilisé sur toute l'image — on n'apprend que les coefficients du filtre, peu importe la taille de l'entrée.

3. Architecture générale

Un CNN classique se compose des couches suivantes dans cet ordre :

Input → Conv → Pooling → Dropout → Flatten → Dense → Sortie (Softmax)

Chaque couche est détaillée dans les sections suivantes.

4. Couche de convolution

L'opération principale d'un CNN est de faire glisser un petit tableau, appelé filtre (ou noyau, kernel, template), sur l'image.

Sur une image, le filtre sert à détecter un motif précis : contours, formes, textures, coins…

Formule

Soit une image $T$ de taille $n \times n$ et un filtre $W$ de taille $m \times m$ (avec $m \le n$). La sortie de la convolution a pour taille :

$$(n - m + 1) \times (n - m + 1)$$

Et chaque case de la sortie est calculée par :

$$\mathrm{Conv}(i, j) = \sum_{k=0}^{m-1} \sum_{l=0}^{m-1} W(k, l) \times T(i + k,\; j + l)$$

📌 Décomposition étape par étape

On place le filtre sur une zone de l'image
On multiplie chaque case du filtre par le pixel correspondant
On additionne tous les résultats
On obtient une valeur dans la sortie

Exemple

Image d'entrée 64×64 avec un filtre 3×3 donne une sortie de taille : $$(64 - 3 + 1) \times (64 - 3 + 1) = 62 \times 62$$

Glissement du filtre — exemple chiffré

Image $5 \times 5$ avec un filtre $3 \times 3$. Le filtre se déplace de gauche à droite, ligne par ligne. La sortie est $3 \times 3$.

Image T (5×5)

3

1

2

0

4

0

5

2

1

3

1

4

3

0

2

1

6

2

1

0

3

2

4

1

Filtre W (3×3)

1

0

1

0

1

0

1

0

1

Sortie centrale

12

La case jaune Stabilo de l'image est la fenêtre du filtre pour calculer la valeur centrale de la sortie. Le détail du calcul :

$$\mathrm{Conv}(2,2) = 5 + 0 + 1 + 0 + 3 + 0 + 1 + 0 + 2 = \boxed{12}$$

(on ne garde que les termes où $W \ne 0$ pour la lisibilité.) On répète l'opération en déplaçant la fenêtre d'un cran sur chaque position valide → 9 valeurs au total, formant la sortie $3 \times 3$.

Padding

Sans précaution, les pixels du bord sont sous-représentés (un coin n'est touché par le filtre qu'une seule fois, alors qu'un pixel central l'est neuf fois pour un filtre $3 \times 3$). De plus la sortie est plus petite que l'entrée.

Le padding consiste à ajouter une bordure de zéros autour de l'image avant la convolution. Deux modes en Keras :

Mode	Effet	Quand l'utiliser
`padding='valid'`	Pas de bordure ; sortie plus petite : $(n - m + 1)^2$.	Par défaut. Quand on veut explicitement réduire la dimension.
`padding='same'`	Bordure de zéros automatique ; sortie de même taille que l'entrée.	Quand on veut empiler plusieurs convolutions sans rétrécir.

Stride

Le stride (pas) contrôle de combien la fenêtre se déplace à chaque étape. Par défaut $s = 1$ (on glisse d'un pixel). Avec $s = 2$, on saute un pixel sur deux → sortie environ deux fois plus petite.

Formule générale de la taille de sortie Avec entrée $n \times n$, filtre $m \times m$, padding $p$ (zéros de chaque côté), stride $s$ : $$\text{sortie} = \left\lfloor \frac{n + 2p - m}{s} \right\rfloor + 1$$ Cas particuliers :

valid ($p=0$, $s=1$) : $(n - m + 1)$
same ($s=1$, $p = (m-1)/2$) : $n$ exactement (filtre impair)
Avec $s = 2$ : environ $n/2$

Conv2D(32, kernel_size=(3, 3), strides=(1, 1), padding='same', activation='relu')

Poids et paramètres de la convolution

Dans une couche de convolution, les valeurs du filtre sont les poids appris par le réseau. On ajoute aussi les biais.

La sortie d'un neurone de convolution s'écrit :

$$y(i, j) = \sigma\!\left( b + \sum_{k, l} w_{k,l} \cdot x(i+k, j+l) \right)$$

où $b$ = biais, $w$ = poids du filtre, $x$ = pixel d'entrée, $\sigma$ = fonction d'activation.

Exemple Keras

Layer	Output Shape	Param #
Conv2D	26 × 26 × 32	320

Conv2D avec 32 filtres de taille 3×3, entrée 1 canal, taille d'entrée 28×28.
Nombre de paramètres = $32 \times (3 \times 3 \times 1 + 1) = 32 \times 10 = \textbf{320}$ (le +1 = biais par filtre).
Taille de sortie : image $(28 - 3 + 1) \times (28 - 3 + 1) = 26 \times 26$.

Fonction d'activation : ReLU

$$\mathrm{ReLU}(x) = \max(0, x)$$

ReLU permet de réduire les coûts d'apprentissage : si $x \ge 0$, alors $x$ ; sinon $0$.

Conv2D(32, kernel_size=(3, 3), activation='relu')

5. Couche de Pooling

Elle sert à réduire la taille des données tout en gardant l'information importante. Elle arrive après la couche de convolution.

Le pooling regroupe les valeurs par petits carrés (typiquement 2×2) puis remplace chaque carré par sa valeur.

MaxPooling : le plus utilisé

Le MaxPooling garde la valeur maximale de chaque zone.

Entrée 4×4

8

11

12

14

6

4

7

10

1

3

16

10

9

12

15

3

max de chaque carré 2×2

Sortie 2×2

11

14

12

16

En Keras : MaxPooling2D(pool_size=(2, 2)).

Sur une entrée 26 × 26 × 32

Layer	Output Shape	Param #
MaxPooling2D	13 × 13 × 32	0

Le pooling n'a aucun paramètre à apprendre (0 param). MaxPooling 2×2 sur 26×26×32 donne 13×13×32.

Empiler Conv + Pooling : la hiérarchie d'apprentissage

L'enchaînement Conv → Pool → Conv → Pool → … suit toujours la même logique :

La taille spatiale (largeur × hauteur) diminue à chaque pooling.
La profondeur (nombre de filtres) augmente à chaque convolution.

Plus on avance dans le réseau, plus les motifs détectés deviennent abstraits :

Profondeur	Ce que le filtre détecte	Exemple visuel
Couches basses	Bordures, contours, gradients de couleur	une ligne horizontale, un coin
Couches intermédiaires	Motifs simples, textures	un œil, une roue, un grain de bois
Couches profondes	Concepts, objets complets	un visage, une voiture, un chat

28×28×1 → Conv → 26×26×32 → Pool → 13×13×32 → Conv → 11×11×64 → Pool → 5×5×64

Taille spatiale qui rétrécit · profondeur qui grossit · niveau d'abstraction qui monte.

6. Couche Dropout

Elle sert à éviter le sur-apprentissage (overfitting). Le sur-apprentissage apparaît quand un modèle colle trop aux données d'entraînement et généralise mal sur de nouvelles données.

Le Dropout prend la sortie de la couche précédente et met certaines valeurs à 0 avec une probabilité donnée.

Exemple Dropout(0.25) → cela veut dire qu'environ 25 % des neurones sont désactivés pendant l'apprentissage.

En résumé : Dropout = copie de la couche précédente + probabilité de mettre certaines valeurs à 0.

7. Flatten

La couche Flatten sert à transformer un tableau en vecteur. Après les couches Conv+Pooling, les données sont sous forme de tableaux 2D ou 3D. Mais une couche Dense attend un vecteur en entrée.

Exemple

Layer	Output Shape	Param #
Flatten	5 408	0

Entrée Flatten : $13 \times 13 \times 32 = 5\,408$. Sortie : vecteur de longueur 5 408. Flatten change uniquement la forme des données — 0 paramètre.

8. Couche Dense / Fully Connected

Une couche Dense est une couche dans laquelle chaque neurone est connecté à tous les neurones de la couche précédente. Elle est utilisée à la fin d'un CNN pour faire la classification.

Dense(10, activation='softmax')

10 neurones de sortie → un par classe (ex. chiffres 0–9). Softmax = une probabilité par classe.

Calcul des paramètres d'une couche dense

$$\text{nb paramètres} = \text{nb sortie} \times (\text{nb entrée} + 1)$$

(le $+1$ correspond au biais.)

Exemple

Layer	Output Shape	Param #
Dense	10	54 090

Entrée = 5 408, sortie = 10 → params = $10 \times (5\,408 + 1) = 54\,090$.

9. Entraînement (epochs, batch, perte, optimiseur)

Entraîner un RN Calculer les poids optimaux. À partir des données d'entrée, le réseau cherche à trouver les meilleurs poids.

Données d'entrée : exemples d'apprentissage — fonction de perte, batch_size, epochs.
Epoch : un passage complet sur l'ensemble d'apprentissage. Ex : epochs = 15 signifie que le réseau voit toutes les données 15 fois.
Batch size : nombre d'exemples traités avant une mise à jour des poids. Ex : batch_size = 10 → le réseau traite 10 images, calcule l'erreur, puis met à jour les poids.

Fonction de perte

Elle mesure l'écart entre la prédiction du modèle et la vraie réponse.

Tâche	Fonction de perte
Classification binaire	`binary_crossentropy`
Classification multi-classe	`categorical_crossentropy`

Optimiseur

Sert à ajuster les poids pour réduire la perte. Exemple : optimizer = 'adam' — c'est l'optimiseur le plus utilisé pour son apprentissage rapide et efficace.

10. Évaluation du modèle

Après l'entraînement, on évalue le modèle sur les données de test.

Accuracy

Mesure le % de bonnes prédictions :

$$\text{accuracy} = \frac{\text{nb bonnes prédictions}}{\text{nb total de prédictions}}$$

Matrice de confusion

Permet de voir les erreurs classe par classe. Elle montre par exemple si le modèle confond chat ↔ chien, avion ↔ bateau…

Précision

Elle répond à la question : « Parmi les images prédites de classe X, combien sont vraiment de classe X ? »

$$\text{précision}_X = \frac{\text{vrais positifs pour X}}{\text{total des prédictions de classe X}}$$

★ Réviser le chapitre

Pour vérifier ta compréhension

Pourquoi un CNN plutôt qu'un RN totalement connecté pour les images ?

Une image possède une structure spatiale (tableau 2D ou 3D RGB). Un RN totalement connecté traite chaque pixel comme une entrée indépendante — il perd l'information de voisinage. Le CNN exploite cette structure via la connexion locale : chaque neurone de convolution est connecté à une petite zone de la couche précédente, ce qui détecte des motifs locaux (contours, formes, textures) et réduit drastiquement le nombre de paramètres.

Comment calcule-t-on la taille de sortie d'une couche de convolution ?

Pour une image $T$ de taille $n \times n$ et un filtre $W$ de taille $m \times m$, la sortie a pour dimensions $(n - m + 1) \times (n - m + 1)$. Exemple : image 64×64 + filtre 3×3 → sortie 62×62.

Combien de paramètres a une couche Conv2D(32, 3×3) sur une entrée à 1 canal ?

$32 \times (3 \times 3 \times 1 + 1) = 320$ paramètres. Détail : 32 filtres, chaque filtre a $3 \times 3 \times 1 = 9$ poids + 1 biais = 10 paramètres. Total : $32 \times 10 = 320$. Le +1 correspond au biais de chaque filtre.

À quoi sert le Dropout et comment l'interpréter ?

Le Dropout évite le sur-apprentissage. Il prend la sortie de la couche précédente et met certaines valeurs à 0 avec une probabilité donnée. Par exemple Dropout(0.25) désactive environ 25 % des neurones pendant l'entraînement. Cela force le réseau à ne pas dépendre d'un sous-ensemble précis de neurones, donc à mieux généraliser.

Pourquoi a-t-on besoin d'un Flatten avant la couche Dense ?

Après les couches Conv+Pooling, les données sont sous forme de tableau 2D ou 3D. Or une couche Dense attend un vecteur 1D en entrée. Flatten « aplatit » le tableau en vecteur — par exemple un tableau $13 \times 13 \times 32 = 5\,408$ valeurs devient un vecteur de longueur 5 408. C'est uniquement un changement de forme — 0 paramètre.

Comment choisir entre binary_crossentropy et categorical_crossentropy ?

Binary : classification à 2 classes (chat / non-chat, spam / non-spam). Categorical : classification multi-classe ($\ge 3$ classes, ex. MNIST 10 chiffres). En multi-classe, la sortie utilise softmax ; en binaire, on peut utiliser sigmoid avec 1 neurone ou softmax avec 2 neurones.

Quelle est la différence entre Accuracy, Précision et Matrice de confusion ?

Accuracy = taux global de bonnes prédictions (toutes classes confondues). Précision pour une classe X = parmi les prédictions de classe X, combien sont réellement de classe X (= VP / (VP + FP)). La matrice de confusion montre les erreurs classe par classe (ex. chat confondu avec chien, avion confondu avec bateau). Accuracy ne dit pas quelles classes sont confondues.

🃏 Flashcards éclair

Clique pour retourner.

Profondeur

Définition Deep Learning ?

tourne →

RN avec grand nombre de couches ; profondeur = nb de couches du réseau.

Architecture CNN

Ordre des couches.

Input → Conv → Pool → Dropout → Flatten → Dense → Softmax

Filtre / kernel

Rôle dans le CNN ?

Petit tableau qui glisse sur l'image pour détecter un motif (contour, forme, texture, coin).

Taille de sortie Conv

Formule pour image $n \times n$ et filtre $m \times m$.

$(n - m + 1) \times (n - m + 1)$

ReLU

Formule + intérêt.

$\mathrm{ReLU}(x) = \max(0, x)$. Évite la saturation des gradients ⇒ apprentissage rapide.

MaxPooling 2×2

Effet sur la taille ?

Garde le max de chaque carré 2×2. Divise chaque dimension par 2 (26×26 → 13×13). 0 paramètre.

Dropout(p)

Quoi et pourquoi ?

Met à 0 environ $p \times 100\,\%$ des neurones pendant l'apprentissage. Évite le sur-apprentissage.

Params Dense

Formule pour nb_out, nb_in.

$\text{params} = \text{nb}_{\text{out}} \times (\text{nb}_{\text{in}} + 1)$
(le +1 = biais)

Epoch vs batch

Différence.

Epoch = 1 passage complet sur les données. Batch size = nb d'exemples avant une MAJ des poids.

Optimiseur Adam

Rôle.

Ajuste les poids pour réduire la perte. Le plus utilisé pour son apprentissage rapide et efficace.

🎯 Quiz QCM

1.Pourquoi un CNN est-il adapté aux images ?

Parce qu'il a moins de couches
Parce qu'il utilise Softmax
Parce qu'il exploite la structure spatiale via la connexion locale
Parce qu'il n'utilise pas de biais

L'image est un tableau structuré (2D ou 3D). Le CNN connecte chaque neurone à une petite zone locale.

2.Quelle est la taille de sortie d'une convolution sur image 28×28 avec filtre 3×3 ?

28 × 28
26 × 26
25 × 25
31 × 31

$(28 - 3 + 1) \times (28 - 3 + 1) = 26 \times 26$.

3.Quel est l'effet d'une couche MaxPooling 2×2 sur un tenseur 26×26×32 ?

26 × 26 × 16 (divise les canaux)
13 × 13 × 32 (divise les 2 dimensions spatiales)
52 × 52 × 32
26 × 26 × 32 (aucun effet)

MaxPooling 2×2 divise chaque dimension spatiale par 2, sans toucher au nombre de canaux. 0 paramètre à apprendre.

4.Combien de paramètres une couche Dense(10) a-t-elle après un Flatten de 5 408 valeurs ?

5 408
54 080
54 090
10

params = nb_out × (nb_in + 1) = 10 × (5 408 + 1) = 54 090. Le +1 correspond au biais.

5.Quelle fonction de perte choisir pour classifier MNIST (10 chiffres) ?

binary_crossentropy
categorical_crossentropy
mean_squared_error
hinge

Multi-classe (10 classes) → categorical_crossentropy + activation Softmax sur la couche de sortie.

6.À quoi sert principalement le Dropout ?

À accélérer l'apprentissage
À réduire le nombre de couches
À normaliser les pixels
À éviter le sur-apprentissage en désactivant aléatoirement des neurones

Dropout(p) désactive environ p × 100 % des neurones pendant l'apprentissage → force le réseau à mieux généraliser.

📋 Anti-sèche du chapitre

Deep Learning = RN avec beaucoup de couches → abstraction progressive
CNN = adapté aux images (matrice 2D ou 3D RGB)
Connexion locale : neurone connecté à une petite zone
Architecture : Conv → Pool → Dropout → Flatten → Dense → Softmax
Convolution : filtre $m \times m$ glisse sur image $n \times n$
Taille sortie conv = $(n - m + 1)^2$
Params Conv = nb_filtres × (m × m × canaux + 1)
ReLU : $\max(0, x)$ — apprentissage rapide
MaxPooling 2×2 : divise par 2 chaque dim, 0 param
Dropout(p) : désactive p × 100 % des neurones
Flatten : tableau → vecteur (0 param)
Dense : params = nb_out × (nb_in + 1)
Softmax en sortie pour multi-classe
Perte binaire : binary_crossentropy
Perte multi : categorical_crossentropy
Optimiseur : Adam (par défaut)
Epoch = 1 passage complet sur les données
Batch size = nb exemples par MAJ
Accuracy = bonnes prédictions / total
Matrice confusion = erreurs classe par classe
Précision = VP / (VP + FP) pour une classe

📐 L'essentiel à connaître

① Dimensionnement — taille de sortie

② Comptage des paramètres

③ Exemple complet déroulé — un model.summary()

④ Réflexes & notions clés

📄 Ressources du cours

🎥 Vidéos recommandées

1. L'idée derrière le Deep Learning

2. Principe d'un CNN (Convnet)

Pourquoi pas un réseau dense ?

3. Architecture générale

4. Couche de convolution

Formule

Exemple

Glissement du filtre — exemple chiffré

Padding

Stride

Poids et paramètres de la convolution

Fonction d'activation : ReLU

5. Couche de Pooling

MaxPooling : le plus utilisé

Empiler Conv + Pooling : la hiérarchie d'apprentissage

6. Couche Dropout

7. Flatten

8. Couche Dense / Fully Connected

Calcul des paramètres d'une couche dense

9. Entraînement (epochs, batch, perte, optimiseur)

Fonction de perte

Optimiseur

10. Évaluation du modèle

Accuracy

Matrice de confusion

Précision

★ Réviser le chapitre

Pour vérifier ta compréhension

🃏 Flashcards éclair

Profondeur

Architecture CNN

Filtre / kernel

Taille de sortie Conv

ReLU

MaxPooling 2×2

Dropout(p)

Params Dense

Epoch vs batch

Optimiseur Adam

🎯 Quiz QCM

📋 Anti-sèche du chapitre

③ Exemple complet déroulé — un `model.summary()`