PythonData Science

Validation with Visualization (1)

, , , ,
  • 데이터 시각화는 머신러닝 과정을 확인하기 좋습니다.
  • 하이퍼파라미터에 따라 확인할 값이 여럿 있고,
  • 숫자로 확인할 수도 있지만 눈에 잘 들어오지 않아 그림으로 표현해 보았습니다.

1. 데이터 & 분석 설정

What’s new in Matplotlib 3.4.0

  • 필요한 라이브러리들을 불러옵니다.
  • 업데이트된 matplotlib 버전 3.4.1을 사용합니다.
  • 새로 생긴 기능을 사용해 볼 것입니다.
1
2
3
4
5
6
7
8
9
10
11
12
13
%matplotlib inline

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

sns.set_context("talk")
sns.set_style("white")
sns.set_palette("Pastel1")

import matplotlib as mpl
mpl.__verion__
  • 실행 결과 :
1
'3.4.1'

  • 현업 데이터를 가져왔습니다.

  • 범주형 2개, 수치형 3개, 400줄짜리 단촐한 데이터입니다.

  • 수치형 변수를 맞추는 regression 문제입니다.

  • train : test = 8 : 2로 분리합니다.

  • 제겐 굳이 index를 뽑아서 분리하는 버릇이 있습니다.

  • 여차할 때 확인해보기 좋습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
df_vcv = pd.read_csv("df_vcv.csv")

train_portion = 0.8

np.random.seed(42)
idx_train = np.random.choice(X.index, size=int(X.shape[0]*train_portion))
idx_test = list(set(X.index) - set(idx_train))

X_train = X.loc[idx_train]
X_test = X.loc[idx_test]

y_train = y.loc[idx_train]
y_test = y.loc[idx_test]

2. 데이터 분포 확인

  • 쪼갠 trainset, testset을 확인합니다.
  • 데이터 분포를 비율로 그려서 trainset과 testset이 비슷한지 봅니다.
  • train을 green, test를 magenta로 나란히 그려서 비교합니다.
코드 보기/접기 
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
fig, axes = plt.subplots(ncols=3, nrows=2, figsize=(12, 8))
axs = axes.ravel()

for ax, col in zip(axs, df_vcv.columns):

    # X features
    if col != "target":
        if df_vcv[col].dtype == "O": # categorical
            df_train = df_vcv.loc[idx_train, col].value_counts().reset_index()
            df_test = df_vcv.loc[idx_test, col].value_counts().reset_index()
            
            width_cat = 0.4
            ax.bar(df_train.index-width_cat/2, df_train[col]/len(idx_train), width=width_cat, ec="g", fc="#AAFFAADD")
            ax.bar(df_test.index+width_cat/2, df_test[col]/len(idx_test), width=width_cat, ec="m", fc="#FFAAFFDD")
            ax.set_xticks(list(range(df_train.shape[0])))
            ax.set_xticklabels(df_train["index"].values)
        
        else: # numerical
            bins = np.linspace(df_vcv[col].min(), df_vcv[col].max(), 20)
            bins_center = (bins[:-1] + bins[1:])/2
            bins_delta = bins[1] - bins[0]
            counts_train, bins_train = np.histogram(df_vcv.loc[idx_train, col], bins=bins)
            counts_test, bins_test = np.histogram(df_vcv.loc[idx_test, col], bins=bins)
            
            width_num = bins_delta/2
            ax.bar(bins_center-width_num/2, counts_train/len(idx_train), width=width_num, ec="g", fc="#AAFFAADD")
            ax.bar(bins_center+width_num/2, counts_test/len(idx_test), width=width_num, ec="m", fc="#FFAAFFDD")
            
    # y feature    
    else:
        sns.kdeplot(df_vcv.loc[idx_train, col], color="g", fill=True, ax=ax, label="train")
        sns.kdeplot(df_vcv.loc[idx_test, col], color="m", fill=True, ax=ax, label="test")
        ax.set_ylabel("")
    
    if col in ["A", "D"]:
        coltype = "categorical"
    else:
        coltype = "numerical"
        
    ax.set_title(f"{col} ({coltype})", pad=12)

handles, labels = axs[5].get_legend_handles_labels()
axs[2].legend(handles, labels, loc="upper left", bbox_to_anchor=(1,0.9))    
fig.tight_layout()
fig.savefig("6_vcv_01.png")


3. Machine Learning

  • 데이터 전처리와 선형회귀에 필요한 라이브러리를 불러옵니다.
1
2
3
4
5
6
7
8
9
10
11
# encoder
from sklearn.preprocessing import OneHotEncoder

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

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

