Comprehensive Guide to Passing Your Machine Learning Exam (French)

This document and its associated practical exercises cover key machine learning algorithms: linear regression, logistic regression, K-nearest neighbors (KNN), support vector machines (SVM), and K-means clustering. It provides detailed explanations of each algorithm, including their objectives, functioning, evaluation metrics, strengths, and limitations. Practical exercises guide the implementation of these algorithms in Python, using libraries like Scikit-learn, and emphasize understanding fundamental concepts, model evaluation, and parameter optimization. This comprehensive overview serves as a valuable resource for mastering these essential machine learning techniques.

Régression Linéaire

Ce document et ce TP traitent de la régression linéaire, un algorithme d'apprentissage supervisé utilisé pour prédire une variable continue (la "cible") en fonction de variables explicatives (les "features").

Résumé du Cours

Introduction à l'apprentissage supervisé:

• Objectif: Créer un modèle prédictif capable de prédire des réponses pour de nouvelles observations.

• Hypothèse: Les données d'entraînement sont représentatives du problème général.

• Fonctionnement: On fournit les données d'entraînement au modèle, qui apprend une fonction permettant de prédire la sortie en minimisant l'erreur de prédiction.

Régression vs Classification:

• Régression: Prédire une valeur continue (ex: prix d'une maison, quantité d'essence consommée).

• Classification: Classer un objet dans une catégorie (ex: spam/non-spam, tumeur bénigne/maligne).

Éléments d'un algorithme d'apprentissage supervisé:

1. Données d'entraînement: Ensemble de données contenant les features et la cible.

2. Modèle d'apprentissage: Fonction mathématique (hθ(x)) avec des paramètres (θ) qui est appris par l'algorithme.

3. Fonction d'erreur: Quantifie l'écart entre la prédiction et la valeur réelle (ex: erreur quadratique moyenne).

4. Méthode de minimisation d'erreur: Algorithme qui ajuste les paramètres du modèle pour minimiser la fonction d'erreur (ex: descente de gradient).

Régression Linéaire:

• Définition: Cherche une relation linéaire entre la variable à prédire (y) et les features (x).

• Modèle: hθ(x) = θ0 + θ1x1 + ... + θnxn

• Fonction d'erreur: Généralement l'erreur quadratique moyenne (MSE).

• Minimisation de l'erreur: Descente de gradient: ajuste itérativement les paramètres pour minimiser l'erreur.

Généralisation:

• La régression linéaire peut être généralisée en utilisant des fonctions de base, permettant de modéliser des relations non linéaires (ex: polynomiale).

Étapes détaillées pour construire un modèle de régression linéaire (sans code):

1. Préparation des données:

   • Collecte des données d'entraînement contenant les features et la cible.

   • Prétraitement des données: nettoyage, transformation, normalisation si nécessaire.

   • Séparation des données en ensembles d'entraînement, de validation et de test.

2. Choix du modèle:

   • Choisir un modèle de régression linéaire (simple ou multiple).

   • Définir la fonction d'erreur (MSE dans la plupart des cas).

   • Sélectionner une méthode de minimisation de l'erreur (descente de gradient).

3. Apprentissage du modèle:

   • Entraîner le modèle sur les données d'entraînement en ajustant les paramètres pour minimiser l'erreur.

4. Évaluation du modèle:

   • Évaluer les performances du modèle sur l'ensemble de validation (pour optimiser les hyperparamètres).

   • Évaluer les performances finales du modèle sur l'ensemble de test.

5. Déploiement du modèle:

   • Déployer le modèle pour effectuer des prédictions sur de nouvelles données.

Évaluation du modèle

• Metrics:

  • Erreur quadratique moyenne (MSE): Mesure l'écart moyen au carré entre les prédictions et les valeurs réelles.

  • Racine carrée de l'erreur quadratique moyenne (RMSE): Permet de comparer l'erreur avec l'échelle de la variable cible.

  • Erreur absolue moyenne (MAE): Mesure l'écart moyen absolu entre les prédictions et les valeurs réelles.

  • Coefficient de détermination (R²): Indique la proportion de la variance de la cible expliquée par le modèle (plus proche de 1, meilleur est le modèle).

