4.1. Przeskalowywanie cechy

# Wczytanie bibliotek.
import numpy as np
from sklearn import preprocessing

# Utworzenie cechy.
feature = np.array([[-500.5],
                    [-100.1],
                    [0],
                    [100.1],
                    [900.9]])

# Utworzenie przelicznika, czyli egzemplarza typu MinMaxScaler.
minmax_scale = preprocessing.MinMaxScaler(feature_range=(0, 1))

# Skalowanie cechy.
scaled_feature = minmax_scale.fit_transform(feature)

# Wyświetlenie cechy.
scaled_feature

array([[ 0.        ],
       [ 0.28571429],
       [ 0.35714286],
       [ 0.42857143],
       [ 1.        ]])





4.2. Standaryzowanie cechy

# Wczytanie bibliotek.
import numpy as np
from sklearn import preprocessing

# Utworzenie cechy.
x = np.array([[-1000.1],
              [-200.2],
              [500.5],
              [600.6],
              [9000.9]])

# Utworzenie przelicznika.
scaler = preprocessing.StandardScaler()

# Przekształcenie cechy.
standardized = scaler.fit_transform(x)

# Wyświetlenie cechy.
standardized

array([[-0.76058269],
       [-0.54177196],
       [-0.35009716],
       [-0.32271504],
       [ 1.97516685]])





# Wyświetlenie średniej i odchylenia standardowego.
print("Średnia:", round(standardized.mean()))
print("Odchylenie standardowe:", standardized.std())

Średnia: 0.0
Odchylenie standardowe: 1.0





# Utworzenie przelicznika.
robust_scaler = preprocessing.RobustScaler()

# Przekształcenie cechy.
robust_scaler.fit_transform(x)

array([[ -1.87387612],
       [ -0.875     ],
       [  0.        ],
       [  0.125     ],
       [ 10.61488511]])





4.3. Normalizowanie obserwacji

# Wczytanie bibliotek.
import numpy as np
from sklearn.preprocessing import Normalizer

# Utworzenie macierzy cech.
features = np.array([[0.5, 0.5],
                     [1.1, 3.4],
                     [1.5, 20.2],
                     [1.63, 34.4],
                     [10.9, 3.3]])

# Zdefiniowanie normalizacji. 
normalizer = Normalizer(norm="l2")

# Przekształcenie macierzy cech.
normalizer.transform(features)

array([[ 0.70710678,  0.70710678],
       [ 0.30782029,  0.95144452],
       [ 0.07405353,  0.99725427],
       [ 0.04733062,  0.99887928],
       [ 0.95709822,  0.28976368]])





# Przekształcenie macierzy cech.
features_l2_norm = Normalizer(norm="l2").transform(features)

# Wyświetlenie macierzy cech.
features_l2_norm

array([[ 0.70710678,  0.70710678],
       [ 0.30782029,  0.95144452],
       [ 0.07405353,  0.99725427],
       [ 0.04733062,  0.99887928],
       [ 0.95709822,  0.28976368]])





# Przekształcenie macierzy cech.
features_l1_norm = Normalizer(norm="l1").transform(features)

# Wyświetlenie macierzy cech.
features_l1_norm

array([[ 0.5       ,  0.5       ],
       [ 0.24444444,  0.75555556],
       [ 0.06912442,  0.93087558],
       [ 0.04524008,  0.95475992],
       [ 0.76760563,  0.23239437]])





# Wyświetlenie sumy.
print("Suma wartości pierwszej obserwacji:",
   features_l1_norm[0, 0] + features_l1_norm[0, 1])

Suma wartości pierwszej obserwacji: 1.0





4.4. Generowanie cech wielomianowych i interakcji

# Wczytanie bibliotek.
import numpy as np
from sklearn.preprocessing import PolynomialFeatures

# Utworzenie macierzy cech.
features = np.array([[2, 3],
                     [2, 3],
                     [2, 3]])

# Utworzenie obiektu typu PolynomialFeatures.
polynomial_interaction = PolynomialFeatures(degree=2, include_bias=False)

# Utworzenie cech wielomianowych.
polynomial_interaction.fit_transform(features)

