Inżynieria cech

Inżynieria cech#

Definicja

Feature Engineering polega na przekształcaniu surowych danych w cechy użyteczne w procesie modelowania.

Info

Tworzenie zmiennych predykcyjnych zawsze powinno opierać się przede wszystkim na zrozumieniu danych i wiedzy biznesowej związanej z danym problemem. Istnieje jednak kilka standardowych technik, które można stosować do tworzenia cech w większości problemów, można tu wyróżnić:

  • przekształcanie zmiennych kategorycznych

  • zmienne na podstawie cech z daty

  • zmienne powstałe przez przesunięcie w czasie

  • transformacje zmiennych numerycznych

  • zmienne interakcji

Uwaga!

Feature Engineering stanowi jeden z ważniejszych etapów w procesie budowy uczenia maszynowego, dlatego należy mu poświęcić dużo uwagi. Często można uzyskać znacznie lepsze wyniki mając prosty model oparty na cechach predykcyjnych dobrze oddających naturę badanego zjawiska niż budując wyrafinowany model w oparciu o zbyt wąski zbiór zmiennych.

Tworzenie przykładowych zbiorów danych#

Zaprezentujemy tutaj 2 przykładowe zbiory danych o różnym charakterze oraz przykłady zmiennych predykcyjnych, które można wygenerować na ich podstawie

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

def generateIceCreamSalesData(month_coef=10000, week_coef=1000, day_coef=100, random_coef =10000):
    dates = pd.date_range(start="2018-01-01", end="2020-12-31", freq ="D")
    df = pd.DataFrame(dates, columns=["SalesDate"])
    df["Month"] = df.SalesDate.dt.month
    df["Week"] = df.SalesDate.dt.isocalendar().week
    df["WeekDay"] = df.SalesDate.dt.dayofweek+1
    df["IceCreamSales"] = (-1*np.power(df.Month-6,2)+np.power(6,2))*month_coef + (-1*np.power(df.Week-27,2)+np.power(27,2))*week_coef +df.WeekDay*day_coef +random_coef * np.random.randint(low =1,high =10, size=len(df))
    return df.loc[:,["SalesDate","IceCreamSales"]]

IceCream_df = generateIceCreamSalesData()
IceCream_df
SalesDate IceCreamSales
0 2018-01-01 183100
1 2018-01-02 233200
2 2018-01-03 173300
3 2018-01-04 173400
4 2018-01-05 223500
... ... ...
1091 2020-12-27 174700
1092 2020-12-28 133100
1093 2020-12-29 83200
1094 2020-12-30 73300
1095 2020-12-31 133400

1096 rows × 2 columns

def generate_used_cars_data(len_df =1000):
    conditions ={"very_bad":1,"bad":2,"medium":3,"good":4,"very_good":5}
    brands =["Fiat","Renault","VW", "Seat", "Skoda","Toyota", "Audi","BMW","Mercedes", "Bugatti"]
    standard_brands = ["Fiat","Renault","VW", "Seat", "Skoda","Toyota"]
    premium_brands = ["Audi","BMW","Mercedes"]
    luxury_brands = ["Bugatti"]
    dict_data ={"condition":np.random.choice(list(conditions.keys()),size=len_df, p = [0.05, 0.15, 0.3, 0.3,0.2 ]),
                "brand":np.random.choice(brands,size=len_df, p=[0.1]*10 ),
                "year_manufactured":np.random.randint(1950,2020,size =len_df)
               }
    df = pd.DataFrame(dict_data)
    df["age"] =2021- df.year_manufactured
    df["mileage"] = df.age *np.random.randint(100,10000, len_df)+np.random.randint(100,10000, len_df)
    
    df["selling_price"] = 100000*df["brand"].isin(standard_brands)+300000*df["brand"].isin(premium_brands)+600000*df["brand"].isin(luxury_brands)
    df["selling_price"] /= np.log1p(df.age)+np.log1p(df.mileage)
    df["condition_num"] = df.condition.map(lambda x:conditions[x])
    df["selling_price"] *=  np.log1p(df["condition_num"])
    df.loc[(df["brand"].isin(luxury_brands))&(df.year_manufactured<=1970)&(df["condition_num"]>3),"selling_price"] *=\
    np.log1p(df.loc[(df["brand"].isin(luxury_brands))&(df.year_manufactured<=1970)&(df["condition_num"]>3),"age"])
    df["selling_price"] = np.round(df["selling_price"])
    return df.loc[:,["selling_price","condition","mileage","brand","year_manufactured"]]

UsedCars_df =generate_used_cars_data()
UsedCars_df
selling_price condition mileage brand year_manufactured
0 31177.0 very_good 480427 Mercedes 1958
1 11937.0 good 55133 Toyota 2009
2 9980.0 good 258516 Fiat 1983
3 58139.0 medium 116723 Bugatti 2008
4 29311.0 good 279471 Mercedes 1971
... ... ... ... ... ...
995 26672.0 bad 15506 Mercedes 2007
996 28641.0 medium 84326 Mercedes 1998
997 52803.0 medium 111880 Bugatti 1960
998 4780.0 very_bad 116769 Toyota 2005
999 27000.0 medium 97860 Mercedes 1972

1000 rows × 5 columns

Cechy tworzone na podstawie danych czasowych#

Pierwszy zbiór danych nazwany tutaj IceCream_df de facto ma charakter szeregu czasowego i patrząc na poniższy wykres mógłby być z powodzeniem przewidywany dedykowanymi metodami do predykcji szeregów czasowych, jednak dla celów pokazania tworzenia zmiennych na podstawie danych o charakterze czasowym potraktujemy to zagadnienie jako problem regresyjny, w którym naszą zmienną celu będzie IceCreamSales.

IceCream_df.set_index("SalesDate").plot(figsize=(15,9), title="IceCream Sales")

<Axes: title={'center': 'IceCream Sales'}, xlabel='SalesDate'>
../_images/fe0ab62dea8ee00df68f416a614c3fba32c21a3a153e683c6153dc754c0d03de.png

Wyraźnie widać tutaj, że sprzedaż lodów ma silnie sezonowy charakter, stąd cechy wyciągnięte z daty powinny znacznie ułatwić dobrą predykcję. Funkcję generującą takie cechy zaprezentowano poniżej:

def extract_date_features(df, date_column):
    df_temp = df.copy()
    df_temp[date_column + 'Quarter'] = df_temp[date_column].dt.quarter
    df_temp[date_column + 'Month'] = df_temp[date_column].dt.month
    df_temp[date_column + 'Week'] = df_temp[date_column].dt.isocalendar().week
    # poniżej zwracany rozkład to 0-6, dodajemy 1 aby przejsc na bardziej intuicyjne wartości 1-7
    df_temp[date_column + 'WeekDay'] = df_temp[date_column].dt.dayofweek + 1 
    df_temp[date_column + 'YearDay'] = df_temp[date_column].dt.day_of_year
    df_temp[date_column + 'isWeekend'] = np.where(df_temp[date_column + 'WeekDay']>5,1,0)
    return df_temp

