Images et ConvNets

Transfer learning

Pour aller plus loin

https://www.deeplearningbook.org/

deeplearningbook

Principaux types de réseaux

1. Feed Forward (Perceptron Multicouche)

Chaque neurone est connecté à tous les neurones de la couche suivante.

Cas d'utilisation: Classification, régression, reconnaissance de patterns simples.

Spécificités:

2. RNN (Recurrent Neural Networks)

Réseaux avec connexions cycliques permettant de traiter des séquences temporelles.

RNN

Cas d'utilisation: Traitement du langage naturel, prédiction de séries temporelles, génération de texte simple, traduction.

Spécificités:

=> excellent post de Karpathy sur RNN

3. Transformers

Cas d'utilisation: NLP (BERT, GPT), vision (Vision Transformers), génération, traduction, modèles de langage de grande taille.

Spécificités:

illustrated-transformer

4. CNN (Convolutional Neural Networks)

Utilise des convolutions au lieu d'une regression linéaire pour extraire des features locales.

ConvNet

Cas d'utilisation: Vision par ordinateur, reconnaissance d'images, détection d'objets, segmentation sémantique.

Spécificités:

Comparaison Rapide

AspectFeed ForwardRNNCNNTransformer
DonnéesTabulairesSéquencesImagesSéquences/Texte
ParallélisationComplèteLimitéeBonneExcellente
MémoireAucuneImpliciteLocaleGlobale (attention)
ComplexitéBasseHauteMoyenneTrès haute
Données requisesPeuMoyennesMoyennesBeaucoup

Bref historique

Inception (2014)

Architecture Inception

Inception
Inception

FLOPs

Les FLOPs (Floating Point Operations) désignent le nombre d’opérations arithmétiques en virgule flottante nécessaires pour exécuter un modèle, et servent à estimer son coût de calcul et sa complexité.

Historique des entraînements

On a la relation suivante entre paramètres et FLOPs:

FLOPs ~= 6 *Parameters * tokens
ModelParametersTraining FLOPs (approx)
GPT-2 (small)1.5B3 × 10^19
GPT-3175B3.14 × 10^23
LLaMA-7B7B~1.4 × 10^21
LLaMA-70B70B~1.4 × 10^22
Étoiles dans l'univers10^22 à 10^24

Cycle de vie d'un modèle

Il y a 5 étapes:

puis comme en ML classique:

Convolutional Neural Network

CNN : Convolutional Neural Network

MLP pas fantastique pour les images

pourtant si on bouge la chaise … ça reste une chaise !

Le CNN capture l'information spatiale, les spécificités locales

CNN

parfait pour :

  • la classification d'images
  • la segmentation d'images
  • la détection d'objet

mais aussi les séries temporelles :

  • numériques : simples et combinées
  • reconnaissance de la parole
  • classification audio
  • analyse des capteurs (IoT)
 CNN

CNN : principe de base

Décomposition de l'image de pixel en pixel, par petit carrés (3x3, 5x5)

CNN principle

Convolution

Filtrage des regions par un filtre (tenseur rang 2 de dimension 3x3 ou 5x5, …).

convolution

le calcul de "convolution"

Convolution

Convolution math

Différent de la convolution en traitement du signal et des images qui retourne et décale le signal d'entrée.

Le mot "convolution" est utilisé en raison du contexte historique, de la similarité conceptuelle et de la cohérence terminologique.

L'idée principale reste la suivante

un noyau (filtre) est appliqué à une entrée (image) pour produire une carte de caractéristiques, qui capture les caractéristiques spatiales importantes de l'entrée.

Pooling

Reduction de dimension (downsampling) : max ou moyenne des valeurs sur une region (2x2, 3x3, 4x4, etc.)

Apres la convolution vient le pooling aussi appelée sous-échantillonnage

But du pooling:

2 techniques de Pooling

prendre le max (plus fréquent) Pooling

prendre la moyenne Pooling

Voir le cours de Stanford sur les CNN

En résumé

Le partie convolution et pooling réalise l'extraction des caractéristiques (features) de l'image d'entrée.

Les coefficients du filtre sont des paramètres d'apprentissage au même titre que les poids des noeuds dans une couche dense

Combiner plusieurs couches de convolution + pooling permet d'extraire des caractéristiques de plus en plus complexes

On peut enchaîner les couches de convolution sans avoir à chaque fois une couche de pooling

Typical CNN

CNN : separation of concerns

The genius of CNNs is the separation of concerns:

Architecture typique

