7 secrets Scikit-Learn que vous ne connaissiez probablement pas

En tant que data scientists possédant des compétences en programmation Python, nous utilisons beaucoup Scikit-Learn. Il s’agit d’un package d’apprentissage automatique généralement enseigné initialement aux nouveaux utilisateurs et qui peut être utilisé jusqu’à la production. Cependant, une grande partie de ce qui est enseigné concerne la mise en œuvre de base, et Scikit-Learn contient de nombreux secrets pour améliorer notre flux de données.

Cet article abordera sept secrets de Scikit-Learn que vous ne connaissiez probablement pas. Sans plus tarder, entrons dans le vif du sujet.

1. Calibrage de probabilité

Certains modèles de tâches de classification de modèles d'apprentissage automatique fournissent une sortie de probabilité pour chaque classe. Le problème avec les résultats de l’estimation de probabilité est qu’ils ne sont pas nécessairement bien calibrés, ce qui signifie qu’ils ne reflètent pas la probabilité réelle du résultat.

Par exemple, votre modèle peut fournir 95 % du résultat de la classe « fraude », mais seulement 70 % de cette prédiction est correcte. L’étalonnage des probabilités viserait à ajuster les probabilités pour refléter la vraisemblance réelle.

Il existe quelques méthodes d'étalonnage, mais les plus courantes sont l'étalonnage sigmoïde et la régression isotonique. Le code suivant utilise Scikit-Learn pour calibrer la technique dans le classificateur.

from sklearn.calibration import CalibratedClassifierCV
from sklearn.svm import SVC

svc = SVC(probability=False)
calibrated_svc = CalibratedClassifierCV(base_estimator=svc, method='sigmoid', cv=5)
calibrated_svc.fit(X_train, y_train)
probabilities = calibrated_svc.predict_proba(X_test)

Vous pouvez modifier le modèle à condition qu'il fournisse une sortie de probabilité. La méthode permet de basculer entre la méthode « sigmoïde » ou « isotonique ».

Par exemple, voici un classificateur Random Forest avec étalonnage isotonique.

from sklearn.calibration import CalibratedClassifierCV
from sklearn.ensemble import RandomForestClassifier

rf = RandomForestClassifier(random_state=42)
calibrated_rf = CalibratedClassifierCV(base_estimator=rf, method='isotonic', cv=5)
calibrated_rf.fit(X_train, y_train)
probabilities = calibrated_rf.predict_proba(X_test)

Si votre modèle ne fournit pas la prédiction souhaitée, envisagez de calibrer votre classificateur.

2. Union des fonctionnalités

Le prochain secret que nous explorerons est la mise en œuvre de l’union des fonctionnalités. Si vous ne le savez pas, l'union de fonctionnalités est une classe Scikit qui permet de combiner plusieurs objets transformateur en un seul transformateur.

C'est un cours précieux lorsque nous souhaitons effectuer plusieurs transformations et extractions à partir du même ensemble de données et les utiliser en parallèle pour notre modélisation d'apprentissage automatique.

Voyons comment ils fonctionnent dans le code suivant.

from sklearn.pipeline import FeatureUnion, Pipeline
from sklearn.decomposition import PCA
from sklearn.feature_selection import SelectKBest
from sklearn.svm import SVC

combined_features = FeatureUnion([
    ("pca", PCA(n_components=2)),
    ("select_best", SelectKBest(k=1))
])

pipeline = Pipeline([
    ("features", combined_features),
    ("svm", SVC())
])

pipeline.fit(X_train, y_train)

Dans le code ci-dessus, nous pouvons voir que nous avons combiné deux méthodes de transformateur pour la réduction de dimensionnalité avec PCA et sélectionné les meilleures fonctionnalités principales dans un seul pipeline de transformateur avec union de fonctionnalités. Les combiner avec le pipeline permettrait à notre union de fonctionnalités d'être utilisée dans un processus singulier.

Il est également possible de chaîner l'union des fonctionnalités si vous souhaitez mieux contrôler la manipulation et le prétraitement des fonctionnalités. Voici un exemple de la méthode précédente dont nous avons discuté avec une union de fonctionnalités supplémentaire.

# First FeatureUnion
first_union = FeatureUnion([
    ("pca", PCA(n_components=5)),
    ("select_best", SelectKBest(k=5))
])

