Maîtriser Scikit-learn : Guide ultime de l'apprentissage en Python

Scikit-learn, souvent appelé sklearn, est une puissante bibliothèque Python open-source pour l'apprentissage automatique. Construite sur NumPy, SciPy et Matplotlib, elle fournit des outils simples et efficaces pour l'exploration, l'analyse et la modélisation des données. Que vous soyez débutant ou expert, l'API intuitive de sklearn est idéale pour construire des modèles prédictifs. Depuis sa sortie en 2007, sklearn est devenu une pierre angulaire de l'écosystème de la science des données Python, soutenu par une communauté dynamique. Il prend en charge l'apprentissage supervisé et non supervisé, ce qui le rend polyvalent pour des tâches telles que la classification, la régression, le regroupement et la réduction de la dimensionnalité.

Pourquoi choisir sklearn ? Son interface cohérente, sa documentation complète et son large éventail d'algorithmes (régression linéaire, machines à vecteurs de support et forêts aléatoires) permettent un prototypage et un déploiement rapides. Ce guide se penche sur les fonctionnalités de base de sklearn, ses applications pratiques et ses techniques avancées pour vous aider à maîtriser l'apprentissage automatique en Python.

Démarrer avec Scikit-learn

Pour commencer, installez sklearn à l'aide de pip :

bash
pip install scikit-learn

Vous pouvez également utiliser conda :

bash
conda install scikit-learn

Assurez-vous que NumPy, SciPy et Pandas sont installés, car ce sont des dépendances. Un environnement virtuel (par exemple, via venv ou conda) permet d'organiser vos projets. Vérifiez l'installation en important sklearn :

python
import sklearn
print(sklearn.__version__)

Sklearn fonctionne de manière transparente dans les Notebooks Jupyter, ce qui facilite l'expérimentation. Téléchargez des échantillons de données, comme Iris ou Boston Housing, directement depuis sklearn :

python
from sklearn.datasets import load_iris
iris = load_iris()

Concepts fondamentaux de Scikit-learn

L'API de Sklearn s'articule autour de trois concepts clés : estimateurs, prédicteurs, et transformateurs. Un estimateur est un objet qui apprend à partir de données (par exemple, un classificateur). Les prédicteurs fournissent des prédictions (par ex, predict() ), tandis que les transformateurs traitent les données à l'avance (par exemple, mise à l'échelle des caractéristiques). Le flux de travail suit un schéma ajustement-transformation-prévision :

python
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

Prétraitement des données est essentielle. Sklearn propose des outils tels que Détartreur standard pour la normalisation, OneHotEncoder pour les variables catégorielles, et SimpleImputer pour les valeurs manquantes. Utiliser Pipeline pour enchaîner les étapes de prétraitement et de modélisation :

python
from sklearn.pipeline import Pipeline
pipeline = Pipeline([('scaler', StandardScaler()), ('clf', LogisticRegression())])

Cela garantit des transformations cohérentes pendant la formation et les tests, réduisant ainsi les erreurs.

Apprentissage supervisé avec sklearn

L'apprentissage supervisé implique des données étiquetées. Sklearn excelle dans deux types d'apprentissage : la classification et la régression.

• Classification : Prédire des catégories (par exemple, spam ou non). Essayez la régression logistique :
• python

from sklearn.linear_model import LogisticRegression
clf = LogisticRegression()
clf.fit(X_train, y_train)

• y_pred = clf.predict(X_test)
• D'autres algorithmes incluent les machines à vecteurs de support (SVC) et les arbres de décision (DecisionTreeClassifier (classificateur d'arbres de décision)). Évaluer les modèles à l'aide de mesures telles que la précision ou le score F1 :
• python

from sklearn.metrics import accuracy_score

