CNN — Convolutional Neural Networks | Merlebti Ahmed Ilyas | Université Tahri Mohammed — Béchar

République Algérienne Démocratique et Populaire

Ministère de l'Enseignement Supérieur et de la Recherche Scientifique
Université Tahri Mohammed — Béchar
Faculté des Sciences Exactes et Informatique
Département d'Informatique

4ème Année Ingénierie — Intelligence Artificielle

Module : TALN (Traitement Automatique du Langage Naturel)

RAPPORT
Réseaux de Neurones Convolutifs
Convolutional Neural Networks (CNN)

Réalisé par : Merlebti Ahmed Ilyas Encadré par : Dr. Hcieni Y.

Année Universitaire 2024 – 2025

Module TALN — 4ème Année IA | Année Universitaire 2024–2025 Page

CNN — Convolutional Neural Networks | Merlebti Ahmed Ilyas | Université Tahri Mohammed — Béchar

Table des Matières

1. Introduction aux Réseaux de Neurones Convolutifs 3

2. Fondements Biologiques et Historiques 4
3. Architecture d'un Réseau CNN 5
4. La Couche de Convolution — Modèle Mathématique 6
5. Couches de Pooling et de Normalisation 7
6. Propagation Avant dans un CNN (Forward Pass) 8
7. Apprentissage par Rétropropagation dans les CNN 9
8. Fonctions de Coût et Métriques d'Évaluation 10
9. Algorithmes d'Optimisation 11
10. Régularisation et Prévention du Surapprentissage 12
11. Initialisation des Poids et Normalisation 13
12. Architectures CNN Célèbres 14
13. Entraînement Pratique d'un CNN 15
14. Applications des Réseaux CNN 16
15. Implémentation : Exemple en Python 17
16. Défis, Limitations et Perspectives 18
17. Conclusion 19
18. Références Bibliographiques 20

Module TALN — 4ème Année IA | Année Universitaire 2024–2025 Page

CNN — Convolutional Neural Networks | Merlebti Ahmed Ilyas | Université Tahri Mohammed — Béchar

1. Introduction aux Réseaux de Neurones Convolutifs

Les réseaux de neurones convolutifs (CNN — Convolutional Neural Networks) représentent l'une des
avancées les plus significatives du deep learning moderne. Spécialement conçus pour traiter des données
ayant une structure topologique (images, signaux audio, séquences), ils exploitent la propriété de partage
des poids pour détecter automatiquement des caractéristiques locales invariantes à la translation.

Un CNN est constitué d'une succession de couches spécialisées : des couches de convolution qui extraient
des caractéristiques hiérarchiques, des couches de pooling qui réduisent la dimensionnalité, et des couches
entièrement connectées (Dense) qui réalisent la classification ou la régression finale. Contrairement aux
réseaux ANN classiques (MLP), les CNN exploitent la structure spatiale des données en imposant la
connectivité locale et le partage des poids.

Définition Formelle
Un réseau de neurones convolutif (CNN) est une architecture de réseau profond spécialisée dans
le traitement de données à structure spatiale (grilles, séquences). Il repose sur trois principes :
• Connectivité locale : chaque neurone n'est connecté qu'à une région limitée (champ récepteur).
• Partage des poids : un même filtre est appliqué sur toute l'entrée, réduisant massivement le nombre
de paramètres.
• Invariance à la translation : détection des motifs indépendamment de leur position.

Les CNN trouvent leur origine dans les travaux de Fukushima (1980) sur le Neocognitron et ont été
popularisés par LeCun et al. (1989, 1998) avec l'application à la reconnaissance de caractères manuscrits
(LeNet). La révolution du deep learning de 2012, avec AlexNet (Krizhevsky et al., 2012), a démontré la
supériorité des CNN sur les méthodes classiques pour la vision par ordinateur, ouvrant la voie à leur
adoption massive dans de nombreux domaines.

Ce rapport présente les fondements théoriques des CNN, leur architecture, leurs mécanismes
d'apprentissage, les grandes architectures de référence, et leurs applications dans des domaines variés
incluant la vision par ordinateur, le traitement du signal et le TALN.

Module TALN — 4ème Année IA | Année Universitaire 2024–2025 Page

CNN — Convolutional Neural Networks | Merlebti Ahmed Ilyas | Université Tahri Mohammed — Béchar

2. Fondements Biologiques et Historiques

2.1 Le Cortex Visuel Biologique

L'inspiration des CNN provient directement des travaux de Hubel et Wiesel (1959–1968) sur le cortex visuel
des mammifères. Ils ont découvert que le cortex visuel V1 est composé de neurones dits cellules simples
(détectant des orientations et positions locales) et de cellules complexes (invariantes à la position). Cette
hiérarchie de détecteurs locaux composés pour former des représentations globales est le principe
fondateur des CNN.

2.2 Chronologie Historique des CNN

Année Événement Clé

1959–68 Hubel & Wiesel : découverte des cellules simples et complexes dans le cortex visuel — Prix Nobel
1981

1980 Fukushima : Neocognitron — premier réseau convolutif inspiré du cortex visuel, sans apprentissage
supervisé

1989 LeCun et al. : application de la rétropropagation aux CNN pour la reconnaissance de chiffres
manuscrits (USPS)

1998 LeCun et al. : LeNet-5 — architecture CNN complète appliquée à la lecture de chèques bancaires
(MNIST)

2003 Simard et al. : best practices pour les CNN appliqués aux documents

2012 Krizhevsky, Sutskever & Hinton : AlexNet — erreur top-5 de 15,3% sur ImageNet, révolution du deep
learning

2014 Simonyan & Zisserman : VGGNet — profondeur avec petits filtres 3×3 systématiques

2014 Szegedy et al. : GoogLeNet / Inception — module Inception pour la profondeur et la largeur
simultanées

2015 He et al. : ResNet — connexions résiduelles permettant des réseaux de 152 couches (erreur top-5 :
3,57%)

2017 Huang et al. : DenseNet — connexions denses entre toutes les couches

2019 Tan & Le : EfficientNet — mise à l'échelle composée (largeur, profondeur, résolution)

2020 Dosovitskiy et al. : Vision Transformer (ViT) — attention sur des patches d'images

Module TALN — 4ème Année IA | Année Universitaire 2024–2025 Page

CNN — Convolutional Neural Networks | Merlebti Ahmed Ilyas | Université Tahri Mohammed — Béchar

3. Architecture d'un Réseau CNN

3.1 Organisation en Couches

Un CNN classique est organisé en deux parties principales : un extracteur de caractéristiques (feature
extractor) constitué de couches convolutives et de pooling, suivi d'un classificateur (classifier) composé de
couches entièrement connectées. Cette séparation fonctionnelle est l'une des forces architecturales des
CNN.

