Machine Learning : État de l'art et bonnes pratiques
- Durée
- Durée :2 jours
- Niveau
- Niveau :Intermédiaire
- Certification
- Certification :Non
1790€ HT
Prochaine session :
Deep Learning avec PyTorch
Concevoir, entraîner, optimiser et déployer des réseaux de neurones avec PyTorchDescription 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.
Programme de la formation
Objectif opérationnel :
Savoir concevoir et entraîner des réseaux de neurones.
Objectif 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.
Jour 1
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
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.
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.
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
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.
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.
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
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.
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é.
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.
Introduction au Deep Learning et à PyTorch
Pourquoi le deep learning : limites du ML classique et apport des réseaux de neurones profondsPanorama 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, contigtOpé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
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écifiquesModè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 tempsLe 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 GPUProfiling 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 completTorchScript : 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.
Public cible :
Des connaissances solides en Python et en machine learning classique sont indispensables : les participants doivent maîtriser NumPy, pandas et avoir déjà entraîné des modèles Scikit-learn. Une familiarité avec les notions d’apprentissage supervisé, de métriques d’évaluation et de surapprentissage est attendue.
Des bases en algèbre linéaire et en calcul différentiel faciliteront la compréhension du mécanisme de backpropagation, bien que ces notions soient rappelées en formation. L’accès à un GPU est requis pour les ateliers d’entraînement.
Prérequis :
Des connaissances solides en Python et en machine learning classique sont indispensables : les participants doivent maîtriser NumPy, pandas et avoir déjà entraîné des modèles Scikit-learn. Une familiarité avec les notions d’apprentissage supervisé, de métriques d’évaluation et de surapprentissage est attendue.
Des bases en algèbre linéaire et en calcul différentiel faciliteront la compréhension du mécanisme de backpropagation, bien que ces notions soient rappelées en formation. L’accès à un GPU est requis pour les ateliers d’entraînement.
J'évalue mes connaissances pour vérifier que je dispose des prérequis nécessaires pour profiter pleinement de cette formation en faisant le test de prérequis.
Date de mise à jour du programme : 29/05/2026
Dates et lieux
Période souhaitée
Lieux
Type d'affichage