Modèles et caractéristiques personnalisés avec Sklearn

Les modèles personnalisés peuvent étendre les fonctionnalités de scikit-learn pour répondre aux besoins de scénarios d'application spécifiques.

Dans scikit-learn, en plus d'utiliser des modèles et des fonctions de prétraitement prêts à l'emploi, les utilisateurs peuvent également créer des modèles, des transformateurs et des fonctionnalités personnalisés selon leurs propres besoins.

La mise en œuvre de modèles et de fonctionnalités personnalisés implique généralement l'héritage des classes de base de scikit-learn, telles que BaseEstimator et TransformerMixin, puis l'implémentation de méthodes spécifiques fit et predict.

Ce chapitre détaillera les aspects suivants :

  1. Transformateur personnalisé
  2. Estimateur personnalisé
  3. Étapes de pipeline personnalisées
  4. Comment utiliser l'héritageBaseEstimatoretTransformerMixinpour implémenter des algorithmes personnalisés

1. Transformateur personnalisé

Un transformateur est un composant utilisé pour transformer des données, comme la standardisation, la sélection de caractéristiques, etc. Les transformateurs personnalisés peuvent hériterTransformerMixin, et implémenterfitettransformméthodes traditionnelles.

Étapes pour personnaliser un transformateur :

  • fitméthode: généralement utilisée pour apprendre les attributs des données (tels que la moyenne, la variance, les critères de sélection de caractéristiques, etc.).fitLa méthode renvoie le transformateur lui-même pour permettre les appels en chaîne.
  • transformméthode: applique les attributs appris pour transformer ou traiter les données.

Exemple de transformateur personnalisé : transformateur de standardisation personnalisé :

Supposons que nous voulions implémenter un transformateur de standardisation personnalisé. La standardisation met à l'échelle chaque caractéristique des données pour avoir une moyenne de 0 et une variance de 1.

Exemple

import numpy as np
from sklearn.base import BaseEstimator, TransformerMixin

class CustomScaler(BaseEstimator, TransformerMixin):
    def fit(self, X, y=None):
        """
Calculer la moyenne et l'écart-type de chaque caractéristique
        """

        self.mean_ = np.mean(X, axis=0)
        self.std_ = np.std(X, axis=0)
        return self  # Renvoyer l'objet lui-même

    def transform(self, X):
        """
Standardiser les données
        """

        return (X - self.mean_) / self.std_

# Tester le transformateur personnalisé
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# Charger les données
data = load_iris()
X, y = data.data, data.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Créer un objet transformateur personnalisé
scaler = CustomScaler()

# Utiliser la standardisation personnalisée
scaler.fit(X_train)
X_train_scaled = scaler.transform(X_train)
X_test_scaled = scaler.transform(X_test)

print("Données d'entraînement mises à l'échelle :\n", X_train_scaled)

La sortie est la suivante :