• Couche d'entrée (Input Layer) : Reçoit les données brutes sous forme de tenseur. Pour une image
couleur, l'entrée est de dimension [H × W × C] où H est la hauteur, W la largeur, et C le nombre de
canaux (3 pour RGB). Aucune transformation n'est appliquée.
• Couches de convolution (Conv Layers) : Couches fondamentales du CNN. Chaque couche applique un
ensemble de filtres apprenables sur l'entrée pour produire des cartes d'activation (feature maps).
Détectent des motifs locaux : bords, textures, formes.
• Couches de normalisation (BN) : Normalisent les activations pour stabiliser et accélérer l'entraînement.
La Batch Normalization (Ioffe & Szegedy, 2015) est désormais standard après les couches convolutives.
• Couches de pooling (Pooling Layers) : Réduisent la dimensionnalité spatiale des feature maps,
introduisant une invariance locale à la translation et réduisant le coût computationnel.
• Couche d'aplatissement (Flatten) : Convertit les feature maps 3D en vecteur 1D pour l'entrée dans les
couches Dense.
• Couches entièrement connectées (Dense Layers) : Réalisent la classification ou la régression finale à
partir des caractéristiques extraites par les couches convolutives.
• Couche de sortie (Output Layer) : Softmax pour la classification multi-classes, Sigmoid pour la
classification binaire, linéaire pour la régression.

3.2 Types de Connexions

Type de Connexion Description

Convolution standard Chaque filtre couvre toute la profondeur de l'entrée. Type le plus courant
pour la vision.

Convolution dépthwise Un filtre distinct par canal d'entrée. Utilisé dans MobileNet pour l'efficacité
computationnelle.

Convolution séparable en profondeur Convolution dépthwise suivie d'une convolution 1×1 pointwise. Réduit
massivamente les paramètres.

Convolution dilatée (atrous) Introduit des espaces entre les éléments du filtre. Augmente le champ
récepteur sans paramètres supplémentaires.

Convolution transposée Inverse de la convolution standard. Utilisée pour l'upsampling dans les
réseaux génératifs et segmentation.

Connexion résiduelle Raccourci entre couches non adjacentes. Fondamentale dans ResNet pour
l'entraînement de réseaux très profonds.

3.3 Représentation Tensorielle

Notation Tensorielle du CNN

Entrée : X ∈ R^(H × W × C) (hauteur × largeur × canaux)

Module TALN — 4ème Année IA | Année Universitaire 2024–2025 Page

CNN — Convolutional Neural Networks | Merlebti Ahmed Ilyas | Université Tahri Mohammed — Béchar

Filtre : K ∈ R^(kH × kW × C × N) (kH, kW = taille filtre, N = nombre de filtres)

Feature map : F ∈ R^(H' × W' × N) avec H' = (H - kH + 2P) / S + 1
P = padding, S = stride
Opération : F[:,:,n] = sum_c (X[:,:,c] * K[:,:,c,n]) + b[n]
* désigne la convolution croisée 2D (cross-correlation)

Module TALN — 4ème Année IA | Année Universitaire 2024–2025 Page

CNN — Convolutional Neural Networks | Merlebti Ahmed Ilyas | Université Tahri Mohammed — Béchar

4. La Couche de Convolution — Modèle Mathématique

4.1 Opération de Convolution Croisée

La couche de convolution est le cœur d'un CNN. Elle applique un ensemble de filtres apprenables (kernels)
sur l'entrée pour produire des cartes d'activation. En pratique, on utilise la corrélation croisée (cross-
correlation) plutôt que la convolution mathématique stricte, car les filtres sont appris et la distinction n'a
pas d'importance.

Formule de la Convolution 2D (Cross-Correlation)

S(i, j) = (I * K)(i, j) = Σ_m Σ_n I(i+m, j+n) · K(m, n) + b

Pour un CNN multi-canaux avec N filtres :

F_n(i, j) = f( Σ_c Σ_m Σ_n X_c(i·S+m, j·S+n) · K_n(m, n, c) + b_n )

Paramètres :
I / X_c : entrée / canal c de l'entrée
K : filtre (kernel) appris — K_n ∈ R^(kH × kW × C)
b : biais du filtre
S : stride (pas de déplacement du filtre)
f : fonction d'activation (typiquement ReLU)

4.2 Hyperparamètres de la Couche Convolutive

Hyperparamètre Rôle et Impact

Nombre de filtres N Nombre de feature maps produites. Détermine la richesse des représentations. Valeurs
typiques : 32, 64, 128, 256, 512.

Taille du filtre (kH × kW) Champ récepteur local. 3×3 est le standard (VGG, ResNet). 5×5 et 7×7 pour plus de
contexte. 1×1 pour les transformations de canaux.

Stride S Pas de déplacement du filtre. S=1 : sortie ≈ entrée. S=2 : réduit la résolution de moitié
(alternative au pooling).

Padding P Ajout de zéros sur les bords. SAME padding (P=kH/2) : préserve la taille spatiale. VALID
padding (P=0) : réduit la taille.

Dilatation D Espacement entre les éléments du filtre. Augmente le champ récepteur effectif sans
paramètres supplémentaires. Utile en segmentation.

4.3 Avantage du Partage des Poids

L'un des atouts majeurs des CNN est la réduction drastique du nombre de paramètres grâce au partage des
poids. Comparaison : pour une entrée 224×224×3 avec 64 filtres 3×3, une couche dense nécessiterait
224×224×3 × 224×224×64 ≈ 21 milliards de paramètres, tandis qu'une couche convolutive n'en requiert que
3×3×3×64 + 64 = 1 792.

Module TALN — 4ème Année IA | Année Universitaire 2024–2025 Page

CNN — Convolutional Neural Networks | Merlebti Ahmed Ilyas | Université Tahri Mohammed — Béchar

5. Couches de Pooling et de Normalisation

5.1 Couches de Pooling

Les couches de pooling réduisent la dimensionnalité spatiale des feature maps, introduisant une invariance
partielle aux translations locales et réduisant le coût computationnel. Elles n'ont pas de paramètres
apprenables.

Type de Pooling Formule et Propriétés

Max Pooling y(i,j) = max{x(i·S+m, j·S+n) | 0≤m,n<k}. Sélectionne la valeur maximale dans chaque
fenêtre. Invariance locale, préserve les motifs les plus forts. Standard actuel.

Average Pooling y(i,j) = (1/k²) Σ x(i·S+m, j·S+n). Moyenne sur la fenêtre. Moins agressif que Max. Utilisé
en Global Average Pooling (GAP) avant la couche Dense.

