Premiers pas avec Scikit-learn pour la classification dans l'apprentissage automatique

Republié par Platon

Suiveurs: 0

Premiers pas avec Scikit-learn pour la classification dans l'apprentissage automatique

Image par l'éditeur

Scikit-learn est l'une des bibliothèques d'apprentissage automatique les plus utilisées construites en python. Sa popularité peut être attribuée à sa structure de code simple et cohérente, conviviale pour les développeurs débutants. En outre, un haut niveau de support est disponible ainsi qu'une flexibilité pour intégrer des fonctionnalités tierces, ce qui rend la bibliothèque robuste et adaptée à la production. La bibliothèque contient plusieurs modèles d'apprentissage automatique pour la classification, la régression et le clustering. Dans ce tutoriel, nous allons explorer le problème de la classification multiclasse à travers différents algorithmes. Plongeons-y directement et construisons nos modèles scikit-learn.

pip install scikit-learn

Nous utiliserons le jeu de données « Wine » disponible dans le module de jeux de données de scikit-learn. Cet ensemble de données comprend 178 échantillons et 3 classes au total. L'ensemble de données est déjà prétraité et converti en vecteurs de caractéristiques, nous pouvons donc l'utiliser directement pour former nos modèles.

from sklearn.datasets import load_wine X, y = load_wine(return_X_y=True)

Nous conserverons 67 % des données pour la formation et les 33 % restants pour les tests.

from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.33, random_state=42
)

Maintenant, nous allons expérimenter 5 modèles différents de complexités différentes et évaluer leurs résultats sur notre ensemble de données.

model_lr = LogisticRegression()
model_lr.fit(X_train, y_train)
y_pred_lr = model_lr.predict(X_test) print("Accuracy Score: ", accuracy_score(y_pred_lr, y_test))
print(classification_report(y_pred_lr, y_test))

Sortie

Accuracy Score: 0.9830508474576272 precision recall f1-score support 0 1.00 0.95 0.98 21 1 0.96 1.00 0.98 23 2 1.00 1.00 1.00 15 accuracy 0.98 59 macro avg 0.99 0.98 0.98 59
weighted avg 0.98 0.98 0.98 59

model_knn = KNeighborsClassifier(n_neighbors=1)
model_knn.fit(X_train, y_train)
y_pred_knn = model_knn.predict(X_test) print("Accuracy Score:", accuracy_score(y_pred_knn, y_test))
print(classification_report(y_pred_knn, y_test))

Sortie

Accuracy Score: 0.7796610169491526 precision recall f1-score support 0 0.90 0.78 0.84 23 1 0.75 0.82 0.78 22 2 0.67 0.71 0.69 14 accuracy 0.78 59 macro avg 0.77 0.77 0.77 59
weighted avg 0.79 0.78 0.78 59

En changeant le paramètre 'n_neighbors=2' on observe une diminution de la valeur de précision. Par conséquent, cela montre que les données sont suffisamment simples et permettent un meilleur apprentissage avec un seul voisin à considérer.

Sortie

Accuracy Score: 0.6949152542372882 precision recall f1-score support 0 0.90 0.72 0.80 25 1 0.75 0.69 0.72 26 2 0.33 0.62 0.43 8 accuracy 0.69 59 macro avg 0.66 0.68 0.65 59
weighted avg 0.76 0.69 0.72 59

from sklearn.naive_bayes import GaussianNB model_nb = GaussianNB()
model_nb.fit(X_train, y_train)
y_pred_nb = model_nb.predict(X_test) print("Accuracy Score:", accuracy_score(y_pred_nb, y_test))
print(classification_report(y_pred_nb, y_test))

Sortie

Accuracy Score: 1.0 precision recall f1-score support 0 1.00 1.00 1.00 20 1 1.00 1.00 1.00 24 2 1.00 1.00 1.00 15 accuracy 1.00 59 macro avg 1.00 1.00 1.00 59
weighted avg 1.00 1.00 1.00 59

from sklearn.tree import DecisionTreeClassifier model_dtclassifier = DecisionTreeClassifier()
model_dtclassifier.fit(X_train, y_train)
y_pred_dtclassifier = model_dtclassifier.predict(X_test) print("Accuracy Score:", accuracy_score(y_pred_dtclassifier, y_test))
print(classification_report(y_pred_dtclassifier, y_test))

