Techniques de prétraitement dans Scikit-Learn

Introduction

Dans ce laboratoire, nous explorerons les techniques de prétraitement disponibles dans scikit-learn. Le prétraitement est une étape essentielle dans tout flux de travail de machine learning car il aide à transformer les données brutes en un format approprié pour l'algorithme d'apprentissage. Nous aborderons diverses techniques de prétraitement telles que la standardisation, la mise à l'échelle, la normalisation, le codage des caractéristiques catégorielles, l'imputation des valeurs manquantes, la génération de caractéristiques polynômiales et la création de transformateurs personnalisés.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous résoudrons rapidement le problème pour vous.

Skills Graph

Standardization

La standardisation est une étape de prétraitement courante pour de nombreux algorithmes de machine learning. Elle transforme les caractéristiques pour qu'elles aient une moyenne nulle et une variance unitaire. Nous pouvons utiliser le StandardScaler de scikit-learn pour effectuer la standardisation.

from sklearn.preprocessing import StandardScaler
import numpy as np

## Create a sample dataset
X = np.array([[1., -1., 2.],
              [2., 0., 0.],
              [0., 1., -1.]])

## Initialize the StandardScaler
scaler = StandardScaler()

## Fit the scaler on the training data
scaler.fit(X)

## Transform the training data
X_scaled = scaler.transform(X)

## Print the transformed data
print(X_scaled)

Mise à l'échelle

Mettre les caractéristiques à une plage spécifique est une autre technique de prétraitement courante. Elle est utile lorsque les caractéristiques ont des échelles différentes et que l'on veut les ramener toutes à une plage similaire. Le MinMaxScaler et le MaxAbsScaler peuvent être utilisés pour effectuer la mise à l'échelle.

from sklearn.preprocessing import MinMaxScaler, MaxAbsScaler
import numpy as np

## Create a sample dataset
X = np.array([[1., -1., 2.],
              [2., 0., 0.],
              [0., 1., -1.]])

## Initialize the MinMaxScaler
min_max_scaler = MinMaxScaler()

## Fit and transform the training data
X_minmax = min_max_scaler.fit_transform(X)

## Print the transformed data
print(X_minmax)

## Initialize the MaxAbsScaler
max_abs_scaler = MaxAbsScaler()

## Fit and transform the training data
X_maxabs = max_abs_scaler.fit_transform(X)

## Print the transformed data
print(X_maxabs)

Normalisation

La normalisation est le processus consistant à mettre à l'échelle les échantillons individuels pour qu'ils aient une norme unitaire. Elle est couramment utilisée lorsque l'amplitude des données n'est pas importante et que l'on n'est intéressé que par la direction (ou l'angle) des données. Nous pouvons utiliser le Normalizer de scikit-learn pour effectuer la normalisation.

from sklearn.preprocessing import Normalizer
import numpy as np

## Create a sample dataset
X = np.array([[1., -1., 2.],
              [2., 0., 0.],
              [0., 1., -1.]])

## Initialize the Normalizer
normalizer = Normalizer()

## Fit and transform the training data
X_normalized = normalizer.fit_transform(X)

## Print the transformed data
print(X_normalized)

Encodage des caractéristiques catégorielles

Les caractéristiques catégorielles doivent être encodées en valeurs numériques avant d'être utilisées dans les algorithmes de machine learning. Nous pouvons utiliser l'OrdinalEncoder et l'OneHotEncoder de scikit-learn pour encoder les caractéristiques catégorielles.

from sklearn.preprocessing import OrdinalEncoder, OneHotEncoder
import numpy as np

## Create a sample dataset
X = [['male', 'from US', 'uses Safari'],
     ['female', 'from Europe', 'uses Firefox']]

## Initialize the OrdinalEncoder
ordinal_encoder = OrdinalEncoder()

## Fit and transform the training data
X_encoded = ordinal_encoder.fit_transform(X)

## Print the transformed data
print(X_encoded)

## Initialize the OneHotEncoder
onehot_encoder = OneHotEncoder()

## Fit and transform the training data
X_onehot = onehot_encoder.fit_transform(X)

## Print the transformed data
print(X_onehot.toarray())

Imputation des valeurs manquantes

Les valeurs manquantes dans un ensemble de données peuvent poser des problèmes pour les algorithmes de machine learning. Nous pouvons utiliser les méthodes fournies dans le module impute de scikit-learn pour gérer les valeurs manquantes. Ici, nous utiliserons le SimpleImputer pour imputer les valeurs manquantes.

from sklearn.impute import SimpleImputer
import numpy as np

## Create a sample dataset with missing values
X = np.array([[1., 2., np.nan],
              [3., np.nan, 5.],
              [np.nan, 4., 6.]])

## Initialize the SimpleImputer
imputer = SimpleImputer()

## Fit and transform the training data
X_imputed = imputer.fit_transform(X)

## Print the transformed data
print(X_imputed)

Génération de caractéristiques polynômes

Parfois, il est avantageux d'ajouter de la complexité à un modèle en considérant les caractéristiques non linéaires des données d'entrée. Nous pouvons utiliser PolynomialFeatures de scikit-learn pour générer des caractéristiques polynômes.

from sklearn.preprocessing import PolynomialFeatures
import numpy as np

## Create a sample dataset
X = np.array([[0, 1],
              [2, 3],
              [4, 5]])

## Initialize the PolynomialFeatures
poly = PolynomialFeatures(2)

## Fit and transform the training data
X_poly = poly.fit_transform(X)

## Print the transformed data
print(X_poly)

Création de transformateurs personnalisés

Dans certains cas, nous pouvons vouloir convertir une fonction Python existante en un transformateur pour faciliter le nettoyage ou le traitement des données. Nous pouvons le faire à l'aide du FunctionTransformer de scikit-learn.

from sklearn.preprocessing import FunctionTransformer
import numpy as np

## Create a custom function
def custom_function(X):
    return np.log1p(X)

## Initialize the FunctionTransformer
transformer = FunctionTransformer(custom_function)

## Create a sample dataset
X = np.array([[0, 1],
              [2, 3]])

## Transform the data using the custom function
X_transformed = transformer.transform(X)

## Print the transformed data
print

Sommaire

Félicitations ! Vous avez terminé le laboratoire de prétraitement des données. Vous pouvez pratiquer d'autres laboratoires sur LabEx pour améliorer vos compétences.