Global Average Pooling (GAP) Réduit chaque feature map à un scalaire (moyenne globale). Remplace les couches
Dense dans GoogLeNet, ResNet. Réduit fortement l'overfitting.

Adaptive Pooling Produce une sortie de taille fixe quelle que soit la taille d'entrée. Utile pour des entrées
de tailles variables (PyTorch AdaptiveAvgPool2d).

L2 Pooling y(i,j) = sqrt(Σ x²(i·S+m, j·S+n)). Norme L2 sur la fenêtre. Moins courant, utilisé dans
certaines architectures de reconnaissance.

5.2 Batch Normalization

La Batch Normalization (Ioffe & Szegedy, 2015) est désormais une composante standard des CNN
modernes. Elle normalise les activations de chaque couche sur le mini-batch pendant l'entraînement, puis
utilise des statistiques globales à l'inférence.

Formule de la Batch Normalization

Normalisation : x̂ _i = (x_i - μ_B) / sqrt(σ²_B + ε)

Mise à l'échelle : y_i = γ · x̂ _i + β

μ_B = (1/m) Σ x_i (moyenne du mini-batch)

σ²_B = (1/m) Σ (x_i - μ_B)² (variance du mini-batch)
γ, β : paramètres apprenables (scale et shift)
ε : terme de stabilité numérique (typiquement 1e-5)

Bénéfices : Accélère l'entraînement, réduit la sensibilité à l'initialisation,

effet régularisant, permet des taux d'apprentissage plus élevés.

5.3 Autres Couches de Normalisation

Normalisation Description et Usage

Layer Normalization (LN) Normalise sur les features d'un exemple unique. Utilisée dans les Transformers.
Indépendante de la taille du batch.

Instance Normalization Normalise chaque feature map séparément. Utilisée dans le style transfer et les
réseaux génératifs.

Module TALN — 4ème Année IA | Année Universitaire 2024–2025 Page

CNN — Convolutional Neural Networks | Merlebti Ahmed Ilyas | Université Tahri Mohammed — Béchar

Group Normalization Divise les canaux en groupes et normalise par groupe. Robuste aux petits batch
sizes. Utile en détection d'objets.

Local Response Normalization Normalisation entre canaux adjacents. Utilisée dans AlexNet, basée sur
(LRN) l'inhibition latérale biologique. Moins utilisée actuellement.

Module TALN — 4ème Année IA | Année Universitaire 2024–2025 Page

CNN — Convolutional Neural Networks | Merlebti Ahmed Ilyas | Université Tahri Mohammed — Béchar

6. Propagation Avant dans un CNN (Forward Pass)

6.1 Définition et Rôle

La propagation avant (forward pass) dans un CNN est la transformation séquentielle des données d'entrée
(images, signaux) en une prédiction finale, à travers les couches convolutives, de normalisation,
d'activation, de pooling, et finalement les couches denses. Chaque couche produit une représentation de
plus en plus abstraite de l'entrée.

6.2 Algorithme de Propagation Avant

Étape Opération Mathématique

Entrée X^(0) = I (tenseur image [H × W × C])

Convolution (couche l) Z^(l) = X^(l-1) * W^(l) + b^(l) (convolution cross-correlation)

Normalisation Z_norm^(l) = BN(Z^(l)) = γ · (Z^(l) - μ) / σ + β

Activation X^(l) = f(Z_norm^(l)) (ReLU : f(x) = max(0, x))

Pooling X^(l+1) = Pool(X^(l)) (Max ou Average sur fenêtres k×k)

Aplatissement x_flat = Flatten(X^(L_conv)) (tenseur 3D → vecteur 1D)

Couches Dense z^(l) = W^(l) · a^(l-1) + b^(l) ; a^(l) = f(z^(l))

Sortie ŷ = Softmax(z^(L)) (distribution de probabilité sur les classes)

Perte L = CrossEntropy(ŷ, y) = -Σ y_i · log(ŷ_i)

6.3 Exemple Numérique

Considérons un CNN minimal avec une entrée 6×6×1, un filtre 3×3 (stride=1, padding=0), suivi d'un
MaxPooling 2×2 (stride=2) :

Exemple de Calcul Pas à Pas

Entrée X (6×6) :
[[1,0,2,3,0,1], [0,1,1,0,2,1], ...]

Filtre K (3×3) = [[1,0,-1],[1,0,-1],[1,0,-1]] (détecteur de bords verticaux)

Feature map après convolution (4×4) :

F(i,j) = Σ_m Σ_n X(i+m, j+n) · K(m,n)
F(0,0) = 1·1 + 0·0 + 2·(-1) + 0·1 + 1·0 + 1·(-1) + ... = valeur entière

Après ReLU : F_relu = max(0, F)

Après MaxPool 2×2 : sortie (2×2) = max dans chaque fenêtre 2×2
Réduction dimensionnelle : 4×4 → 2×2 (facteur 4)

Module TALN — 4ème Année IA | Année Universitaire 2024–2025 Page

CNN — Convolutional Neural Networks | Merlebti Ahmed Ilyas | Université Tahri Mohammed — Béchar

7. Apprentissage par Rétropropagation dans les CNN

7.1 Principe Général

L'entraînement d'un CNN repose sur la rétropropagation du gradient (backpropagation), formalisée par
Rumelhart, Hinton et Williams (1986) et adaptée aux couches convolutives par LeCun (1989). L'algorithme
calcule le gradient de la fonction de coût par rapport à chaque paramètre du réseau en appliquant
récursivement la règle de la chaîne, de la sortie vers l'entrée.

7.2 Les Quatre Étapes de l'Entraînement CNN

Étape Description Détaillée

1. Forward Pass L'image traverse le réseau couche par couche. Toutes les valeurs intermédiaires (Z^(l), X^(l))
sont stockées en mémoire pour le backward pass.

2. Calcul de la perte La fonction de coût L(ŷ, y) mesure l'écart entre la prédiction et la vérité. Pour la classification :
entropie croisée. Pour la détection : combinaison de termes de localisation et de classification.

3. Backward Pass Le gradient de L est calculé par rapport à chaque filtre W^(l) et biais b^(l). La rétropropagation
dans une couche de convolution nécessite une convolution transposée pour propager le
gradient.

4. Mise à jour Les paramètres (filtres, biais) sont mis à jour par descente de gradient : W ← W - η · ∂L/∂W. En
pratique, on utilise Adam, SGD+Momentum ou RMSprop.

7.3 Gradient dans une Couche Convolutive

Rétropropagation dans une Couche de Convolution

Signal d'erreur reçu : δ^(l) = ∂L/∂Z^(l)

