introduction

scikit-learn est une bibliothèque d'apprentissage automatique pratique pour Python qui peut être facilement utilisée avec Numpy, Scipy et Matplotlib. scikit-learn devient beaucoup plus facile à utiliser une fois que vous connaissez le modèle de conception d'API.

Cette fois, j'expliquerai le charme de scikit-learn en me basant sur l'article de l'auteur de scikit-learn.

Conception de base

Les objets scikit-learn sont conçus selon plusieurs modèles pour maintenir la cohérence de l'API. ** En comprenant ce modèle, vous pouvez utiliser n'importe quel objet sans aucun inconvénient. ** **

Estimator scikit-learn est basé sur une interface appelée Estimator. ** L'estimateur entraîne un modèle (paramètre) basé sur les données. ** ** Il a toujours une méthode appelée fit, et il apprend en passant des données à l'argument de fit. Vous pouvez également définir les hyperparamètres requis pour l'entraînement (dans le constructeur ou la méthode set_params).

Une classe appelée LogisticRegression qui effectue une régression logistique est également l'un des estimateurs.

from sklearn.linear_model import LogisticRegession
clf = LogisticRegression(penalty="l1") #Paramètres des hyper paramètres
clf.fit(X_train, y_train) #Apprenez le modèle basé sur les données d'entraînement

Predictor De nombreux estimateurs introduisent également des interfaces Predictor. ** Predictor fait des prédictions (sorties) basées sur le modèle appris dans fit. ** ** Passer des données en tant qu'argument à la méthode predict renvoie une prédiction. Il dispose également d'une méthode appelée «score», qui vous permet d'évaluer le modèle en passant un ensemble de données et une étiquette.

Par exemple, «LogisticRegression» est un prédicteur, vous pouvez donc utiliser les méthodes «prédire» et «score» sans aucun problème.

clf.predict(X_test) #Prédire les données de test

clf.score(X_test, y_test) #Comparez les attentes et les réponses réelles sur les données de test

Transformer En plus de Predictor, il existe également une classe qui introduit une interface appelée Transformer. Comme son nom l'indique, ** Transformer peut transformer les données. ** ** Il est utilisé plus souvent dans les API de traitement de données que dans les modèles d'apprentissage automatique. Renvoie les données transformées à l'aide d'une méthode appelée transform. De plus, en utilisant la méthode fit_transform, il est conçu pour que l'apprentissage et la transformation puissent être effectués en même temps.

L'exemple ci-dessous implémente une transformation par StandardScaler qui standardise l'ensemble de données. Pour StandardScaler, vous apprendrez la moyenne et la variance de chaque trace plutôt qu'un modèle complexe.

from sklearn.preprocessing import StandardScaler 
scaler = StandScaler()
X_train = scaler.fit_transform(X_train) #Apprentissage et transformation des données de formation
X_test = scaler.transform(X_test) #Déformation sans apprentissage des données de test (en utilisant la moyenne / variance des données d'entraînement)

De plus, les interfaces Predictor et Transformer peuvent être installées en même temps.

Obtenir des paramètres / hyper paramètres

Les hyper paramètres que vous définissez et les paramètres appris sont enregistrés dans l'objet. (Les noms des paramètres appris se terminent par un trait de soulignement) Pour plus d'informations sur l'accès aux paramètres et aux hyperparamètres, voir "Attributs" dans la documentation de chaque objet.

Exemple: obtenir la moyenne et la variance apprises par StandardScaler

#Continuez de l'avant
mean = scaler.mean_
variance = scaler.var_

Par conséquent, tout estimateur

Créez une instance et définissez des hyper paramètres
Apprenez avec fit
Vérifiez les paramètres appris qui atteignent l'objectif avec «prédire», «score», «transformer», etc. Vous pouvez facilement créer un flux de travail en suivant la procédure. Tout le traitement des données pour modéliser l'apprentissage / l'évaluation peut être effectué à l'aide d'estimateur.

Conception appliquée

Synthèse d'estimateur

Puisque tous les estimateurs ont la même méthode, ** vous pouvez facilement combiner plusieurs estimateurs. ** ** Utilisez «Pipeline» pour le traitement parallèle et «FeatureUnion» pour le traitement parallèle.

Par exemple, si vous souhaitez standardiser vos données et effectuer une régression logistique, vous pouvez utiliser un pipeline pour implémenter le processus proprement.

from sklearn.pipeline import Pipeline
pipe = Pipeline([
    {'std_scaler', StandardScaler()},
    {'log_reg', LogisticRegression()} #Recevoir les données déformées du transformateur
])
pipe.fit(X_train, y_train)
pipe.score(X_test, y_test)

La validation croisée est également un estimateur

scikit-learn vous permet de valider des hyperparamètres à l'aide de classes telles que GridSearchCV et RandomSearchCV. Ceux-ci introduisent également l'interface Estimator et utilisent «fit» pour apprendre.

Exemple: utilisez Grid Search pour trouver les hyperparamètres optimaux pour la régression logistique

from sklearn.model_selection import GridSearchCV
clf = GridSearchCV(
    estimator=LogisticRegression(),
    param_grid={
        'C' = [1, 3, 10, 30, 100]
    }
)
clf.fit(X_train, y_train) # param_Entraînez plusieurs modèles en appliquant les hyper paramètres de la grille un par un
best_clf = clf.best_estimator_ #Obtenez le meilleur estimateur!

Créez votre propre estimateur

En créant une classe avec des méthodes définies dans l'interface, telles que fit, ** vous pouvez facilement l'utiliser pour les pipelines et la validation. ** ** Lors de la création d'un Estimator, héritez de BaseEstimator, et lors de la création d'un Transformer, etc., héritez du Mixin approprié en même temps.

Exemple de transformateur:

from sklearn.base import BaseEstimator, TransformerMixin

class MyTransformer(BaseEstimator, TransformerMixin):
  def __init__(self, param_1, param_2):
    #Traitement des hyper paramètres
    self.param_1 = param_1
    # ...

  def fit(self, X, y=None):
    #En traitement
    return self 

  def transform(self, X, y=None):
     #Traitement matriciel Numpy
     # X = ...
    return X 

  # fit_transform est automatiquement implémenté par Transformer Mixin

transformer = MyTransformer()
X_transformed = transformer.fit_transform(X_train)

Conclusion

Bien que scikit-learn fournisse des objets qui implémentent diverses méthodes d'apprentissage automatique, même si vous ne comprenez pas le contenu, vous pouvez tous les utiliser si vous comprenez les modèles de conception Estimator, Predictor et Transformer. L'API scikit-learn est attrayante car elle est hautement cohérente et vous pouvez facilement procéder à l'apprentissage automatique.

Cohérence de la conception de l'API scikit-learn