array([[ 2.,  3.,  4.,  6.,  9.],
       [ 2.,  3.,  4.,  6.,  9.],
       [ 2.,  3.,  4.,  6.,  9.]])





interaction = PolynomialFeatures(degree=2,
              interaction_only=True, include_bias=False)
interaction.fit_transform(features)

array([[ 2.,  3.,  6.],
       [ 2.,  3.,  6.],
       [ 2.,  3.,  6.]])





4.5. Transformacja cech

# Wczytanie bibliotek.
import numpy as np
from sklearn.preprocessing import FunctionTransformer

# Utworzenie macierzy cech.
features = np.array([[2, 3],
                     [2, 3],
                     [2, 3]])

# Zdefiniowanie prostej funkcji.
def add_ten(x: int) -> int:
    return x + 10

# Przygotowanie operacji przekształcenia.
ten_transformer = FunctionTransformer(add_ten)

# Przekształcenie macierzy cech.
ten_transformer.transform(features)

array([[12, 13],
       [12, 13],
       [12, 13]])





# Wczytanie biblioteki.
import pandas as pd

# Utworzenie obiektu typu DataFrame.
df = pd.DataFrame(features, columns=["feature_1", "feature_2"])

# Wywołanie funkcji.
df.apply(add_ten)





4.6. Wykrywanie elementów odstających

# Wczytanie bibliotek.
import numpy as np
from sklearn.covariance import EllipticEnvelope
from sklearn.datasets import make_blobs

# Utworzenie symulowanych danych.
features, _ = make_blobs(n_samples = 10,
                         n_features = 2,
                         centers = 1,
                         random_state = 1)

# Zastąpienie wartości pierwszej obserwacji wartościami odstającymi.
features[0,0] = 10000
features[0,1] = 10000

# Utworzenie detektora.
outlier_detector = EllipticEnvelope(contamination=.1)

# Wypełnienie detektora.
outlier_detector.fit(features)

# Wykrywanie elementów odstających.
outlier_detector.predict(features)

array([-1,  1,  1,  1,  1,  1,  1,  1,  1,  1])





# Utworzenie jednej cechy.
feature = features[:,0]

# Utworzenie funkcji zwracającej indeks elementów odstających.
def indicies_of_outliers(x: int) -> np.array(int):
    q1, q3 = np.percentile(x, [25, 75])
    iqr = q3 - q1
    lower_bound = q1 - (iqr * 1.5)
    upper_bound = q3 + (iqr * 1.5)
    return np.where((x > upper_bound) | (x < lower_bound))

# Wywołanie zdefiniowanej funkcji.
indicies_of_outliers(feature)

(array([0]),)





4.7. Obsługa elementów odstających

# Wczytanie biblioteki.
import pandas as pd

# Utworzenie obiektu typu DataFrame.
houses = pd.DataFrame()
houses['Price'] = [534433, 392333, 293222, 4322032]
houses['Bathrooms'] = [2, 3.5, 2, 116]
houses['Square_Feet'] = [1500, 2500, 1500, 48000]

# Filtrowanie obserwacji.
houses[houses['Bathrooms'] < 20]





# Wczytanie biblioteki.
import numpy as np

# Utworzenie cechy na podstawie wyrażenia boolowskiego.
houses["Outlier"] = np.where(houses["Bathrooms"] < 20, 0, 1)

# Wyświetlenie danych.
houses





# Obliczenie logarytmu cechy.
houses["Log_Of_Square_Feet"] = [np.log(x) for x in houses["Square_Feet"]]

# Wyświetlenie danych.
houses





4.8. Dyskretyzacja cech

# Wczytanie bibliotek.
import numpy as np
from sklearn.preprocessing import Binarizer

# Utworzenie cechy.
age = np.array([[6],
                [12],
                [20],
                [36],
                [65]])

# Utworzenie egzemplarza klasy Binarizer.
binarizer = Binarizer(threshold=18)

# Przekształcenie cechy.
binarizer.fit_transform(age)

array([[0],
       [0],
       [1],
       [1],
       [1]])