Gradient par rapport aux filtres :

∂L/∂W^(l) = X^(l-1) * δ^(l) (corrélation croisée entre entrée et δ)

Gradient par rapport aux biais :

∂L/∂b^(l) = Σ_i Σ_j δ^(l)(i,j) (somme sur la feature map)

Propagation vers la couche précédente :

δ^(l-1) = δ^(l) ★ rot180(W^(l)) · f'(Z^(l-1))
★ : convolution complète (full convolution) avec filtre retourné

7.4 Gradient à travers Max Pooling

Le max pooling n'a pas de paramètres apprenables, mais le gradient doit traverser cette couche. Lors du
backward pass, le gradient est routé uniquement vers l'élément qui avait la valeur maximale ("argmax")
lors du forward pass. Les autres éléments reçoivent un gradient nul. C'est pourquoi le masque argmax est
stocké lors du forward pass.

Module TALN — 4ème Année IA | Année Universitaire 2024–2025 Page

CNN — Convolutional Neural Networks | Merlebti Ahmed Ilyas | Université Tahri Mohammed — Béchar

8. Fonctions de Coût et Métriques d'Évaluation

8.1 Fonctions de Coût pour les CNN

Le choix de la fonction de coût dépend de la tâche. Les CNN sont utilisés pour des tâches très diverses —
classification, détection d'objets, segmentation sémantique, estimation de profondeur — chacune
nécessitant une fonction de coût adaptée.
Fonction de Coût Formule et Domaine d'Application

Entropie Croisée Catégorielle L = -Σ y_i · log(ŷ_i). Classification multi-classes (sortie Softmax). Standard pour
ImageNet, CIFAR.

Entropie Croisée Binaire L = -[y·log(ŷ) + (1-y)·log(1-ŷ)]. Classification binaire ou multi-label (plusieurs

Sigmoid).

MSE / L2 L = (1/n) Σ (y_i - ŷ_i)². Régression (estimation de profondeur, super-résolution).

Smooth L1 (Huber) L1 pour grandes erreurs, L2 pour petites. Utilisée dans Faster R-CNN pour la
régression des bounding boxes.

Focal Loss L = -α(1-p_t)^γ log(p_t). Corrige le déséquilibre de classes (Lin et al., 2017).
Standard en détection d'objets (RetinaNet).

IoU / GIoU Loss Mesure le chevauchement entre boîtes prédites et réelles. Directement
différentiable pour l'entraînement des détecteurs.

Dice Loss 2|A∩B|/(|A|+|B|). Utilisée en segmentation médicale. Robuste au déséquilibre

de classes spatiales.

8.2 Métriques d'Évaluation

Métrique Formule et Interprétation

Top-1 Accuracy Proportion d'images correctement classées (classe prédite = vraie classe).
Standard ImageNet.

Top-5 Accuracy Proportion d'images où la vraie classe est dans les 5 premières prédictions.
Utilisée pour ImageNet.

mAP (mean Average Precision) Moyenne des AP sur toutes les classes. Standard en détection d'objets (COCO,
Pascal VOC).

IoU (Intersection over Union) IoU = |A∩B| / |A∪B|. Évalue la qualité des bounding boxes. Seuil typique : 0.5
(IoU@0.5).

mIoU (mean IoU) Moyenne des IoU sur toutes les classes. Standard en segmentation sémantique.

F1-Score 2 · Precision · Recall / (Precision + Recall). Équilibre Précision et Rappel pour la

classification.

FID (Fréchet Inception Distance) Mesure la qualité des images générées (GAN, VAE) par rapport aux images
réelles.

Module TALN — 4ème Année IA | Année Universitaire 2024–2025 Page

CNN — Convolutional Neural Networks | Merlebti Ahmed Ilyas | Université Tahri Mohammed — Béchar

9. Algorithmes d'Optimisation

9.1 La Descente de Gradient Stochastique (SGD)

La descente de gradient stochastique (SGD) avec momentum reste l'optimiseur de référence pour
l'entraînement de grands CNN (ResNet, EfficientNet). Elle est souvent préférée à Adam pour la
généralisation finale, bien que plus sensible au réglage du taux d'apprentissage.
Variante Description et Formule de Mise à Jour

SGD classique w ← w - η · ∇L(w). Simple mais instable. Nécessite un taux d'apprentissage

soigneusement réglé.

SGD + Momentum v ← μ·v - η·∇L(w) ; w ← w + v. Accumule l'historique des gradients. μ typiquement 0.9.
Accélère la convergence.

SGD + Nesterov Calcul du gradient à la position anticipée. Légère amélioration sur Momentum
classique. Préféré par certains auteurs.

Mini-Batch SGD Mise à jour sur des sous-ensembles de 32 à 256 images. Standard en vision par
ordinateur.

9.2 Optimiseurs Avancés

Optimiseur Mécanisme Clé Avantages et Inconvénients

Adam Combine Momentum + RMSprop + correction Converge rapidement. Peut généraliser moins bien
du biais. m_t = β₁m_{t-1} + (1-β₁)g_t ; v_t = que SGD sur ImageNet.
β₂v_{t-1} + (1-β₂)g²_t

AdamW Adam + weight decay découplé. L'application Meilleure généralisation. Utilisé pour fine-tuning de
directe de L2 dans Adam est incorrecte — ViT, EfficientNet.
AdamW le corrige.

RMSprop Moyenne mobile du carré des gradients. w ← Bon pour les réseaux récurrents intégrés aux CNN.
w - η·g/sqrt(E[g²]+ε) Stable.

Lion Optimiseur récent (Chen et al., 2023). Utilise Efficace sur les grands modèles de vision. En cours
seulement le signe du gradient. Mémoire d'adoption.
réduite.

LARS / LAMB Adaptent le taux d'apprentissage par couche Permettent d'utiliser batch size 32 000+ pour
selon la norme des paramètres. Conçus pour ResNet. Utilisés à grande échelle.
les très grands batch sizes.

Stratégies de Learning Rate pour les CNN

• Warm-up cosine decay : augmentation linéaire initiale puis décroissance cosinus. Standard ResNet, ViT.
• Step decay : réduction par facteur 0.1 à des époques prédéfinies (ex : 30, 60, 90 pour ImageNet).
• One-cycle policy (Smith, 2018) : montée puis descente cyclique. Bonne généralisation rapide.
• Linear scaling rule (Goyal et al., 2017) : η ∝ batch_size. Permet le passage à l'échelle distribué.

Module TALN — 4ème Année IA | Année Universitaire 2024–2025 Page

CNN — Convolutional Neural Networks | Merlebti Ahmed Ilyas | Université Tahri Mohammed — Béchar