3.1. Pipeline 구축

sklearn: Column Transformer with Mixed Types

  • scaler와 one-hot encoder 등을 수행하며 데이터가 바뀌는 과정을 바라볼 수 있습니다.

  • 변환이 눈과 손에 익지 않았을 때는 유용한 방법이지만 깊이 분석하기엔 한계가 있습니다.

  • 예를 들어 feature importance를 도출할 때, one-hot encoding이 수행된 범주형 인자는 원소 하나하나에 대한 중요도가 나와버려 정작 인자의 중요도를 구하기 어렵습니다.

  • 체계적으로 분석할 수 있도록 pipeline을 구축합시다.

  • 범주형 데이터와 수치형 데이터에 다른 전처리를 수행합니다.

  • sklearn의 set_config(display='diagram')을 이용하면 그림으로 볼 수 있습니다.

코드 보기/접기 
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
# linear regression model
def linear(degree):
    
    # categorical and numerical features
    cat_features = ["A", "D"]
    cat_transformer = OneHotEncoder(sparse=False)
    
    num_features = ["B", "C", "E"]
    num_transformer = Pipeline(steps=[("scaler", StandardScaler()),
                                      ("polynomial", PolynomialFeatures(degree=degree, 
                                                                        include_bias=True))])
    
    # preprocessor
    preprocessor = ColumnTransformer(transformers=[("num", num_transformer, num_features),
                                                   ("cat", cat_transformer, cat_features)
                                                  ])
    
    # modeling
    model = Pipeline(steps=[("preprocessor", preprocessor), 
                            ("linear", LinearRegression())
                           ])
    
    return model

# pipeline output    
from sklearn import set_config
set_config(display='diagram')  

model = linear(3)
display(model)

pipeline 구조

  • set_config(display='text')를 통해 출력 모드를 바꿀 수 있습니다.
1
2
set_config(display='text') 
model.fit(X_train, y_train)
  • 실행 결과
1
2
3
4
5
6
7
8
9
10
11
Pipeline(steps=[('preprocessor',
                 ColumnTransformer(transformers=[('num',
                                                  Pipeline(steps=[('scaler',
                                                                   StandardScaler()),
                                                                  ('polynomial',
                                                                   PolynomialFeatures(degree=3))]),
                                                  ['B', 'C', 'E']),
                                                 ('cat',
                                                  OneHotEncoder(sparse=False),
                                                  ['A', 'D'])])),
                ('linear', LinearRegression())])

3.2. 평가: metrics

  • 파이프라인으로 구축한 머신러닝 모델의 성능을 평가합니다.
  • 평가 지표로는 MAE(mean absolute error), RMSE(root mean squared error), R2(coefficient of determination)를 사용합니다.
  • 모델과 데이터를 넣으면 예측결과와 평가지표를 뽑아주는 함수를 만듭니다.
코드 보기/접기 
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
# evaluation metrics
from sklearn.metrics import mean_absolute_error as mae_
from sklearn.metrics import mean_squared_error as mse_
from sklearn.metrics import r2_score as r2_

# 평가지표 계산 함수
def get_metrics(model, X_train, X_test, y_train, y_test):
    # train
    y_pred_train = model.predict(X_train)
    mae_train = mae_(y_train, y_pred_train)
    rmse_train = np.sqrt(mse_(y_train, y_pred_train))
    r2_train = r2_(y_train, y_pred_train)

    # test
    y_pred_test = model.predict(X_test)
    mae_test = mae_(y_test, y_pred_test)
    rmse_test = mse_(y_test, y_pred_test, squared=False)
    r2_test = r2_(y_test, y_pred_test)

    return y_pred_train,y_pred_test, mae_train, mae_test, rmse_train, rmse_test, r2_train, r2_test

# 평가지표 도출
y_pred_train, y_pred_test, mae_train, mae_test, rmse_train, rmse_test, r2_train, r2_test = \
get_metrics(model, X_train, X_test, y_train, y_test)

# 평가지표 출력
print("# train dataset")
print(f"  MAE : {mae_train:.3f}")
print(f"  RMSE: {rmse_train:.3f}")
print(f"  R2  : {r2_train:.3f}")
print("\n# test dataset")
print(f"  MAE : {mae_test:.3f}")
print(f"  RMSE: {rmse_test:.3f}")
print(f"  R2  : {r2_test:.3f}")
  • 실행 결과:
1
2
3
4
5
6
7
8
9
# train dataset
  MAE : 0.394
  RMSE: 0.537
  R2  : 0.513

# test dataset
  MAE : 0.427
  RMSE: 0.568
  R2  : 0.379

