PythonDeep Learning

pytorch & sklearn pipeline

, , ,
  • 저는 tabular data를 다룹니다.
  • 간혹 딥러닝을 하고 싶지만 표준화등 전처리도 해야 합니다.
  • 범주형 변수를 인코딩해서 feature importance도 보고 싶습니다.
  • skorch(sklearn + pytorch)를 사용하면 가능합니다.

1. skorch = sklearn + pytorch

skorch documentation
skorch tutorials

  • 저같은 사람들을 위해 skorch라는 라이브러리가 있습니다.
  • scikit-learn의 장점인 grid search 등을 딥러닝과 함께 사용할 수 있고
  • tutorial에서 transfer learning, U-Net, Seq2Seq 등을 지원합니다.


2. sklearn pipeline

scikit-learn.pipeline.Pipeline

  • scikit-learn의 파이프라인은 데이터 전처리에서 발생하는 불확실성을 줄여줍니다.
  • 데이터가 거쳐갈 길을 단단하게 만들어줌으로써 실수를 사전에 예방할 수 있습니다.
  • 특히 PCA나 One-hot encoding처럼 trainset의 정보를 기억해서 testset에 적용해야 할 때 좋습니다.

2.1. 예제 데이터셋

  • 펭귄 데이터셋을 사용해서 펭귄 체중 예측모델을 만들어 봅니다.
  • 편의를 위해 결측치까지 싹 지운 채로 시작합니다.
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    %matplotlib inline

    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt
    import seaborn as sns
    from copy import deepcopy

    # 시각화 설정
    sns.set_context("talk")
    sns.set_style("white")
    font_title = {"color":"gray"}

    # Linux 한글 사용 설정
    plt.rcParams['font.family']=['NanumGothic', 'sans-serif']
    plt.rcParams['axes.unicode_minus'] = False

    # 펭귄 데이터셋 불러오기
    df_peng = sns.load_dataset("penguins")
    df_peng.dropna(inplace=True)
    df_peng.isna().sum()
  • 실행 결과: 결측치가 모두 제거되었습니다.
    1
    2
    3
    4
    5
    6
    7
    8
    species              0
    island               0
    bill_length_mm       0
    bill_depth_mm        0
    flipper_length_mm    0
    body_mass_g          0
    sex                  0
    dtype: int64
  • 데이터셋을 준비합니다.
  • 펭귄 체중만 y, 나머지는 모두 X입니다.
    1
    2
    3
    y = df_peng["body_mass_g"]
    X = df_peng.drop("body_mass_g", axis=1)
    X.head(3)

  • trainset과 testset으로 나눕니다.
    1
    2
    3
    4
    # data split
    from sklearn.model_selection import train_test_split

    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

2.2. pipeline 구축

  • scikit-learn으로 pipeline을 구축합니다.
  • numerical feature는 회귀모델 적용을 고려한 PolynomialFeatures와
  • 데이터 정규화를 위한 RobustScaler를 거칩니다.
  • categorical feature는 OneHotEncoder를 거칩니다.

  • 필요한 라이브러리를 불러옵니다.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    # encoder
    from sklearn.preprocessing import OneHotEncoder
    from sklearn.preprocessing import RobustScaler

    # machine learning models
    from sklearn.linear_model import LinearRegression
    from sklearn.ensemble import RandomForestRegressor
    from sklearn.preprocessing import PolynomialFeatures

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

    # metrics
    from sklearn.metrics import r2_score
    from sklearn.metrics import mean_squared_error

  • pipeline을 구축하는 함수를 만듭니다.

  • get_model_0()을 실행하면 파이프라인이 만들어질 것입니다.

  • 전처리 후 머신러닝 모델로는 선형회귀와 랜덤포레스트를 선택할 수 있습니다.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    def get_model_0(X_cols, degree=1, method="lr"):
        
        X_cols_ = deepcopy(X_cols)
        
        # 1-1.categorical feature에 one-hot encoding 적용
        cat_features = list(set(X_cols) & set(["species", "island", "sex"]))
        cat_transformer = OneHotEncoder(sparse=False, handle_unknown="ignore")

        # 1-2.numerical feature는 Power Transform과 Scaler를 거침
        num_features = list(set(X_cols) - set(cat_features))
        num_features.sort()
        num_transformer = Pipeline(steps=[("polynomial", PolynomialFeatures(degree=degree)), 
                                          ("scaler", RobustScaler())
                                         ])

        # 1. 인자 종류별 전처리 적용
        preprocessor = ColumnTransformer(transformers=[("num", num_transformer, num_features), 
                                                       ("cat", cat_transformer, cat_features)])
        
        # 2. 전처리 후 머신러닝 모델 적용
        if method == "lr":
            ml = LinearRegression(fit_intercept=True)
        elif method == "rf":
            ml = RandomForestRegressor()

            
        # 3. Pipeline
        model = Pipeline(steps=[("preprocessor", preprocessor), 
                                ("ml", ml)])
        
        return model

  • 6번째, 10번째 행을 보시면 조금 특이한 처리가 들어가 있습니다.

  • feature selection에 사용되는 장치입니다.

  • feature 이름들을 하드코딩하면 feature selection이 불가능하기 때문에 이렇게 합니다.

  • 만들어진 구조를 확인합니다.
  • 일단 모든 인자를 모두 입력합니다.
    1
    2
    3
    4
    from sklearn import set_config
    set_config(display='diagram')
    model_0 = get_model_0(list(X_train.columns), degree=1, method="lr")
    model_0

