L’utilisation croissante des modèles de Machine Learning a rendu le processus d’analyse de données beaucoup plus facile et moins chaotique lorsqu’il s’agit d’extraire et de traiter des ensembles de données complexes.
Les Data Engineers et les développeurs utilisent désormais lee Machine Learning pour prendre des décisions plus précises et plus sûres. La popularité croissante des algorithmes de Machine Learning s’accompagne d’une demande croissante d’outils efficaces et polyvalents tels que Scikit-Learn. La connaissance de cette bibliothèque est devenue une exigence essentielle pour les Data Scientists professionnels et les ingénieurs en Machine Learrning.
Scikit-Learn répond aux besoins des débutants dans le domaine ainsi qu’à ceux qui résolvent des problèmes d’apprentissage supervisé. Dans cet article, nous verrons ce qu’est Scikit-Learn, ses principales fonctionnalités et applications, et nous expliquerons comment cette bibliothèque fonctionne en pratique à l’aide d’exemples tirés du monde réel.
Apprentissage du Machine Learning par la pratique
« Machine Learning avec Scikit-Learn – 3e éd.: Mise en oeuvre et cas concrets » est un excellent ouvrage pour tous ceux qui s’intéressent au Machine Learning. Il couvre à la fois les aspects théoriques et pratiques du Machine Learning, offrant une compréhension complète du domaine.
Le livre utilise des exemples clairs, dont beaucoup sont tirés du texte, et des exercices pratiques pour aider les lecteurs à appliquer les concepts et les techniques dans des scénarios du monde réel. Il s’agit d’un ouvrage incontournable pour tous ceux qui cherchent à construire des systèmes intelligents et à se tenir au courant des derniers développements dans le domaine du Machine Learning.
Qu’est-ce que Scikit-Learn ?
Scikit-Learn est une bibliothèque libre et gratuite pour le Machine Learning en Python. Elle fournit une sélection efficace de ressources pour la modélisation statistique, l’analyse et l’exploitation des données, ainsi qu’un support pour l’apprentissage supervisé et non supervisé. Considérée comme l’une des solutions les plus polyvalentes et les plus populaires du marché, elle est construite sur l’interaction avec d’autres bibliothèques Python, notamment NumPy, SciPy et Matplotlib.
Avec des outils pour l’ajustement, la sélection et l’évaluation de modèles, ainsi que pour le pré-traitement des données, Scikit-Learn est considérée comme la bibliothèque la plus utile et la plus robuste pour le Machine Learning en Python.
En tant que bibliothèque de haut niveau, elle permet de définir des modèles de données prédictifs en quelques lignes de code seulement. Si tu cherches une introduction au Machine learning, Scikit-Learn est bien documentée et relativement facile à apprendre et à utiliser.
Parmi les principaux algorithmes disponibles dans la bibliothèque, citons :
1. Régression Linéaire
La régression linéaire est utilisée dans divers domaines, tels que la prévision de ventes, l’analyse de tendances et la prédiction de prix.
Il s’agit d’un modèle qui cherche à établir une relation linéaire entre les variables indépendantes et la variable dépendante continue. L’objectif de la régression linéaire est de trouver l’équation qui décrit le mieux la relation entre les variables, afin de prédire les valeurs de la variable dépendante pour de nouvelles valeurs de la variable indépendante.
L’équation de la régression linéaire est une droite qui représente la relation entre les variables. Il est possible de trouver la meilleure droite de régression en utilisant la méthode des moindres carrés, qui minimise la somme des carrés des différences entre les prédictions de la droite et les valeurs réelles de la variable dépendante.
Par exemple, elle peut être utilisée pour prédire le prix d’une maison en fonction de ses caractéristiques, telles que la superficie, le nombre de pièces et l’emplacement, ou pour prédire les ventes d’un produit en fonction de l’investissement dans la publicité et de la période de l’année.
from sklearn.linear_model import LinearRegression
import pandas as pd
# Chargement du jeu de données
data = pd.read_csv("house_prices.csv")
# sépare les variables indépendantes (features) et dépendantes (prix)
X = data.drop("price", axis=1)
y = data["price"]
# crée le moddèle de régression linéaire
model = LinearRegression()
# ajuste le modèle saux donnée d'apprentissage
model.fit(X, y)
# effectue une prédiction pour un nouvel ensemble de features
new_house= [[1500, 3, 2]] # superficie, nb de pièces, nb de salles de bains
price= model.predict(nova_casa)
print("Prix attendu pour la nouvelle maison : ", price)Il est important de se rappeler qu’il est nécessaire d’effectuer une analyse exploratoire des données et de les pré-traiter correctement avant d’appliquer un modèle de Machine Learning.
En outre, il existe de nombreuses autres techniques et modèles de régression disponibles dans la bibliothèque, chacun ayant ses propres avantages et inconvénients.
La régression linéaire peut également être étendue aux modèles de régression multiple, qui incluent plus d’une variable indépendante, ou aux modèles de régression non linéaire, qui utilisent d’autres formes d’équations pour modéliser la relation entre les variables.
2. Régression Logistique
La régression logistique est un algorithme d’apprentissage supervisé utilisé pour les problèmes de classification binaire, tels que la détection de spam, la prédiction de l’admission à une université sur la base d’un ensemble d’attributs ou la détection de la fraude à la carte de crédit.
Il est utilisé pour trouver la relation entre une ou plusieurs variables indépendantes et la probabilité qu’une classe particulière soit choisie.
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
# charger le dataset iris
iris = load_iris()
# diviser l'ensemble de données en 2 ensembles : entraînement et test
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.3)
# créer le modèle de régression logistique
logreg = LogisticRegression()
# ajuster le modèle aux données d'apprentissage
logreg.fit(X_train, y_train)
# prédire les valeurs cibles pour les données de test
y_pred = logreg.predict(X_test)
# imprimer le score d'exactitude (accuracy) du modèle
print("Accuracy : ", logreg.score(X_test, y_test))Ce code charge l’ensemble de données iris, le divise en ensembles d’entraînement et de test, crée un modèle de régression logistique, ajuste le modèle aux données d’apprentissage et prédit les valeurs cibles pour les données de test. Enfin, il imprime le score de précision du modèle.
La régression logistique peut également être étendue aux problèmes de classification multiclasse à l’aide d’une approche appelée « One-vs-All », dans laquelle plusieurs régressions logistiques sont entraînées pour chaque classe, puis la classe ayant la probabilité la plus élevée est choisie.
3. Decision Tree
Un arbre de décision peut être utilisé pour déterminer le diagnostic d’une maladie sur la base des symptômes, des antécédents médicaux et des résultats des tests, pour prédire des achats sur la base du comportement de navigation sur le web ou pour évaluer la solvabilité d’un candidat sur la base de ses informations financières et professionnelles.
Les arbres de décision sont construits à partir d’un ensemble de données d’entraînement, où chaque nœud de l’arbre pose une question sur un attribut de l’ensemble de données, et la réponse détermine le chemin à suivre. À la fin de l’arbre, chaque feuille représente une classe ou une valeur de régression.
Pour construire l’arbre, l’algorithme divise récursivement les données en sous-ensembles plus petits sur la base de critères d’impureté, tels que l’entropie ou l’indice de Gini, jusqu’à ce que tous les échantillons d’un nœud appartiennent à la même classe ou présentent une valeur homogène pour une variable de régression.
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
# charger le dataset iris
iris = load_iris()
# séparer les caractéristiques (variables indépendantes) et la cible (variable dépendante)
X = iris.data
y = iris.target
# créer un classificateur Decision Tree
clf = DecisionTreeClassifier()
# ajuster le modèle aux données
clf.fit(X, y)
# utiliser le modèle pour faire des prédictions
new_observation = [[5.2, 3.1, 4.2, 1.5]] # une nouvelle observation à prédire
prediction = clf.predict(new_observation)
print("Prédiction pour la nouvelle observation : ", prediction)Ce code utilise la fonction load_iris de scikit-learn pour charger le célèbre ensemble de données Iris, qui consiste en 150 observations de fleurs d’iris, avec quatre caractéristiques pour chaque observation (longueur du sépale, largeur du sépale, longueur du pétale et largeur du pétale), et une variable cible indiquant l’espèce de chaque fleur (setosa, versicolor ou virginica).
Le code sépare ensuite les caractéristiques et la cible de l’ensemble de données et crée un objet DecisionTreeClassifier, qui est ajusté aux données à l’aide de la méthode fit. Enfin, une nouvelle observation est utilisée pour effectuer une prédiction à l’aide de la méthode predict, et le résultat est imprimé sur la console.
4. Random Forest
Random Forest est utilisé dans divers problèmes de classification et de régression, tels que la prévision de ventes, l’analyse de sentiments, la détection de fraudes, le diagnostic médical et bien d’autres.
Cet algorithme utilise plusieurs arbres de décision pour effectuer la classification ou la régression de données avec différents sous-ensembles aléatoires de variables d’entrée, et en combinant les prédictions de chaque arbre pour produire une prédiction unique.
Chaque arbre de la forêt aléatoire est construit à l’aide d’une technique d’échantillonnage aléatoire des données d’entraînement, où chaque arbre est entraîné sur un sous-ensemble aléatoire des données d’entrée. Ce processus est connu sous le nom de « bagging » et permet d’éviter l’ajustement excessif (overfitting), car la forêt aléatoire dispose d’une grande variété de modèles pour prédire la réponse.
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
# générer un ensemble de données aléatoires
X, y = make_classification(n_features=4, random_state=0)
# créer un classificateur de RandomForest avec 100 estimateurs
rf = RandomForestClassifier(n_estimators=100, random_state=0)
# ajuster le modèle aux données
rf.fit(X, y)
# prédire la classe d'une nouvelle observation
new_observation = [[-2, 2, -1, 1]]
print("Predicted class:", rf.predict(new_observation))Ce code génère un ensemble de données aléatoires, crée un objet RandomForestClassifier avec 100 estimateurs, ajuste le modèle aux données et prédit la classe d’une nouvelle observation.
Le principal avantage de Random Forest c’est sa capacité à traiter des problèmes complexes et de haute dimension, produisant des prédictions précises même sur des ensembles de données comportant de nombreuses features. En outre, elle permet d’interpréter les résultats, car il est possible d’évaluer l’importance relative de chaque variable dans la prise de décision.
5. Support Vector Machines
Les SVMs sont un algorithme supervisé puissant pour la classification et peuvent être utilisés dans une variété d’applications, telles que la classification d’images, la classification de textes, la détection de fraudes, le diagnostic médical, la reconnaissance de formes, entre autres.
L’algorithme consiste à trouver l’hyperplan qui sépare le mieux les classes de données d’entrée. L’hyperplan est défini comme la surface qui maximise la distance entre les deux classes, appelée marge.
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn import svm
# charger le dataset iris
iris = datasets.load_iris()
# diviser l'ensemble de données en ensembles d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.3, random_state=42)
# créer un classificateur SVM avec un noyau linéaire
clf = svm.SVC(kernel='linear')
# entraîner le classificateur SVM sur l'ensemble d'entraînement
clf.fit(X_train, y_train)
# faire des prédictions sur l'ensemble de test
y_pred = clf.predict(X_test)
# imprimer l'accuracy du classificateur
accuracy = clf.score(X_test, y_test)
print("Accuracy : ", accuracy)Dans cet exemple, nous chargeons d’abord l’ensemble de données sur les iris et nous le divisons en deux ensembles, l’un pour l’entraînement et l’autre pour le test.
Nous créons ensuite un classificateur SVM avec un noyau linéaire et nous l’entraînons sur l’ensemble d’entraînement. Enfin, nous effectuons des prédictions sur l’ensemble de test et imprimons la précision du classificateur.
Le principal avantage des SVMs c’est leur capacité à séparer les classes avec une dimensionnalité élevée et des données non linéaires. En outre, les SVMs sont relativement robustes aux valeurs aberrantes et ont la capacité de traiter des problèmes avec un grand nombre de variables indépendantes. Toutefois, le choix du noyau et des paramètres peut constituer un défi, et le temps d’apprentissage peut être plus long que pour d’autres algorithmes de classification.
6. Naive Bayes
Naive Bayes est un algorithme de Machine Learning supervisé utilisé dans les problèmes de classification et d’analyse de texte. Il repose sur le théorème de Bayes et sur l’hypothèse d’indépendance conditionnelle entre les variables d’entrée (x).
L’algorithme suppose que chaque variable d’entrée est indépendante des autres, ce qui signifie que la présence ou l’absence d’une feature particulière n’affecte pas la probabilité de la présence ou de l’absence d’autres caractéristiques.
Naive Bayes est utilisé dans diverses applications telles que l’analyse des sentiments, la catégorisation des textes, la détection des spams, la classification des documents, entre autres. Il est particulièrement efficace dans les problèmes comportant de nombreuses variables indépendantes, où d’autres algorithmes de Machine Learning peuvent ne pas être en mesure de gérer la haute dimensionnalité.
from sklearn.naive_bayes import GaussianNB
import numpy as np
# données d'entraînement
X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])
Y = np.array([1, 1, 1, 2, 2, 2])
# créer un classificateur Naive Bayes et l'adapter aux données
clf = GaussianNB()
clf.fit(X, Y)
# faire une prédiction pour un nouveau point de données
new_point = [[0, 0]]
prediction = clf.predict(new_point)
print("Prediction:", prediction)Dans cet exemple, nous utilisons le classificateur gaussien Naive Bayes pour classer les points de données dans l’une des deux classes. Nous créons un ensemble de données d’entraînement avec deux features (coordonnées x et y) et leurs étiquettes de classe correspondantes, puis nous adaptons le classificateur à ces données. Enfin, nous faisons une prédiction pour un nouveau point de données dont les coordonnées sont (0, 0). Le classificateur prédit que ce nouveau point de données appartient à la classe 1.
Naive Bayes est rapide, efficace et facile à mettre en œuvre. Il nécessite un ensemble d’entraînement relativement petit pour estimer les probabilités des données d’entrée et de sortie, et peut traiter des données catégorielles ou numériques. L’un des inconvénients de Naive Bayes est l’hypothèse d’indépendance conditionnelle, qui peut ne pas être réaliste dans certains cas.
7. k-Nearest Neighbors
KNN est un algorithme de Machine Learning supervisé utilisé dans les problèmes de classification et de régression. L’algorithme consiste à trouver les K plus proches voisins d’un nouveau point de données d’entrée, à partir d’un ensemble de données d’apprentissage. Ensuite, l’algorithme classifie le nouveau point de données en fonction de la classe majoritaire des K plus proches voisins.
La valeur de K est un hyperparamètre qui peut être ajusté pour améliorer la précision de l’algorithme. Une petite valeur de K peut entraîner une classification plus sensible au bruit dans l’ensemble de données, tandis qu’une grande valeur de K peut lisser les limites de décision et réduire l’effet du bruit.
Le KNN est utilisé dans diverses applications, telles que la reconnaissance des formes, l’analyse d’images, la détection d’anomalies, la recommandation de produits, entre autres. Il est particulièrement utile pour les problèmes comportant peu de variables indépendantes et une grande quantité de données d’apprentissage.
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
# charger le dataset iris
iris = load_iris()
# diviser l'ensemble de données en ensembles d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.3)
# créer un classificateur kNN avec k=3
knn = KNeighborsClassifier(n_neighbors=3)
# adapter le classificateur aux données d'apprentissage
knn.fit(X_train, y_train)
# prédire les classes de l'ensemble de test
y_pred = knn.predict(X_test)
# imprimer l'accuracy du classificateur
accuracy = knn.score(X_test, y_test)
print("Accuracy : ", accuracy)Ce code charge l’ensemble de données iris, le divise en ensembles d’entraînement et de test, crée un classificateur kNN avec k=3, ajuste le classificateur aux données d’entraînement, puis prédit les classes de l’ensemble de test. Enfin, il imprime la précision du classificateur sur l’ensemble de test.
L’un des principaux inconvénients du KNN est la nécessité de stocker toutes les données d’entraînement, ce qui peut rendre l’algorithme lent et consommer beaucoup de mémoire sur de grands ensembles de données. En outre, le choix de la valeur de K peut constituer un défi, et l’algorithme peut avoir des difficultés à traiter des données d’entrée comportant de nombreuses variables indépendantes.
8. Gradient Boosting
Le Gradient Boosting est utilisé dans diverses applications, telles que la prévision de séries temporelles, la détection de fraudes, la classification d’images, entre autres.
Il est particulièrement utile dans les problèmes de données à haute dimension et avec un large éventail de features, comme c’est souvent le cas dans les problèmes d’analyse de texte.
Le Gradient Boosting présente de nombreux avantages, tels qu’une grande précision et la capacité de traiter des ensembles de données complexes. Il s’agit d’un algorithme très flexible qui peut être utilisé avec un large éventail de fonctions de perte et d’apprentissage. L’algorithme est également capable de traiter des données catégoriques et manquantes.
from sklearn.datasets import make_classification
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# générer un ensemble de données de classification binaire aléatoire
X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, random_state=42)
# diviser les données en ensembles d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# créer un classificateur de type "gradient boosting" avec des paramètres par défaut
clf = GradientBoostingClassifier()
# entraîner le modèle sur les données d'entraînement
clf.fit(X_train, y_train)
# faire des prédictions sur les données de test
y_pred = clf.predict(X_test)
# calculer l'exactitude du modèle
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy : ", accuracy)Dans cet exemple, nous commençons par générer un ensemble de données de classification binaire aléatoire à l’aide de la fonction make_classification de scikit-learn.
Nous divisons ensuite les données en ensembles d’entraînement et de test à l’aide de la fonction train_test_split.
Ensuite, nous créons un classificateur GradientBoostingClassifier avec des paramètres par défaut, nous l’ajustons sur les données d’entraînement et nous faisons des prédictions sur les données de test.
Enfin, nous calculons la précision du modèle à l’aide de la fonction accuracy_score de scikit-learn.
Cependant, l’implémentation du Gradient Boosting peut être complexe, et le réglage des paramètres peut être difficile. En outre, l’algorithme peut être lent sur de grands ensembles de données et peut avoir du mal à gérer des données déséquilibrées.
9. Réseaux de neurones artificiels (ANNs)
Les réseaux de neurones artificiels (Artificial Neural Networks – ANNs) sont des algorithmes de Machine Learning inspirés du fonctionnement du cerveau humain. Ils sont composés de plusieurs couches de neurones interconnectés capables d’apprendre à partir de données et d’effectuer des tâches telles que la classification, la régression et la reconnaissance de formes, entre autres.
Chaque neurone d’un ANN reçoit un ensemble d’entrées, applique une transformation non linéaire et produit une sortie. Les couches de neurones d’un ANN sont organisées en une architecture, qui peut être de différents types, comme entièrement connectée, convolutive, récurrente, etc.
Les ANNs sont utilisés dans diverses applications d’apprentissage automatique, telles que la reconnaissance vocale, la reconnaissance d’images, le traitement du langage naturel, etc. Ils peuvent être particulièrement utiles dans les tâches qui impliquent des données non linéaires et de haute dimension.
from sklearn.neural_network import MLPClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
# charger le dataset
data = load_iris()
# diviser les données en ensembles d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(data.data, data.target, random_state=1)
# créer le modèle de réseau de neurones
model = MLPClassifier(hidden_layer_sizes=(10,))
# entraîner le modèle sur les données d'entraînement
model.fit(X_train, y_train)
# évaluer le modèle sur les données de test
accuracy = model.score(X_test, y_test)
print("Accuracy : ", accuracy)Dans cet exemple, nous chargeons l’ensemble de données des iris et le divisons en ensembles d’entraînement et de test.
Nous créons ensuite un modèle MLPClassifier avec une seule couche cachée de 10 neurones et nous l’entraînons sur les données d’apprentissage.
Enfin, nous évaluons la précision du modèle sur les données de test.
Cependant, les ANNs peuvent être très gourmands en ressources informatiques et nécessitent de grandes quantités de données pour l’apprentissage. Le choix de l’architecture et des paramètres appropriés est essentiel pour obtenir de bonnes performances, et l’interprétabilité des résultats peut constituer un défi. En outre, les ANNs peuvent souffrir d’un sur-apprentisssage (overfitting) dans des ensembles de données petits ou complexes, et il peut être difficile d’expliquer comment les décisions sont prises.
10. Analyse en composantes principales
L’analyse en composantes principales (Principal Component Analysis – PCA) est une technique de réduction de la dimensionnalité utilisée pour identifier les principales variables d’un ensemble de données.
Elle permet de trouver un sous-ensemble de variables qui expliquent la majeure partie de la variabilité des données d’origine. La PCA cherche à transformer un ensemble de variables corrélées en un nouvel ensemble de variables non corrélées, appelées composantes principales.
La PCA est largement utilisée dans les applications de Machine Learning, en particulier dans le pré-traitement des données et l’analyse exploratoire des données. Elle peut être utilisée pour identifier des patterns (= tendances ou modèles) dans les données, identifier les valeurs aberrantes, réduire la dimensionnalité des données et pour la visualisation de données dans des espaces à faible dimension.
from sklearn.datasets import load_iris
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt
# charger le dataset iris
iris = load_iris()
# appliquer la PCA à l'ensemble de données
pca = PCA(n_components=2)
X_pca = pca.fit_transform(iris.data)
# tracer les deux premières composantes principales
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=iris.target)
plt.xlabel('Première composante principale')
plt.ylabel('Deuxième composante principale')
plt.show()Ce code charge le jeu de données des iris et applique la PCA pour réduire les données à seulement deux composantes principales.
Il trace ensuite ces deux composantes, colorées par l’espèce de l’iris. Il s’agit d’un exemple simple d’utilisation de PCA pour la réduction de la dimensionnalité et la visualisation.
L’un des principaux avantages de la PCA est qu’elle permet de réduire la dimensionnalité des données sans perdre beaucoup d’informations.
Cependant, l’interprétation des composantes principales peut s’avérer difficile, en particulier lorsque de nombreuses variables sont impliquées. En outre, la PCA suppose que les données d’origine sont normalement distribuées et linéairement corrélées, ce qui n’est pas toujours le cas.
11. Analyse discriminante linéaire
L’analyse discriminante linéaire (Linear Discriminant Analysis = LDA) est une technique de Machine Learning supervisée utilisée pour la classification des données.
Elle cherche à trouver une combinaison linéaire des variables indépendantes qui sépare au mieux les classes de données. La LDA suppose que les données sont normalement distribuées et que les covariances sont égales pour toutes les classes.
La LDA est souvent utilisée pour la réduction de la dimensionnalité, car elle peut être utilisée pour projeter les données dans un espace de dimension inférieure qui sépare au mieux les classes.
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis from sklearn.datasets import load_iris # charger le dataset iris iris = load_iris() # séparer les features X et la variable cible y X = iris.data y = iris.target # créer une instance de la classe LinearDiscriminantAnalysis lda = LinearDiscriminantAnalysis() # ajuster le modèle LDA aux données lda.fit(X, y) # transformer les données dans le nouveau système de coordonnées X_lda = lda.transform(X) # imprimer les trois premières lignes des données transformées print(X_lda[:3])
Dans ce code, nous chargeons l’ensemble de données des iris et séparons les features et la variable cible.
Ensuite, nous créons une instance de la classe LinearDiscriminantAnalysis, ajustons le modèle LDA aux données et transformons les données dans le nouveau système de coordonnées.
Enfin, nous imprimons les trois premières lignes des données transformées. L’analyse discriminante linéaire a été utilisée dans diverses applications, notamment la reconnaissance des patterns, le traitement des images et la détection des fraudes.
Cependant, la méthode LDA présente certaines limites, telles que l’hypothèse de normalité et d’égalité des covariances, qui peut ne pas s’appliquer à certains ensembles de données. En outre, la méthode LDA est moins robuste dans le cas de données comportant de nombreuses valeurs aberrantes ou déséquilibrées en termes de nombre d’échantillons par classe.
12. Clustering k-Means
La méthode K-Means est largement utilisée dans divers domaines tels que la segmentation de la clientèle, l’analyse d’images et le regroupement de documents.
Par exemple, il peut être utilisé pour regrouper des clients en différents segments sur la base de leurs caractéristiques d’achat, telles que l’âge, le sexe et l’historique d’achat, ou pour segmenter des images d’un champ d’étoiles en groupes d’étoiles présentant des caractéristiques similaires, telles que la luminosité et la couleur.
from sklearn.cluster import KMeans
import numpy as np
# créer des données d'exemple
X = np.array([[1, 2], [1, 4], [1, 0],
[4, 2], [4, 4], [4, 0]])
# créer un modèle KMeans avec 2 clusters
kmeans = KMeans(n_clusters=2)
# adapter le modèle aux données
kmeans.fit(X)
# imprimer les affectations des clusters
print(kmeans.labels_)Ce code crée un ensemble de données à deux dimensions et utilise KMeans pour classer les données en deux groupes. Les affectations de clusters résultantes sont imprimées sur la console.
L’une des principales limitations de la méthode k-means est la nécessité de prédéfinir le nombre de clusters (k) à trouver, ce qui peut s’avérer problématique dans certains cas.
En outre, les k-means supposent que les formes des clusters sont sphériques et que les variances entre les clusters sont égales, ce qui n’est pas toujours vrai dans la pratique. D’autres techniques de clustering, telles que le clustering hiérarchique, peuvent être plus adaptées dans certains cas.
Conclusion
Ce ne sont là que quelques exemples des algorithmes de Machine Learning disponibles dans la bibliothèque. Scikit-Learn offre également une variété d’utilitaires et de fonctions pour le pré-traitement et l’évaluation des modèles, ainsi que des fonctionnalités avancées telles que l’ajustement des hyperparamètres et les pipelines de flux de travail de Machine Learning.
En conclusion, Scikit-Learn est l’une des principales bibliothèques de Machine Learning en Python, offrant une large gamme d’algorithmes et d’outils pour la modélisation prédictive et l’analyse de données. Il est important de se rappeler que chaque algorithme a ses propres limites et hypothèses, il est donc important de choisir la technique appropriée pour le problème en question et de s’assurer que les données d’entrée répondent aux exigences de l’algorithme choisi.