3.3. Visualization: Parity Plot

  • 머신러닝 모델의 예측력은 평가 지표와 같은 수치로 도출되지만 충분하지 않습니다.

  • 어떤 부분이 잘 맞고 어디가 틀린지 확인해야 보완할 수 있습니다.

  • 데이터 시각화를 통해 확인해 봅시다.

  • 참값과 예측값을 비교하는 방법으로 parity plot을 흔히 사용합니다.

  • 참값과 예측값이 $$y = x$$에 가까울 수록 좋습니다.

  • x와 y축 범위를 일치시켜 그립니다.

  • return ax로 axes를 받을 수 있도록 설계합니다.

코드 보기/접기 
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
def plot_parity(true, predict, c="c", mae=None, rmse=None, r2=None, equal=False,
                title=None, xlabel="true", ylabel="predict", ax=None):
    
    # if axes not defined, create one.
    if not ax:
        fig, ax = plt.subplots(figsize=(4, 4))
    
    # scatter plot
    ax.scatter(true, predict, c=c, s=10, alpha=0.3)
    
    # x, y limits
    min_ = min(ax.get_xbound()[0], ax.get_ybound()[0])
    max_ = max(ax.get_xbound()[1], ax.get_ybound()[1])
    ax.set_xlim(min_, max_)
    ax.set_ylim(min_, max_)
    
    # x, y ticks
    lb, ub = ax.get_ybound()
    
    ticks =[x for x in ax.get_xticks() if x >= lb and x <= ub]
    ax.set_xticks(ticks)
    ax.set_xticklabels(ticks)
    ax.set_yticks(ticks)
    ax.set_yticklabels(ticks)
    
    # grids
    ax.set_aspect("equal")
    ax.grid(axis="both", c="lightgray")
    if equal:
        ax.plot([lb, ub], [lb, ub], c="k", alpha=0.3)
    
    # x, y labels and title
    ax.set_xlabel(xlabel, fontsize=16, labelpad=8)
    ax.set_ylabel(ylabel, fontsize=16, labelpad=8)
    ax.set_title(title, fontsize=16, pad=8)
    
    # metrics
    ax.text(0.95, 0.3, f" MAE ={mae:0.3f}",
            transform=ax.transAxes, fontsize=16, ha="right")
    ax.text(0.95, 0.22, f"RMSE ={rmse:0.3f}", 
            transform=ax.transAxes, fontsize=16, ha="right")
    ax.text(0.95, 0.14, f"R2 ={r2:0.3f}", 
            transform=ax.transAxes, fontsize=16, ha="right")
    
    return ax
1
2
3
4
ax = plot_parity(y_train, y_pred_train, mae=mae_train, rmse=rmse_train, r2=r2_train, equal=True)
fig = ax.figure  # axes가 속한 figure 접근
fig.tight_layout()
fig.savefig("6_vcv_02.png")


3.4. Visualization: Parity Plots

  • train data와 test 데이터를 함께 그리려고 합니다.
  • 방금 만든 plot_parity() 함수를 두 번 사용합니다.
코드 보기/접기 
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
def plot_parities(X_train, X_test, y_train, y_test, title):
    
    # get metrics
    y_pred_train, y_pred_test, mae_train, mae_test, rmse_train, rmse_test, r2_train, r2_test = \
    get_metrics(model, X_train, X_test, y_train, y_test)
    
    # figure prepartion
    fig, axs = plt.subplots(ncols=2, figsize=(8, 5), sharex=True, sharey=True)
    
    c_train, c_test = "g", "m"
    axs[0] = plot_parity(y_train, y_pred_train, c_train, 
                         mae_train, rmse_train, r2_train, title=f"train", ax=axs[0])
    min0, max0 = axs[0].get_xbound()
    
    axs[1] = plot_parity(y_test, y_pred_test, c_test, 
                         mae_test, rmse_test, r2_test, title=f"test", ax=axs[1])
    min1, max1 = axs[1].get_xbound()
    
    # mis setting
    axs[1].set_ylabel(None)
    min_, max_ = min(min0, min1), max(max0, max1)
    axs[1].set_xlim(min_, max_)
    axs[1].set_ylim(min_, max_)
    for ax in axs:
        ax.plot([min_, max_], [min_, max_], "k", alpha=0.3)
    
    fig.suptitle(title, fontsize=20, ha="center")
    fig.tight_layout()
    fig.savefig(f"{title}.png")