Input Image
    ↓
[Conv + ReLU + Pooling] ← Feature Extraction (Layers 1-N)
[Conv + ReLU + Pooling] ← Hierarchical features
[Conv + ReLU + Pooling]
    ↓
Flatten (reshape to 1D vector)
    ↓
[Dense + ReLU]          ← Classic Feed Forward
[Dense + ReLU]          ← Classification/Regression
[Dense (output)]
    ↓
Prediction (class probabilities)

What Happens at Each Stage

Convolutional Layers (Feature Extraction):

Result: The image is progressively compressed into a high-level feature vector

Fully Connected Layers (Decision Making):

Example (VGG-16)

Input: 224×224×3 image
    ↓
Conv blocks (13 layers): Extract features → 7×7×512
    ↓
Flatten: 7×7×512 = 25,088 neurons
    ↓
Dense layers (3 layers):
  - Dense(4096) + ReLU
  - Dense(4096) + ReLU
  - Dense(1000) + Softmax → class prediction

Backpropagation

Backpropagation updates ALL layers, including the convolutional filters.

Dense layers:

Convolutional layers:

Example

Initial Conv Filter (3×3):
[0.1  -0.2   0.3]
[0.5   0.0  -0.1]
[-0.2  0.4   0.1]

After 1 training step (backprop computes gradients):
[0.12  -0.19   0.31]  ← Each weight adjusted
[0.51   0.01  -0.08]
[-0.18  0.42   0.12]

The gradient tells how much each weight contributed to the loss

Plusieurs Filtres de Convolution

On a toujours plusieurs filtres en parallèle.

Exemple Concret

Input: Image 32×32×3 (RGB)

Cas 1 : UN SEUL filtre 3×3

Input: 32×32×3
Filtre: 3×3×3 (hauteur × largeur × canaux)

Paramètres du filtre:
3 × 3 × 3 = 27 paramètres (+ 1 bias) = 28 total

Output: 30×30×1 (une seule feature map)

Dans ce cas on n'extrait qu'une seule feature (par exemple "les bords verticaux"). Ce qui ne suffit pas

Cas 2 : 32 FILTRES en parallèle

Input: 32×32×3

32 filtres différents, chacun 3×3×3:
- Filtre 1: 3×3×3 = 27 params
- Filtre 2: 3×3×3 = 27 params
- ...
- Filtre 32: 3×3×3 = 27 params

Total: 32 × 27 = 864 paramètres (+ 32 bias) ≈ 896 total

Output: 30×30×32 (32 feature maps différentes!)

Chaque filtre apprend une feature différente:

Visualisation

Input: 32×32×3
┌─────────────────┐
│   RGB Image     │
└─────────────────┘
        ↓
    [32 filtres en parallèle]
        ↓
    ┌──┬──┬──┬──┬─...─┐
    │FM│FM│FM│FM│     │ ← 32 Feature Maps
    └──┴──┴──┴──┴─...─┘
    Chacun 30×30
        ↓
Output: 30×30×32

Comment ça change dans un Deep Network

VGG-16 Example:

Layer 1:
Input:  224×224×3
Filtres: 64 × (3×3×3) = 64 × 27 = 1,728 params
Output: 222×222×64

    ↓

Layer 2 (reçoit les 64 feature maps):
Input:  222×222×64
Filtres: 128 × (3×3×64) = 128 × 576 = 73,728 params ← BEAUCOUP plus!
Output: 220×220×128

    ↓

Layer 3:
Input:  220×220×128
Filtres: 256 × (3×3×128) = 256 × 1,152 = 294,912 params
Output: 218×218×256

Observation:

Couche 1: 1,728 params
Couche 2: 73,728 params (42× plus)
Couche 3: 294,912 params (170× plus!)

Pourquoi?
- Plus de filtres (64 → 128 → 256)
- Plus de canaux d'entrée (3 → 64 → 128)

Formule: params = (kernel_size² × input_channels × output_filters)

Formule Générale

Pour une couche Conv:

Paramètres = (Kernel_Height × Kernel_Width × Input_Channels × Output_Filters) + Output_Filters

Exemple:
- Kernel: 3×3
- Input channels: 64
- Output filters: 128

Params = (3 × 3 × 64 × 128) + 128 = 73,728 + 128 = 73,856

Résumé

AspectDétail
Un filtre1 feature map en sortie
32 filtres32 feature maps en sortie (32 features différentes détectées)
Paramètres croissentAvec le nombre de filtres ET le nombre de canaux d'entrée
Plus profondChaque couche reçoit plus de canaux → explosion de paramètres

