🤖 Formation Machine Learning

1. Introduction à la classification et à la régression

Comprendre la différence entre prédire une variable catégorielle (classification) et une variable continue (régression). Applications concrètes : prédiction de churn client, estimation de prix immobilier...

2. Préparation des données

• Nettoyage : gestion des valeurs manquantes, traitement des outliers.
• Feature Engineering : création de nouvelles variables pertinentes.
• Encodage : Label Encoding, One-Hot Encoding.
• Normalisation / Standardisation : scaler les données avec MinMaxScaler ou StandardScaler.

3. Choix du modèle

• Classification : Logistic Regression, KNN, Decision Tree, Random Forest, SVM.
• Régression : Linear Regression, Ridge, Lasso, ElasticNet, Decision Tree Regressor.

4. Entraînement du modèle

Séparation du dataset avec train_test_split. Paramétrage du modèle et lancement de l'entraînement sur les données d'apprentissage.

5. Évaluation des performances

• Classification : Accuracy, Precision, Recall, F1-Score, ROC AUC.
• Régression : MAE (Mean Absolute Error), MSE (Mean Squared Error), RMSE (Root Mean Squared Error), R² Score.

6. Optimisation et validation croisée

• Cross-validation pour éviter le surapprentissage (overfitting).
• Recherche d’hyperparamètres avec GridSearchCV ou RandomizedSearchCV.

7. Industrialisation rapide

Création de pipelines automatiques pour chaîner préparation, entraînement et prédiction en une seule étape avec sklearn.pipeline.Pipeline.

1. Définir la problématique

Clarification des objectifs : est-ce un problème de classification, de régression, de détection d'anomalies ou de recommandation ? Quelle est la variable cible à prédire ?

2. Comprendre les données (Data Understanding)

• Exploration initiale : dimensions, types de variables.
• Analyse univariée et bivariée (statistiques descriptives, graphiques).
• Détection des anomalies et valeurs manquantes.

3. Préparer les données (Data Preparation)

• Nettoyage : gestion des outliers et des valeurs manquantes.
• Transformation : normalisation, standardisation, encodage catégoriel.
• Création de nouvelles features (feature engineering).
• Séparation en ensembles d'entraînement et de test.

4. Sélection du modèle

• Choix initial selon la nature du problème et la taille des données.
• Comparaison rapide de plusieurs modèles de base (baseline models).

5. Entraînement et validation

• Entraîner le modèle sur l'ensemble d'entraînement.
• Évaluer sur l'ensemble de validation (ou par cross-validation).
• Calculer des métriques précises adaptées à la problématique (classification : f1, ROC AUC ; régression : R², RMSE).

6. Optimisation du modèle

• Réglage des hyperparamètres (GridSearchCV, RandomSearchCV, Optuna...).
• Réduction du surapprentissage avec régularisation, dropout, pruning.

7. Interprétation des résultats

• Importance des variables (Feature Importance, SHAP values).
• Compréhension des biais éventuels et limitations du modèle.

8. Déploiement (MLOps basique)

Exporter le modèle (Pickle, joblib). Déployer une API simple (FastAPI, Flask). Intégrer dans un pipeline de production automatisé (CI/CD).

1. Feature Engineering : Introduction

Le feature engineering consiste à créer, transformer ou sélectionner les variables explicatives (features) pour maximiser les performances des modèles d'apprentissage.

2. Création de nouvelles variables

• Combinaison de features existantes (ex : ratio, différence, produit).
• Extraction d'informations (ex : extraire le jour, le mois à partir d'une date).
• Encodage de variables catégorielles (One-Hot Encoding, Target Encoding, Ordinal Encoding).
• Discrétisation de variables continues en classes (binning, bucketing).

3. Transformation des variables

• Log-transformation pour corriger une distribution asymétrique.
• Square root, Box-Cox ou Yeo-Johnson transformations.
• Gestion des valeurs extrêmes (Winsorization, clipping).

4. Normalisation et standardisation

• Normalisation (MinMaxScaler) : ramener les données entre 0 et 1.
• Standardisation (StandardScaler) : centrer les données (moyenne = 0) et réduire l’écart-type à 1.
• Choix : la normalisation est utile pour les modèles basés sur des distances (KNN, SVM), la standardisation pour la régression linéaire, les modèles linéaires et le clustering.