10. Régularisation et Prévention du Surapprentissage

10.1 Le Problème du Surapprentissage dans les CNN

Les CNN modernes comptent des millions à des milliards de paramètres, les rendant très susceptibles au
surapprentissage (overfitting), particulièrement lorsque les données d'entraînement sont insuffisantes. Le
surapprentissage se manifeste par une faible perte d'entraînement et une perte de validation élevée. La
régularisation est donc cruciale pour la généralisation.
Technique Mécanisme et Formule

L2 Regularization (Weight Decay) L_reg = L + λ/2 · Σ||W||². Pénalise les grands poids. Avec SGD, revient à une
décroissance multiplicative : W ← (1-ηλ)W - η∇L.

Dropout (Srivastava et al., 2014) Désactive aléatoirement une fraction p des neurones. En CNN, le Spatial Dropout
désactive des canaux entiers (plus efficace que le dropout neurone par neurone
pour les feature maps).

Data Augmentation Transformations aléatoires préservant l'étiquette : flip horizontal, recadrage,

rotation, color jitter, CutOut, MixUp, CutMix. Augmente efficacement la diversité
du dataset.

Early Stopping Surveille la perte de validation. Arrête l'entraînement quand la performance

stagne. Sauvegarde le meilleur modèle (ModelCheckpoint).

Label Smoothing (Szegedy et al., Cibles lissées : y_ls = (1-ε)·y + ε/K. ε typiquement 0.1. Réduit la sur-confiance du
2016) modèle. Améliore la calibration.

Stochastic Depth (Huang et al., Désactive aléatoirement des couches entières pendant l'entraînement. Réduit
2016) l'overfitting et accélère l'entraînement des réseaux très profonds.

DropBlock (Ghiasi et al., 2018) Supprime des blocs contigus de feature maps. Plus efficace que Dropout standard
pour les CNN car les activations sont corrélées spatialement.

10.2 Techniques d'Augmentation Avancées

Augmentation Description

MixUp (Zhang et al., 2018) x̃ = λ·x_i + (1-λ)·x_j ; ỹ = λ·y_i + (1-λ)·y_j. Mélange linéaire d'images et étiquettes.

CutMix (Yun et al., 2019) Remplace une région rectangulaire d'une image par la région correspondante
d'une autre image. Étiquettes mixées proportionnellement à la surface.

AutoAugment (Cubuk et al., 2019) Recherche automatique de politiques d'augmentation optimales via
apprentissage par renforcement.

RandAugment (Cubuk et al., 2020) Sélection aléatoire parmi N transformations avec magnitude M. Simplifie
AutoAugment, performances comparables.

Module TALN — 4ème Année IA | Année Universitaire 2024–2025 Page

CNN — Convolutional Neural Networks | Merlebti Ahmed Ilyas | Université Tahri Mohammed — Béchar

11. Initialisation des Poids et Normalisation

11.1 Importance de l'Initialisation dans les CNN

L'initialisation des filtres convolutifs est critique pour éviter les problèmes de gradient dès le début de
l'entraînement. Dans un CNN profond, un mauvais choix d'initialisation peut conduire à une variance des
activations qui explose ou s'effondre au fil des couches.
Méthode Formule et Usage Recommandé

Initialisation à Zéro W = 0. INTERDIT : tous les filtres apprennent la même chose. Symétrie parfaite non
brisée.

Xavier / Glorot (2010) W ~ U[-√(6/(n_in+n_out)), √(6/(n_in+n_out))]. Conçu pour Sigmoid/Tanh. Maintient

variance constante.

He / Kaiming (2015) W ~ N(0, 2/n_in). Standard pour ReLU dans les CNN. Compense le facteur 1/2 dû à
ReLU.

MSRA (He et al., 2015) Variante He pour les couches convolutives : σ² = 2 / (kH · kW · C_in). Standard ResNet.

Orthogonale W initialisée comme matrice orthogonale. Préserve les normes. Utile pour les CNN
récurrents (ConvLSTM).

11.2 Normalisation des Données d'Entrée

Pour les CNN appliqués aux images, la normalisation des données d'entrée est standard. Les valeurs de
pixels (0-255) sont normalisées par les statistiques du dataset d'entraînement :
• ImageNet : mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225] par canal RGB. Standard pour le
transfer learning.
• Normalisation simple : x_norm = x / 255.0 ou x_norm = (x - 0.5) / 0.5. Rapide, moins précise.
• Whitening (PCA/ZCA) : décorrèle les features. Utile pour CIFAR-10/100 classique.

11.3 Transfer Learning et Fine-Tuning

Le transfer learning est l'une des pratiques les plus importantes en CNN : utiliser un modèle pré-entraîné
sur un grand dataset (ImageNet) comme point de départ pour une tâche cible. Les premières couches
(détecteurs de bas niveau : bords, textures) sont généralement gelées, et les dernières couches sont fine-
tunées sur le nouveau dataset.

Stratégies de Transfer Learning

• Feature extraction : geler toutes les couches convolutives, réentraîner uniquement le classificateur.
• Fine-tuning partiel : dégeler les N dernières couches convolutives. LR réduit (η/10 à η/100).
• Fine-tuning complet : décharger tous les poids avec un très faible LR. Pour grands datasets cibles.
• Linear probing : n'entraîner qu'une couche linéaire sur les features gelées. Standard pour évaluation.

Module TALN — 4ème Année IA | Année Universitaire 2024–2025 Page

CNN — Convolutional Neural Networks | Merlebti Ahmed Ilyas | Université Tahri Mohammed — Béchar

12. Architectures CNN Célèbres

La recherche en CNN a produit une série d'architectures de référence qui ont progressivement établi l'état
de l'art sur les benchmarks majeurs (ImageNet, CIFAR, COCO). Comprendre ces architectures est essentiel
pour tout ingénieur en intelligence artificielle.

Architecture Année Innovation Clé Top-5 ImageNet

LeNet-5 1998 Premier CNN complet pour la reconnaissance de N/A (MNIST)

caractères. Filtres 5×5, average pooling, activation tanh.

AlexNet 2012 ReLU, Dropout, Data Augmentation, GPU training, LRN. 15.3%
Révolutionne la vision par ordinateur.

VGGNet-16/19 2014 Profondeur avec petits filtres 3×3 systématiques. Montre 7.3%
que la profondeur est clé.

GoogLeNet/ 2014 Module Inception (convolutions parallèles 1×1, 3×3, 6.7%

Inception V1 5×5). 22 couches, seulement 5M paramètres.

ResNet- 2015 Connexions résiduelles. Permet d'entraîner des réseaux 3.57%