• Sur-apprentissage vs Sous-apprentissage:

  • Sur-apprentissage: Le modèle apprend trop bien les données d'entraînement et ne généralise pas bien aux nouvelles données.

  • Sous-apprentissage: Le modèle ne capture pas suffisamment les informations dans les données d'entraînement et a de mauvaises performances.

Limites du modèle de régression linéaire

• Relations linéaires: Le modèle suppose une relation linéaire entre les features et la cible. Si la relation est non linéaire, les performances du modèle seront réduites.

• Données bruitées: Le modèle peut être sensible aux valeurs aberrantes (outliers) dans les données.

• Complexité: Pour des problèmes avec un grand nombre de features, le modèle peut devenir complexe à entraîner et à interpréter.

Points forts du modèle de régression linéaire

• Simple et facile à comprendre: Le modèle est simple à comprendre et à interpréter.

• Rapide à entraîner: Le modèle est généralement rapide à entraîner, même pour des ensembles de données volumineux.

• Bonne base: Le modèle peut servir de base pour des modèles plus complexes.

TP1: Implémentation de la régression linéaire

Le TP1 guide l'utilisateur à travers l'implémentation de la régression linéaire en Python. Il inclut plusieurs parties:

Partie 1:

• Générer des données aléatoires.

• Implémenter la régression linéaire à une seule variable en définissant les fonctions suivantes:

  • Modèle hθ(x).

  • Fonction d'erreur J(θ).

  • Gradient ∂J/∂θ.

  • Descente de gradient.

• Afficher graphiquement les données, les prédictions et l'évolution du coût.

• Calculer le coefficient de détermination (R²) pour évaluer les performances.

Partie 2:

• Ajouter une deuxième variable pour implémenter une régression linéaire à deux variables.

• Afficher les données et les prédictions en 3D.

Partie 3:

• Appliquer une transformation non linéaire aux données pour créer un modèle de régression polynomiale d'ordre 2.

Partie 4:

• Utiliser la bibliothèque Scikit-learn pour implémenter la régression linéaire.

• Découper les données en ensembles d'entraînement et de test.

• Entraîner et évaluer le modèle sur les données.

• Appliquer le modèle à deux jeux de données "Salary_Data.csv" et "USA_Housing.csv".

Préparation à l'examen

Pour se préparer à l'examen, il faut comprendre:

• Les concepts fondamentaux de l'apprentissage supervisé, de la régression linéaire et de la descente de gradient.

• Les différents éléments d'un algorithme d'apprentissage supervisé.

• Les étapes détaillées de la construction d'un modèle de régression linéaire.

• Les différentes metrics d'évaluation du modèle.

• Les limites et les points forts du modèle de régression linéaire.

• Savoir implémenter la régression linéaire en Python (en utilisant les fonctions fournies dans le TP).

• Savoir analyser et interpréter les résultats du modèle.

Régression Logistique

Ce document et ce TP traitent de la régression logistique, un algorithme d'apprentissage supervisé utilisé pour la classification binaire, c'est-à-dire pour prédire l'appartenance d'un élément à une de deux classes possibles (0 ou 1).

Résumé du Cours

Introduction à la classification:

• Objectif: Classer des éléments en différentes catégories (ex: spam/non-spam, tumeur bénigne/maligne).

• Différence avec la régression: La variable cible est discrète (0 ou 1).

• Approches: Régression logistique, SVM, KNN.

Régression Logistique:

• Fonctionnement:

  • Utilise la fonction sigmoïde (σ(z)) pour transformer la sortie de la régression linéaire en une probabilité comprise entre 0 et 1.

  • La probabilité correspond à la probabilité que l'élément appartienne à la classe 1.

• Modèle: hθ(x) = σ(θTX)

• Fonction d'erreur: La fonction d'erreur logarithmique est généralement utilisée.

• Minimisation de l'erreur: Descente de gradient: ajuste itérativement les paramètres pour minimiser l'erreur.

• Frontière de décision: La frontière de décision est la solution de l'inéquation θTX ≥ 0 (y=1).

Métriques d'évaluation pour la classification:

• Matrice de confusion: Tableau qui résume les prédictions correctes et incorrectes.

• Accuracy: Proportion d'éléments correctement classés.

• Error Rate: Proportion d'éléments incorrectement classés.

• Sensitivity (Recall): Proportion d'éléments de la classe 1 correctement prédits.

