Aller au contenu principal
  • ACN_ATLAS
  • Cours pratique
  • Informatique

Formation Deep Learning avec PyTorch

Concevoir, entraîner, optimiser et déployer des réseaux de neurones avec PyTorch

Demander un devis
Une formatrice accompagne deux participants penchés sur leurs notes, en salle de formation
Durée
3 jours
Niveau
Fondamental
Modalités
Présentiel / Distanciel

Description de la formation PyTorch

Qu’est-ce que Deep Learning avec PyTorch ?

Le deep learning est une branche de l’intelligence artificielle qui permet de concevoir des réseaux de neurones capables d’apprendre à partir de grands volumes de données. PyTorch est aujourd’hui l’un des frameworks de référence pour construire, entraîner, déboguer et déployer ces modèles grâce à son API Python intuitive et à son graphe de calcul dynamique. 

Pourquoi suivre une formation Deep Learning avec PyTorch ?

Suivre une formation Deep Learning avec PyTorch permet de développer des compétences opérationnelles pour créer des modèles adaptés à la vision par ordinateur, au traitement du langage naturel ou aux séries temporelles. Cette formation met l’accent sur la pratique à travers un projet fil rouge, DataInsure, qui consiste à construire un classifieur de documents de bout en bout, depuis la manipulation des tenseurs jusqu’au déploiement via TorchServe.

Atelier en salle : une participante présente des notes au tableau

Objectifs pédagogiques

À l'issue de cette formation Deep Learning avec PyTorch, vous aurez acquis les connaissances nécessaires pour :

  • Construire des réseaux de neurones.
  • Entraîner et évaluer des modèles.
  • Optimiser et déboguer les architectures.
  • Déployer des modèles DL.

Objectifs opérationnels

Savoir concevoir et entraîner des réseaux de neurones.

Programme

Contenu du cours

Jour 1

Introduction au Deep Learning et à PyTorch

Pourquoi le deep learning : limites du ML classique et apport des réseaux de neurones profonds
Panorama des architectures : MLP, CNN, RNN, Transformers — quand utiliser quoi ?
PyTorch dans l’écosystème DL : positionnement face à TensorFlow/Keras et JAX
Installation, configuration GPU (CUDA) et prise en main de l’environnement de travail
La philosophie « define-by-run » : graphe de calcul dynamique et avantages pour le débogage
Présentation du projet fil rouge DataInsure : architecture de la plateforme IA cible

Tenseurs, opérations et autograd

Création et manipulation de tenseurs : dtype, device, shape, contigt
Opérations mathématiques : broadcasting, produits matriciels, réductions
Le moteur de différentiation automatique : requires_grad, backward(), grad
Comprendre le graphe de calcul : feuilles, nœuds intermédiaires et accumulation des gradients
Pièges classiques : gradient explosion, vanishing gradient, detach() et no_grad()
Passage CPU / GPU : .to(device), .cuda(), .cpu()Travaux pratiquesObjectif : Comprendre le mécanisme de backpropagation en implémentant une descente de gradient manuelle sur des données DataInsure.
Descriptif : Avant d’utiliser nn.Module, les participants implémentent de zéro une régression linéaire sur les données clients DataInsure (age, ancienneté du contrat, nombre de sinistres antérieurs) pour prédire un score de risque. L’objectif est de provoquer d’abord une erreur volontaire, calculer le gradient sans appeler zero_grad(), pour observer l’accumulation des gradients et comprendre pourquoi zero_grad() est indispensable dans une boucle d’entraînement. Le gradient correct est ensuite calculé avec backward() et les poids sont mis à jour manuellement. Les résultats sont comparés à la solution analytique pour valider l’implémentation.

Construire des réseaux de neurones avec nn.Module

La classe nn.Module : définir __init__ et forward()
Couches standards : nn.Linear, nn.ReLU, nn.BatchNorm1d, nn.Dropout
Conteneurs : nn.Sequential, nn.ModuleList, nn.ModuleDict
Initialisation des poids : Xavier, He, impact sur la convergence
Inspecter un modèle : named_parameters(), torchinfoTravaux pratiquesObjectif : Implémenter un réseau fully connected pour la pré-classification des données textuelles DataInsure et comprendre l’impact de l’architecture sur les performances.
Descriptif : Construction d’un MLP avec nn.Module pour classifier les demandes DataInsure en trois catégories (sinistre, devis, résiliation) à partir de features textuelles encodées (TF-IDF précalculé). Les participants comparent trois architectures : une couche cachée (modèle baseline), deux couches avec BatchNorm, trois couches avec Dropout. Pour chaque configuration, les performances sur le jeu de validation DataInsure sont mesurées et les courbes de loss et d’accuracy tracées avec Matplotlib. Cette expérimentation directe montre pourquoi la profondeur et la régularisation ne sont pas des réglages arbitraires mais des décisions motivées par les données.