2.3. pipeline 전처리 확인

  • pipeline에서 전처리 모듈만 떼어서 실행합니다.
  • pipeline의 모듈을 호출하는 방법은 모델이름[“모듈이름”]입니다.
  • 따라서 우리의 전처리 모듈은 model_0[“preprocessor”]입니다.
    1
    2
    3
    X_train_pp = model_0["preprocessor"].fit_transform(X_train)
    print(X_train_pp.shape)
    X_train_pp[0]
  • 실행 결과: 첫 행만 찍어봤습니다. 숫자가 많습니다
    1
    2
    3
    4
    (266, 12)
    array([ 0.        , -0.80645161,  0.08579088,  1.        ,  1.        ,
            0.        ,  0.        ,  0.        ,  0.        ,  1.        ,
            0.        ,  1.        ])
  • 6개의 인자를 넣었는데 12개가 나왔습니다.
  • 처음의 0은 LinearRegression에서 만든 intercept 항입니다.
  • 네번째 1부터는 species, island, sex의 one-hot encoding 결과물입니다.
  • 전처리 이후 데이터 분포도 확인합니다.
  • 시각화 코드는 다소 길고, 여기선 중요하지 않아서 접었습니다.
    코드 보기/접기 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    # Figure 생성
    fig = plt.figure(figsize=(12, 8), constrained_layout=True)

    # Subfigures 생성
    subfigs = fig.subfigures(nrows=2, wspace=0.05)
    subfigs[0].set_facecolor("lightgray")
    subfigs[1].set_facecolor("beige")

    # subfigs[0]: raw data
    axs0 = subfigs[0].subplots(ncols=3, nrows=1)

    sns.kdeplot(X_train["bill_depth_mm"], cut=0, fill=True, ax=axs0[0])
    sns.kdeplot(X_train["bill_length_mm"], cut=0, fill=True, ax=axs0[1])
    sns.kdeplot(X_train["flipper_length_mm"], cut=0, fill=True, ax=axs0[2])

    # subfigs[1]: preprocessed data
    axs1 = subfigs[1].subplots(ncols=3, nrows=1)

    sns.kdeplot(X_train_pp[:,1], cut=0, fill=True, ax=axs1[0])
    sns.kdeplot(X_train_pp[:,2], cut=0, fill=True, ax=axs1[1])
    sns.kdeplot(X_train_pp[:,3], cut=0, fill=True, ax=axs1[2])

    for ax in axs1:
        ax.axvline(0, c="gray", alpha=0.5)

    for axs in [axs0, axs1]:
        for i, (ax, title) in enumerate(zip(axs, ['bill_depth_mm', 'bill_length_mm', 'flipper_length_mm'])):
            ax.set_xlabel("")
            ax.set_title(f"{title}", fontdict=font_title, pad=16)
            if i > 0:
                ax.set_ylabel(" \n")

    subfigs[0].suptitle("raw data\n", fontweight="bold")
    subfigs[1].suptitle("preprocessed data\n", fontweight="bold")
    fig.suptitle(" ")


  • RobustScaler의 효과가 잘 보입니다.

