Transfer Learning¶

1. Principes¶

Le transfer learning consiste à réutiliser un modèle déjà entraîné sur un large dataset (ImageNet, ~14 M d'images, 1 000 classes) et à l'adapter à une nouvelle tâche avec peu de données.

Pourquoi ça marche ?¶

Les premières couches d'un réseau de neurones apprennent des features génériques (contours, textures, motifs) qui sont utiles pour presque toutes les tâches visuelles. Seules les dernières couches sont spécialisées pour la tâche d'origine.

Deux approches¶

Workflow type en Keras¶

# 1. Charger le backbone pré-entraîné SANS la tête de classification
base_model = keras.applications.MobileNetV3Large(
    weights="imagenet",
    input_shape=(224, 224, 3),
    include_top=False,
)

# 2. Geler le backbone
base_model.trainable = False

# 3. Ajouter un classifier head
inputs = keras.Input(shape=(224, 224, 3))
x = base_model(inputs, training=False)  # training=False → BatchNorm en mode inférence
x = keras.layers.GlobalAveragePooling2D()(x)
x = keras.layers.Dropout(0.2)(x)
outputs = keras.layers.Dense(1, activation="sigmoid")(x)
model = keras.Model(inputs, outputs)

2. Architectures de base¶

MobileNetV3¶

MobileNetV3 existe en deux variantes : Large (meilleure accuracy) et Small (ultra-léger).

EfficientNet (B0 → B7)¶

3. Dataset — Préparation & Bonnes Pratiques¶

Taille recommandée¶

Répartition des données¶

Équilibrage des classes¶

Un dataset déséquilibré (ex : 90% real, 10% fake) biaise le modèle vers la classe majoritaire.

Techniques de rééquilibrage :

from sklearn.utils.class_weight import compute_class_weight
import numpy as np

weights = compute_class_weight(
    "balanced",
    classes=np.array([0, 1]),
    y=train_labels
)
class_weight = {0: weights[0], 1: weights[1]}

model.fit(train_ds, class_weight=class_weight)

4. Data Augmentation¶

La data augmentation crée des variations artificielles des images d'entraînement pour améliorer la généralisation.

Augmentations recommandées pour l'anti-spoofing¶

Implémentation Keras¶

augmentation_layers = keras.Sequential([
    keras.layers.RandomFlip("horizontal"),
    keras.layers.RandomBrightness(0.2),
    keras.layers.RandomContrast(0.2),
])

5. Pipeline d'entraînement en 2 phases¶

Vue d'ensemble¶

graph LR
    A[Backbone pré-entraîné<br/>ImageNet] --> B[Phase 1<br/>Feature Extraction]
    B --> C{Accuracy<br/>suffisante ?}
    C -->|Oui| D[✅ Export]
    C -->|Non| E[Phase 2<br/>Fine-Tuning]
    E --> D

Phase 1 — Transfer Learning (backbone gelé)¶

model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=1e-3),
    loss="binary_crossentropy",
    metrics=["accuracy"],
)
model.fit(train_ds, validation_data=val_ds, epochs=10)

Phase 2 — Fine-Tuning (backbone dégelé)¶

# Dégeler le backbone
base_model.trainable = True

# Recompiler avec un LR très faible
model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=1e-5),
    loss="binary_crossentropy",
    metrics=["accuracy"],
)
model.fit(train_ds, validation_data=val_ds, epochs=10)

Diagnostic des courbes d'apprentissage¶

6. Quantification Post-Training (PTQ)¶

Pourquoi quantifier ?¶

Méthodes de quantification¶

Dataset de calibration¶

Pour la quantification INT8, un dataset de calibration est nécessaire :

• Taille : 100 à 500 échantillons représentatifs
• Contenu : un sous-ensemble du train ou du val set
• Rôle : déterminer les plages min/max des activations pour optimiser la quantification

def representative_dataset():
    for image, _ in train_ds.take(100):
        yield [image]

converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset
tflite_model = converter.convert()

PTQ vs QAT — Quand choisir quoi ?¶

7. Conversion & Déploiement TFLite¶

Pipeline de conversion¶

graph LR
    A[Modèle Keras<br/>.keras] --> B[TFLite Float32<br/>.tflite]
    A --> C[TFLite INT8<br/>_qt.tflite]
    B --> D[Déploiement<br/>maximum accuracy]
    C --> E[Déploiement<br/>mobile / edge]

Code de conversion¶

converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()

with open("model.tflite", "wb") as f:
    f.write(tflite_model)

converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset
tflite_model = converter.convert()

with open("model_qt.tflite", "wb") as f:
    f.write(tflite_model)

Vérification post-conversion¶

8. Checklist & Anti-patterns¶

✅ Checklist avant entraînement¶

• Dataset équilibré (ou class weights configurés)
• Split train / val / test effectué (pas de fuite de données)
• Images redimensionnées à la taille du backbone (224×224)
• Pixels normalisés dans la plage attendue par le backbone
• Data augmentation activée si dataset < 5 000 images/classe
• Backbone gelé pour la Phase 1

✅ Checklist avant déploiement¶

• Courbes de learning vérifiées (pas d'overfitting)
• Modèle évalué sur le test set (jamais vu pendant le training)
• Conversion TFLite testée (Float32 + INT8)
• Accuracy post-quantification vérifiée (delta < 2%)
• Taille du modèle acceptable pour la cible (mobile, edge…)

❌ Anti-patterns courants¶

Références¶

• Transfer learning & fine-tuning — TensorFlow Guide
• Post-training quantization — TF Model Optimization
• Quantification post-entraînement — Google AI Edge / LiteRT