IceCream_df_extended = extract_date_features(IceCream_df,"SalesDate")
IceCream_df_extended
SalesDate IceCreamSales SalesDateQuarter SalesDateMonth SalesDateWeek SalesDateWeekDay SalesDateYearDay SalesDateisWeekend
0 2018-01-01 183100 1 1 1 1 1 0
1 2018-01-02 233200 1 1 1 2 2 0
2 2018-01-03 173300 1 1 1 3 3 0
3 2018-01-04 173400 1 1 1 4 4 0
4 2018-01-05 223500 1 1 1 5 5 0
... ... ... ... ... ... ... ... ...
1091 2020-12-27 174700 4 12 52 7 362 1
1092 2020-12-28 133100 4 12 53 1 363 0
1093 2020-12-29 83200 4 12 53 2 364 0
1094 2020-12-30 73300 4 12 53 3 365 0
1095 2020-12-31 133400 4 12 53 4 366 0

1096 rows × 8 columns

Cechy powstałe przez przesunięcie w czasie#

Analizując wykres można zaobserwować, że sprzedaż lodów nie jest liniowo zależna od zmiennych takich jak numer kwartału, numer miesiąca czy numer tygodnia, aby uzyskać lepsze wyniki warto zbudować cechy w oparciu o przesunięte w czasie wartości zmiennej celu.

Uwaga!

Przy korzystaniu ze zmiennych przesuniętych w czasie, w szczególności opartych o wcześniejsze wartości zmiennej celu należy zawsze wziąć pod uwagę jakie dane będziemy mieli dostępne na moment predykcji, inaczej możemy popełnić jeden z najczęstszych błędów czyli data leakage. Przy założeniu, że mamy przewidywać sprzedaż lodów np na rok do przodu wykorzystanie sprzedaży lodów z dnia poprzedniego stanowi data leakage, ponieważ ta informacja nie będzie dostępna na moment predykcji w tej samej formie. Moglibyśmy natomiast uwzględnić sprzedaż lodów sprzed roku, jako, że ta informacja będzie dostępna w tej samej formie.

Tutaj dla uproszczenia zakładamy chwilowo, że horyzont predykcji to tylko 1 dzień do przodu, co pozwoli zaprezentować większy zakres zmiennych przesuniętych w czasie.

def get_shifted_target_values(df, lag_values, date_column, target_column):
    df_temp = df.copy()
    df_temp =df_temp.sort_values(by=date_column)
    for lag in lag_values:
        df_temp[target_column +"_lagged_" + str(lag)] = df_temp[target_column].shift(lag)
    return df_temp

Uwzględniając, że przewidujemy z horyzontem czasowym tylko na dzień w przód, pierwszym kandydatem na wartość przesunięcia jest 1 dzień, jako, że w danych o charakterze szeregu czasowego podobieństwo kolejnych obserwacji będzie siłą rzeczy relatywnie wysokie. Z analizy wykresu można łatwo wywnioskować, że wartośc przesunięcia 365 dni również będzie miała dużą siłę predykcyjną. Ponadto można tutaj wypróbować 7 dni co powinno być przydatne w przypadku tygodniowej sezonowości danych

IceCream_df_extended = get_shifted_target_values(IceCream_df_extended, [1,7,365], "SalesDate","IceCreamSales")
IceCream_df_extended
SalesDate IceCreamSales SalesDateQuarter SalesDateMonth SalesDateWeek SalesDateWeekDay SalesDateYearDay SalesDateisWeekend IceCreamSales_lagged_1 IceCreamSales_lagged_7 IceCreamSales_lagged_365
0 2018-01-01 183100 1 1 1 1 1 0 <NA> <NA> <NA>
1 2018-01-02 233200 1 1 1 2 2 0 183100 <NA> <NA>
2 2018-01-03 173300 1 1 1 3 3 0 233200 <NA> <NA>
3 2018-01-04 173400 1 1 1 4 4 0 173300 <NA> <NA>
4 2018-01-05 223500 1 1 1 5 5 0 173400 <NA> <NA>
... ... ... ... ... ... ... ... ... ... ... ...
1091 2020-12-27 174700 4 12 52 7 362 1 134600 243700 194600
1092 2020-12-28 133100 4 12 53 1 363 0 174700 184100 174700
1093 2020-12-29 83200 4 12 53 2 364 0 133100 124200 133100
1094 2020-12-30 73300 4 12 53 3 365 0 83200 154300 83200
1095 2020-12-31 133400 4 12 53 4 366 0 73300 164400 223300

1096 rows × 11 columns

Widzimy, że początek zbioru danych zawiera teraz wartości puste, ze względu na fakt, że dla wartości z roku 2018 nie istniały obserwacje cofnięte o rok. Do pokazywania liczby niepustych wartości w ramce danych przydatna jest funkcja info z biblioteki pandas.

IceCream_df_extended.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1096 entries, 0 to 1095
Data columns (total 11 columns):
 #   Column                    Non-Null Count  Dtype         
---  ------                    --------------  -----         
 0   SalesDate                 1096 non-null   datetime64[ns]
 1   IceCreamSales             1096 non-null   Int64         
 2   SalesDateQuarter          1096 non-null   int32         
 3   SalesDateMonth            1096 non-null   int32         
 4   SalesDateWeek             1096 non-null   UInt32        
 5   SalesDateWeekDay          1096 non-null   int32         
 6   SalesDateYearDay          1096 non-null   int32         
 7   SalesDateisWeekend        1096 non-null   int32         
 8   IceCreamSales_lagged_1    1095 non-null   Int64         
 9   IceCreamSales_lagged_7    1089 non-null   Int64         
 10  IceCreamSales_lagged_365  731 non-null    Int64         
dtypes: Int64(4), UInt32(1), datetime64[ns](1), int32(5)
memory usage: 74.0 KB

oczywiście wartości puste należy potem w jakiś sposób obsłużyć, poprzez ich usunięcie lub imputację

Info

Tworząc zmienne oparte o cechy przesunięte w czasie warto mieć na uwadze, że dane historyczne mogą zawierać wartości odstające. Dlatego zamiast brać wprost wartość sprzed np. 365 dni można rozważyć wygładzenie wartości stosując medianę z 5 dniowego okna, którego środek stanowi wartość sprzed 365 dni.

Cechy kategoryczne i ich transformacje#

Dla zilustrowania transformacji na zmiennych kategorycznych posłużymy się drugim z przygotowanych zbiorów danych, gdzie chcemy przewidzieć cenę sprzedaży używanego samochodu.

UsedCars_df.head()
selling_price condition mileage brand year_manufactured
0 31177.0 very_good 480427 Mercedes 1958
1 11937.0 good 55133 Toyota 2009
2 9980.0 good 258516 Fiat 1983
3 58139.0 medium 116723 Bugatti 2008
4 29311.0 good 279471 Mercedes 1971

Jak widzimy występują tutaj 2 cechy kategoryczne condition oraz brand, na podstawie których zaprezentujemy które transformacje danych najlepiej zastosować w którym przypadku. Aby umożliwić wykorzystanie tych cech w predykcji niezbędne jest odpowiednie ich przekształcenie w wartości numeryczne.

UsedCars_df.condition.unique()

array(['very_good', 'good', 'medium', 'bad', 'very_bad'], dtype=object)

patrząc na atrybuty zmiennej condition widzimy, że ma ona charakter porządkowy - jesteśmy w stanie łatwo ustalić naturalną kolejność jej atrybutów. Stanowi ona zatem dobrego kandydata do zastosowania kodowania porządkowego.