Entraînement, fonctions de loss et optimiseurs

La boucle d’entraînement PyTorch : zero_grad(), forward, loss.backward(), optimizer.step()
Fonctions de loss : CrossEntropyLoss, BCELoss, MSELoss, quelle loss pour quel problème ?
Optimiseurs : SGD (avec momentum), Adam, AdamW, intuitions et différences
DataLoader et Dataset : charger et batcher les données efficacement
Suivi de l’entraînement : logging des métriques et TensorBoard avec SummaryWriter
Séparer clairement entraînement, validation et test : bonnes pratiques
Quiz d’évaluation des acquis de la journéeJour 2 

Réseaux de neurones convolutifs (CNN)

Convolution 2D : noyaux, stride, padding, dilation — intuition géométrique
Pooling (MaxPool, AvgPool) et réduction spatiale
Architecture d’un CNN : blocs convolutifs + classifieur fully connected
Architectures de référence : LeNet, AlexNet, VGG : évolution et logique
Visualiser les feature maps : comprendre ce que le réseau « voit »
Augmentation de données avec torchvision.transforms

Travaux pratiquesObjectif : Construire un CNN pour classifier les images de documents DataInsure et mesurer le gain par rapport au MLP du jour précédent.
Descriptif : Le MLP du Jour 1 traitait des features TF-IDF : les participants reprennent la même tâche de classification (sinistre / devis / résiliation) mais cette fois à partir des images numérisées des documents DataInsure. Un CNN est construit avec trois blocs Conv2D + MaxPool + ReLU suivi d’un classifieur. Le pipeline complet est implémenté : ImageFolder pour charger les images, transforms pour la normalisation et l’augmentation (rotation, flip horizontal), DataLoader batché. Les feature maps de la première couche sont visualisées pour comprendre quels motifs visuels (en-tête, signature, tampon) le réseau apprend à détecter. La comparaison des métriques MLP vs CNN illustre concrètement l’apport de la convolution pour les données structurées spatialement.

Régularisation, batch normalization et diagnostic

Dropout : principe, impact sur le training vs l’inférence (model.train() / model.eval())
Batch Normalization : normalisation des activations, avantages pour la convergence
Learning rate scheduling : StepLR, CosineAnnealingLR, ReduceLROnPlateau
Diagnostiquer un entraînement : courbes de loss, overfitting, underfitting, instabilité
Gradient clipping pour les réseaux profondsTravaux pratiquesObjectif : Diagnostiquer le surapprentissage du classifieur documentaire DataInsure et mettre en œuvre les techniques de régularisation adaptées.
Descriptif : Le CNN du TP précédent est délibérément sur-paramétré (nombre de filtres doublé, profondeur augmentée) pour créer un surapprentissage visible dans TensorBoard. Les participants doivent d’abord diagnostiquer le problème à partir des courbes : le loss de validation monte alors que le loss d’entraînement descend. Ils appliquent ensuite les remèdes successivement, ajout de Dropout après chaque bloc convolutif, BatchNorm, augmentation plus agressive des données, et mesurent l’impact de chaque modification sur le gap train/validation. Cette approche « déboguer avant de résoudre » correspond à la réalité du métier.

Transfer Learning et fine-tuning avec torchvision