2.3. pipeline 학습

  • pipeline 전체를 사용해서 학습시킵니다.

  • 명령은 scikit-learn 스타일 그대로 .fit()입니다.

    1
    model_0.fit(X_train, y_train)

  • 학습이 잘 되었는지 결과를 확인합니다.

  • parity plot 시각화 코드는 접어두었습니다.

    코드 보기/접기 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    # parity plot
    def plot_parity(model, y_true, y_pred=None, X_to_pred=None, ax=None, **kwargs):
        if not ax:
            fig, ax = plt.subplots(figsize=(5, 5))
        
        if y_pred is None:
            y_pred = model.predict(X_to_pred)
        ax.scatter(y_true, y_pred, **kwargs)
        xbound = ax.get_xbound()
        xticks = [x for x in ax.get_xticks() if xbound[0] <= x <= xbound[1]]
        ax.set_xticks(xticks)
        ax.set_xticklabels([f"{x:.0f}" for x in xticks])
        ax.set_yticks(xticks)
        ax.set_yticklabels([f"{x:.0f}" for x in xticks])
        dxbound = 0.05*(xbound[1]-xbound[0])
        ax.set_xlim(xbound[0]-dxbound, xbound[1]+dxbound)
        ax.set_ylim(xbound[0]-dxbound, xbound[1]+dxbound)
        
        rmse = mean_squared_error(y_true, y_pred, squared=False)
        r2 = r2_score(y_true, y_pred)
        ax.text(0.95, 0.1, f"RMSE = {rmse:.2f}\nR2 = {r2:.2f}", transform=ax.transAxes, 
                fontsize=14, ha="right", va="bottom", bbox={"boxstyle":"round", "fc":"w", "pad":0.3})
        
        ax.grid(True)
        
        return ax
        
    fig, axs = plt.subplots(ncols=2, figsize=(8, 4), constrained_layout=True, sharey=True)
    plot_parity(model_0, y_train, X_to_pred=X_train, ax=axs[0], c="g", s=10, alpha=0.5)
    plot_parity(model_0, y_test, X_to_pred=X_test, ax=axs[1], c="m", s=10, alpha=0.5)

    for ax, title in zip(axs, ["train", "test"]):
        ax.set_title(title, fontdict=font_title, pad=16)


  • 단순 선형 회귀 모델인데 제법 쓸만합니다.

  • 이제 pipeline에 랜덤포레스트 모델을 탑재해서 돌려봅니다.

    1
    2
    3
    model_1 = get_model_0(list(X_train.columns), degree=1, method="rf")
    model_1.fit(X_train, y_train)
    model_1


  • 과적합이 의심되긴 하지만 랜덤포레스트도 잘 나오네요.

  • 이번에는 feature selection도 되는지 확인합니다.

  • 부리 길이bill_length_mm와 종species만 가지고 결과를 예측해봅니다.

    1
    2
    model_2 = get_model_0(["bill_length_mm", "species"], degree=1, method="rf")
    model_2.fit(X_train, y_train)


  • 멀쩡한 인자들을 제외했으니 성능이 떨어지는 건 정상입니다.

  • pipeline을 작성하기에 따라 feature 중 일부만 넣어도 동작한다는 것이 중요합니다.

3. pytorch deep learning

  • 딥러닝은 다른 방법에 비해 복잡하고 연산자원이 많이 들지만 장점이 많습니다.
  • 이미지나 시계열을 다룰 때 큰 힘을 발휘하는데, 간혹 tabular data에도 필요합니다.
  • pytorch만을 사용해서 모델을 만들어보고 pipeline에 탑재해서도 결과를 얻어봅니다.