• Specificity: Proportion d'éléments de la classe 0 correctement prédits.

• Precision: Proportion d'éléments prédits comme appartenant à la classe 1 qui sont réellement de la classe 1.

• F-score: Moyenne harmonique de la précision et du rappel.

• Courbe ROC: Graphique représentant le taux de vrais positifs (TPR) en fonction du taux de faux positifs (FPR) pour différents seuils de classification.

• AUC (Area Under the Curve): Surface sous la courbe ROC.

Types de régression logistique:

• Binaire: Variable cible avec deux résultats possibles.

• Multinomiale: Variable cible avec plus de deux résultats possibles sans ordre.

• Ordinale: Variable cible avec plus de deux résultats possibles avec ordre.

Classification multi-classes:

• Stratégies: One-vs-one (OVO), One-vs-all (OVA).

Étapes détaillées pour construire un modèle de régression logistique (sans code):

1. Préparation des données:

   • Collecte des données d'entraînement contenant les features et la cible (0 ou 1).

   • Prétraitement des données: nettoyage, transformation, normalisation si nécessaire.

   • Séparation des données en ensembles d'entraînement, de validation et de test.

2. Choix du modèle:

   • Choisir un modèle de régression logistique.

   • Définir la fonction d'erreur (logarithmique).

   • Sélectionner une méthode de minimisation de l'erreur (descente de gradient).

3. Apprentissage du modèle:

   • Entraîner le modèle sur les données d'entraînement en ajustant les paramètres pour minimiser l'erreur.

4. Évaluation du modèle:

   • Évaluer les performances du modèle sur l'ensemble de validation (pour optimiser les hyperparamètres).

   • Évaluer les performances finales du modèle sur l'ensemble de test en utilisant les metrics appropriées (matrice de confusion, accuracy, sensitivity, specificity, precision, F-score, courbe ROC, AUC).

5. Déploiement du modèle:

   • Déployer le modèle pour effectuer des classifications sur de nouvelles données.

TP2: Implémentation de la régression logistique

Le TP2 guide l'utilisateur à travers l'implémentation de la régression logistique en Python. Il inclut plusieurs parties:

Partie 1:

• Générer un ensemble de données simples contenant deux features et une cible binaire.

• Implémenter la régression logistique en définissant les fonctions suivantes:

  • Fonction sigmoïde hθ(x).

  • Fonction d'erreur J(θ).

  • Gradient ∂J/∂θ.

  • Descente de gradient.

• Prédire les classes pour les données d'entraînement.

• Calculer les différentes metrics d'évaluation.

Partie 2:

• Utiliser la bibliothèque Scikit-learn pour implémenter la régression logistique.

• Appliquer le modèle au dataset "breast_cancer".

• Découper les données en ensembles d'entraînement et de test.

• Entraîner et évaluer le modèle.

• Tracer la courbe ROC.

Préparation à l'examen

Pour se préparer à l'examen, il faut comprendre:

• Les concepts fondamentaux de la classification binaire, de la régression logistique et de la descente de gradient.

• Les différentes étapes de la construction d'un modèle de régression logistique.

• Les différentes metrics d'évaluation du modèle et leur interprétation.

• Savoir implémenter la régression logistique en Python (en utilisant les fonctions fournies dans le TP).

• Savoir analyser et interpréter les résultats du modèle.

L'algorithme KNN (K plus proches voisins)

Résumé du Cours

Principe du KNN:

L'algorithme KNN (K Nearest Neighbors) se base sur l'idée que des éléments similaires ont tendance à être proches les uns des autres. Pour classifier un nouvel élément, KNN recherche les K éléments les plus proches dans l'espace des features, et la classe majoritaire parmi ces voisins est attribuée à l'élément à classifier.

Fonctionnement:

1. Calculer la distance: Déterminer la distance entre l'élément à classifier et tous les autres éléments de l'ensemble d'entraînement.

2. Identifier les K plus proches voisins: Sélectionner les K éléments ayant les plus petites distances par rapport à l'élément à classifier.

3. Voter pour la classe majoritaire (classification) ou calculer la moyenne (régression):

   • Classification: Attribuer à l'élément à classifier la classe la plus fréquente parmi ses K voisins.

   • Régression: Attribuer à l'élément à classifier la moyenne (ou une autre fonction d'agrégation) des valeurs de la variable cible de ses K voisins.

