0Pricing
Learn AI with Python · Leçon

Ajustement fin : dégel et réentraînement

base_model.trainable = True, dégel couche par couche, taux d’apprentissage différenciés.

Ajustement fin : dégel et réentraînement est une leçon Learn AI with Python gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn AI with Python, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn AI with Python comprend 4 leçons au total.

Quand effectuer un ajustement fin

Une fois que l’extraction de caractéristiques a entraîné votre tête, l’ajustement fin permet d’obtenir une précision supplémentaire en laissant la partie supérieure de la base préentraînée s’adapter à vos données. Effectuez-le uniquement lorsque la tête est stable ; sinon, les grands gradients d’une tête aléatoire risquent d’endommager la base.

Déverrouiller la base

Définissez base.trainable = True pour rendre à nouveau les poids modifiables. À elle seule, cette instruction déverrouille toutes les couches, ce qui est généralement trop agressif.

base.trainable = True
print("Trainable layers:", sum(l.trainable for l in base.layers))

Geler les N premières couches

Les premières couches contiennent des détecteurs génériques de contours et de textures que vous souhaitez conserver. Gelez à nouveau les N premières couches et effectuez l’ajustement fin uniquement sur les couches plus profondes, spécifiques à la tâche.

base.trainable = True
freeze_until = 100   # keep first 100 layers frozen

for layer in base.layers[:freeze_until]:
    layer.trainable = False
for layer in base.layers[freeze_until:]:
    layer.trainable = True

Pourquoi utiliser un taux d’apprentissage très faible

L’ajustement fin nécessite un taux d’apprentissage minuscule, tel que 1e-5. Les poids préentraînés sont déjà performants ; vous souhaitez seulement les modifier légèrement. Un taux élevé provoque un oubli catastrophique et efface les connaissances ImageNet que vous cherchiez à réutiliser.

Recompiler après le déverrouillage

Vous devez recompiler le modèle après avoir modifié les indicateurs trainable, afin que Keras reconstruise la liste des poids recevant des gradients. Définissez ici le faible taux d’apprentissage.

from tensorflow.keras.optimizers import Adam

model.compile(
    optimizer=Adam(learning_rate=1e-5),
    loss="categorical_crossentropy",
    metrics=["accuracy"]
)

Le processus en deux phases

  1. Phase 1 (extraction de caractéristiques) : base gelée, entraînez la tête à environ 1e-3 jusqu’à ce que la précision de validation plafonne.
  2. Phase 2 (ajustement fin) : déverrouillez les couches supérieures, recompilez avec environ 1e-5, puis poursuivez l’entraînement.

Cette séparation stabilise l’entraînement et protège les caractéristiques préentraînées.

Poursuivre l’entraînement durant la phase 2

Reprenez l’entraînement là où la phase 1 s’est arrêtée en utilisant initial_epoch, afin que les journaux et les planifications restent continus.

history2 = model.fit(
    train_ds,
    validation_data=val_ds,
    epochs=20,
    initial_epoch=10   # phase 1 ended at epoch 10
)

Planificateur du taux d’apprentissage

Un planificateur réduit progressivement le taux d’apprentissage afin que les mises à jour diminuent à mesure que le modèle converge. ReduceLROnPlateau le réduit automatiquement lorsque la perte de validation stagne.

from tensorflow.keras.callbacks import ReduceLROnPlateau

lr_cb = ReduceLROnPlateau(
    monitor="val_loss", factor=0.5,
    patience=2, min_lr=1e-7
)
model.fit(train_ds, validation_data=val_ds,
          epochs=20, callbacks=[lr_cb])

Précautions concernant BatchNorm

ResNet et EfficientNet contiennent des couches BatchNormalization qui suivent des statistiques courantes. Lors de l’ajustement fin, conserver les couches BN gelées (ou en mode inférence) donne souvent des résultats plus stables, car mettre à jour leurs statistiques sur un petit jeu de données peut nuire à la précision.

Attention au surapprentissage

Le réglage fin ajoute de nombreux paramètres entraînables, ce qui augmente le risque de surapprentissage. Combattez-le avec l’augmentation des données, Dropout et EarlyStopping sur la perte de validation.

from tensorflow.keras.callbacks import EarlyStopping

stop = EarlyStopping(monitor="val_loss",
                     patience=4,
                     restore_best_weights=True)

Mise en pratique

Une procédure de réglage fin robuste consiste à entraîner la tête, dégeler les couches supérieures, geler BN, recompiler avec un taux de 1e-5, puis entraîner avec un planificateur et un arrêt anticipé. Comparez toujours la précision de validation avant et après pour vérifier que le réglage fin a réellement été utile.

Vérification rapide

Testez vos connaissances sur le réglage fin.

Récapitulatif

Vous avez appris à effectuer un réglage fin en définissant base.trainable=True, en regelant les N premières couches, en recompilant avec un taux d’apprentissage très faible (1e-5), puis en exécutant un processus en deux phases. Un planificateur du taux d’apprentissage et un arrêt anticipé assurent la stabilité, et les couches BatchNorm nécessitent une attention particulière. Ensuite : les modèles légers pour le déploiement en périphérie.

Questions Fréquemment Posées

La leçon « Ajustement fin : dégel et réentraînement » est-elle gratuite ?

Oui — le texte complet de « Ajustement fin : dégel et réentraînement » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn AI with Python, passe à CoddyKit PRO. Le cours Learn AI with Python comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Ajustement fin : dégel et réentraînement » ?

base_model.trainable = True, dégel couche par couche, taux d’apprentissage différenciés. Tu pratiques Learn AI with Python avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Learn AI with Python ?

Aucune expérience préalable n'est requise. Learn AI with Python sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Ajustement fin : dégel et réentraînement » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Learn AI with Python ?

Oui. Chaque leçon Learn AI with Python inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Concepts et stratégies de l’apprentissage par transfert
  2. Utiliser VGG16 et ResNet50 comme modèles de base
  3. Ajustement fin : dégel et réentraînement
  4. MobileNet et EfficientNet pour le déploiement en périphérie
← Retour à Learn AI with Python