1
plot_parities(X_train, X_test, y_train, y_test, "linear regression (degree=3)")


  • train, test 결과가 모두 마음에 들지 않습니다.
  • 선형회귀 차수를 바꿔서 확인합시다.
  • 먼저, 1차 함수를 시도해 봅니다.
코드 보기/접기 
1
2
3
4
5
6
7
model = linear(1)
model.fit(X_train, y_train)

y_pred_train, y_pred_test, mae_train, mae_test, rmse_train, rmse_test, r2_train, r2_test = \
get_metrics(model, X_train, X_test, y_train, y_test)

plot_parities(X_train, X_test, y_train, y_test, "linear regression (degree=1)")


  • 역시 별로입니다.
  • 이번에는 5차 함수를 시도합니다.
코드 보기/접기 
1
2
3
4
5
6
7
model = linear(5)
model.fit(X_train, y_train)

y_pred_train, y_pred_test, mae_train, mae_test, rmse_train, rmse_test, r2_train, r2_test = \
get_metrics(model, X_train, X_test, y_train, y_test)

plot_parities(X_train, X_test, y_train, y_test, "linear regression (degree=5)")


  • 1, 3, 5차 모두 마음에 들지 않습니다.
  • 차수에 대한 경향을 보면 답에 가까워질 것 같습니다.
  • Grid Search를 사용하면 좋을 것 같습니다.

3.5. Grid Search: polynomial order

  • sklearn에서 제공하는 GridSearchCV는 다음에 씁시다.
  • 변수가 하나뿐이니 수동으로 바꾸어가면서 성능을 평가합니다.
코드 보기/접기 
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
def plot_metrics(X_train, X_test, y_train, y_test, title):
    maes_train, maes_test = [], []
    rmses_train, rmses_test = [], []
    r2s_train, r2s_test = [], []

    # polynomial degree
    for degree in range(1, 6):
        # model build
        model = linear(degree)
        model.fit(X_train, y_train)

        # model evaluation
        y_pred_train, y_pred_test, mae_train, mae_test, rmse_train, rmse_test, r2_train, r2_test = \
        get_metrics(model, X_train, X_test, y_train, y_test)

        # store metrics
        maes_train.append(mae_train)
        maes_test.append(mae_test)
        rmses_train.append(rmse_train)
        rmses_test.append(rmse_test)
        r2s_train.append(r2_train)
        r2s_test.append(r2_test)

    # data visualization
    fig, axs = plt.subplots(ncols=3, figsize=(12, 5))

    axs[0].plot(maes_train, maes_test, "ro-", lw=3)
    axs[1].plot(rmses_train, rmses_test, "go-", lw=3)
    axs[2].plot(r2s_train, r2s_test, "bo-", lw=3)

    # numbering: degree
    for i in range(len(maes_train)):
        axs[0].text(maes_train[i], maes_test[i], str(i+1), ha="center", fontsize=14, 
                    bbox = {"boxstyle":"circle", "facecolor":"w", "edgecolor":"r"})
        axs[1].text(rmses_train[i], rmses_test[i], str(i+1), ha="center", fontsize=14, 
                    bbox = {"boxstyle":"circle", "facecolor":"w", "edgecolor":"g"})
        axs[2].text(r2s_train[i], r2s_test[i], str(i+1), ha="center", fontsize=14, 
                    bbox = {"boxstyle":"circle", "facecolor":"w", "edgecolor":"b"})

    # mis
    for ax, metric in zip(axs, ["MAE", "RMSE", "R2"]):
        min_ = min(ax.get_xlim()[0], ax.get_ylim()[0])
        max_ = max(ax.get_xlim()[1], ax.get_ylim()[1])
        ax.plot([min_, max_], [min_, max_], "-k", alpha=0.3)
        ax.set_xlim(min_, max_)
        ax.set_ylim(min_, max_)
        ax.set_title(metric, pad=12)
        ax.set_xlabel("train")
        ticks = [round(x,1) for x in ax.get_xticks() if x <= ax.get_xbound()[1] and  x >= ax.get_xbound()[0]]
        ax.set_xticks(ticks)
        ax.set_xticklabels(ticks)
        ax.set_yticks(ticks)
        ax.set_yticklabels(ticks)
        ax.grid()


    axs[0].set_ylabel("test")

    fig.suptitle(f"{title}", fontsize=24)
    fig.tight_layout()
    fig.savefig(f"{title.replace('(','_').replace(')','_')}.png")


  • 가로축은 trainset, 세로축은 testset입니다.

  • 차수가 거듭될수록 MAE와 RMSE, R2 모두 overfitting이 관찰됩니다.

  • 1차나 2차를 고르면 되나 싶지만, 한번 더 확인합시다.

  • train과 test 데이터 분할을 다시 해서 확인합니다.

  • split에 사용된 numpy random seed를 교체해서 데이터를 다시 만들고 똑같이 진행합니다.