# Second FeatureUnion
second_union = FeatureUnion([
    ("poly", PolynomialFeatures(degree=2, include_bias=False)),
    ("scaled", StandardScaler())
])

pipeline = Pipeline([
    ("first_union", first_union),
    ("second_union", second_union),
    ("svm", SVC())
])

pipeline.fit(X_train, y_train)
score = pipeline.score(X_test, y_test)

Il s’agit d’une excellente méthodologie pour ceux qui ont besoin d’un prétraitement approfondi au début du processus de modélisation d’apprentissage automatique.

3. Agglomération de fonctionnalités

Le prochain secret que nous explorerions est l’agglomération de fonctionnalités. Il s'agit d'une méthode de sélection de fonctionnalités de Scikit-Learn mais qui utilise un clustering hiérarchique pour fusionner des fonctionnalités similaires.

L'agglomération de fonctionnalités est une méthodologie de réduction de dimensionnalité, ce qui signifie qu'elle est utile lorsqu'il existe de nombreuses fonctionnalités et que certaines fonctionnalités sont significativement corrélées les unes aux autres. Il repose également sur un clustering hiérarchique, fusionnant les fonctionnalités en fonction du critère de liaison et de la mesure de distance que nous avons définis.

Voyons comment cela fonctionne dans le code suivant.

from sklearn.cluster import FeatureAgglomeration

agglo = FeatureAgglomeration(n_clusters=10)
X_reduced = agglo.fit_transform(X)

Nous définissons le nombre de fonctionnalités souhaitées en définissant les numéros de cluster. Voyons comment nous transformons la mesure de distance en similarité cosinus.

agglo = FeatureAgglomeration(metric='cosine')

Nous pouvons également changer la méthode de liaison avec le code suivant.

agglo = FeatureAgglomeration(linkage='average')

Ensuite, nous pouvons également modifier la fonction pour agréger les fonctionnalités de la nouvelle fonctionnalité.

import numpy as np 
agglo = FeatureAgglomeration(pooling_func=np.median)

Essayez d'expérimenter l'agglomération de fonctionnalités pour acquérir le meilleur ensemble de données pour votre modélisation.

4. Division prédéfinie

La division prédéfinie est une classe Scikit-Learn utilisée pour une stratégie de validation croisée personnalisée. Il spécifie le schéma lors de la division des données de formation et de test. C'est une méthode précieuse lorsque nous souhaitons diviser nos données d'une certaine manière et que le pli K standard ou le pli K stratifié sont insuffisants.

Essayons le fractionnement prédéfini en utilisant le code ci-dessous.

from sklearn.model_selection import PredefinedSplit, GridSearchCV

# -1 for training, 0 for test
test_fold = [-1 if i < 100 else 0 for i in range(len(X))]
ps = PredefinedSplit(test_fold)

param_grid = {'parameter': [1, 10, 100]}
grid_search = GridSearchCV(model, param_grid, cv=ps)
grid_search.fit(X, y)

Dans l'exemple ci-dessus, nous définissons le schéma de répartition des données en sélectionnant les cent premières données comme formation et le reste comme test.

La stratégie de fractionnement dépend de vos besoins. Nous pouvons changer cela grâce au processus de pondération.

sample_weights = np.random.rand(100)
test_fold = [-1 if i < 80 else 0 for i in range(len(X))]
ps = PredefinedSplit(test_fold)

Cette stratégie offre une nouvelle approche du processus de fractionnement des données, alors essayez-la pour voir si elle vous offre des avantages.

5. Démarrage à chaud

Avez-vous entraîné un modèle d'apprentissage automatique qui nécessite un ensemble de données étendu et souhaitez-vous l'entraîner par lots ? Ou utilisez-vous un apprentissage en ligne qui nécessite un apprentissage progressif utilisant des données en streaming ? Si vous vous trouvez dans ces cas, vous ne souhaitez pas recycler le modèle depuis le début.

C’est là qu’un bon départ pourrait vous aider.

Le démarrage à chaud est un paramètre du modèle Scikit-Learn qui nous permet de réutiliser notre dernière solution formée lors de la réajustement du modèle. Cette méthode est utile lorsque nous ne voulons pas recycler notre modèle à partir de zéro.

Par exemple, le code ci-dessous montre le processus de démarrage à chaud lorsque nous ajoutons plus d'arbres au modèle et le réentraînons sans recommencer depuis le début.