Sortie

Accuracy Score: 0.9661016949152542 precision recall f1-score support 0 0.95 0.95 0.95 20 1 1.00 0.96 0.98 25 2 0.93 1.00 0.97 14 accuracy 0.97 59 macro avg 0.96 0.97 0.97 59
weighted avg 0.97 0.97 0.97 59

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import RandomizedSearchCV def get_best_parameters(): params = { "n_estimators": [10, 50, 100], "max_features": ["auto", "sqrt", "log2"], "max_depth": [5, 10, 20, 50], "min_samples_split": [2, 4, 6], "min_samples_leaf": [2, 4, 6], "bootstrap": [True, False], } model_rfclassifier = RandomForestClassifier(random_state=42) rf_randomsearch = RandomizedSearchCV( estimator=model_rfclassifier, param_distributions=params, n_iter=5, cv=3, verbose=2, random_state=42, ) rf_randomsearch.fit(X_train, y_train) best_parameters = rf_randomsearch.best_params_ print("Best Parameters:", best_parameters) return best_parameters parameters_rfclassifier = get_best_parameters() model_rfclassifier = RandomForestClassifier( **parameters_rfclassifier, random_state=42
) model_rfclassifier.fit(X_train, y_train) y_pred_rfclassifier = model_rfclassifier.predict(X_test) print("Accuracy Score:", accuracy_score(y_pred_rfclassifier, y_test))
print(classification_report(y_pred_rfclassifier, y_test))

Sortie


Best Parameters: {'n_estimators': 100, 'min_samples_split': 6, 'min_samples_leaf': 4, 'max_features': 'log2', 'max_depth': 5, 'bootstrap': True}
Accuracy Score: 0.9830508474576272 precision recall f1-score support 0 1.00 0.95 0.98 21 1 0.96 1.00 0.98 23 2 1.00 1.00 1.00 15 accuracy 0.98 59 macro avg 0.99 0.98 0.98 59
weighted avg 0.98 0.98 0.98 59

Dans cet algorithme, nous avons effectué quelques réglages d'hyperparamètres pour obtenir la meilleure précision. Nous avons défini une grille de paramètres composée de plusieurs valeurs parmi lesquelles choisir pour chaque paramètre. De plus, nous avons utilisé l'algorithme Randomized Search CV pour rechercher le meilleur espace de paramètres pour le modèle. Enfin, nous transmettons les paramètres obtenus au classifieur et formons le modèle.

Des modèles photo	Précision	Observations
Régression logistique	98.30%	Atteint une grande précision. Le modèle est capable de bien généraliser sur l'ensemble de données de test.
Les voisins les plus proches	77.96%	L'algorithme n'est pas capable d'apprendre correctement la représentation des données.
Naïf Bayes	100%	Le modèle est moins complexe, il surajuste donc les données pour obtenir une précision absolue.
Classificateur d'arbre de décision	96.61%	Atteint une précision décente.
Classificateur de forêt aléatoire	98.30%	Étant une approche basée sur l'ensemble, elle fonctionne mieux que l'arbre de décision. Le réglage des hyperparamètres lui permet d'atteindre une précision similaire à la régression logistique.

Dans ce didacticiel, nous avons appris comment commencer à créer et entraîner des modèles d'apprentissage automatique dans scikit-learn. Nous avons implémenté et évalué quelques algorithmes pour avoir une idée de base de leurs performances. On peut toujours adopter des stratégies avancées pour l’ingénierie des fonctionnalités, le réglage des hyperparamètres ou la formation pour améliorer les performances. Pour en savoir plus sur les fonctionnalités offertes par scikit-learn, rendez-vous sur la documentation officielle - Introduction à l'apprentissage automatique avec scikit-learn, Machine Learning en Python avec scikit-learn.

Yesha Shastri est un développeur et écrivain passionné d'intelligence artificielle qui poursuit une maîtrise en apprentissage automatique à l'Université de Montréal. Yesha est intriguée à l'idée d'explorer des techniques d'IA responsables pour résoudre des défis qui profitent à la société et partager ses apprentissages avec la communauté.