코드 보기/접기 
1
2
3
4
5
6
7
8
9
np.random.seed(0)
idx_train_2 = np.random.choice(X.index, size=int(X.shape[0]*train_portion))
idx_test_2 = list(set(X.index) - set(idx_train_2))

X_train_2 = X.loc[idx_train_2]
X_test_2 = X.loc[idx_test_2]

y_train_2 = y.loc[idx_train_2]
y_test_2 = y.loc[idx_test_2]
1
plot_metrics(X_train_2, X_test_2, y_train_2, y_test_2, "polynomial degree vs metrics (2)")


  • 1차보다 2차가 $$y = x$$에 가깝습니다.
  • 그런데 그게 문제가 아닐 것 같습니다. 거동이 완전히 바뀌었습니다.
  • 데이터에 따른 편차가 상당히 큽니다.

3.6. Grid Search Cross Validation: polynomial order

sklearn: GridSearchCV

  • 그런데 하나 잊은 것이 있습니다.

  • test data는 최종 검증용으로만 사용해야지, 이렇게 성능을 테스트셋에 맞추면 결국 테스트셋에 오버피팅될 뿐입니다.

  • 이건 안봤다고 치고 덮어놓고, train data만 가지고 최적을 찾아봅시다.

  • Grid Search + Cross Validation이 필요합니다.

  • 다항식의 차수만 바꾸면서 각각의 cross validataion score를 측정합니다.

  • cv=5로 다섯 번 수행한 교차검증의 평균과 표준편차를 구합니다.

  • 성능이 좋으려면 평균이 높아야 하고, 표준편차는 작아야 합니다.

  • 교차검증을 신뢰하려면 적어도 표준편차라도 작아야 합니다.

  • 과연 그럴지 확인합니다.

코드 보기/접기 
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
def plot_cv(X_train, y_train, title):
    fig, axs = plt.subplots(ncols=3, figsize=(12, 5))

    # polynomial degree
    for degree in range(1, 6):
        # model build
        model = linear(degree)

        # cross validation
        for scoring, ax in zip(["neg_mean_absolute_error", "neg_mean_squared_error", "r2"], axs):
            scores = cross_val_score(model, X_train, y_train, scoring=scoring, cv=10)
            if scoring.startswith("neg_"):
                scores = -scores

            # bar plot
            cvs = ax.bar(degree, scores.mean()) 
            # bar label : bar마다 데이터값 표기
            ax.bar_label(cvs, fmt="%.2f", fontsize=14, padding=5)
            # error bar 표현
            ax.errorbar(degree, scores.mean(), yerr=scores.std(), 
                        ecolor="darkgray", capsize=5, capthick=2)

    for title_, ax in zip(["MAE", "RMSE", "R2"], axs):
        ax.set_title(title_, pad=12)
        ax.grid(axis="y", c="lightgray", ls=":")
        xticks = list(range(1, 6))
        ax.set_xticks(xticks)
        ax.set_xticklabels(xticks)

    fig.suptitle(f"{title}", fontsize=24)
    fig.tight_layout()
    fig.savefig(f"{title.replace('(','_').replace(')','_')}.png")
* `ax.bar()`에 `yerr`를 사용하면 굳이 `ax.errorbar()` 없이도 에러바 표현이 가능합니다. * 그러나 이 경우 모처럼 matplotlib 3.4에 처음 도입된 `ax.bar_label()`이 errorbar 위에 붙어 보기 힘듭니다.
  • Grid Search 결과를 곧장 그려봅니다.
1
plot_cv(X_train, y_train, "polynomial order vs metrics (cross validation)")


  • 바꾸었던 데이터를 적용해 봅니다.
1
plot_cv(X_train, y_train, "polynomial order vs metrics 2 (cross validation)")


  • 두 경우 모두, 결과를 신뢰하기에는 RMSE와 R2의 표준편차가 너무나 큽니다.

  • 특히 MAE보다 RMSE의 표준편차가 크다는 점에서 이상치의 역할이 큼을 짐작할 수 있습니다.

  • 5차에서는 $$R^2 < 0$$ 마저 등장하는데, 모든 범위에서 선형 회귀가 힘을 쓰지 못합니다.

  • 선형 회귀가 엉망이라는 점에서 비선형성이 매우 강하다는 추측을 할 수 있습니다.

  • 다음 글에서는 비선형 회귀에 도전하겠습니다.


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

Share