from sklearn.ensemble import GradientBoostingClassifier

#100 trees
model = GradientBoostingClassifier(n_estimators=100, warm_start=True)
model.fit(X_train, y_train)

# Add 50 trees
model.n_estimators += 50
model.fit(X_train, y_train)

Il est également possible d’effectuer un entraînement par lots avec la fonction de démarrage à chaud.

from sklearn.linear_model import SGDClassifier

model = SGDClassifier(max_iter=1000, warm_start=True)

# Train on first batch
model.fit(X_batch_1, y_batch_1)

# Continue training on second batch
model.fit(X_batch_2, y_batch_2)

Expérimentez avec un démarrage à chaud pour toujours avoir le meilleur modèle sans sacrifier le temps d'entraînement.

6. Apprentissage progressif

Et en parlant d'apprentissage progressif, nous pouvons également utiliser Scikit-Learn pour le faire. Comme mentionné ci-dessus, l’apprentissage incrémentiel – ou apprentissage en ligne – est un processus de formation en apprentissage automatique dans lequel nous introduisons séquentiellement de nouvelles données.

Il est souvent utilisé lorsque notre ensemble de données est étendu ou que les données sont censées arriver au fil du temps. Il est également utilisé lorsque nous nous attendons à ce que la distribution des données change au fil du temps, un recyclage constant est donc nécessaire, mais pas à partir de zéro.

Dans ce cas, plusieurs algorithmes de Scikit-Learn fournissent une prise en charge d'apprentissage incrémentielle en utilisant la méthode d'ajustement partiel. Cela permettrait à la formation du modèle de se dérouler par lots.

Regardons un exemple de code.

from sklearn.linear_model import SGDClassifier
import numpy as np

classes = np.unique(y_train)
model = SGDClassifier()
for batch_X, batch_y in data_stream:
    model.partial_fit(batch_X, batch_y, classes=classes)

L'apprentissage incrémentiel continuera à fonctionner tant que la boucle se poursuivra.

Il est également possible d’effectuer un apprentissage incrémentiel non seulement pour la formation du modèle mais également pour le prétraitement.

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
for batch_X, batch_y in data_stream:
    batch_X = scaler.partial_fit_transform(batch_X)
    model.partial_fit(batch_X, batch_y, classes=classes)

Si votre modélisation nécessite un apprentissage incrémentiel, essayez d'utiliser la méthode d'ajustement partiel de Scikit-Learn.

7. Accéder aux fonctionnalités expérimentales

Toutes les classes et fonctions de Scikit-Learn n'ont pas été publiées dans la version stable. Certains sont encore expérimentaux et nous devons les activer avant de les utiliser.

Si nous voulons activer les fonctionnalités, nous devons voir quelles fonctionnalités sont encore dans la version expérimentale et importer l'API d'activation de l'expérience depuis Scikit-Learn.

Voyons un exemple de code ci-dessous.

# Enable the experimental feature
from sklearn.experimental import enable_iterative_imputer  
from sklearn.impute import IterativeImputer

imputer = IterativeImputer(random_state=0)

Au moment de la rédaction de cet article, la classe IterativeImputer est encore en phase expérimentale et nous devons importer l'activateur au début avant d'utiliser la classe.

Une autre fonctionnalité qui est encore en phase expérimentale est la méthodologie de recherche de moitié.

from sklearn.experimental import enable_halving_search_cv
from sklearn.model_selection import HalvingRandomSearchCV
from sklearn.model_selection import HalvingGridSearchCV

Si vous trouvez des fonctionnalités utiles dans Scikit-Learn mais que vous ne parvenez pas à y accéder, elles sont peut-être en phase expérimentale, alors essayez d'y accéder en important l'activateur.

Conclusion

Scikit-Learn est une bibliothèque populaire utilisée dans de nombreuses implémentations d'apprentissage automatique. Il y a tellement de fonctionnalités dans la bibliothèque qu’il y en a sans aucun doute beaucoup que vous ignorez. Pour résumer, les sept secrets que nous avons abordés dans cet article étaient :

1. Calibrage de probabilité
2. Union des fonctionnalités
3. Agglomération de fonctionnalités
4. Division prédéfinie
5. Démarrage à chaud
6. Apprentissage progressif
7. Accéder aux fonctionnalités expérimentales

J'espère que cela a aidé!