Scaled training data:
 [[-1.47393679  1.20365799 -1.56253475 -1.31260282]
 [-0.13307079  2.99237573 -1.27600637 -1.04563275]
 [ 1.08589829  0.08570939  0.38585821  0.28921757]
 [-1.23014297  0.75647855 -1.2187007  -1.31260282]
 [-1.7177306   0.30929911 -1.39061772 -1.31260282]
....

Explication :

La classe CustomScaler implémente un processus de standardisation similaire à StandardScaler dans scikit-learn.

  • fitLa méthode calcule la moyenne et l'écart type des données d'entraînement et enregistre ces valeurs.
  • transformLa méthode utilise lafitmoyenne et l'écart type calculés dans la méthode fit pour transformer les données.

2. Estimateur personnalisé

Un estimateur fait référence au modèle lui-même, tel que les régresseurs, les classificateurs, etc.

Les estimateurs personnalisés doivent hériter de la classe BaseEstimator et implémenter les méthodes fit et predict.

Étapes pour un estimateur personnalisé :

  • fitméthode: utilisée pour entraîner le modèle et calculer les paramètres requis (tels que les poids, les biais, etc.).
  • predictméthode: prédit les données d'entrée en fonction des paramètres entraînés.

Exemple d'estimateur personnalisé : classifieur simple

Supposons que nous voulions implémenter un classifieur très simple : utiliser la moyenne de chaque caractéristique comme seuil ; si la valeur d'une caractéristique dépasse la moyenne, prédire la classe 1 ; sinon, prédire la classe 0.

Exemple

from sklearn.base import BaseEstimator
import numpy as np

class SimpleClassifier(BaseEstimator):
    def fit(self, X, y):
        """
Entraîner le modèle : calculer la moyenne de chaque caractéristique
        """

        self.mean_ = np.mean(X, axis=0)
        return self  # Renvoyer l'objet lui-même

    def predict(self, X):
        """
Classer en fonction de la moyenne : si la valeur de la caractéristique est supérieure à la moyenne, prédire 1 ; sinon, prédire 0
        """

        return (X > self.mean_).astype(int)

# Test du classifieur personnalisé
X_train = np.array([[1.5, 2.5], [2.0, 3.0], [3.5, 4.5], [4.0, 5.0]])
y_train = np.array([0, 0, 1, 1])

# Créer un objet classifieur personnalisé
classifier = SimpleClassifier()

# Entraîner le modèle
classifier.fit(X_train, y_train)

# Faire des prédictions
X_test = np.array([[2.5, 3.5], [1.0, 2.0]])
y_pred = classifier.predict(X_test)

print("Predictions:", y_pred)

La sortie est la suivante :

Predictions: [[0 0]
 [0 0]]

Explication :

  • fitLa méthode calcule la moyenne des données d'entraînement et la stocke dansself.mean_l'attribut.
  • predictLa méthode effectue des prédictions de classification en comparant les données de test avec la moyenne.

Ce type de classifieur personnalisé n'est pas couramment utilisé en pratique, mais il montre comment utiliser BaseEstimator pour créer un modèle simple.


3. Étapes de pipeline personnalisées

scikit-learn permet d'utiliser des transformateurs et des estimateurs personnalisés comme étapes de pipeline. Cela permet d'intégrer le prétraitement des données et l'entraînement du modèle dans un seul flux de travail. Les modèles et caractéristiques personnalisés peuvent fonctionner avec les pipelines tout comme les transformateurs et estimateurs intégrés.

Utilisation de transformateurs et d'estimateurs personnalisés dans un pipeline

Exemple

import numpy as np
from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.pipeline import Pipeline


class CustomScaler(BaseEstimator, TransformerMixin):
    def fit(self, X, y=None):
        """
Calculer la moyenne et l'écart-type de chaque caractéristique
        """

        self.mean_ = np.mean(X, axis=0)
        self.std_ = np.std(X, axis=0)
        return self  # Renvoyer l'objet lui-même

    def transform(self, X):
        """
Standardiser les données
        """

        return (X - self.mean_) / self.std_
   

class SimpleClassifier(BaseEstimator):
    def fit(self, X, y):
        """
Entraîner le modèle : calculer la moyenne de chaque caractéristique
        """

        self.mean_ = np.mean(X, axis=0)
        return self  # Renvoyer l'objet lui-même

    def predict(self, X):
        """
Classer en fonction de la moyenne : si la valeur de la caractéristique est supérieure à la moyenne, prédire 1 ; sinon, prédire 0
        """

        return (X > self.mean_).astype(int)

# Test du classifieur personnalisé
X_train = np.array([[1.5, 2.5], [2.0, 3.0], [3.5, 4.5], [4.0, 5.0]])
y_train = np.array([0, 0, 1, 1])

# Créer un pipeline contenant une standardisation personnalisée et un classifieur
pipeline = Pipeline([
    ('scaler', CustomScaler()),  # Standardisation personnalisée
    ('classifier', SimpleClassifier())  # Classifieur personnalisé
])

# Entraîner le pipeline
pipeline.fit(X_train, y_train)

X_test = np.array([[2.5, 3.5], [1.0, 2.0]])
# Prédire
y_pred = pipeline.predict(X_test)
print("Predictions:", y_pred)

La sortie est la suivante :

Predictions: [[0 0]
 [0 0]]

Explication :

Nous utilisons CustomScaler et SimpleClassifier comme étapes du pipeline, en tirant parti du pipeline pour effectuer automatiquement le prétraitement des données et l'entraînement du modèle.

De cette façon, l'ensemble du flux de travail du pipeline peut être réalisé avec une seule méthode fit et predict, tout en maintenant l'efficacité et la simplicité.


Comment implémenter des algorithmes personnalisés en héritant de BaseEstimator et TransformerMixin

  • BaseEstimator: est la classe de base de tous les estimateurs scikit-learn. Elle fournitget_params()etset_params()méthodes, ce qui permet aux estimateurs personnalisés de fonctionner ensembleGridSearchCVavec d'autres outils.
  • TransformerMixin: est la classe de base de tous les transformateurs scikit-learn. Elle fournitfit_transform()méthodes, ce qui permet aux transformateurs d'être utilisés ensemblePipelineavec le pipeline.

En héritant de ces deux classes de base, nous pouvons très facilement créer nos propres modèles et caractéristiques personnalisés, et utiliser les outils de scikit-learn (tels que GridSearchCV et Pipeline) pour le réglage et l'évaluation.

Exemple complet de transformateur et d'estimateur personnalisés :

Exemple

from sklearn.base import BaseEstimator, TransformerMixin
import numpy as np

class CustomEstimator(BaseEstimator, TransformerMixin):
    def fit(self, X, y=None):
        # Simuler un "modèle" simple : calculer la moyenne de chaque caractéristique
        self.mean_ = np.mean(X, axis=0)
        return self

    def transform(self, X):
        # Standardiser les données en fonction de la moyenne
        return X - self.mean_

    def predict(self, X):
        # Méthode de prédiction simple : si la valeur de la caractéristique est supérieure à la moyenne, prédire 1 ; sinon, prédire 0
        return (X > self.mean_).astype(int)

# Utiliser un estimateur et un transformateur personnalisés
from sklearn.pipeline import Pipeline
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# Charger les données
data = load_iris()
X, y = data.data, data.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Créer un pipeline
pipeline = Pipeline([
    ('custom', CustomEstimator())
])

# Entraîner le modèle
pipeline.fit(X_train, y_train)

# Prédire
y_pred = pipeline.predict(X_test)
print("Predictions:", y_pred)

Dans l'exemple ci-dessus, nous avons créé un estimateur personnalisé, CustomEstimator, qui non seulement effectue la standardisation (transform) mais effectue aussi la prédiction (predict). Ensuite, nous l'avons utilisé comme partie d'un pipeline pour l'entraînement et la prédiction.

La sortie est la suivante :

Predictions: [[1 0 1 1]
 [0 1 0 0]
 [1 0 1 1]
 [1 0 1 1]
 [1 0 1 1]
 [0 1 0 0]
 [0 0 0 1]
 [1 1 1 1]
 [1 0 1 1]
 [0 0 1 1]
...
Autres extensions