Definicja

kodowania porządkowe (ang. Ordinal encoding) - reprezentacja każdego atrybutu kodowanej zmiennej jako kolejnej liczby naturalnej.

Poniżej zaprezentujemy kodowanie porządkowe z użyciem transformera OrdinalEncoder, najpierw jednak podzielimy nasze dane na zbiór treningowy i testowy, aby lepiej odwzorować to, że dane treningowe są oddzielone od danych produkcyjnych, na których model będzie potem stosowany.

from sklearn.preprocessing import OrdinalEncoder
from sklearn.model_selection import train_test_split

Tutaj dla uproszczenia stosujemy podział tylko na zbiór treningowy i testowy, generalnie najlepszą praktyką jest wydzielenie osobnego zbioru testowego reprezentującego zdolność modelu do generalizacji na nowych, niewidzianych wcześniej danych i dobór najlepszego zestawu parametrów i transformacji stosując walidację krzyżową (ang. cross-validation) na zbiorze treningowym.

X_train, X_test = train_test_split(UsedCars_df, test_size =0.25, random_state=42)

Następnie tworzymy obiekt klasy OrdinalEncoder, określamy tutaj porządek cechy atrybutów cechy, którą chcemy przetransformować, inaczej mogą one zostać po prostu posortowane alfabetycznie co najczęściej nie będzie odpowiadało ich znaczeniu biznesowemu.

oe= OrdinalEncoder(categories =[['very_bad', 'bad', 'medium', 'good', 'very_good']],
                   handle_unknown ='use_encoded_value', unknown_value=np.NaN)
Uwaga!

Kodując atrybuty należy mieć świadomość, że na nowych danych mogą pojawić się niewidziane wcześniej wartości, które należy w jakiś sposób obsłużyć. Domyślnym zachowaniem OrdinalEncoder w takiej sytuacji jest zwrócenie wyjątku, tutaj skorzystaliśmy z przypisania mu ustalonej wartości, gdzie wybraliśmy przypisanie wartości pustej. Następnie taką wartość można zastąpić np. dominantą ze zbioru treningowego, lub przypisać jej wartość neutralną, którą tutaj byłoby 2 odpowiadające kategorii medium.

Zdecydowanie najlepszym sposobem użycia wszystkich transformerów jest skorzystanie z pipeline, co zostanie zaprezentowane potem. Tutaj zaprezentujemy najprostsze wykorzystanie polegające na skorzystaniu z metod fit i transform. OrdinalEncoder stosujemy tylko do przekształcenia jednej cechy, gdyby było inaczej moglibyśmy wykonać fit na całym zbiorze treningowym a następnie przetransformować zbiory treningowy i testowy.

oe.fit(X_train.condition.values.reshape(-1, 1))
X_train["condition_transformed"] = oe.transform(X_train.condition.values.reshape(-1, 1))
X_test["condition_transformed"] = oe.transform(X_test.condition.values.reshape(-1, 1))
Uwaga!

Jeśli nie korzystamy z pipeline należy zwrócić szczególną uwagę żeby metody fit używać tylko na zbiorze treningowym a następnie mając już “nauczony” transformer stosować metodę transform na pozostałych zbiorach. Inaczej może dojść do przecieku informacji ze zbioru testowego.

Możemy jeszcze sprawdzić czy przypisanie atrybutów na zbiorach treningowym i testowym jest prawidłowe, a następnie pozbyć się pierwotnej kolumny, wartości pierwotne mogą być łatwo odzyskane z przetransformowanych danych stosując metodę inverse_transform.

X_train[["condition","condition_transformed"]].drop_duplicates().sort_values(by="condition_transformed")
condition condition_transformed
777 very_bad 0.0
323 bad 1.0
82 medium 2.0
991 good 3.0
894 very_good 4.0 
X_test[["condition","condition_transformed"]].drop_duplicates().sort_values(by="condition_transformed")
condition condition_transformed
740 very_bad 0.0
660 bad 1.0
859 medium 2.0
521 good 3.0
411 very_good 4.0 
X_train.drop(["condition"],axis=1, inplace=True)
X_test.drop(["condition"],axis=1, inplace=True)

X_train
selling_price mileage brand year_manufactured condition_transformed
82 9734.0 90070 VW 2005 2.0
991 40928.0 33220 Mercedes 2018 3.0
789 11695.0 28116 Renault 2017 2.0
894 263202.0 260642 Bugatti 1965 4.0
398 35576.0 55983 Audi 2008 3.0
... ... ... ... ... ...
106 10291.0 199870 Toyota 1991 3.0
270 24521.0 464421 BMW 1972 2.0
860 49449.0 325697 Bugatti 1960 2.0
435 9085.0 111523 Renault 1984 2.0
102 35939.0 86944 Audi 1986 4.0

750 rows × 5 columns

Widzimy, że do zakodowania pozostała nam jeszcze cecha - brand, w odróżnieniu od poprzednio rozważanej cechy tutaj nie ma oczywistego naturalnego porządku, dlatego należy tutaj zastosować inne podejście.

Definicja

kodowania 1 z n (ang. One-hot encoding) - reprezentacja każdego atrybutu kodowanej zmiennej jako osobnej zmiennej binarnej, gdzie występowanie rozważanego atrybutu dla danej obserwacji oznaczane jest jako 1, a wszystkie pozostałe atrybuty oznaczane są jako 0.

Kodowanie 1 z n stanowi jeden z najczęściej używanych i najbardziej intuicyjnych sposobów kodowania, jednak jego główną wadą jest zwiększanie wymiarowości danych, co zaraz zaprezentujemy.

Najpierw pokażemy jak posługiwać się transformerem OneHotEncoder.

from sklearn.preprocessing import OneHotEncoder

Tworzymy obiekt klasy OneHotEncoder, podobnie jak w przypadku poprzedniego transformera, tu także domyślnym sposobem obsługi nieznanych atrybutów jest zwracanie wyjątku, my wybieramy handle_unknown=”ignore” co sprawi, że nieznane atrybuty reprezentowane będą po prostu jako 0 we wszystkich zakodowanych kolumnach.

Natomiast ustawienie sparse_output=False sprawia, że zwracane dane będą typu np.array zamiast domyślnego sparse matrix.

ohe = OneHotEncoder(handle_unknown="ignore", sparse_output=False)

Należy zwrócić uwagę, że we wszystkich transformerach z biblioteki sklearn stosowane jest to samo API, w związku z tym tutaj analogicznie jak w poprzednim przypadku możemy skorzystać z metod fit i transform.

ohe.fit(X_train.brand.values.reshape(-1, 1))
brand_transformed_train = ohe.transform(X_train.brand.values.reshape(-1, 1))
brand_transformed_test = ohe.transform(X_test.brand.values.reshape(-1, 1))
print(f"rozmiar zakodowanej kolumny brand na danych treningowych to: {brand_transformed_train.shape}")
print(f"rozmiar zakodowanej kolumny brand na danych testowych to: {brand_transformed_test.shape}")
print(brand_transformed_train)