3.1. pytorch only

  • 파이토치로 신경망 모델을 만들고 같은 데이터로 같은 문제를 풀어봅니다.

  • 간단한 신경망 모델을 만듭니다. 나중에 pipeline 안에 넣을 겁니다.

  • feature selection을 대비해서 input dimension을 가변적으로 만듭니다.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    from torch import optim
    from torch.optim.lr_scheduler import CyclicLR

    import torch
    import torch.nn as nn

    class RegressorModule(nn.Module): 
        def __init__(self, ninput=11, init_weights=True):
            super(RegressorModule, self).__init__()
            
            self.model = nn.Sequential(nn.Linear(ninput, 16),
                                       nn.ReLU(),
                                       nn.Linear(16, 16),
                                       nn.ReLU(),
                                       nn.Linear(16, 12),
                                       nn.ReLU(),
                                       nn.Linear(12, 8),
                                       nn.ReLU(),
                                       nn.Linear(8, 1),
                                       )
            if init_weights:
                self._initialize_weights()
            
        def forward(self, X, **kwargs):
            return self.model(X)
        
        def _initialize_weights(self):
            for m in self.modules():
                if isinstance(m, nn.Linear):
                    nn.init.normal_(m.weight, 0, 0.01)
                    nn.init.constant_(m.bias, 0)

  • pytorch에 데이터를 넣으려면 tensor로 만들어야 합니다.

    1
    2
    X_train_tensor = torch.Tensor(pd.get_dummies(X_train).astype(np.float32).values)
    y_train_tensor = torch.Tensor(y_train.astype(np.float32).values)

  • 지금 만든 모델에 학습을 시킬 수 있는 코드를 구현합니다.

  • 1만 epoch동안 충분히 데이터를 넣어봅니다.

  • loss function으로는 RMSELoss를 구현해서 사용했습니다.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    net = RegressorModule()

    class RMSELoss(nn.Module):
        def __init__(self, eps=1e-6):
            super().__init__()
            self.mse = nn.MSELoss()
            self.eps = eps
            
        def forward(self,yhat,y):
            loss = torch.sqrt(self.mse(yhat,y) + self.eps)
            return loss
        
    loss_func = RMSELoss()
    optimizer = optim.Adam(net.parameters(), lr=0.001)

    losses = []
    for i in range(10000):
        optimizer.zero_grad()
        output = net.forward(X_train_tensor)
        loss = loss_func(output, y_train_tensor.view(-1, 1))
        loss.backward()
        optimizer.step()
        
        losses.append(loss)
        
    plt.plot(losses)


  • 제법 학습이 잘 된 것 같습니다.

  • 예측 성능을 확인합니다.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    # numpy array를 pytorch tensor로 변환
    X_test_tensor = torch.Tensor(pd.get_dummies(X_test).astype(np.float32).values)

    # 예측값
    y_pred_train_tensor = net.forward(X_train_tensor)
    y_pred_test_tensor = net.forward(X_test_tensor)

    # pytorch tensor를 다시 numpy array로 변환
    y_pred_train = y_pred_train_tensor.detach().numpy()
    y_pred_test = y_pred_test_tensor.detach().numpy()


  • 딥러닝으로도 제법 괜찮은 성능이 나오는 것을 확인했습니다.