Métrique de proximité:

• Mesure la similarité entre deux vecteurs (enregistrements).

• Choix importants: distance euclidienne, distance de Manhattan, etc.

• Influence la qualité de la classification/régression.

Classification multi-classes:

• Le principe reste le même, la classe majoritaire parmi les K voisins est choisie.

Évaluation des performances:

• Classification: Matrice de confusion, accuracy, precision, recall, F-score, etc.

• Régression: MAE, MSE, RMSE, R², etc.

Choix de la valeur de K:

• K trop petit: sensible au bruit.

• K trop grand: perte de la notion de "proximité".

• Méthodes de sélection:

  • Règle du pouce: K = √m (m = nombre d'instances d'entraînement).

  • Méthode Elbow: visualiser l'erreur en fonction de K et choisir le K au niveau du "coude".

KNN pondéré:

• Pondération des voisins en fonction de leur distance: les voisins plus proches ont plus d'influence.

• Permet d'affiner la prédiction.

Robustesse et faiblesses:

Points forts:

• Simple à comprendre et à implémenter.

• Peu de paramètres à régler.

• Pas d'apprentissage au sens classique (apprentissage "lazy").

Points faibles:

• Coûteux en calcul, surtout pour les grandes données.

• Sensible à la malédiction de la dimensionalité.

• Le choix de la métrique de distance et de K est crucial.

TP3: Implémentation de KNN

Partie 1: KNN simple pour la classification binaire:

1. Importation des librairies: Pandas, Seaborn, Matplotlib, NumPy.

2. Acquisition des données: Charger un dataset et l'explorer.

3. Normalisation des features: Mettre les features à la même échelle pour éviter les biais.

4. Séparation des données en ensembles d'entraînement et de test:train_test_split.

5. Utilisation de KNN:

   • Instancier le modèle KNeighborsClassifier.

   • Entraîner le modèle avec fit.

   • Faire des prédictions avec predict.

6. Prédictions et évaluations:

   • Afficher la matrice de confusion et le rapport de classification.

7. Choisir une valeur de K:

   • Entraîner et évaluer le modèle pour différentes valeurs de K.

   • Visualiser le taux d'erreur en fonction de K (méthode Elbow).

   • Choisir le K optimal et comparer les performances.

8. Explorer différentes métriques de distance:

   • Répéter les étapes précédentes avec différentes métriques de distance.

   • Comparer les résultats et conclure.

Partie 2: Classification multi-classes avec KNN:

• Appliquer KNN à un dataset avec plus de deux classes (ex: "iris.csv").

Partie 3: KNN pondéré pour la régression:

• Appliquer KNN pondéré à un dataset de régression (ex: "salary_data.csv").

• Choisir K avec la méthode Elbow.

• Évaluer les performances du modèle.

Préparation à l'examen

Pour se préparer à l'examen, assurez-vous de:

• Comprendre le fonctionnement de l'algorithme KNN pour la classification et la régression.

• Connaître les différentes étapes de l'implémentation de KNN en Python.

• Savoir choisir une métrique de distance et une valeur de K appropriées.

• Interpréter les résultats des métriques d'évaluation.

• Comprendre les avantages et les inconvénients de KNN.

les Support Vector Machines (SVM)

Résumé du Cours

Introduction aux SVMs:

• Objectif: Trouver l'hyperplan optimal qui sépare au mieux les données en deux classes.

• Marge: Distance entre l'hyperplan et les points de données les plus proches (vecteurs de support).

• SVM à marge dure: Fonctionne bien pour les données linéairement séparables, cherche une marge maximale.

Fonctionnement des SVMs:

1. Définir un hyperplan: Trouver une droite (2D), un plan (3D) ou un hyperplan (n dimensions) qui sépare les données.

2. Maximiser la marge: Choisir l'hyperplan qui maximise la distance aux points de données les plus proches de chaque classe.

3. Vecteurs de support: Les points de données les plus proches de l'hyperplan, utilisés pour définir la marge.

Cas des données non linéairement séparables:

• SVM à marge souple (Soft Margin SVM): Permet des erreurs de classification en utilisant des variables d'écart.