Les multiples filtres en parallèle : plein de détecteurs différents qui travaillent en même temps

Interet de multiplier les couches Conv - Pooling

Chaque set va extraire des caractéristiques de plus en plus complexes et générales

Premier ensemble de convolution + pooling :

Deuxième ensemble de convolution + pooling :

Pratique - notebook CNN

Sur le dataset Cats and Dogs

Notebook on Colab

Tensorboard

https://www.tensorflow.org/tensorboard

Le tableau de bord Scalar montre comment le loss et les paramètres changent à chaque epoch. Vous pouvez également l'utiliser pour suivre la vitesse d'entraînement, le taux d'apprentissage et d'autres valeurs scalaires.

Le tableau de bord Graphs vous permet de visualiser votre modèle. Dans ce cas, le graphique Keras des couches s'affiche, ce qui peut vous aider à vous assurer qu'il est correctement construit.

Les tableaux de bord et Histogrammes montrent la distribution d'un Tensor au fil du temps. Cela peut être utile pour visualiser les poids et les biais et vérifier qu'ils changent de manière attendue.

tensorboard tutorial

techniques de reduction de l'overfit en deep learning

Augmenter les données

A chaque etape, le ImageDataGenerator prend un certain nombre (batch_size) d'images et les transforme aléatoirement (ou non)

De cette façon, le modèle voit des variations des images ce qui réduit l'overfitting

2 modes :

Les transformations possibles sont

Pour aller plus loin : construire un pipeline input https://www.tensorflow.org/guide/data

BATCH SIZE

Le gradient qui sert à mettre à jour les poids du noeud lors de la rétropropagation est estimé à chaque fois sur une partie du dataset

le nombre d'échantillon estimé à chaque étape est appelé le batch size.

Valeurs courantes : N = 16, 32, 64, …

Le batch size est défini dans le train_generator, et le test_generator

train_generator = train_datagen.flow_from_directory(train_dir,
                                                    batch_size=20,
                                                    class_mode='binary',
                                                    target_size=(150, 150))

Comment régler le batch size ?

Augmenter le batch size

Réduire le batch size

Faut il réduire ou augmenter le batch size pour compenser l'overfit ?

D'un côté réduire le batch size réduit aussi l'overfit car :

Mais de l'autre côté augmenter le batch size réduit aussi l'overfit car:

Approfondissement

INPUT -> [[CONV -> RELU]*N -> POOL?]*M -> [FC -> RELU]*K -> FC

Lire la partie architecture du cours de Stanford Convolutional Neural Networks https://cs231n.github.io/convolutional-networks/#architectures

Pour aller plus loin

L'excellent cours de stanford, notamment la section sur l'architecture https://cs231n.github.io/convolutional-networks/#architectures

Ce cours récapitulatif https://stanford.edu/~shervine/teaching/cs-230/cheatsheet-convolutional-neural-networks

Le chapitre sur la convolution du Deep Learning book https://www.deeplearningbook.org/contents/convnets.html

A vous de jouer

CNN Notebook
# Transfer Learning et fine tuning

le Fine tuning

En prenant pour départ un grand modèle déjà entraîné, l'idée est de réutiliser le modèle pour l'extraction des données

Nécessite souvent beaucoup de données et des ressources informatiques puissantes

Transfer learning (plus facile)

En prenant pour départ un grand modèle déjà entraîné, l'idée est de réutiliser le modèle pour l'extraction des données

Peu de données, faibles ressources informatiques

Transfer learning - 2 façon d'opérer

Workflow complet

Alternative plus légère

Dans ce cas vous ne faites passer le modèle de base sur vos données qu'une seule fois, plutôt qu'une fois par époque d'entraînement. Donc c'est beaucoup plus rapide et moins coûteux.

Combiner les modèles keras

inner_model = Sequential([
    layers.Input(shape=(10,)),
    layers.Dense(32, activation='relu'),
    layers.Dense(16, activation='relu')
])

outer_model = Sequential([
    inner_model,  # Include the inner model as a layer
    layers.Dense(64, activation='relu'),
    layers.Dense(1, activation='sigmoid')
])

# Compile the outer model
outer_model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

Transfer learning

On va utiliser le modèle InceptionV3 : Total params: 21802784 (83.17 MB) + 311 layers!!!

Inception V3

Inception V3

Notebook transfer learning

Notebook transfer learning

Version du notebook plus recente

Notebook transfer learning V2

1 / 0