3.2. pytorch @pipeline

  • skorch를 이용해서 pytorch를 pipeline 안에 탑재합니다.
  • skorch은 pytorch를 scikit-learn 객체처럼 만들어주는 일을 합니다.
  • 그래서 skorch로 감싼 pytorch 객체의 학습은 fit()이고,
  • 예측은 .forward()</b>가 아니라 <b>.predict()입니다.
  • skorch의 NeuralNetRegressor()로 딥러닝 모듈 전체를 감싸고,
  • 학습에 필요한 인자를 매개변수로 전달합니다.
  • 그리고 중요한 사항이 하나 있습니다.
  • scikit-learn이 뱉는 np.float64를 np.float32로 변환해야 합니다.
  • 이를 위해 custom transformer를 만들어 적용합니다.
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    from skorch import NeuralNetRegressor
    from sklearn.base import BaseEstimator, TransformerMixin

    def get_model_T(X_cols, degree=1, method="lr"):
        
        X_cols_ = deepcopy(X_cols)
        
        # 1-1.categorical feature에 one-hot encoding 적용
        cat_features = list(set(X_cols) & set(["species", "island", "sex"]))
        cat_transformer = OneHotEncoder(sparse=False, handle_unknown="ignore")

        # 1-2.numerical feature는 Power Transform과 Scaler를 거침
        num_features = list(set(X_cols) - set(cat_features))
        num_features.sort()
        num_transformer = Pipeline(steps=[("polynomial", PolynomialFeatures(degree=degree)), 
                                          ("scaler", RobustScaler())
                                         ])

        # 1. 인자 종류별 전처리 적용
        preprocessor = ColumnTransformer(transformers=[("num", num_transformer, num_features), 
                                                       ("cat", cat_transformer, cat_features)])
        
        # 2. float64를 float32로 변환
        class FloatTransformer(BaseEstimator, TransformerMixin):
            def __init__(self):
                pass
            def fit(self, X, y=None):
                return self
            def transform(self, x):
                return np.array(x, dtype=np.float32)
        
        # 3. 전처리 후 머신러닝 모델 적용
        if method == "lr":
            ml = LinearRegression(fit_intercept=True)
        elif method == "rf":
            ml = RandomForestRegressor()
        elif method == "torch":
            ninput = len(num_features) + 1
            if "species" in cat_features:
                ninput += 3
            if "island" in cat_features:
                ninput += 3
            if "sex" in cat_features:
                ninput += 2
                
            net = NeuralNetRegressor(RegressorModule(ninput=ninput, init_weights=False),
                             max_epochs=1000, verbose=0,
                             warm_start=True,
    #                          device='cuda',
                             criterion=RMSELoss,
                             optimizer = optim.Adam,
                             optimizer__lr = 0.01
                            )
            ml = net

            
        # 3. Pipeline
        model = Pipeline(steps=[("preprocessor", preprocessor), 
                                ("float64to32", FloatTransformer()),
                                ("ml", ml)])
        
        return model

  • 모델을 만들고 확인합니다.

  • 앞서 pytorch로 구현한 뉴럴넷 구조가 그대로 들어가 있습니다.

    1
    2
    3
    model_T = get_model_T(list(X_train.columns), degree=1, method="torch")
    model_T.fit(X_train, y_train.astype(np.float32).values.reshape(-1, 1))
    model_T


  • 성능을 확인합니다. 준수하네요.

4. permutation feature importance

  • 같은 파이프라인에서 선형, 트리, 딥러닝이 모두 구현되었습니다.
  • 각각의 인자 중요도를 한번 확인해보겠습니다.
  • permutation importance를 사용합니다.
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    from sklearn.inspection import permutation_importance

    # Linear Regression
    pi_0 = permutation_importance(model_0, X_test, y_test, n_repeats=30, random_state=0)

    # Random Forest
    pi_1 = permutation_importance(model_1, X_test, y_test, n_repeats=30, random_state=0)

    # Neural Network
    pi_T = permutation_importance(model_T, X_test, y_test, n_repeats=30, random_state=0)

    # 시각화
    fig, axs = plt.subplots(ncols=3, figsize=(15, 5), constrained_layout=True, sharey=True)

    for ax, pi, title in zip(axs, [pi_0, pi_1, pi_T], ["Linear Reg.", "Random Forest", "Neural Net"]):
        ax.barh(X_test.columns, pi.importances_mean, xerr=pi.importances_std, color="orange")
        ax.invert_yaxis()
        ax.set_xlim(0, )
        ax.set_title(title, fontdict=font_title, pad=16)

  • 입력 feature별 인자 중요도가 깔끔하게 정리되었습니다.
  • 양상도 전반적으로 비슷하게 나오네요.
  • 사소한 기능같지만 tabular data를 딥러닝으로 돌렸을 때 이 그림을 그리기가 어려웠습니다.
  • 이 글과 코드가 비슷한 어려움을 겪는 여러분께 도움이 되면 좋겠습니다.


도움이 되셨나요? 카페인을 투입하시면 다음 포스팅으로 변환됩니다

Share