50/101/152 de 152+ couches. Révolution architecturale.

DenseNet-121 2017 Connexions denses (chaque couche reçoit les feature ~5%
maps de toutes les couches précédentes).

MobileNet 2017– Convolutions dépthwise séparables. Optimisé pour ~7–9%

V1/V2/V3 19 mobile/edge. Paramètres réduits ×8-9.

EfficientNet B0– 2019 Mise à l'échelle composée (largeur, profondeur, 2.9%

B7 résolution) avec Neural Architecture Search.

ResNeXt 2017 Agrégation de transformations. Généralise VGG et ~4%

Inception. Paramètre de cardinalité.

ConvNeXt 2022 CNN pur modernisé avec les principes des Transformers ~2%
(Liu et al., 2022). Compétitif avec ViT.

12.1 Le Bloc Résiduel (ResNet)

Bloc Résiduel de ResNet (He et al., 2016)

Formule : H(x) = F(x, {W_i}) + x

F(x, {W_i}) : transformation résiduelle à apprendre

x : skip connection (identité ou projection 1×1 si dimensions différentes)

Architecture du bloc (ResNet-50 Bottleneck) :

x → Conv 1×1 → BN → ReLU → Conv 3×3 → BN → ReLU → Conv 1×1 → BN → + x → ReLU

Avantage : le réseau peut apprendre F(x)=0 si la couche est inutile,

évitant la dégradation observée avec la profondeur sans connexions résiduelles.

Module TALN — 4ème Année IA | Année Universitaire 2024–2025 Page

CNN — Convolutional Neural Networks | Merlebti Ahmed Ilyas | Université Tahri Mohammed — Béchar

13. Entraînement Pratique d'un CNN

13.1 Pipeline d'Entraînement

Étape Détails Pratiques

1. Préparation du Organisation des données (classes/dossiers ou CSV/JSON), analyse de la distribution des classes,
dataset vérification de la qualité des images (résolution, corruption).

2. Prétraitement Redimensionnement (224×224 standard), normalisation ImageNet, pipeline d'augmentation (flip,

et augmentation crop, color jitter). Utiliser [Link] ou DataLoader PyTorch.

3. Choix de Transfer learning depuis ImageNet fortement recommandé. Choisir selon la taille du dataset et les
l'architecture contraintes de déploiement (EfficientNet, ResNet, MobileNet).

4. Réglage des LR : 1e-3 (Adam) ou 1e-1 (SGD+momentum). Batch : 32–256. Epochs : 50–200 avec early stopping.
hyperparamètres Dropout 0.2–0.5.

5. Entraînement Monitorer les courbes loss/accuracy train et validation. Utiliser TensorBoard ou W&B.
Sauvegarder les meilleurs checkpoints.

6. Diagnostic Analyser la matrice de confusion. Inspecter les erreurs. Visualiser les Grad-CAM pour
l'interprétabilité.

7. Déploiement Conversion en ONNX, TorchScript ou TFLite. Quantification int8 pour edge. Serveur TF Serving,
TorchServe ou Triton Inference Server.

13.2 Diagnostic des Problèmes d'Entraînement

Symptôme Diagnostic Solution

Loss train faible, val. élevée Overfitting Data augmentation plus forte, Dropout, L2,
réduire la complexité

Loss train et val. élevées Underfitting Modèle plus profond, transfer learning, plus
d'époques

Loss ne diminue pas LR trop petit ou initialisation Augmenter LR, utiliser He init., vérifier BN
mauvaise

Loss explose LR trop grand ou gradient explosif Réduire LR, gradient clipping, vérifier les
données

Convergence lente LR trop petit ou mauvais Warm-up cosine, AdamW, batch norm
optimiseur

NaN dans les activations Gradient explosif sévère LR très bas, gradient clipping, vérifier les
données d'entrée

Module TALN — 4ème Année IA | Année Universitaire 2024–2025 Page

CNN — Convolutional Neural Networks | Merlebti Ahmed Ilyas | Université Tahri Mohammed — Béchar

14. Applications des Réseaux CNN

14.1 Vision par Ordinateur

Les CNN dominent la vision par ordinateur depuis AlexNet (2012). Ils sont la base de toutes les tâches
visuelles modernes : classification d'images, détection d'objets, segmentation sémantique et d'instance,
estimation de profondeur, reconnaissance faciale, et pose estimation.
Domaine Application Spécifique Architecture / Performance

Classification ImageNet — 1000 classes, 1.2M images EfficientNet-B7 : Top-1 84.3% ; ViT-L : 85.2%

Détection d'objets COCO Detection — 80 classes, bounding YOLO v8 : mAP@50 53.9% en temps réel
boxes

Segmentation ADE20K — 150 catégories sémantiques SegFormer : mIoU 51.8%

sémantique

Segmentation Segmentation IRM, CT scan, histologie U-Net et variantes : IoU > 90% sur organes
médicale

Reconnaissance Identification et vérification de visages ArcFace : LFW 99.83% de précision

faciale

Estimation de Profondeur monoculaire depuis une seule MiDaS, DPT : δ₁ accuracy > 90%
profondeur image

Vision industrielle Contrôle qualité — défauts de surface Précision > 99% sur défauts visuels

Médecine Détection de cancers, pathologies oculaires AUC > 0.97 sur rétinopathie diabétique

14.2 Applications au-delà de la Vision

Domaine Application Approche CNN

TALN (NLP) Classification de textes, sentiment CNN 1D sur embeddings de mots (Kim, 2014)
analysis

Audio / Parole Reconnaissance vocale, classification CNN sur spectrogrammes mel (MelSpec + ResNet)
audio

Bioinformatique Prédiction de liaison ADN-protéine, CNN 1D sur séquences nucléotidiques

épissage alternatif

Finance Détection de fraude sur données CNN 1D sur séries temporelles de transactions
séquentielles

Physique Reconstruction de trajectoires en CNN sur images de détecteurs (CERN/LHCb)

physique des particules

Climatologie Détection de phénomènes climatiques CNN sur données satellitaires / grilles

extrêmes géographiques

Module TALN — 4ème Année IA | Année Universitaire 2024–2025 Page

CNN — Convolutional Neural Networks | Merlebti Ahmed Ilyas | Université Tahri Mohammed — Béchar

15. Implémentation : Exemple en Python

15.1 Construction d'un CNN avec Keras/TensorFlow

L'implémentation d'un CNN en Python est devenue très accessible grâce aux frameworks modernes. Voici
un exemple complet illustrant la construction, la compilation et l'entraînement d'un CNN pour la
classification multi-classes sur CIFAR-10 :

Code Python — CNN Complet avec Keras (CIFAR-10)