5. Sélection des variables (Feature Selection)

• Suppression des variables à faible variance.
• Utilisation de la corrélation pour détecter la redondance (matrice de corrélation, heatmap).
• Techniques de sélection supervisée : SelectKBest, RFE (Recursive Feature Elimination), L1-regularization (Lasso).

6. Bonnes pratiques

• Appliquer transformations et sélections dans un pipeline (Pipeline Scikit-learn).
• Garder un historique des transformations pour assurer la reproductibilité.
• Valider l’impact de chaque transformation sur les performances via des benchmarks itératifs.

1. Introduction aux Pipelines

Un pipeline est une chaîne d'étapes de traitement des données et de modélisation. Il permet d'automatiser et d'uniformiser les processus de preprocessing et d'entraînement dans une seule structure reproductible.

2. Création d’un Pipeline avec Scikit-learn

• Enchaînement de plusieurs transformations (imputation, normalisation, encodage).
• Ajout du modèle final (ex : régression, classification).
• Exemple : Pipeline(steps=[('scaler', StandardScaler()), ('classifier', LogisticRegression())])

3. Pourquoi utiliser un Pipeline ?

• Garantir que les transformations soient bien appliquées sur les données de test (pas seulement d'entraînement).
• Éviter les fuites de données ("Data Leakage") en validant toutes les étapes dans un environnement contrôlé.
• Faciliter le déploiement et la mise en production des modèles.

4. Hyperparameter Tuning : GridSearchCV

La recherche d'hyperparamètres optimaux est cruciale pour maximiser les performances d'un modèle.

• GridSearchCV teste automatiquement différentes combinaisons d'hyperparamètres via validation croisée (Cross-Validation).
• Il est intégré directement au pipeline : chaque transformation et modèle est évalué correctement.
• Exemple de param_grid : {'classifier__C': [0.1, 1, 10], 'classifier__penalty': ['l1', 'l2']}

5. Cross-validation dans le Pipeline

• Utiliser cross_val_score sur un pipeline complet pour évaluer sa robustesse.
• Evite de surévaluer le modèle grâce à la validation croisée systématique.

6. Bonnes pratiques

• Incorporer systématiquement toutes les étapes dans un pipeline.
• Documenter chaque transformation pour assurer une transparence totale.
• Optimiser les pipelines avant déploiement pour accélérer le traitement sur les nouvelles données.

1. Introduction au Clustering

Le clustering est une méthode d'apprentissage non supervisé visant à regrouper automatiquement des données similaires sans connaissance préalable des classes existantes.

2. K-Means : algorithme de partitionnement

• Algorithme itératif qui partitionne les données en K clusters en minimisant la variance intra-cluster.
• Principe : chaque observation appartient au cluster dont le centre est le plus proche (minimisation de la distance euclidienne).
• Limites : nécessite de connaître le nombre de clusters à l’avance, sensible aux valeurs extrêmes et aux formes non sphériques.

3. DBSCAN : Clustering par densité

• Regroupe les points denses ensemble, séparant les zones à faible densité.
• Avantages : détecte automatiquement le nombre de clusters, gère bien les outliers et les formes complexes.
• Paramètres clés : eps (rayon de voisinage) et min_samples (nombre minimal de points pour former un cluster).

4. Clustering hiérarchique agglomératif

• Approche bottom-up : chaque observation commence comme son propre cluster, puis les clusters sont fusionnés progressivement selon un critère de similarité.
• Produits finaux : arbre de dendrogramme permettant de choisir dynamiquement le nombre de clusters.
• Distance de linkage : single, complete, average, ward (minimisation de la variance totale).

5. Comment choisir l'algorithme ?

• K-Means : si les données sont sphériques et peu bruitées.
• DBSCAN : si les données contiennent des formes irrégulières et du bruit.
• Hiérarchique : si vous souhaitez explorer différents niveaux de granularité et visualiser la hiérarchie naturelle des groupes.

6. Visualisation des clusters

Utilisation de t-SNE, PCA ou UMAP pour réduire la dimension et visualiser efficacement les clusters formés.

1. Pourquoi réduire la dimension ?

• Faciliter la visualisation des données en 2D ou 3D.
• Éliminer le bruit et les redondances dans les variables.
• Améliorer la performance des modèles en réduisant la complexité.
• Accélérer les temps d’entraînement.

2. PCA (Analyse en Composantes Principales)

• Technique linéaire qui transforme les variables d'origine en nouvelles composantes orthogonales maximisant la variance.
• Utilisé pour la compression, la visualisation et la détection d’outliers.
• Limite : capte mal les structures non linéaires complexes.

3. t-SNE (t-distributed Stochastic Neighbor Embedding)

• Technique non-linéaire dédiée principalement à la visualisation de données en haute dimension en 2D/3D.
• Préserve les relations locales entre les points.
• Très utilisé pour explorer visuellement des clusters complexes.
• Attention : sensible aux paramètres comme le perplexity et peut produire des résultats différents à chaque exécution.

4. UMAP (Uniform Manifold Approximation and Projection)

• Nouvelle méthode non-linéaire ultra-performante pour la réduction de dimension.
• Conserve mieux à la fois la structure locale et globale que t-SNE.
• Utilisé pour le clustering, la visualisation rapide, et comme étape de prétraitement pour l’apprentissage supervisé.
• Paramètres clés : n_neighbors et min_dist.

5. Comment choisir ?

• PCA : rapide et efficace pour des structures linéaires.
• t-SNE : pour explorer visuellement des structures très complexes mais uniquement pour visualiser.
• UMAP : pour un excellent compromis entre performance, rapidité et conservation des structures.

6. Bonnes pratiques

• Appliquer un prétraitement : normalisation ou standardisation des données avant réduction.
• Tester différents paramètres (perplexity pour t-SNE, n_neighbors pour UMAP).
• Fixer un random_state pour obtenir des résultats reproductibles.

1. Qu'est-ce qu'une série temporelle ?

• Données mesurées dans le temps de manière régulière (jours, mois, secondes...)
• Exemples : cours de la bourse, consommation électrique, trafic réseau, météo.
• Caractéristiques : tendance, saisonnalité, cycles, bruit.

2. ARIMA (AutoRegressive Integrated Moving Average)

• Modèle statistique traditionnel pour la prévision de séries temporelles stationnaires.
• Combine 3 éléments : autorégression (AR), différenciation (I), moyenne mobile (MA).
• Bien adapté aux séries sans saisonnalité complexe.
• Exige un pré-traitement : rendre la série stationnaire avant l'entraînement.

3. Prophet (développé par Facebook)

• Framework open-source conçu pour modéliser automatiquement la tendance, la saisonnalité et les effets de vacances.
• Très efficace même avec peu de données et des séries bruitées.
• Idéal pour les séries avec une forte saisonnalité et des ruptures de tendance.
• Utilise des modèles additifs flexibles (y(t) = tendance + saisonnalité + jours spéciaux + erreur).
• Très simple à utiliser, parfait pour un Data Engineer qui veut livrer rapidement une solution robuste.

4. LSTM (Long Short-Term Memory)

• Type de réseau de neurones récurrent (RNN) conçu pour capturer les dépendances temporelles longues.
• Parfait pour des séries très complexes ou de grandes quantités de données séquentielles.
• Capable d'apprendre les patterns longs et non linéaires (ex : comportement utilisateur, trading haute fréquence...)
• Nécessite plus de ressources (temps d'entraînement, tuning hyperparamètres).

5. Comment choisir ?

• ARIMA : pour des séries simples, peu bruitées, sans grosse saisonnalité.
• Prophet : pour déployer vite des prévisions sur des séries avec saisonnalité, anomalies ou jours fériés.
• LSTM : pour des projets complexes où les dépendances sont longues, irrégulières ou non linéaires.

6. Bonnes pratiques

• Décomposer la série : comprendre la tendance, saisonnalité et résidus avant modélisation.
• Utiliser des métriques adaptées : MAE, RMSE, MAPE.
• Faire attention au sur-apprentissage, notamment avec les réseaux de neurones.
• Prévoir suffisamment de données pour évaluer sérieusement la performance (train/test split temporel, pas aléatoire).

1. Introduction aux systèmes de recommandation

• Objectif : prédire les préférences d'un utilisateur pour lui proposer des contenus ou produits pertinents.
• Applications : e-commerce, plateformes de streaming (Netflix, Spotify), réseaux sociaux, moteurs de recherche, etc.

2. Approche basée sur le contenu (Content-Based Filtering)

• Recommande des éléments similaires à ceux qu'un utilisateur a aimés dans le passé.
• Utilise des caractéristiques (features) des items (ex. : genre d'un film, type de produit, catégories d'articles).
• Modèles utilisés : KNN, SVM, réseaux de neurones.
• Avantages : Pas besoin de données des autres utilisateurs, personnalisation rapide.
• Limites : Manque d'exploration, risque de "bulle de filtres".

3. Approche collaborative (Collaborative Filtering)

• Basé sur les comportements collectifs (notes, clics, achats) des utilisateurs similaires.
• Deux méthodes principales :
  • User-based : Recommande ce que des utilisateurs similaires ont apprécié.
  • Item-based : Recommande des items souvent associés ensemble.
• Exemples : systèmes de type "les utilisateurs ayant acheté X ont aussi acheté Y".
• Modèles utilisés : matrices de similarité, factorisation de matrices (SVD, ALS), autoencoders.
• Limites : problème du "cold start" (nouveaux utilisateurs/items sans historique).

4. Approche hybride

• Combine contenu et filtrage collaboratif pour bénéficier des forces de chacun.
• Peut utiliser plusieurs techniques : pondération, empilement (stacking), modèles séquentiels.
• Exemples : Netflix combine vos habitudes de visionnage (collaboratif) avec les genres préférés (contenu).

5. Enjeux pratiques

• Scalabilité : pouvoir traiter des millions d'utilisateurs et d'items rapidement (cf. Approximate Nearest Neighbors, embeddings...)
• Interprétabilité : surtout dans les secteurs critiques (santé, finance) pour expliquer les recommandations.
• Cold start : prévoir des solutions pour nouveaux utilisateurs/items (questionnaires, hybridation).
• Biais : éviter la recommandation systématique d'un seul type d'item (favoriser la diversité).

6. Technologies clés

• scikit-learn pour les modèles de base.
• Surprise (librairie spécialisée pour le collaborative filtering).
• TensorFlow Recommenders pour des modèles deep learning de recommandation.
• Utilisation de bases NoSQL (MongoDB, Neo4j) ou systèmes de vector search (Faiss, Milvus) pour le passage à l'échelle.

1. Définition de l'anomalie

• Une anomalie (ou outlier) est une observation qui s'écarte de manière significative du comportement attendu ou de la distribution normale des données.
• Détecter les anomalies permet d'identifier des erreurs, des fraudes, des défaillances ou des opportunités.

2. Approches classiques de détection d'anomalies

• Basées sur les statistiques : écart-type, score de Z, test de Grubbs.
• Basées sur la distance : k-Nearest Neighbors (KNN), Isolation Forest, Local Outlier Factor (LOF).
• Basées sur le modèle : One-Class SVM, autoencoders pour l'apprentissage non supervisé.

3. Détection d'anomalies en Machine Learning

• Formulation souvent comme un problème de classification binaire : normal vs anomalie.
• Utilisation de réseaux neuronaux auto-encodeurs pour repérer les déviations subtiles dans des jeux de données complexes.
• Exploration de méthodes semi-supervisées lorsque seules quelques anomalies sont connues.

4. Cas d’usage métiers

• Finance : Détection de transactions frauduleuses sur cartes bancaires.
• Industrie : Maintenance prédictive (détection précoce de pannes d'équipements).
• Cybersécurité : Détection d'intrusions, d'accès non autorisés, de malwares.
• Santé : Identification d'anomalies dans les examens médicaux (IRM, ECG).
• E-commerce : Analyse de comportements d'achat inhabituels pour la prévention de fraudes.

5. Outils et bibliothèques

• scikit-learn : IsolationForest, LocalOutlierFactor, OneClassSVM.
• PyOD : Librairie spécialisée pour l'outlier detection (plus de 30 algorithmes).
• TensorFlow et PyTorch : pour implémenter des auto-encodeurs avancés.

6. Enjeux critiques

• Équilibre précision/sensibilité : mieux vaut parfois rater une anomalie (faux négatif) que générer trop d'alertes fausses (faux positifs).
• Adaptabilité : un modèle doit s'adapter à l'évolution des comportements au fil du temps (retraining nécessaire).
• Interprétabilité : en particulier pour des domaines régulés (finance, santé).