rozmiar zakodowanej kolumny brand na danych treningowych to: (750, 10)
rozmiar zakodowanej kolumny brand na danych testowych to: (250, 10)
[[0. 0. 0. ... 0. 0. 1.]
 [0. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 ...
 [0. 0. 1. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 [1. 0. 0. ... 0. 0. 0.]]

Jak widzimy kolumna brand reprezentowana jest teraz jako array gdzie każdy atrybut ze zbioru treningowego zaprezentowany jest w osobnej kolumnie binarnej. Można to sprawdzić zliczając liczbę unikalnych atrybutów tej kolumny na zbiorze treningowym.

X_train.brand.nunique()

10

Kolejność atrybutów odpowiadających kolumnom wynikowego arraya można zobaczyć korzystając z atrybutu categories_

ohe.categories_

[array(['Audi', 'BMW', 'Bugatti', 'Fiat', 'Mercedes', 'Renault', 'Seat',
        'Skoda', 'Toyota', 'VW'], dtype=object)]

Całą transformację wraz z dodaniem przetransformowanej zmiennej do zbioru treningowego można zrealizować za pomocą prostej funkcji.

def OneHotEncode(X_train, X_test, encoded_column_name, **encoder_kwargs):
    
    ohe = OneHotEncoder(**encoder_kwargs)
    ohe.fit(X_train[encoded_column_name].values.reshape(-1, 1))
    transformed_train = ohe.transform(X_train[encoded_column_name].values.reshape(-1, 1))
    transformed_test = ohe.transform(X_test[encoded_column_name].values.reshape(-1, 1))
    
    column_names = [encoded_column_name +"_"+category for category in list(ohe.categories_[0]) ]
    df_transformed_train = pd.DataFrame(transformed_train, columns = column_names)
    df_transformed_test = pd.DataFrame(transformed_test, columns = column_names)
    
    df_out_train = X_train.reset_index(drop=True).drop([encoded_column_name], axis=1)
    df_out_test = X_test.reset_index(drop=True).drop([encoded_column_name], axis=1)
    df_out_train = pd.concat([df_out_train, df_transformed_train],axis=1)
    df_out_test = pd.concat([df_out_test, df_transformed_test],axis=1)
    
    return df_out_train, df_out_test

Powyższa funkcja zwraca zbiór treningowy i testowy po dodaniu odpowiednio nazwanych kolumn powstałych po transformacji obiektem OneHotEncoder i usunięciu pierwotnej zmiennej. Argumenty do OneHotEncoder przekazywane są z pomocą **encoder_kwargs

X_train_ohe, X_test_ohe = OneHotEncode(X_train, X_test, "brand", handle_unknown="ignore",sparse_output=False)
X_train_ohe.head()
selling_price mileage year_manufactured condition_transformed brand_Audi brand_BMW brand_Bugatti brand_Fiat brand_Mercedes brand_Renault brand_Seat brand_Skoda brand_Toyota brand_VW
0 9734.0 90070 2005 2.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0
1 40928.0 33220 2018 3.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0
2 11695.0 28116 2017 2.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0
3 263202.0 260642 1965 4.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0
4 35576.0 55983 2008 3.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0
Info

Alternatywnie zamiast OneHotEncoder można wykorzystać funkcję get_dummies z biblioteki pandas, która jest nieco prostsza w użyciu, jednak OneHotEncoder jest lepiej dostosowany do obsługi niewidzianych wartości, a ponadto znacznie łatwiej go zastosować w ramach pipeline.

Jak widzimy nawet przy tak niskiej liczbie atrybutów wymiarowość naszych danych znacznie wzrosła. W prawdziwych zastosowaniach możemy się spotkać ze zbiorami danych mającymi wiele zmiennych kategorycznych o dziesiątkach lub setkach unikalnych atrybutów, więc metodę OneHotEncoder zaleca się stosować tylko tam, gdzie atrybuty są niezbyt liczne, w pozostałych sytuacjach lepiej skorzystać z kodowania zmienną celu

Definicja

kodowanie zmienną celu (ang. Target encoding) - reprezentacja każdego atrybutu kodowanej zmiennej jako estymata średniej wartości zmiennej celu na danych treningowych.

Kodowanie zmienną celu stanowi jedną z najbardziej uniwersalnych metod kodowania zmiennych kategorycznych, nie wymaga naturalnego porządku w danych jak kodowanie porządkowe i nie zwiększa wymiarowości danych jak kodowanie 1 z n.

Istnieje wiele różnych sposobów kodowania zmiennej celu, my tutaj posłużymy się metodą James-Stein Encoder dostępną w bibliotece category_encoders.

Definicja

Formuła na zakodowaną wartość k-tego atrybutu kodowanej zmiennej: $\( X_{k} = (1-B) *Avg(Y_{k}) +B*Avg(Y) \)$

gdzie:

\(X_{k}\) - wartość przypisana k-temu atrybutowi kodowanej zmiennej kategorycznej

\(Avg(Y_{k})\) - średnia wartości zmiennej celu dla k-tego atrybutu zmiennej kategorycznej

\(Avg(Y)\) - globalna średnia zmiennej celu na zbiorze treningowym

\(B\) -waga globalnej średniej, wyliczona według formuły: $\( B = \frac{Var(Y_{k})}{Var(Y) + Var(Y_{k})} \)$ gdzie:

\(Var(Y_{k})\) - wariancja zmiennej celu dla k-tego atrybutu zmiennej kategorycznej

\(Var(Y)\) - wariancja zmiennej celu dla całego zbioru treningowego

Importujemy potrzebną klasę.

from category_encoders.james_stein import JamesSteinEncoder

Tworzymy obiekt klasy JamesSteinEncoder, wybierając kolumnę brand do przekształcenia. Domyślnie przekształcone zostaną wszystkie kolumny kategoryczne.

jse = JamesSteinEncoder(cols=["brand"])

Tak jak w transformerach z biblioteki sklearn także tutaj posługujemy się metodami fit i transform, jednak jako, że jest to kodowanie zmienną celu niezbędne jest jej podanie do metody fit, dlatego najpierw wydzielimy zmienną celu.

y_train = X_train.selling_price
y_test = X_test.selling_price
X_train = X_train.drop("selling_price",axis=1)
X_test = X_test.drop("selling_price",axis=1)

jse.fit(X_train,y_train)
X_train_jse = jse.transform(X_train)
X_test_jse = jse.transform(X_test)
X_train_jse.head()
mileage brand year_manufactured condition_transformed
82 90070 9787.766659 2005 2.0
991 33220 30302.777850 2018 3.0
789 28116 10059.608852 2017 2.0
894 260642 45904.731329 1965 4.0
398 55983 28211.949596 2008 3.0

Jak widzimy zmienna brand została teraz zastąpiona estymatami średniej wartości zmiennej celu w zależności od brandu.

Łączenie atrybutów cech kategorycznych#

Oprócz standardowych metod transformacji zmiennych kategorycznych opisanych w poprzedniej sekcji można też stosować różne przekształcenia polegające na łączeniu pierwotnych atrybutów w podgrupy. Takie łączenie może być oparte na podobieństwie atrybutów pod katęm statystycznym np. zbliżony poziom średniej wartości zmiennej celu lub, co bardziej zalecane - na wiedzy domenowej.

Tutaj zaprezentujemy prosty przykład łączenia atrybutów oparty na wiedzy domenowej - załóżmy, że znamy podział wszystkich marek samochodów ze zmiennej brand na 3 relatywnie jednolite podgrupy - marki podstawowe, marki premium i marki luksusowe. Na tej podstawie stworzymy nową zmienną korzystając z prostej funkcji:

def brand_binning(brand):
    result ="standard"
    standard_brands = ["Fiat","Renault","VW", "Seat", "Skoda","Toyota"]
    premium_brands = ["Audi","BMW","Mercedes"]
    luxury_brands = ["Bugatti"]
    if brand in luxury_brands:
        result = "luxury"
    elif brand in premium_brands:
        result = "premium"
    return result

X_train["brand_binned"] = X_train["brand"].map(lambda x:brand_binning(x))
X_test["brand_binned"] = X_test["brand"].map(lambda x:brand_binning(x))
X_train.head()
mileage brand year_manufactured condition_transformed brand_binned
82 90070 VW 2005 2.0 standard
991 33220 Mercedes 2018 3.0 premium
789 28116 Renault 2017 2.0 standard
894 260642 Bugatti 1965 4.0 luxury
398 55983 Audi 2008 3.0 premium

Możemy też sprawdzić jak wygląda unikalne przypisanie pomiędzy pierwotną, a zgrupowaną zmienną:

X_train[["brand","brand_binned"]].drop_duplicates().sort_values(by="brand_binned")
brand brand_binned
894 Bugatti luxury
991 Mercedes premium
398 Audi premium
266 BMW premium
82 VW standard
789 Renault standard
323 Seat standard
731 Fiat standard
380 Toyota standard
797 Skoda standard

jak widzimy przypisanie zostało przeprowadzone poprawnie, nowa zmienna niesie mniej informacji niż zmienna pierwotna, dlatego zastąpienie nią pierwotnej zmiennej może być pomocne jeśli mamy problem z przeuczeniem modelu. Oczywiście tak powstałą zmienną należy potem jeszcze przetransformować zgodnie z wytycznymi z poprzedniej sekcji.

Cechy oparte na wiedzy domenowej oraz cechy interakcji#

Zaprezentowane powyżej grupowanie marek polegało na przekształceniu zmiennej kategorycznej w oparciu o wiedzę domenową. Tutaj pokażemy przykłady zastosowania wiedzy domenowej na zmiennych numerycznych i interakcji cech numerycznych i katgorycznych.

Przykładem prostej cechy opartej na wiedzy domenowej może być wiek samochodu w momencie sprzedaży. Nie mamy tutaj informacji o dacie transakcji, dlatego można dla ułatwienia założyć, że wszystkie transakcje odbyły się w bieżącym roku.

X_train["age"] = 2021 - X_train["year_manufactured"]
X_test["age"] = 2021 - X_test["year_manufactured"]
X_train
mileage brand year_manufactured condition_transformed brand_binned age
82 90070 VW 2005 2.0 standard 16
991 33220 Mercedes 2018 3.0 premium 3
789 28116 Renault 2017 2.0 standard 4
894 260642 Bugatti 1965 4.0 luxury 56
398 55983 Audi 2008 3.0 premium 13
... ... ... ... ... ... ...
106 199870 Toyota 1991 3.0 standard 30
270 464421 BMW 1972 2.0 premium 49
860 325697 Bugatti 1960 2.0 luxury 61
435 111523 Renault 1984 2.0 standard 37
102 86944 Audi 1986 4.0 premium 35

750 rows × 6 columns

Zmienne interakcji można wygenerować stosując np. iloczyny poszczególnych zmiennych numerycznych, tutaj wydaje się to nie być najlepszy pomysł, ponieważ intuicyjnie czujemy, że np mnożenie przebiegu * rok produkcji nie będzie zbyt dobrą cechą predykcyjną. Można natomiast wyliczyć np. średni roczny przebieg dzieląc przebieg przez dodany powyżej wiek samochodu.

X_train["avg_yearly_mileage"] = np.round(X_train["mileage"]/X_train["age"])
X_test["avg_yearly_mileage"] = np.round(X_test["mileage"]/X_test["age"])
X_train
mileage brand year_manufactured condition_transformed brand_binned age avg_yearly_mileage
82 90070 VW 2005 2.0 standard 16 5629.0
991 33220 Mercedes 2018 3.0 premium 3 11073.0
789 28116 Renault 2017 2.0 standard 4 7029.0
894 260642 Bugatti 1965 4.0 luxury 56 4654.0
398 55983 Audi 2008 3.0 premium 13 4306.0
... ... ... ... ... ... ... ...
106 199870 Toyota 1991 3.0 standard 30 6662.0
270 464421 BMW 1972 2.0 premium 49 9478.0
860 325697 Bugatti 1960 2.0 luxury 61 5339.0
435 111523 Renault 1984 2.0 standard 37 3014.0
102 86944 Audi 1986 4.0 premium 35 2484.0

750 rows × 7 columns

Innym przykładem zmiennej opartej stricte na wiedzy domenowej łączącej ze sobą informacje ze zmiennych numerycznych i kategorycznych mogła by być informacja o klasycznych modelach. Załóżmy, że modele luksusowych marek wyprodukowane przed 1970 rokiem są modelami klasycznymi i jeśli ich stan jest co najmniej dobry to ich cena jest znacznie wyższa niż by to wynikało z wieku auta, gdzie normalnie spodziewamy się ujemnej relacji z ceną sprzedaży.

X_train.loc[(X_train.brand_binned=="luxury")&(X_train.year_manufactured<=1970)&(X_train.condition_transformed>2.0),"is_classic"]=1
X_train["is_classic"] = X_train["is_classic"].fillna(0)
X_test.loc[(X_test.brand_binned=="luxury")&(X_test.year_manufactured<=1970)&(X_test.condition_transformed>2.0),"is_classic"]=1
X_test["is_classic"] = X_test["is_classic"].fillna(0)
X_train["is_classic"].value_counts()

is_classic
0.0    739
1.0     11
Name: count, dtype: int64

Takie przypadki są stosunkowo rzadkie, ale tego typu zmienna może pomóc w dokładniejszym przewidzeniu tych obserwacji.

Cechy oparte na transformacji zmiennych numerycznych#

Dość powszechnie spotykaną praktyką jest stosowanie nieliniowych transformacji zmiennych numerycznych, co zazwyczaj sprzyja uzyskaniu lepszej jakości predykcji ze względu na fakt, że modele najlepiej radzą sobie gdy rozkłady zmiennych są zbliżone do rozkładu normalnego.

Często spotykaną jest po prostu logarytmowanie zmiennych numerycznych, tutaj natomiast posłużymy się gotowym transformerem z biblioteki sklearn, a mianowicie PowerTransformer

from sklearn.preprocessing import PowerTransformer

Zanim dokonamy transformacji sprawdźmy jak wyglądają rozkłady zmiennych numerycznych, ograniczymy się tutaj do przebiegu, wieku i średniego przebiegu.

num_columns = ["mileage", "age","avg_yearly_mileage"]
X_train[num_columns].hist(figsize=(15,9), bins=30)

array([[<Axes: title={'center': 'mileage'}>,
        <Axes: title={'center': 'age'}>],
       [<Axes: title={'center': 'avg_yearly_mileage'}>, <Axes: >]],
      dtype=object)
../_images/df2f1be41983335cadc47e0e28678511fa94b0aa14ba18b3ef5be649cbcad109.png

Można tu zaobserwować, że rozkład przebiegu jest silnie skośny, pozostałe 2 zmienne mają rozkład zbliżony do jednostajnego.

pt=PowerTransformer(standardize=False)

Tworzymy obiekt klasy PowerTransformer, korzystamy tutaj z domyślnej transformacji Yeo-Johnson, zmieniamy natomiast ustawienie o sprowadzeniu do rozkładu o średniej równej 0 i odchyleniu standardowym równym 1, które domyślnie jest ustawione na True.

Info

Domyślna transformacja czyli metoda Yeo-Johnsona może być stosowana niezależnie od znaku transformowanych zmiennych, natomiast alternatywna transformacja Box-Cox wymaga ściśle dodatnich zmiennych na wejściu.

pt.fit(X_train[num_columns])
X_train_num_transformed = pd.DataFrame(pt.transform(X_train[num_columns]), columns =num_columns)
X_test_num_transformed =  pd.DataFrame(pt.transform(X_test[num_columns]), columns =num_columns)

Analogicznie jak przy poprzednio stosowanych transformerach korzystamy tutaj z metod fit i transform, a następnie konwertujemy wynik na ramkę danych.

Przeanalizujmy jak mocno zmieniły się rozkłady poszczególnych zmiennych:

X_train_num_transformed.hist(figsize=(15,9), bins=30)

array([[<Axes: title={'center': 'mileage'}>,
        <Axes: title={'center': 'age'}>],
       [<Axes: title={'center': 'avg_yearly_mileage'}>, <Axes: >]],
      dtype=object)
../_images/9b73b5a2d66dbd761869e81e7893411d55d7739351193fa207c8cb0ee196ab18.png 
X_test_num_transformed.hist(figsize=(15,9), bins=30)

array([[<Axes: title={'center': 'mileage'}>,
        <Axes: title={'center': 'age'}>],
       [<Axes: title={'center': 'avg_yearly_mileage'}>, <Axes: >]],
      dtype=object)
../_images/faba281d237fc9467ed87b1f53a1f8369a450f72542a602e86b8fcabd765c3b9.png

Zmienna mileage na zbiorze treningowym z silnie skośnej nabrała cech rozkładu normalnego, pozostałe przypadki nie wyglądają jednak na rozkład normalny.

Wypróbujmy inny sposób modyfikacji rozkładu - QuantileTransformer

from sklearn.preprocessing import QuantileTransformer

tworzymy obiekt klasy QuantileTransformer, zamiast bazowego rozkładu jednostajnego wybierając rozkład normalny

qt = QuantileTransformer(n_quantiles=100, output_distribution="normal")

qt.fit(X_train[num_columns])
X_train_num_transformed = pd.DataFrame(qt.transform(X_train[num_columns]), columns =num_columns)
X_test_num_transformed =  pd.DataFrame(qt.transform(X_test[num_columns]), columns =num_columns)

X_train_num_transformed.hist(figsize=(15,9), bins=30)

array([[<Axes: title={'center': 'mileage'}>,
        <Axes: title={'center': 'age'}>],
       [<Axes: title={'center': 'avg_yearly_mileage'}>, <Axes: >]],
      dtype=object)
../_images/bfc3c6f81710b21bf8dcc906f6367a749c251265de4063d64bcc01fad968b43e.png 
X_test_num_transformed.hist(figsize=(15,9), bins=30)

array([[<Axes: title={'center': 'mileage'}>,
        <Axes: title={'center': 'age'}>],
       [<Axes: title={'center': 'avg_yearly_mileage'}>, <Axes: >]],
      dtype=object)
../_images/c2986fa8eab1096b8034643f91e782114b3ccc9c45f36b510ba950b491ec6f44.png

Jak widzimy rozkłady są teraz zupełnie inne, na zbiorze treningowym bardzo zbliżone do rozkładu normalnego, jednak na zbiorze testowym juz dość znacznie się różnią, co może wynikać po części z niewielkiego rozmiaru próby.

Info

To jaki dokładnie zestaw transformacji ostatecznie wybrać powinno wynikać przede wszystkim z obserwacji ustalonej wcześniej metryki jakości modelu.

Łączenie zmiennych numerycznych w przedziały#

Podobnie jak w przypadku zmiennych kategorycznych, zmienne numeryczne również można przekształcać grupując razem pewne ich wartości. Proces taki nazywamy kubełkowaniem.

Definicja

Kubełkowanie (ang. binning) polega na łączeniu wartości zmiennych numerycznych w przedziały, ma to na celu zmniejszenie możliwości przeuczenia modelu.

Wybór takich przedziałów może występować zarówno na podstawie cech rozkładu zmiennych (np wartości kwartyli) jak i wiedzy domenowej, tutaj zaprezentujemy obie możliwości.

Do podziału wg statystyk pozycyjnych z rozkładu wykorzystamy funkcję qcut z biblioteki pandas.

X_train["mileage_binned_4"] = pd.qcut(X_train["mileage"], q=4)
X_train["mileage_binned_10"] = pd.qcut(X_train["mileage"], q=10)
X_train[["mileage","mileage_binned_4","mileage_binned_10"]]
mileage mileage_binned_4 mileage_binned_10
82 90070 (59171.0, 147567.5] (75319.3, 108682.0]
991 33220 (3425.999, 59171.0] (24242.6, 47628.0]
789 28116 (3425.999, 59171.0] (24242.6, 47628.0]
894 260642 (147567.5, 284573.75] (251218.4, 311300.6]
398 55983 (3425.999, 59171.0] (47628.0, 75319.3]
... ... ... ...
106 199870 (147567.5, 284573.75] (197371.2, 251218.4]
270 464421 (284573.75, 706399.0] (400413.4, 706399.0]
860 325697 (284573.75, 706399.0] (311300.6, 400413.4]
435 111523 (59171.0, 147567.5] (108682.0, 147567.5]
102 86944 (59171.0, 147567.5] (75319.3, 108682.0]

750 rows × 3 columns

Stworzyliśmy tutaj 2 nowe cechy na zbiorze treningowym w oparciu o kwartyle i decyle rozkładu zmiennej mileage. Jak widzimy poszczególnym wartościom przypisane zostały wartości przedziałów do których one wpadają w danym podziale na kubełki.

Jeśli chcemy samodzielnie określić etykiety przedziałów można posłużyć się parametrem labels

X_train["mileage_binned_4"] = pd.qcut(X_train["mileage"], q=4, labels=np.arange(1,5))
X_train["mileage_binned_10"] = pd.qcut(X_train["mileage"], q=10, labels=np.arange(1,11))
X_train[["mileage","mileage_binned_4","mileage_binned_10"]]
mileage mileage_binned_4 mileage_binned_10
82 90070 2 4
991 33220 1 2
789 28116 1 2
894 260642 3 8
398 55983 1 3
... ... ... ...
106 199870 3 7
270 464421 4 10
860 325697 4 9
435 111523 2 5
102 86944 2 4

750 rows × 3 columns

Uwaga!

Wszystkie przekształcenia wykorzystujące informacje o rozkładach cech należy implementować najpierw na zbiorze treningowym, a następnie w oparciu o rozkład ze zbioru treningowego - na zbiorze testowym. Inaczej wykorzystujemy informacje ze zbioru testowego i przestaje on być niezależny.

Tutaj możemy skorzystać z parametru retbins i dostać granice kubełków, a następnie w oparciu o te granice dokonać identycznego podziału na zbiorze testowym.

_, bins = pd.qcut(X_train["mileage"], q=4, retbins=True)
bins

array([  3426.  ,  59171.  , 147567.5 , 284573.75, 706399.  ])

Alternatywnym podejściem jest użycie funkcji cut z biblioteki pandas, która pozwala podzielić wartości zmiennej na zdefiniowaną liczbę przedziałów o identycznej szerokości lub przypisać je do zdefiniowanych samodzielnie przedziałów.

Załóżmy, że jeśli chodzi o wiek samochodu znaczenie mają przedziały do 3 lat, od 3 do 7, od 7 do 12, 12-25 oraz ponad 25. Możemy łatwo dokonać takiego przypisania przydzielając poszczególnym kubełkom odpowiednie nazwy:

X_train["age_binned"] = pd.cut(X_train["age"],[0,3,7,12,25,100], labels =["new","middle_age","old","very_old","extremely_old"] )
X_train[["age","age_binned"]]
age age_binned
82 16 very_old
991 3 new
789 4 middle_age
894 56 extremely_old
398 13 very_old
... ... ...
106 30 extremely_old
270 49 extremely_old
860 61 extremely_old
435 37 extremely_old
102 35 extremely_old

750 rows × 2 columns

Normalizacja i Standaryzacja#

Załóżmy, że finalnie mamy zbiór danych złożony stricte ze zmiennych numerycznych:

X_train = X_train.loc[:,["mileage","condition_transformed", "age","avg_yearly_mileage","is_classic"]]
X_test = X_test.loc[:,["mileage","condition_transformed", "age","avg_yearly_mileage","is_classic"]]
X_train
mileage condition_transformed age avg_yearly_mileage is_classic
82 90070 2.0 16 5629.0 0.0
991 33220 3.0 3 11073.0 0.0
789 28116 2.0 4 7029.0 0.0
894 260642 4.0 56 4654.0 1.0
398 55983 3.0 13 4306.0 0.0
... ... ... ... ... ...
106 199870 3.0 30 6662.0 0.0
270 464421 2.0 49 9478.0 0.0
860 325697 2.0 61 5339.0 0.0
435 111523 2.0 37 3014.0 0.0
102 86944 4.0 35 2484.0 0.0

750 rows × 5 columns

Możemy łatwo zaobserwować, że zmienne znacznie różnią się pod względem średniej czy wariancji:

np.round(X_train.describe(),2)
mileage condition_transformed age avg_yearly_mileage is_classic
count 750.00 750.00 750.00 750.00 750.00
mean 186124.88 2.43 36.17 5362.59 0.01
std 150773.18 1.11 20.31 2878.18 0.12
min 3426.00 0.00 2.00 190.00 0.00
25% 59171.00 2.00 18.00 2963.25 0.00
50% 147567.50 2.00 36.00 5336.00 0.00
75% 284573.75 3.00 54.00 7693.75 0.00
max 706399.00 4.00 71.00 13805.00 1.00

Niektóre metody modelowania są zależne od odległości bądź wariancji zmiennych, więc chcąc aby wpływ danej zmiennej na predykcje wynikał przede wszystkim z jej związku ze zmienną celu, a nie ze skali, powinniśmy zastosować normalizację lub standaryzację

zacznijmy od normalizacji, zrealizujemy ją za pomocą kolejnego transformera z biblioteki sklearn: MinMaxScaler

Definicja

Normalizacja polega na przekształcaniu zmiennej do zakresu wartości <0,1> poprzez odjęcie minumum i podzielenie przez różnicę pomiędzy maksimum, a minimum z rozkładu.

from sklearn.preprocessing import MinMaxScaler

Tworzymy obiekt klasy MinMaxScaler korzystając z bazowych ustawień, możliwa jest zmiana docelowego zakresu wartości z bazowego <0,1> na dowolnie wybrany poprzez użycie parametru feature_range

mm = MinMaxScaler()

Metody są oczywiście analogiczne jak w poprzednich przypadkach, konwertujemy wyniki z powrotem na ramki danych aby łatwiej było je oglądać.

mm.fit(X_train)
X_train_mm_scaled = pd.DataFrame(mm.transform(X_train), columns=X_train.columns)
X_test_mm_scaled = pd.DataFrame(mm.transform(X_test), columns=X_test.columns)
np.round(X_train_mm_scaled.describe(),2)
mileage condition_transformed age avg_yearly_mileage is_classic
count 750.00 750.00 750.00 750.00 750.00
mean 0.26 0.61 0.50 0.38 0.01
std 0.21 0.28 0.29 0.21 0.12
min 0.00 0.00 0.00 0.00 0.00
25% 0.08 0.50 0.23 0.20 0.00
50% 0.21 0.50 0.49 0.38 0.00
75% 0.40 0.75 0.75 0.55 0.00
max 1.00 1.00 1.00 1.00 1.00

Jak widzimy wszystkie cechy zostały teraz przeniesione do tego samego zakresu wartości <0,1>, ale ich średnia i odchylenie standardowe nie są identyczne. Oczywiście nie mamy gwarancji, że na nowych danych nie pojawią się wartości spoza wykresu widzianego na zbiorze treningowym. Jeśli chcemy być pewni, że znormalizowane zmienne zachowają swój zakres wartości należy tworząc obiekt klasy MinMaxScaler ustawić parametr clip na True.

Uwaga!

Nie zaleca się korzystania z MinMaxScaler dla zmiennych posiadających wartości odstające. Jeśli takie wartości nie zostaną wcześniej prawidłowo obsłużone, to większość “normalnych” wartości zmiennej będzie “upchana” w małym zakresie wartości co nie będzie sprzyjać jej wartości dla predykcji.

Zaprezentujemy teraz przykład standaryzacji z wykorzystaniem transformera StandardScaler z biblioteki sklearn.

Definicja

Standaryzacja polega na przekształcaniu zmiennej do rozkładu o wartości oczekiwanej 0 i odchyleniu standardowym 1 poprzez odjęcie średniej i podzielenie przez odchylenie standardowe.

from sklearn.preprocessing import StandardScaler

Tworzymy obiekt klasy StandardScaler korzystając z bazowych ustawień.

ss =StandardScaler()

Metody rownież są analogiczne jak w poprzednich przypadkach, konwertujemy wyniki z powrotem na ramki danych aby łatwiej było je oglądać.

ss.fit(X_train)
X_train_ss_scaled = pd.DataFrame(ss.transform(X_train), columns=X_train.columns)
X_test_ss_scaled = pd.DataFrame(ss.transform(X_test), columns=X_test.columns)
np.round(X_train_ss_scaled.describe(),2)
mileage condition_transformed age avg_yearly_mileage is_classic
count 750.00 750.00 750.00 750.00 750.00
mean 0.00 0.00 0.00 -0.00 0.00
std 1.00 1.00 1.00 1.00 1.00
min -1.21 -2.19 -1.68 -1.80 -0.12
25% -0.84 -0.38 -0.90 -0.83 -0.12
50% -0.26 -0.38 -0.01 -0.01 -0.12
75% 0.65 0.52 0.88 0.81 -0.12
max 3.45 1.42 1.72 2.94 8.20

W przeciwieństwie do poprzedniego przekształcenia zmienne mają identyczną średnią i odchylenie standardowe, za to różnią sie zakresami wartości.

Info

Jako że StandardScaler opiera się na użyciu średniej i odchylenia standardowego z transformowanej zmiennej, również nie jest on wolny od wpływu wartości odstających. Jeśli chcemy być pewni, że wartości odstające nie będą miały wpływu na skalę przekształconej zmiennej można skorzystać z klasy RobustScaler

Łączenie różnych transformacji w ramach pipeline#

Cofnijmy się teraz na chwilę do etapu generowania danych i zobaczmy jak można w łatwy i niezawodny sposób łączyć ze sobą różne transformacje z wykorzystaniem obiektów Pipeline oraz ColumnTransformer.

Definicja

Pipeline jest to przepływ danych przez ułożone w kolejności moduły wykonujące ustalone transformacje, zazwyczaj ostatnim elementem jest model predykcyjny.

UsedCars_df =generate_used_cars_data()
X = UsedCars_df.drop("selling_price",axis=1)
y = UsedCars_df["selling_price"]
X["age"] = 2021 - X["year_manufactured"]
X.drop("year_manufactured", axis=1, inplace=True)
X_train, X_test, y_train, y_test = train_test_split(X,y, test_size=0.25, random_state=42)
X_train
condition mileage brand age
82 good 148609 Toyota 33
991 medium 265511 Mercedes 46
789 bad 267325 BMW 34
894 bad 128838 Mercedes 14
398 very_good 56099 Bugatti 6
... ... ... ... ...
106 very_good 220605 Renault 41
270 bad 25647 Bugatti 3
860 good 130978 Skoda 69
435 medium 54449 Mercedes 12
102 very_good 173734 BMW 46

750 rows × 4 columns

Zdefiniujmy teraz grupy zmiennych, które będziemy poddawać poszczególnym transformacjom.

columns_for_ordinal_encoding =["condition"]
columns_for_target_encoding =["brand"]
numerical_columns =["age","mileage"]

Następnie importujemy niezbędne klasy.

from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline

Definiujemy pipeline do przetwarzania poszczególnych grup kolumn, pipeline mogą zawierać wiele kroków, tutaj dla uproszczenia wykorzystamy jednoelementowe.

pipeline_oe = Pipeline(steps =[("OrdinalEncoder",
                            OrdinalEncoder(
                               categories =[['very_bad', 'bad', 'medium', 'good', 'very_good']],
                               handle_unknown ='use_encoded_value', unknown_value=np.NaN))])

pipeline_jse = Pipeline(steps=[("JamesSteinEncoder",JamesSteinEncoder())])

pipeline_num = Pipeline(steps=[("PowerTransformer",PowerTransformer(standardize=False))])

Następnie przypisujemy zmienne do poszczególnych transformacji, korzystając z obiektu ColumnTransformer.

column_transformer = ColumnTransformer(
                        transformers=[
                         ('categorical_oe', pipeline_oe, columns_for_ordinal_encoding),
                         ('categorical_jse', pipeline_jse, columns_for_target_encoding),
                         ('numerical', pipeline_num, numerical_columns)
                         ])

Sam ColumnTransformer również może być częścią pipeline, przykładowo możemy na koniec zastosować standaryzacje.

preprocessing_pipeline = Pipeline(steps = [
                        ("column_transformer", column_transformer),
                        ("scaler",StandardScaler())
                    ])

Jeśli używamy pipeline bez modelu predykcyjnego na końcu to stosujemy te same metody co przy zwykłych transformerach.

preprocessing_pipeline.fit(X_train,y_train)

Pipeline(steps=[('column_transformer',
                 ColumnTransformer(transformers=[('categorical_oe',
                                                  Pipeline(steps=[('OrdinalEncoder',
                                                                   OrdinalEncoder(categories=[['very_bad',
                                                                                               'bad',
                                                                                               'medium',
                                                                                               'good',
                                                                                               'very_good']],
                                                                                  handle_unknown='use_encoded_value',
                                                                                  unknown_value=nan))]),
                                                  ['condition']),
                                                 ('categorical_jse',
                                                  Pipeline(steps=[('JamesSteinEncoder',
                                                                   JamesSteinEncoder())]),
                                                  ['brand']),
                                                 ('numerical',
                                                  Pipeline(steps=[('PowerTransformer',
                                                                   PowerTransformer(standardize=False))]),
                                                  ['age', 'mileage'])])),
                ('scaler', StandardScaler())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.

Po uruchomieniu metody fit widzimy wszystkie kroki całego pipeline.

X_train_transformed = preprocessing_pipeline.transform(X_train)
X_test_transformed = preprocessing_pipeline.transform(X_test)
print(f"rozmiar zbioru treningowego po transformacji: {X_train_transformed.shape}")
print(f"rozmiar zbioru testowego po transformacji: {X_test_transformed.shape}")
print(X_train_transformed)

rozmiar zbioru treningowego po transformacji: (750, 4)
rozmiar zbioru testowego po transformacji: (250, 4)
[[ 0.50587656 -0.7539805  -0.1243365   0.06738941]
 [-0.43325072  0.73826442  0.49518832  0.72375972]
 [-1.37237799  0.79688578 -0.07513987  0.73208546]
 ...
 [ 0.50587656 -0.78425597  1.51220275 -0.06236112]
 [-0.43325072  0.73826442 -1.25201323 -0.85198094]
 [ 1.44500383  0.79688578  0.49518832  0.23410118]]

Jak widzimy zwrócony zbiór treningowy ma typ danych array, a jego wymiary odpowiadają tym przed transformacją, zgodność wymiarów zależy jednak od zastosowanych transformacji.

Jeśli pipeline jest zakończony modelem predykcyjnym jego metody są identyczne jak metody modelu, czyli korzystamy z fit i predict, tak jak w poniższym przykładzie.

from sklearn.linear_model import LinearRegression

final_pipeline = Pipeline(steps = [
                ("preprocessing", preprocessing_pipeline),
                ("model", LinearRegression())
                ])

Poniżej pokazujemy jak wytrenować pipeline w oparciu o zbiór treningowy, a następnie dokonać predykcji na zbiorze testowym.

final_pipeline.fit(X_train, y_train)
X_test_predicted = pd.Series(final_pipeline.predict(X_test),name="prediction")
X_test_predicted.head()

0    -3726.001540
1    -4937.851707
2     3584.721377
3    66356.806370
4    11252.177654
Name: prediction, dtype: float64

Podsumowanie#

Powyżej zaprezentowaliśmy kilka różnych przykładów przekształcania surowych danych w cechy predykcyjne przydatne przy modelowaniu. Niektóre transformacje można z powodzeniem stosować przy pracy nad innymi problemami, inne należy raczej potraktować jako inspirację. Ważne aby prace nad Feature Engineering poprzedzone były dobrym zrozumieniem danych. Niezwykle ważne jest tutaj aby już na tym etapie stosować odpowiednią strategię walidacyjną, aby zapobiec korzystaniu z informacji ze zbioru testowego, inaczej nasze wyniki nie będą miarodajne.