import tensorflow as tf
from tensorflow import keras
from [Link] import layers

# 1. Chargement et prétraitement
(X_train, y_train), (X_test, y_test) = [Link].cifar10.load_data()
X_train = X_train.astype('float32') / 255.0
X_test = X_test.astype('float32') / 255.0
# Normalisation ImageNet standard
mean = [0.4914, 0.4822, 0.4465]; std = [0.2023, 0.1994, 0.2010]

# 2. Pipeline d'augmentation
data_aug = [Link]([
[Link]('horizontal'),
[Link](32, 32, padding=4),
[Link](0.1),
])

# 3. Architecture CNN
def residual_block(x, filters, stride=1):
shortcut = x
x = layers.Conv2D(filters, 3, stride, padding='same', use_bias=False)(x)
x = [Link]()(x)
x = [Link]()(x)
x = layers.Conv2D(filters, 3, 1, padding='same', use_bias=False)(x)
x = [Link]()(x)
if stride != 1:
shortcut = layers.Conv2D(filters, 1, stride, use_bias=False)(shortcut)
shortcut = [Link]()(shortcut)
return [Link]()([x, shortcut])

inputs = [Link](shape=(32, 32, 3))

x = layers.Conv2D(64, 3, padding='same', use_bias=False)(inputs)
x = [Link]()(x)
x = [Link]()(x)
x = residual_block(x, 64)
x = residual_block(x, 128, stride=2)
x = residual_block(x, 256, stride=2)
x = layers.GlobalAveragePooling2D()(x)
x = [Link](0.3)(x)

Module TALN — 4ème Année IA | Année Universitaire 2024–2025 Page

CNN — Convolutional Neural Networks | Merlebti Ahmed Ilyas | Université Tahri Mohammed — Béchar

outputs = [Link](10, activation='softmax')(x)

model = [Link](inputs, outputs)

# 4. Compilation et entraînement
[Link](
optimizer=[Link](learning_rate=0.1, momentum=0.9, weight_decay=1e-4),
loss='sparse_categorical_crossentropy', metrics=['accuracy']
)
callbacks = [
[Link](initial_lr=0.1, first_decay_steps=50),
[Link](patience=10, restore_best_weights=True)
]
history = [Link](X_train, y_train, epochs=200, batch_size=128,
validation_split=0.1, callbacks=callbacks)

# 5. Évaluation — Résultat attendu : ~93–94% sur CIFAR-10

loss, acc = [Link](X_test, y_test)
print(f'Précision test : {acc*100:.2f}%')

15.2 Hyperparamètres Clés et Leur Réglage

Hyperparamètre Valeur Utilisée & Justification

Architecture résiduelle Blocs résiduels : évitent la dégradation avec la profondeur. Optimal pour
CIFAR-10.

Global Average Pooling Remplace les couches Dense après convolutions. Réduit les paramètres et
l'overfitting.

SGD + Momentum 0.9 Meilleure généralisation finale que Adam pour les CNN sur vision. LR initial
0.1.

Cosine Annealing Décroissance cosinus du LR avec redémarrages : meilleure exploration et

convergence.

Weight Decay 1e-4 Régularisation L2 découplée. Standard pour les CNN de vision par
ordinateur.

Dropout 0.3 avant Dense Régularisation légère avant la classification finale. Pas de Dropout dans les
couches conv.

BatchNorm partout Après chaque Conv, avant ReLU. Stabilise l'entraînement, permet LR élevé.

Module TALN — 4ème Année IA | Année Universitaire 2024–2025 Page

CNN — Convolutional Neural Networks | Merlebti Ahmed Ilyas | Université Tahri Mohammed — Béchar

16. Défis, Limitations et Perspectives

16.1 Défis Techniques Fondamentaux

• Coût computationnel : L'entraînement de grands CNN sur ImageNet nécessite des centaines de GPU-
heures. EfficientNet-B7 compte 66M de paramètres et requiert 2 600 heures de GPU. L'inférence en
temps réel sur edge devices reste un défi.
• Inductive bias spatial : Les CNN supposent une structure locale et translationnellement invariante. Ils
sont moins adaptés aux données sans structure spatiale claire ou aux longues dépendances globales.
• Manque de Robustesse : Les CNN sont vulnérables aux exemples adversariaux (Szegedy et al., 2014) —
perturbations imperceptibles induisant des erreurs avec haute confiance. Robustesse aux distributional
shifts (changements de domaine) insuffisante.
• Interprétabilité : Les décisions des CNN restent difficiles à interpréter. Les méthodes actuelles (Grad-
CAM, LIME, SHAP) donnent des explications partielles. Problème critique dans les domaines
réglementés (médecine, justice).
• Besoin de données annotées : La supervision supervisée requiert de grandes quantités d'images
étiquetées. L'annotation est coûteuse et chronophage. Active learning et weak supervision atténuent
ce problème.

16.2 Perspectives et Directions de Recherche

Direction de Recherche Objectif et Approche

CNN + Transformers hybrides Combiner la localité des CNN avec l'attention globale des Transformers
(ConvNeXt, SwinTransformer, MaxViT).

Auto-supervision (SSL) Apprendre des représentations visuelles sans labels : DINO, SimCLR, MAE
(Masked AutoEncoder). Performances proches du supervisé.

Efficacité computationnelle Pruning, quantification (int8, int4), Neural Architecture Search (NAS), knowledge
distillation.

Robustesse aux attaques Adversarial training certifié, purification par diffusion, représentations
invariantes.

Généralisation multi-domaines Domain adaptation, domain generalization, test-time adaptation.

IA Explicable (XAI) Grad-CAM++, LIME, SHAP, concept-based explanations (TCAV). Vers des CNN
interpretables by design.

Apprentissage continuel Permettre aux CNN d'apprendre de nouvelles classes sans oublier les anciennes
(catastrophic forgetting).

Module TALN — 4ème Année IA | Année Universitaire 2024–2025 Page

CNN — Convolutional Neural Networks | Merlebti Ahmed Ilyas | Université Tahri Mohammed — Béchar

17. Conclusion
Les réseaux de neurones convolutifs (CNN) représentent l'une des contributions les plus profondes et
durables du deep learning à l'intelligence artificielle. Nés de l'intuition biologique du cortex visuel et
formalisés par les travaux de LeCun, ils ont révolutionné la vision par ordinateur à partir de 2012 avec
AlexNet, et se sont depuis imposés comme la référence pour tout traitement de données à structure
spatiale.