• Astuce du noyau (Kernel Trick): Transforme les données dans un espace de plus grande dimension pour trouver une séparation linéaire.

Noyaux courants:

• Linéaire: Convient aux données linéairement séparables.

• Polynomial: Crée des frontières de décision non linéaires.

• RBF (Radial Basis Function): Crée des frontières de décision plus complexes.

Avantages des SVMs:

• Efficace pour les ensembles de données complexes.

• Fonctionne bien avec un grand nombre de features.

• Robuste au sur-apprentissage.

Inconvénients des SVMs:

• Peut être lent à entraîner pour les grands ensembles de données.

• Le choix du noyau et des paramètres peut être délicat.

Étapes pour construire un modèle SVM (Support Vector Machine)

1. Préparation des données

• Collecte et exploration des données: Rassembler les données d'entraînement contenant les features et les labels de classe. Examiner les données pour comprendre leur structure, leurs types et identifier les éventuelles valeurs manquantes ou aberrantes.

• Nettoyage et prétraitement des données: Gérer les valeurs manquantes (imputation ou suppression), traiter les valeurs aberrantes (remplacement ou suppression), convertir les variables catégorielles en numériques (encodage one-hot, label encoding), et mettre à l'échelle les features (standardisation, normalisation) pour éviter les biais liés à des échelles différentes.

• Séparation des données en ensembles d'entraînement, de validation et de test: Diviser les données en trois ensembles distincts: un ensemble d'entraînement pour l'apprentissage du modèle, un ensemble de validation pour l'optimisation des hyperparamètres et un ensemble de test pour l'évaluation finale des performances du modèle.

2. Choix du modèle et des hyperparamètres

• Sélection du noyau (kernel): Le choix du noyau est crucial pour les SVM car il définit la façon dont les données seront transformées dans un espace de plus grande dimension pour permettre la séparation linéaire. Les noyaux courants incluent:

  • Linéaire: Convient aux données linéairement séparables.

  • Polynomial: Adapté aux données avec des relations non-linéaires polynomiales.

  • RBF (Radial Basis Function): Noyau gaussien, capable de modéliser des relations non-linéaires complexes.

• Réglage des hyperparamètres: Les hyperparamètres contrôlent le comportement de l'algorithme SVM. Les plus importants sont:

  • C (paramètre de régularisation): Contrôle le compromis entre la maximisation de la marge et la minimisation des erreurs de classification. Un C élevé pénalise plus les erreurs et peut conduire à un surajustement, tandis qu'un C faible favorise une marge plus large mais peut entraîner un sous-apprentissage.

  • Gamma: Contrôle l'influence de chaque point d'entraînement sur la construction de la frontière de décision. Un gamma élevé donne plus d'importance aux points d'entraînement proches, ce qui peut entraîner une frontière de décision plus complexe et un surajustement, tandis qu'un gamma faible prend en compte un plus grand nombre de points d'entraînement et produit une frontière de décision plus lisse.

3. Apprentissage du modèle SVM

• Entraînement du modèle: Utiliser l'ensemble d'entraînement pour apprendre le modèle SVM en trouvant l'hyperplan optimal qui maximise la marge et minimise les erreurs de classification.

• Identification des vecteurs supports: Les vecteurs supports sont les points d'entraînement situés sur les marges ou qui violent la marge. Ils jouent un rôle crucial dans la définition de la frontière de décision.

4. Optimisation des hyperparamètres

• Validation croisée (Cross-validation): Utiliser la validation croisée sur l'ensemble de validation pour évaluer les performances du modèle avec différentes combinaisons d'hyperparamètres (C, gamma, noyau). Cela permet de sélectionner les hyperparamètres qui donnent les meilleures performances sur des données non vues.

• Recherche sur grille (GridSearchCV): Une méthode courante pour la validation croisée et l'optimisation des hyperparamètres. GridSearchCV teste systématiquement toutes les combinaisons d'hyperparamètres spécifiées dans une grille prédéfinie et sélectionne la meilleure combinaison en fonction d'une métrique d'évaluation choisie (ex: accuracy, F1-score).

5. Évaluation du modèle

• Prédiction sur l'ensemble de test: Une fois les hyperparamètres optimisés, utiliser le modèle entraîné pour prédire les classes de l'ensemble de test.