# Wartości progowe cechy.
np.digitize(age, bins=[20,30,64])

array([[0],
       [0],
       [1],
       [2],
       [3]])





# Wartości progowe cechy.
np.digitize(age, bins=[20,30,64], right=True)

array([[0],
       [0],
       [0],
       [2],
       [3]])





# Wartości progowe cechy.
np.digitize(age, bins=[18])

array([[0],
       [0],
       [1],
       [1],
       [1]])





4.9. Grupowanie obserwacji przy użyciu klastra

# Wczytanie bibliotek.
import pandas as pd
from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans

# Utworzenie symulowanej macierzy cech.
features, _ = make_blobs(n_samples = 50,
                         n_features = 2,
                         centers = 3,
                         random_state = 1)

# Utworzenie obiektu typu DataFrame.
dataframe = pd.DataFrame(features, columns=["feature_1", "feature_2"])

# Utworzenie klastra za pomocą algorytmu k średnich.
clusterer = KMeans(3, random_state=0)

# Wypełnienie klastra.
clusterer.fit(features)

# Prognozowanie wartości.
dataframe["group"] = clusterer.predict(features)

# Wyświetlenie kilku pierwszych obserwacji.
dataframe.head(5)





4.10. Usuwanie obserwacji, w których brakuje wartości

# Wczytanie biblioteki.
import numpy as np

# Utworzenie macierzy cech.
features = np.array([[1.1, 11.1],
                     [2.2, 22.2],
                     [3.3, 33.3],
                     [4.4, 44.4],
                     [np.nan, 55]])

# Zachowanie jedynie tych obserwacji, w których nie brakuje danych (co jest możliwe dzięki użyciu znaku ~).
features[~np.isnan(features).any(axis=1)]

array([[  1.1,  11.1],
       [  2.2,  22.2],
       [  3.3,  33.3],
       [  4.4,  44.4]])





# Wczytanie biblioteki.
import pandas as pd

# Wczytanie danych.
dataframe = pd.DataFrame(features, columns=["feature_1", "feature_2"])

# Usunięcie obserwacji, w których brakuje wartości.
dataframe.dropna()





4.11. Uzupełnianie brakujących wartości

# Wczytanie bibliotek.
import numpy as np
from sklearn.impute import KNNImputer
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_blobs

# Utworzenie symulowanej macierzy cech.
features, _ = make_blobs(n_samples = 1000,
                         n_features = 2,
                         random_state = 1)

# Standaryzacja cech.
scaler = StandardScaler()
standardized_features = scaler.fit_transform(features)

# Pozbycie się pierwszej wartości pierwszej cechy.
true_value = standardized_features[0,0]
standardized_features[0,0] = np.nan

# Prognozowanie brakującej wartości w macierzy cech.
knn_imputer = KNNImputer(n_neighbors=5)
features_knn_imputed = knn_imputer.fit_transform(standardized_features)

# Porównanie wartości rzeczywistej i prognozowanej.
print("Wartość rzeczywista:", true_value)
print("Wartość prognozowana:", features_knn_imputed[0,0])

Wartość rzeczywista: 0.8730186114
Wartość prognozowana: 1.09553327131





# Wczytanie bibliotek.
import numpy as np
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_blobs

# Utworzenie symulowanej macierzy cech.
features, _ = make_blobs(n_samples = 1000,
                         n_features = 2,
                         random_state = 1)

# Standaryzacja cech.
scaler = StandardScaler()
standardized_features = scaler.fit_transform(features)

# Pozbycie się pierwszej wartości pierwszej cechy.
true_value = standardized_features[0,0]
standardized_features[0,0] = np.nan

# Utworzenie obiektu modułu Imputer i użycie strategii „średniej”.
mean_imputer = SimpleImputer(strategy="mean")

# Wygenerowanie wartości.
features_mean_imputed = mean_imputer.fit_transform(features)

# Porównanie wartości rzeczywistej i prognozowanej.
print("Wartość rzeczywista:", true_value)
print("Wartość prognozowana:", features_mean_imputed[0,0])

Wartość rzeczywista: 0.8730186114
Wartość prognozowana: -3.05837272461