Principe du transfer learning : features génériques vs features spécifiques
Modèles pré-entraînés dans torchvision.models : ResNet, EfficientNet, ViT
Stratégies : feature extraction vs fine-tuning partiel vs fine-tuning complet
Adapter la dernière couche au nombre de classes spécifique
Learning rate différentiel : taux plus faibles pour les couches bassesTravaux pratiquesObjectif : Améliorer les performances du classifieur documentaire DataInsure par fine-tuning de ResNet et préparer le modèle final pour le suivi MLflow (module 8).
Descriptif : Chargement de ResNet50 pré-entraîné sur ImageNet. Remplacement de la couche fc par une tête de classification à trois sorties (sinistre / devis / résiliation DataInsure). Phase 1 : entraînement de la tête seule (backbone gelé) pendant 5 époques. Phase 2 : dégel des deux derniers blocs résiduels et fine-tuning avec un learning rate différentiel 10× plus faible sur le backbone. Comparaison systématique des trois modèles construits dans ce module (MLP, CNN custom, ResNet finé-tuné) sur le jeu de test DataInsure. Le meilleur modèle est sauvegardé en state_dict avec ses métadonnées (accuracy, F1 par classe) : ce checkpoint sera réutilisé dans le module MLflow comme artefact à versionner et déployer.Jour 3

Réseaux récurrents et séries temporelles (RNN, LSTM, GRU)

Principe des RNN : état caché, dépendances temporelles, unfold dans le temps
Le problème du vanishing gradient dans les RNN profonds
LSTM : les trois portes (oubli, entrée, sortie) et la mémoire à long terme
GRU : simplification du LSTM, compromis performance/complexité
Mise en forme des données séquentielles : (batch, seq_len, features)Travaux pratiquesObjectif : Implémenter un LSTM pour prédire l’évolution mensuelle du volume de déclarations de sinistres DataInsure.
Descriptif : DataInsure dispose de 36 mois d’historique sur le volume de déclarations de sinistres par catégorie (auto, habitation, santé). Un LSTM bidirectionnel est construit pour prédire le volume du mois suivant à partir d’une fenêtre glissante de 6 mois. Les participants créent d’abord un Dataset personnalisé avec sliding window, entraînent le LSTM et comparent ses prédictions à deux baselines : moyenne mobile et régression linéaire. La discussion porte sur l’interprétation des résultats : à quel horizon le LSTM apporte-t-il vraiment de la valeur face à des méthodes plus simples ? Ce questionnement crédible est au cœur de la valeur ajoutée d’un praticien.

Optimisation avancée et débogage des architectures

Mixed precision training (torch.autocast, GradScaler) : accélération sur GPU
Profiling PyTorch : torch.profiler pour identifier les goulots d’étranglement
Débogage avancé : nan dans les gradients, explosion des activations, dying ReLU
Reproducibilité : seeds, déterminisme CUDA
Introduction au DataParallel pour les environnements multi-GPUTravaux pratiquesObjectif : Diagnostiquer et résoudre un bug de nan dans les gradients du classifieur DataInsure, puis mesurer le gain du mixed precision training.
Descriptif : Un script d’entraînement du classifieur DataInsure contient une erreur volontaire : une couche de normalisation personnalisée effectue une division sans vérifier que le dénominateur n’est pas nul, produisant des NaN dans les gradients après quelques itérations. Les participants utilisent torch.autograd.set_detect_anomaly(True) pour localiser l’opération fautive, corrigent le bug, puis activent torch.autocast pour le mixed precision training. Le gain en temps d’entraînement et en occupation mémoire GPU est mesuré et discuté.

Déploiement des modèles PyTorch

Sauvegarder et charger un modèle : state_dict vs modèle complet
TorchScript : convertir un modèle en graphe statique pour la production
Export ONNX : format interopérable pour déploiement multi-plateforme
Inférence avec ONNX Runtime : latence et optimisation
TorchServe : servir un modèle PyTorch comme API RESTTravaux pratiquesObjectif : Déployer le classifieur documentaire DataInsure comme service REST via TorchServe et exposer l’API qui sera consommée par le chatbot Rasa (module 6).
Descriptif : Le modèle ResNet fine-tuné (meilleur checkpoint sauvegardé au Jour 2) est d’abord exporté en TorchScript, puis en ONNX. Benchmark de latence entre PyTorch natif et ONNX Runtime sur un lot de 100 images. Un handler TorchServe est écrit pour encapsuler le prétraitement (redimensionnement, normalisation) et le post-traitement (softmax, label mapping). Le modèle est empaquetté (.mar) et le serveur TorchServe est démarré. Des requêtes JSON sont envoyées via curl avec des images de documents DataInsure. La documentation de l’API REST produite est présentée comme la « spec d’interface » que le module Rasa (module 6) consommera pour router les documents entrants vers le bon service DataInsure.

Programme mis à jour le 29/05/2026

Formations liées