• Évaluation des performances: Calculer les métriques d'évaluation appropriées (matrice de confusion, accuracy, precision, recall, F-score, AUC, etc.) pour évaluer la performance du modèle sur des données non vues et choisir le modèle avec les meilleures performances globales.

6. Déploiement et utilisation du modèle

• Déployer le modèle: Intégrer le modèle entraîné dans un système réel pour effectuer des prédictions sur de nouvelles données.

• Surveillance et maintenance du modèle: Surveiller les performances du modèle dans le temps et le réentraîner si nécessaire avec de nouvelles données pour maintenir sa précision et sa pertinence.

Remarques importantes

• Noyau linéaire vs noyau non-linéaire: Si les données sont linéairement séparables, un noyau linéaire est suffisant. Sinon, un noyau non-linéaire (polynomial, RBF) est nécessaire pour transformer les données dans un espace de plus grande dimension où la séparation linéaire est possible.

• Compromis biais-variance: Le choix des hyperparamètres (C, gamma) influence le compromis biais-variance. Un modèle avec un biais élevé est trop simple et ne capture pas la complexité des données (sous-apprentissage), tandis qu'un modèle avec une variance élevée est trop complexe et s'ajuste trop aux données d'entraînement (surajustement). L'optimisation des hyperparamètres permet de trouver un équilibre entre biais et variance.

Préparation à l'examen

Pour se préparer à l'examen, assurez-vous de:

• Comprendre le principe de fonctionnement des SVMs et leur objectif.

• Connaître les différents types de SVMs (à marge dure et souple).

• Savoir comment le Kernel Trick permet de gérer les données non linéaires.

• Identifier les noyaux courants et leurs applications.

• Pouvoir implémenter et évaluer un modèle SVM en Python en utilisant Scikit Learn.

• Comprendre l'importance de la recherche sur grille pour optimiser les hyperparamètres.

L'algorithme K-means

Résumé du Cours

Introduction au clustering:

• Apprentissage non supervisé: Découvrir des structures cachées dans les données sans labels.

• Clustering: Regrouper des données similaires en groupes (clusters).

K-means:

• Algorithme de clustering par partitionnement: Divise les données en K clusters.

• Distance: Utilise une mesure de distance (ex: euclidienne) pour évaluer la similarité entre les points de données.

• Centroides: Chaque cluster est représenté par un point central (centroïde).

Fonctionnement de K-means:

1. Initialisation: Choisir aléatoirement K points de données comme centroïdes initiaux.

2. Affectation: Affecter chaque point de données au cluster dont le centroïde est le plus proche.

3. Mise à jour: Calculer les nouveaux centroïdes des clusters en fonction des points qui leur sont affectés.

4. Répéter les étapes 2 et 3 jusqu'à ce que les centroïdes ne bougent plus ou qu'un nombre maximal d'itérations soit atteint.

Qualité d'un clustering:

• Compacité: Les points d'un même cluster doivent être proches les uns des autres.

• Séparation: Les clusters doivent être bien distincts les uns des autres.

• Mesures de qualité: Within-cluster sum of squares (WCSS), silhouette score, etc.

Choix du nombre de clusters (K):

• Méthodes: Elbow method, silhouette analysis, gap statistic, etc.

Avantages de K-means:

• Simple à comprendre et à implémenter.

• Relativement rapide.

• Fonctionne bien pour les grands ensembles de données.

Inconvénients de K-means:

• Sensible aux valeurs aberrantes (outliers).

• Le nombre de clusters (K) doit être spécifié à l'avance.

• Les résultats peuvent varier en fonction de l'initialisation des centroïdes.

• Difficulté à gérer les clusters de formes et de densités différentes.

Étapes pour construire un modèle K-means

K-means est un algorithme de clustering de partitionnement qui vise à regrouper des points de données similaires en K clusters distincts. Voici les étapes pour construire un modèle K-means:

1. Préparation des données:

• Collecte et exploration des données: Rassembler les données à analyser, qui doivent être composées de features numériques. Examiner les données pour comprendre leur structure, les types de features et identifier les valeurs manquantes ou aberrantes.

• Nettoyage et prétraitement des données: Gérer les valeurs manquantes (imputation ou suppression), traiter les valeurs aberrantes (remplacement ou suppression), et mettre à l'échelle les features (standardisation, normalisation) pour éviter que des features avec des échelles différentes n'influencent de manière disproportionnée le calcul de la distance.

