Vorverarbeitungstechniken in Scikit-Learn

Einführung

In diesem Lab werden wir die in scikit-learn verfügbaren Vorverarbeitungstechniken untersuchen. Die Vorverarbeitung ist ein essentieller Schritt in jedem Machine-Learning-Workflow, da sie hilft, die Rohdaten in ein geeignetes Format für den Lernalgorithmus zu transformieren. Wir werden verschiedene Vorverarbeitungstechniken wie Standardisierung, Skalierung, Normalisierung, Kodierung kategorischer Merkmale, Imputation fehlender Werte, Generierung polynomieller Merkmale und Erstellung benutzerdefinierter Transformatoren behandeln.

Tipps für die VM

Nachdem der VM-Start abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu öffnen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund der Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Standardisierung

Die Standardisierung ist ein üblicher Vorverarbeitungsschritt für viele Machine-Learning-Algorithmen. Sie transformiert die Merkmale, sodass sie einen Mittelwert von Null und eine Varianz von Eins haben. Wir können den StandardScaler aus scikit-learn verwenden, um die Standardisierung durchzuführen.

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)

Skalierung

Das Skalieren von Merkmalen in einen bestimmten Bereich ist eine weitere übliche Vorverarbeitungstechnik. Sie ist nützlich, wenn Merkmale unterschiedliche Skalen haben und wir sie alle in einen ähnlichen Bereich bringen möchten. Der MinMaxScaler und der MaxAbsScaler können verwendet werden, um die Skalierung durchzuführen.

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)

Normalisierung

Die Normalisierung ist der Prozess, um einzelne Proben so zu skalieren, dass sie eine Einheitsnorm haben. Sie wird häufig verwendet, wenn die Größe der Daten nicht wichtig ist und wir uns nur für die Richtung (oder den Winkel) der Daten interessieren. Wir können den Normalizer aus scikit-learn verwenden, um die Normalisierung durchzuführen.

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)

Kodierung kategorischer Merkmale

Kategorische Merkmale müssen in numerische Werte kodiert werden, bevor sie in Machine-Learning-Algorithmen verwendet werden können. Wir können den OrdinalEncoder und den OneHotEncoder aus scikit-learn verwenden, um kategorische Merkmale zu kodieren.

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 von fehlenden Werten

Fehlende Werte in einem Datensatz können Probleme bei Machine-Learning-Algorithmen verursachen. Wir können die Methoden aus dem impute-Modul von scikit-learn verwenden, um fehlende Werte zu behandeln. Hier werden wir den SimpleImputer verwenden, um fehlende Werte zu imputieren.

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)

Erzeugung von Polynommerkmalen

Manchmal ist es vorteilhaft, der Komplexität eines Modells durch die Berücksichtigung nichtlinearer Merkmale der Eingabedaten hinzuzufügen. Wir können die PolynomialFeatures aus scikit-learn verwenden, um Polynommerkmale zu erzeugen.

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)

Erstellen benutzerdefinierter Transformatoren

In einigen Fällen möchten wir eine vorhandene Python-Funktion in einen Transformator umwandeln, um die Datenbereinigung oder -verarbeitung zu erleichtern. Wir können dies mit dem FunctionTransformer aus scikit-learn erreichen.

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

Zusammenfassung

Herzlichen Glückwunsch! Sie haben das Lab "Preprocessing Data" abgeschlossen. Sie können in LabEx weitere Labs ausprobieren, um Ihre Fähigkeiten zu verbessern.