Scikit-learn est une bibliothèque Python open source qui simplifie le processus de création de modèles d'apprentissage automatique. Il offre une interface claire et cohérente qui aide les utilisateurs débutants et expérimentés à travailler efficacement.

• Prend en charge des tâches telles que le clustering de régression de classification et le prétraitement
• Rend la création de modèles rapide et fiable
• Fournit des outils prêts à l’emploi pour la formation et l’évaluation
• Réduit la complexité en évitant la mise en œuvre manuelle des algorithmes

Installation et utilisation de Scikit-learn

Avant de commencer à construire des modèles, nous devons installer Scikit-learn. Il nécessite Python 3.8 ou plus récent et dépend de deux bibliothèques importantes : NumPy et SciPy. Assurez-vous qu'ils sont installés en premier.

java essaie d'attraper

Pour installer Scikit-learn, exécutez la commande suivante :

pip install -U scikit-learn

Cela téléchargera et installera la dernière version de Scikit-learn ainsi que ses dépendances. Voyons les différentes étapes impliquées dans le processus de création d'un modèle à l'aide de la bibliothèque Scikit-learn.

Étape 1 : chargement d'un ensemble de données

Un ensemble de données se compose de :

• Caractéristiques (X) : Variables d'entrée qui décrivent les données
• Cible (y) : La valeur que nous voulons prédire

Scikit-learn fournit des ensembles de données intégrés tels que Iris Digits et Boston Housing. Utilisation de l'ensemble de données Iris :

• load_iris() charge les données
• X stocke les données des fonctionnalités
• y stocke les étiquettes cibles
• feature_names et target_names donnent des noms descriptifs

Nous pouvons inspecter les premières lignes pour comprendre la structure. Pour les ensembles de données personnalisés, Pandas est couramment utilisé pour charger des fichiers externes tels que des CSV.

from sklearn.datasets import load_iris iris = load_iris() X = iris.data y = iris.target feature_names = iris.feature_names target_names = iris.target_names print('Feature names:' feature_names) print('Target names:' target_names) print('nType of X is:' type(X)) print('nFirst 5 rows of X:n' X[:5]) 

Sortir: 

Parfois, nous devons travailler sur nos propres données personnalisées, puis nous chargeons un ensemble de données externe. Pour cela, nous pouvons utiliser le bibliothèque des pandas pour faciliter le chargement et la manipulation des ensembles de données.

Pour cela vous pouvez vous référer à notre article sur Comment importer un fichier CSV dans Pandas ?

Étape 2 : diviser l'ensemble de données

Pour évaluer équitablement un modèle, nous divisons les données en :

• Ensemble d'entraînement : utilisé pour entraîner le modèle
• Ensemble de tests : utilisé pour évaluer dans quelle mesure le modèle se généralise

En utilisant train_test_split, nous divisons l'ensemble de données Iris de sorte que 60 % soient destinés à la formation et 40 % aux tests (test_size=0,4). random_state=1 garantit la reproductibilité.

tableau de chaînes en programmation C

Après séparation, nous obtenons :

• X_train y_train -> Données d'entraînement
• X_test y_test -> Données de test

La vérification des formes garantit que les données sont correctement divisées.

from sklearn.model_selection import train_test_split X_train X_test y_train y_test = train_test_split(X y test_size=0.4 random_state=1) 

Vérifions maintenant le Formes des données fractionnées pour garantir que les deux ensembles ont des proportions correctes de données, évitant ainsi toute erreur potentielle dans l'évaluation ou la formation du modèle.

print('X_train Shape:' X_train.shape) print('X_test Shape:' X_test.shape) print('Y_train Shape:' y_train.shape) print('Y_test Shape:' y_test.shape) 

Sortir:

tojson java

Étape 3 : Gérer les données catégorielles

Les algorithmes d'apprentissage automatique fonctionnent avec des entrées numériques, les données catégorielles (texte) doivent donc être converties en nombres. S’ils ne sont pas correctement codés, les modèles peuvent mal interpréter les catégories. Scikit-learn propose plusieurs méthodes de codage :

1. Encodage des étiquettes : Il convertit chaque catégorie en un entier unique. Par exemple, dans une colonne avec des catégories telles que « chat », « chien » et « oiseau », cela les convertirait respectivement en 0, 1 et 2. Cette méthode fonctionne bien lorsque les catégories ont un ordre significatif tel que Faible, Moyen et Élevé.

• LabelEncoder() : Il est initialisé pour créer un objet encodeur qui convertira les valeurs catégorielles en étiquettes numériques.
• fit_transform() : Cette méthode adapte d'abord l'encodeur aux données catégorielles, puis transforme les catégories en étiquettes numériques correspondantes.

from sklearn.preprocessing import LabelEncoder categorical_feature = ['cat' 'dog' 'dog' 'cat' 'bird'] encoder = LabelEncoder() encoded_feature = encoder.fit_transform(categorical_feature) print('Encoded feature:' encoded_feature) 

Sortir:

Fonctionnalité codée : [1 2 2 1 0]

2. Encodage à chaud : One-Hot Encoding crée des colonnes binaires distinctes pour chaque catégorie. Ceci est utile lorsque les catégories n'ont pas d'ordre naturel. Exemple : chat chien oiseau -> 3 nouvelles colonnes (chat/chien/oiseau) avec des 1 et des 0.