Au fil de ce rapport, nous avons exploré les fondements mathématiques de la convolution et son
implémentation efficace en tenseurs, la richesse architecturale des CNN modernes (ResNet, EfficientNet,
ConvNeXt), les mécanismes d'apprentissage par rétropropagation adaptés aux couches convolutives, et les
techniques de régularisation et d'optimisation essentielles à la généralisation.

Les CNN ont démontré leur efficacité dans un spectre d'applications remarquablement large : classification
d'images, détection d'objets, segmentation, diagnostic médical, reconnaissance vocale via
spectrogrammes, bioinformatique et au-delà. Leur inductive bias spatial — connectivité locale, partage des
poids, invariance à la translation — les rend particulièrement efficaces pour les données structurées
spatialement.

Malgré leurs succès, les CNN font face à des défis persistants : vulnérabilité aux exemples adversariaux,
coût computationnel élevé, besoin de grandes quantités de données annotées, et manque
d'interprétabilité. L'émergence des Vision Transformers (ViT) et des architectures hybrides CNN-
Transformer représente la prochaine étape, combinant les forces des deux paradigmes.

Synthèse Finale

Les réseaux convolutifs reposent sur trois principes fondamentaux :

• Connectivité locale : chaque filtre perçoit une région limitée de l'entrée (champ récepteur).
• Partage des poids : un même filtre détecte le même motif partout dans l'image.
• Hiérarchie de représentations : des couches successives extraient des motifs de complexité croissante
(bords → textures → parties → objets).

La maîtrise des CNN — de la convolution à ResNet en passant par le transfer learning —

constitue le socle indispensable de tout ingénieur en intelligence artificielle moderne.

Module TALN — 4ème Année IA | Année Universitaire 2024–2025 Page

CNN — Convolutional Neural Networks | Merlebti Ahmed Ilyas | Université Tahri Mohammed — Béchar

18. Références Bibliographiques

Ouvrages Fondamentaux

• Goodfellow, I., Bengio, Y. & Courville, A. (2016). Deep Learning. MIT Press. ISBN: 978-0-262-03561-3.
Chapitres 9 (Réseaux Convolutifs) et 11 (Applications pratiques).
• LeCun, Y., Bengio, Y. & Hinton, G.E. (2015). Deep Learning. Nature, 521, 436–444.
doi:10.1038/nature14539.
• Chollet, F. (2021). Deep Learning with Python, 2nd Edition. Manning Publications. ISBN: 978-
1617296864.
• Geron, A. (2022). Hands-On Machine Learning with Scikit-Learn, Keras & TensorFlow, 3rd Edition.
O'Reilly. ISBN: 978-1098125974.
Articles Scientifiques Fondateurs — CNN

• Hubel, D.H. & Wiesel, T.N. (1962). Receptive Fields, Binocular Interaction and Functional Architecture in
the Cat's Visual Cortex. Journal of Physiology, 160(1), 106–154.
• Fukushima, K. (1980). Neocognitron: A Self-organizing Neural Network Model for a Mechanism of
Pattern Recognition Unaffected by Shift in Position. Biological Cybernetics, 36(4), 193–202.
• LeCun, Y., Bottou, L., Bengio, Y. & Haffner, P. (1998). Gradient-Based Learning Applied to Document
Recognition. Proceedings of the IEEE, 86(11), 2278–2324.
• Krizhevsky, A., Sutskever, I. & Hinton, G.E. (2012). ImageNet Classification with Deep Convolutional
Neural Networks. NIPS 2012. Advances in Neural Information Processing Systems, 25.
• Simonyan, K. & Zisserman, A. (2014). Very Deep Convolutional Networks for Large-Scale Image
Recognition. ICLR 2015. arXiv:1409.1556.
• Szegedy, C. et al. (2015). Going Deeper with Convolutions (GoogLeNet/Inception V1). CVPR 2015.
• He, K., Zhang, X., Ren, S. & Sun, J. (2016). Deep Residual Learning for Image Recognition. CVPR 2016.
arXiv:1512.03385.
• Huang, G. et al. (2017). Densely Connected Convolutional Networks. CVPR 2017. arXiv:1608.06993.
• Howard, A.G. et al. (2017). MobileNets: Efficient Convolutional Neural Networks for Mobile Vision
Applications. arXiv:1704.04861.
• Tan, M. & Le, Q. (2019). EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks. ICML
2019. arXiv:1905.11946.
• Liu, Z. et al. (2022). A ConvNet for the 2020s (ConvNeXt). CVPR 2022. arXiv:2201.03545.
Articles Scientifiques — Techniques de Base

• Ioffe, S. & Szegedy, C. (2015). Batch Normalization: Accelerating Deep Network Training by Reducing
Internal Covariate Shift. ICML 2015. arXiv:1502.03167.
• Srivastava, N. et al. (2014). Dropout: A Simple Way to Prevent Neural Networks from Overfitting. Journal
of Machine Learning Research, 15(1), 1929–1958.
• Kingma, D.P. & Ba, J. (2015). Adam: A Method for Stochastic Optimization. ICLR 2015. arXiv:1412.6980.
• He, K. et al. (2015). Delving Deep into Rectifiers (He Initialization). ICCV 2015. arXiv:1502.01852.
• Lin, T.Y. et al. (2017). Focal Loss for Dense Object Detection (RetinaNet). ICCV 2017. arXiv:1708.02002.
• Selvaraju, R.R. et al. (2017). Grad-CAM: Visual Explanations from Deep Networks. ICCV 2017.
• Yun, S. et al. (2019). CutMix: Training Strategy that Makes Strong Classifiers with Localizable Features.
ICCV 2019. arXiv:1905.04899.
Ressources Pédagogiques et Outils

Module TALN — 4ème Année IA | Année Universitaire 2024–2025 Page

CNN — Convolutional Neural Networks | Merlebti Ahmed Ilyas | Université Tahri Mohammed — Béchar

• CS231n — Convolutional Neural Networks for Visual Recognition, Stanford University. Andrej Karpathy,
Fei-Fei Li. Disponible : [Link]
• Practical Deep Learning for Coders — [Link]. Jeremy Howard & Rachel Thomas. Disponible :
[Link]
• TensorFlow Documentation & Tutorials. Disponible : [Link] — Guide officiel, Keras API, tutoriels
CNN.
• PyTorch Tutorials & torchvision. Disponible : [Link]/tutorials — Transfer learning, fine-tuning,
modèles pré-entraînés.
• Papers With Code — Image Classification on ImageNet. Disponible : [Link]/sota — Suivi
des SOTA.
• Hugging Face timm (PyTorch Image Models). Disponible : [Link]/huggingface/pytorch-image-
models — 700+ architectures CNN pré-entraînées.

Module TALN — 4ème Année IA | Année Universitaire 2024–2025 Page