• print(accuracy_score(y_test, y_pred))
• Régression: Prédire des valeurs continues (par exemple, les prix de l'immobilier). La régression linéaire est un outil de base :
• python

from sklearn.linear_model import LinearRegression
reg = LinearRegression()

• reg.fit(X_train, y_train)
• Des options avancées telles que Ridge ou Lasso gèrent la régularisation. Mesurez les performances à l'aide de l'erreur quadratique moyenne (EQM) :
• python

from sklearn.metrics import mean_squared_error

• print(erreur_moyenne_carrée(y_test, y_pred))

Apprentissage non supervisé avec sklearn

L'apprentissage non supervisé permet de trouver des modèles dans des données non étiquetées. Sklearn prend en charge le regroupement et la réduction de la dimensionnalité.

• Regroupement: Regrouper les points de données similaires. K-Means est populaire :
• python

from sklearn.cluster import KMeans
kmeans = KMeans(n_clusters=3)

• clusters = kmeans.fit_predict(X)
• DBSCAN gère mieux les grappes non sphériques pour les ensembles de données complexes.
• Réduction de la dimensionnalité: Réduire les caractéristiques tout en préservant l'information. L'analyse en composantes principales (ACP) est largement utilisée :
• python

from sklearn.decomposition import PCA
pca = PCA(n_composants=2)

• X_réduit = pca.fit_transform(X)
• Visualiser des données de haute dimension avec t-SNE pour l'analyse exploratoire.

Sélection et évaluation des modèles

Pour garantir la robustesse des modèles, sklearn propose des outils de validation et de réglage. Validation croisée évalue la généralisation :

python
from sklearn.model_selection import cross_val_score
scores = cross_val_score(clf, X, y, cv=5)
print(scores.mean())

Réglage des hyperparamètres optimise les modèles. Utilisez GridSearchCV :

python
from sklearn.model_selection import GridSearchCV
param_grid = {'C' : [0.1, 1, 10]}
grid = GridSearchCV(LogisticRegression(), param_grid, cv=5)
grid.fit(X_train, y_train)
print(grid.best_params_)

La division des données en ensembles de formation et de test permet d'éviter l'ajustement excessif :

python
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

Fonctionnalités avancées et conseils

Les méthodes d'ensemble de Sklearn, comme Random Forest et Gradient Boosting, combinent des modèles pour de meilleures performances :

python
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(n_estimateurs=100)
rf.fit(X_train, y_train)

Traiter les ensembles de données déséquilibrés avec des techniques telles que SMOTE (via déséquilibre-apprentissage) ou des poids de classe. Sauvegarder les modèles pour les réutiliser :

python
import joblib
joblib.dump(clf, 'model.pkl')
clf = joblib.load('model.pkl')

Sélection de caractéristiques avec SélectionnerKBest ou l'élimination récursive des caractéristiques (RFE) améliore l'efficacité.

Exemple concret : Prévoir les prix de l'immobilier

Construisons un modèle de régression en utilisant le jeu de données Boston Housing (ou un jeu de données similaire, Boston étant déprécié). Charger les données :

python
import pandas as pd
from sklearn.datasets import fetch_california_housing
logement = fetch_california_housing()
X = pd.DataFrame(housing.data, columns=housing.feature_names)
y = logement.cible

Prétraitement et formation :

python
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression

pipeline = Pipeline([('scaler', StandardScaler()), ('reg', LinearRegression())])
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
pipeline.fit(X_train, y_train)
y_pred = pipeline.predict(X_test)
print(erreur_moyenne_carrée(y_test, y_pred))

Interprétez les coefficients pour comprendre l'importance des caractéristiques. Visualiser les prédictions avec Matplotlib pour mieux comprendre.

Conclusion et ressources

Scikit-learn simplifie l'apprentissage automatique grâce à son API unifiée et à ses outils robustes. Du prétraitement à la modélisation avancée, il permet aux scientifiques des données de s'attaquer efficacement aux problèmes du monde réel. Approfondissez vos connaissances avec les outils de Scikit-learn documentation officielledes concours Kaggle, ou des livres comme Hands-On Machine Learning with Scikit-learn, Keras, and TensorFlow.

Carmatec offre des solutions robustes, évolutives et performantes. Solutions Python sur mesure pour accélérer votre transformation numérique. De l'application web à l'intégration de l'IA, notre expert Développeurs Python créer des solutions intelligentes, prêtes pour l'avenir, qui stimulent la croissance de l'entreprise.