• L'entrée doit être remodelée en un tableau 2D
• OneHotEncoder(sparse_output=False) génère des colonnes binaires

from sklearn.preprocessing import OneHotEncoder import numpy as np categorical_feature = ['cat' 'dog' 'dog' 'cat' 'bird'] categorical_feature = np.array(categorical_feature).reshape(-1 1) encoder = OneHotEncoder(sparse_output=False) encoded_feature = encoder.fit_transform(categorical_feature) print('OneHotEncoded feature:n' encoded_feature) 

Sortir:

Outre l'encodage d'étiquettes et l'encodage One-Hot, il existe d'autres techniques telles que Encodage moyen .

Étape 4 : Former le modèle

Maintenant que nos données sont prêtes, il est temps de former un modèle d’apprentissage automatique. Scikit-learn dispose de nombreux algorithmes avec une interface cohérente pour la prédiction et l'évaluation de la formation. Ici, nous utiliserons Régression logistique à titre d'exemple.

Note : Nous n’entrerons pas dans les détails du fonctionnement de l’algorithme car nous souhaitons uniquement comprendre sa mise en œuvre. 

• log_reg = LogisticRegression(max_iter=200) : Création d'un objet classificateur de régression logistique.
• log_reg.fit(X_train y_train) : Utiliser ceci le modèle de régression logistique ajuste les paramètres du modèle pour s’adapter au mieux aux données.

from sklearn.linear_model import LogisticRegression log_reg = LogisticRegression(max_iter=200) log_reg.fit(X_train y_train) 

Étape 5 : Faire des prédictions

Une fois formés, nous utilisons le modèle pour faire des prédictions sur les données de test X_test en appelant la méthode prédire. Cela renvoie les étiquettes prédites y_pred.

• log_reg.predict : Il utilise un modèle de régression logistique entraîné pour prédire les étiquettes des données de test X_test.

y_pred = log_reg.predict(X_test) 

Étape 6 : Évaluation de la précision du modèle

Vérifiez les performances de notre modèle en comparant y_test et y_pred. Nous utilisons ici la méthode Accuracy_score du module de métriques.

from sklearn import metrics print('Logistic Regression model accuracy:' metrics.accuracy_score(y_test y_pred)) 

Sortir:

chaîne en c

Précision du modèle de régression logistique : 0,9666666666666667

Nous voulons maintenant que notre modèle fasse des prédictions sur de nouveaux échantillons de données. Ensuite, l’échantillon d’entrée peut simplement être transmis de la même manière que nous transmettons n’importe quelle matrice de fonctionnalités. Ici, nous l'avons utilisé comme échantillon = [[3 5 4 2] [2 3 5 4]]

sample = [[3 5 4 2] [2 3 5 4]] preds = log_reg.predict(sample) pred_species = [iris.target_names[p] for p in preds] print('Predictions:' pred_species) 

Sortir: 

Prédictions : [np.str_('virginica') np.str_('virginica')]

Caractéristiques de Scikit-learn

Scikit-learn est utilisé car il rend la création de modèles d'apprentissage automatique simple et efficace. Voici quelques raisons importantes :

1. Outils prêts à l'emploi : Il fournit des fonctions intégrées pour les tâches courantes telles que les modèles de formation au prétraitement des données et la réalisation de prédictions. Cela permet de gagner du temps en évitant d’avoir à coder des algorithmes à partir de zéro.
2. Évaluation facile du modèle : Avec des outils tels que la validation croisée et les mesures de performances, cela permet de mesurer le fonctionnement de notre modèle et d'identifier les domaines à améliorer.
3. Large prise en charge d'algorithmes : Il propose de nombreux algorithmes d'apprentissage automatique populaires, notamment la régression de classification et le clustering, ce qui nous donne la flexibilité de choisir le bon modèle pour notre problème.
4. Intégration fluide : Construit sur d'importantes bibliothèques Python telles que NumPy et SciPy afin de s'intégrer dans notre flux de travail d'analyse de données existant.
5. Interface simple et cohérente : La même syntaxe simple fonctionne sur différents modèles et facilite l'apprentissage et le basculement entre les algorithmes.
6. Le réglage du modèle simplifié : Des outils tels que la recherche par grille nous aident à affiner les paramètres de notre modèle pour améliorer la précision sans tracas supplémentaires.

Avantages de l'utilisation de Scikit-learn

• Convivial : L'interface cohérente et simple de Scikit-learn le rend accessible aux débutants et idéal pour les experts.
• Gain de temps : Les outils et algorithmes prédéfinis réduisent le temps de développement, ce qui nous permet de nous concentrer davantage sur la résolution des problèmes que sur les détails du codage.
• Meilleures performances du modèle : Des outils de réglage et d'évaluation faciles à utiliser aident à améliorer la précision et la fiabilité du modèle.
• Flexible et évolutif : Prend en charge un large éventail d'algorithmes et s'intègre facilement à d'autres bibliothèques Python, ce qui le rend adapté aux projets de toute taille.
• Fort soutien de la communauté : Une grande communauté active assure des mises à jour régulières, une documentation complète et de nombreuses ressources pour nous aider lorsque nous sommes bloqués.