2. Choix du nombre de clusters (K):

• Méthodes heuristiques:

  • Méthode Elbow: Tracer la somme des distances au carré entre chaque point et le centre de son cluster (inertie) en fonction de K. Choisir le K au niveau du "coude" de la courbe, là où l'inertie commence à diminuer moins rapidement.

  • Silhouette score: Mesurer la similarité d'un point à son propre cluster par rapport aux autres clusters. Un score plus élevé indique une meilleure clustering.

• Connaissance du domaine: Utiliser des informations préalables sur les données pour guider le choix de K.

3. Initialisation des centres de clusters:

• Initialisation aléatoire: Sélectionner aléatoirement K points de données comme centres de clusters initiaux.

• K-means++: Une méthode d'initialisation plus robuste qui sélectionne les centres de clusters initiaux de manière plus stratégique pour éviter les optima locaux.

4. Assignation des points aux clusters:

• Calculer la distance: Pour chaque point de données, calculer la distance euclidienne (ou une autre mesure de distance) par rapport à chaque centre de cluster.

• Assigner au cluster le plus proche: Assigner chaque point de données au cluster dont le centre est le plus proche.

5. Mise à jour des centres de clusters:

• Calculer le nouveau centre: Pour chaque cluster, calculer la moyenne de tous les points de données qui lui sont assignés. Ce point moyen devient le nouveau centre du cluster.

6. Répéter les étapes 4 et 5 jusqu'à convergence:

• Critère de convergence: L'algorithme a convergé lorsque l'assignation des points aux clusters ne change plus ou que la variation des centres de clusters est inférieure à un seuil défini.

7. Évaluation du modèle (optionnel):

• Interprétation des clusters: Examiner les caractéristiques des points de données dans chaque cluster pour interpréter leur signification et identifier des motifs dans les données.

• Metrics de performance (si labels disponibles): Si les données sont étiquetées, utiliser des métriques telles que l'indice de Rand ajusté (ARI) ou le score de pureté pour évaluer la qualité de la clustering.

Remarques importantes:

• K-means est sensible à l'initialisation des centres de clusters. Plusieurs exécutions de l'algorithme avec des initialisations différentes peuvent être nécessaires pour trouver une solution optimale.

• L'algorithme suppose que les clusters sont de forme sphérique et de taille similaire. Il peut ne pas fonctionner correctement avec des données contenant des clusters de formes complexes ou de densités très différentes.

• Le choix de K est crucial pour obtenir des résultats significatifs.

TP5: Implémentation de K-means

Partie 1: Clustering avec K-means:

1. Importation des librairies: Seaborn, Matplotlib.

2. Création de données: Générer des données synthétiques avec make_blobs.

3. Visualisation des données: Afficher les données générées.

4. Création des clusters:

   • Instancier le modèle KMeans avec le nombre de clusters souhaité.

   • Entraîner le modèle avec fit.

   • Obtenir les labels des clusters avec labels_.

   • Obtenir les coordonnées des centroïdes avec cluster_centers_.

5. Visualisation des clusters: Afficher les données avec les clusters trouvés et les centroïdes.

Partie 2: Exploration de K-means:

1. Appliquer K-means au dataset "iris":

   • Charger le dataset "iris".

   • Appliquer K-means pour regrouper les données.

   • Visualiser les clusters et analyser les résultats.

2. Générer des données avec chevauchement:

   • Utiliser make_blobs pour générer des données avec des clusters qui se chevauchent.

   • Appliquer K-means et observer les résultats.

3. Explorer les limitations de K-means:

   • Identifier les cas où K-means ne parvient pas à trouver les clusters optimaux (ex: clusters de formes différentes).

Préparation à l'examen

Pour se préparer à l'examen, assurez-vous de:

• Comprendre les concepts de base du clustering et l'objectif de K-means.

• Connaître les étapes de l'algorithme K-means et son fonctionnement.

• Savoir comment choisir le nombre de clusters (K).

• Pouvoir interpréter les résultats d'un clustering K-means.

• Connaître les avantages et les inconvénients de K-means.

• Savoir implémenter K-means en Python avec Scikit Learn.