Validation with Visualization (3)

2021-04-09

2021-04-15

machine learning, matplotlib, python, sklearn, visualization

데이터 불균형으로 인해 train, validation, test dataset의 결과가 따로 놉니다.
층화추출로 데이터를 최대한 균등하게 분할합시다.
hyperparameter도 라이브러리를 사용해 편리하게 피팅합시다.

6. Validation set 고정

새로운 노트북을 만들어 데이터를 불러옵니다.

%matplotlib inline

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

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

# 데이터 불러오기
df_vcv = pd.read_csv("df_vcv.csv")
df_vcv.head()

6.1. 랜덤추출

sklearn.model_selection.train_test_split

이번엔 index를 사용하지 않고 데이터를 분할합니다.

편하게 sklearn의 train_test_split()을 사용합니다.

from sklearn.model_selection import train_test_split

# data split
df_trainval, df_test = train_test_split(df_vcv, test_size=0.2, random_state=42)
df_train, df_val = train_test_split(df_trainval, train_size=0.75, random_state=42)

# index
idx_train = df_train.index
idx_val = df_val.index
idx_test = df_test.index

데이터가 잘 분할되었는지 확인합니다.
지난번 글에 있는 코드를 고쳐서 train, validation, test set의 분포를 그립니다.

코드가 길어서 접어두었습니다. 클릭하면 펴집니다.

코드 보기/접기

def plot_distribution(df, idx_train, idx_val, idx_test, filename):
    fig, axes = plt.subplots(ncols=3, nrows=2, figsize=(12, 8))
    axs = axes.ravel()

    for ax, col in zip(axs, df.columns):
        if col != "target":
            if df[col].dtype == "O": # categorical
                df_train = df.loc[idx_train, col].value_counts().reset_index()
                df_val = df.loc[idx_val, col].value_counts().reset_index()
                df_test = df.loc[idx_test, col].value_counts().reset_index()

                width_cat = 0.8/3
                ax.bar(df_train.index-width_cat, df_train[col]/len(idx_train), width=width_cat, ec="g", fc="#AAFFAADD")
                ax.bar(df_val.index, df_val[col]/len(idx_val), width=width_cat, ec="c", fc="#AAFFFFDD")
                ax.bar(df_test.index+width_cat, 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[col].min(), df[col].max(), 10)
                bins_center = (bins[:-1] + bins[1:])/2
                bins_delta = bins[1] - bins[0]
                counts_train, bins_train = np.histogram(df.loc[idx_train, col], bins=bins)
                counts_val, bins_val = np.histogram(df.loc[idx_val, col], bins=bins)
                counts_test, bins_test = np.histogram(df.loc[idx_test, col], bins=bins)

                width_num = bins_delta/3
                ax.bar(bins_center-width_num, counts_train/len(idx_train), width=width_num, ec="g", fc="#AAFFAADD")
                ax.bar(bins_center, counts_val/len(idx_val), width=width_num, ec="g", fc="#AAFFFFDD")
                ax.bar(bins_center+width_num, counts_test/len(idx_test), width=width_num, ec="m", fc="#FFAAFFDD")

        else:
            sns.kdeplot(df.loc[idx_train, col], color="g", fill=True, ax=ax, label="train")
            sns.kdeplot(df.loc[idx_val, col], color="c", fill=True, ax=ax, label="val.")
            sns.kdeplot(df.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.set_facecolor("w")
    fig.savefig(filename)

matplotlib은 bar plot을 나란히 놓기가 영 성가신 것이 사실입니다.

1	plot_distribution(df_vcv, idx_train, idx_val, idx_test, "68_vcv_1.png")

categorical은 그나마 좀 나은데 numerical들이 울퉁불퉁합니다.
이 데이터들을 최대한 균등하게 나누어 봅시다.

6.2. 층화추출: stratified sampling

층화추출은 train_test_split()에 stratify= 매개변수를 넣으면 됩니다.

1
2
3

# stratify split fail
df_trainval, df_test = train_test_split(df_vcv, test_size=0.2, random_state=42,
                                        stratify=df_vcv[["B", "C", "E"]])

그런데 에러가 납니다.
- 층화추출은 데이터의 종류에 따라 경우의 수가 결정됩니다.
- B x C x E = 5 x 5 x 4 = 100개는 되어야 하는데,
- test dataset이 400 x 0.2 = 80개밖에 안됩니다.
- 욕심을 줄이고 B와 C에만 층화추출을 적용합니다.

1차로 train + val : test set을 8:2로 나누고
2차로 train : val 을 3:1로 나눕니다.

최종적으로 train : val : test = 3 : 1 : 1 로 나눕니다.

# stratify split success
df_trainval, df_test = train_test_split(df_vcv, test_size=0.2, random_state=42,
                                        stratify=df_vcv[["B", "C"]])
df_train, df_val = train_test_split(df_trainval, train_size=0.75, random_state=42,
                                        stratify=df_trainval[["B", "C"]])

# index
idx_train = df_train.index
idx_val = df_val.index
idx_test = df_test.index

# visualization
plot_distribution(df_vcv, idx_train, idx_val, idx_test, "68_vcv_2.png")

분포가 한결 균일해집니다.

6.3. 더 층화추출

B와 C에 비해 E가 덜 균일한 것이 영 아쉽습니다.
B를 절반으로 나누어서라도 층화추출을 적용해 봅니다.

E의 범위를 측정해서 절반으로 자릅니다

np.quantile()을 사용합니다.

# quantizing E

qbins = np.quantile(df_vcv["E"], np.linspace(0, 1, 3))
qbins[0] = -np.inf
qbins[-1] = np.inf
print(qbins)

qlabels = np.arange(2)
print(qlabels)

실행결과 :
1
2
[-inf 2.5 inf]
[0 1]

2.5를 중심으로 나눈 기준을 이용해 0과 1로 인코딩을 합니다.

pd.cut()을 사용합니다.

1 2	df_vcv["E_cat"] = pd.cut(df_vcv["E"], bins=qbins, labels=qlabels) df_vcv.head()

B, C에 E_cat까지 이용해 나눕니다.

실제 사용할 데이터가 아니더라도 층화추출에 적용할 수 있습니다.

# stratify split success
df_trainval, df_test = train_test_split(df_vcv, test_size=0.2, random_state=42,
                                        stratify=df_vcv[["B", "C", "E_cat"]])
df_train, df_val = train_test_split(df_trainval, train_size=0.75, random_state=42,
                                        stratify=df_trainval[["B", "C", "E_cat"]])

# index
idx_train = df_train.index
idx_val = df_val.index
idx_test = df_test.index

# visualization
plot_distribution(df_vcv, idx_train, idx_val, idx_test, "68_vcv_3.png")

왠지 오히려 더 안좋습니다.

아까 나누었던 B, C 층화추출을 채택하고, train, val, test set을 만듭니다.

# stratify split success
df_trainval, df_test = train_test_split(df_vcv, test_size=0.2, random_state=42,
                                        stratify=df_vcv[["B", "C"]])
df_train, df_val = train_test_split(df_trainval, train_size=0.75, random_state=42,
                                        stratify=df_trainval[["B", "C"]])

# index
idx_train = df_train.index
idx_val = df_val.index
idx_test = df_test.index

# dataset
X = df_vcv[["A", "B", "C", "D", "E"]]
y = df_vcv["target"]

X_train, X_val, X_test = X.loc[idx_train], X.loc[idx_val], X.loc[idx_test]
y_train, y_val, y_test = y[idx_train], y[idx_val], y[idx_test]

7. 머신러닝

7.1. 사전 준비

지난 글까지와 달리 이번 글에서는 고정된 validation set을 사용합니다.
한편 hyperparameter는 이것저것 바꿔 넣을 것입니다.
사용된 함수들을 일부 수정합니다. 자세한 설명은 생략합니다.

7.1.1. pipeline

파이프라인을 구축합니다.

학습과 예측에 필요한 데이터와 하이퍼파라미터만 넣으면 되도록 만듭니다.

코드 보기/접기

# encoder
from sklearn.preprocessing import OneHotEncoder

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

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

# machine learning models
from sklearn.svm import SVR
from sklearn.kernel_ridge import KernelRidge
from sklearn.neighbors import KNeighborsRegressor

def get_model(method="svr", param=None):
    
    # 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(include_bias=True))])

    # preprocessor
    preprocessor = ColumnTransformer(transformers=[("num", num_transformer, num_features),
                                                   ("cat", cat_transformer, cat_features)
                                                  ])

    # modeling
    if method == "svr":
        model = Pipeline(steps=[("preprocessor", preprocessor), 
                                ("svr", SVR())
                               ])
    elif method == "kridge":
        model = Pipeline(steps=[("preprocessor", preprocessor), 
                                ("kridge", KernelRidge())
                               ])
    elif method == "knr":
        model = Pipeline(steps=[("preprocessor", preprocessor), 
                                ("knr", KNeighborsRegressor())
                               ])
        
    model.set_params(**param)
    return model

예제 hyperparameter를 입력해서 모델이 잘 생성되는지 확인합니다.

# example: svr

# hyperparameter
param = {'preprocessor__num__polynomial__degree': 3, 
         'svr__kernel': 'rbf', 'svr__C': 100, 'svr__gamma': 0.01}

# model
model = get_model(method="svr", param=param)

# visualize
from sklearn import set_config

set_config(display='diagram')  
display(model)

7.1.2. evaluation

모델 평가를 위한 함수를 마련합니다.

# 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, y):
    y_pred = model.predict(X)
    mae = mae_(y, y_pred)
    rmse = mse_(y, y_pred, squared=False)
    r2 = r2_(y, y_pred)
    
    return y_pred, mae, rmse, r2
    
model.fit(X_train, y_train)
y_pred_val, mae_val, rmse_val, r2_val = get_metrics(model, X_val, y_val)
print(f"#  mae_val : {mae_val:.3f}")
print(f"# rmse_val : {rmse_val:.3f}")
print(f"#   r2_val : {r2_val:.3f}")

실행 결과 :

1
2
3

#  mae_val : 0.296
# rmse_val : 0.437
#   r2_val : 0.513

7.1.3. parity plots

평가 결과를 scatter plot과 함께 시각화하는 함수를 만듭니다.
지난 글에 있던 코드를 수정해서 확장성을 높였습니다.

tran & val만 볼 수도, train & val & test도 가능합니다.

코드 보기/접기

# single parity plot
def plot_parity(true, predict, c="c", mae=None, rmse=None, r2=None, 
                equal=True, 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
    if mae:
        ax.text(0.95, 0.3, f" MAE ={mae:0.3f}",
                transform=ax.transAxes, fontsize=16, ha="right")
    if rmse:
        ax.text(0.95, 0.22, f"RMSE ={rmse:0.3f}", 
                transform=ax.transAxes, fontsize=16, ha="right")
    if r2:
        ax.text(0.95, 0.14, f"R2 ={r2:0.3f}", 
                transform=ax.transAxes, fontsize=16, ha="right")
    
    return ax
    
# multiple parity plots	
def plot_parities(model, X_train, y_train, X_val=None, y_val=None, X_test=None, y_test=None, title=None, train=False):
    
    # validataion and test
    vis_val = False
    if (X_val is not None) and (y_val is not None):
        vis_val = True
        
    vis_test = False
    if (X_test is not None) and (y_test is not None):
        vis_test = True
    
    # train
    if train:
        model.fit(X_train, y_train)
        
    # prediction and get_metrics
    y_pred_train, mae_train, rmse_train, r2_train = get_metrics(model, X_train, y_train)
    
    if vis_val:
        y_pred_val, mae_val, rmse_val, r2_val = get_metrics(model, X_val, y_val)
        
    if vis_test:
        X_trainval = pd.concat([X_train, X_val], axis=0)
        y_trainval = pd.concat([y_train, y_val], axis=0)
        model.fit(X_trainval, y_trainval)
        y_pred_test, mae_test, rmse_test, r2_test = get_metrics(model, X_test, y_test)
        
    # figure preparation
    ncols = 1
    if vis_val:
        ncols += 1
    if vis_test:
        ncols += 1
        
    ax_width = 5
    if ncols > 1:
        ax_width = 4
    
    fig, axs = plt.subplots(ncols=ncols, figsize=(ax_width*ncols, 5), sharex=True, sharey=True)
    if not isinstance(axs, np.ndarray):
        axs = [axs]
    
    c_train, c_val, c_test = "g", "c", "m"
    
    axs[0] = plot_parity(y_train, y_pred_train, c=c_train, mae=mae_train, rmse=rmse_train, r2=r2_train, 
                         title="train", ax=axs[0])
    mins = [axs[0].get_xbound()[0]]
    maxs = [axs[0].get_xbound()[1]]
    
    if vis_val:
        axs[1] = plot_parity(y_val, y_pred_val, c=c_val, mae=mae_val, rmse=rmse_val, r2=r2_val, 
                             ylabel=None, title="validation", ax=axs[1])
        mins.append(axs[1].get_xbound()[0])
        maxs.append(axs[1].get_xbound()[1])   
    
    if vis_test:
        axs[2] = plot_parity(y_test, y_pred_test, c=c_test, mae=mae_test, rmse=rmse_test, r2=r2_test, 
                             ylabel=None, title="test (train by full trainset)", ax=axs[2])
        mins.append(axs[2].get_xbound()[0])
        maxs.append(axs[2].get_xbound()[1])
        
    # suptitle
    if title:
        fig.suptitle(title, fontsize=20, ha="center")
    
    fig.tight_layout()
    fig.set_facecolor("w")
    
    if title:
        fig.savefig(f"{title.replace('(', '_').replace(')', '_').replace(':', '_')}.png")

train 후 validation을 출력하고,
train set과 validation set을 합쳐 다시 학습합니다.
그 후에 test set으로 최종 성능을 평가합니다.

층화추출이 적용되니 크게 고민하지 않은 값들을 넣었는데도 성능이 좋습니다.

1 2	plot_parities(model, X_train, y_train, X_val, y_val, X_test, y_test, title="test: SVR", train=True)

![](test_ SVR.png)

7.2. hyperparameter optimization

이제 hyperparameter 최적화에 들어갑니다.
모든 변수의 조합을 탐색하는 grid search와
앞선 결과를 바탕으로 최적 탐색을 하는 bayesian search를 해 봅니다.

7.2.1. grid search

준비된 데이터셋을 모두 넣으면 grid search를 수행해서 결과를 출력하게 합니다.
지난 글과 다른 형식으로 출력해 봅니다.

grid search를 수행해서 DataFrame 형식으로 출력합니다.

코드 보기/접기

from itertools import product

def gs_model(X_train, y_train, X_val, y_val, method="svr", param_grid=None):
    
    # param_grid
    param_ks = param_grid.keys()
    param_vs = list(product(*param_grid.values()))
    
    df = pd.DataFrame(columns=list(param_ks)
                      + ["mae_train", "mae_val", "rmse_train", "rmse_val", "r2_train", "r2_val"]
                      + ["y_pred_train", "y_pred_val"])
    
    for i, vs in enumerate(param_vs):
        param = dict(zip(param_ks, vs))
        
        model = get_model(method=method, param=param)
        
        # train
        model.fit(X_train, y_train)
        
        # evaluation
        y_pred_train, mae_train, rmse_train, r2_train = get_metrics(model, X_train, y_train)
        y_pred_val, mae_val, rmse_val, r2_val = get_metrics(model, X_val, y_val)
        
        # output
        df.loc[i] = list(vs) + [mae_train, mae_val, 
                                rmse_train, rmse_val, 
                                r2_train, r2_val, 
                                y_pred_train, y_pred_val]
    
    return df

gs_model()를 이용해서 모든 결과를 출력하는 함수를 만듭니다.

gs_model() 결과물의 dataframe index에 따라 평가 결과를 출력합니다.

코드 보기/접기

def plot_gs(X_train, y_train, X_val, y_val, method="svr", param_grid=None, filename=None):
    df = gs_model(X_train, y_train, X_val, y_val, method=method, param_grid=param_grid)
    df_sort = df.sort_values("r2_val", ascending=False)
    
    # best params
    best_params = df_sort[list(param_grid.keys())].iloc[0].to_dict()
    best_params_idx = df_sort.index[0]
    print(best_params)
    
    # train vs validation plot
    ax = df_svr[["r2_train", "r2_val"]].plot(figsize=(12, 4))
    ax.axvline(best_params_idx, c="g", ls=":")
    fig = ax.figure
    fig.set_facecolor("w")
    
    if filename:
        fig.savefig(filename)
        
    return best_params

hyperparameter 범위를 설정하고 grid search를 수행합니다.

# hyperparameter space
param_grid = {'preprocessor__num__polynomial__degree': [2],
              'svr__kernel': ['rbf'], #['linear', 'poly', 'rbf', 'sigmoid'],
              'svr__C': np.logspace(-2, 2, 11),
              'svr__gamma': np.linspace(0.01, 0.1, 11),
              'svr__coef0': [0]}
              
# grid search & visualization 수행			  
best_params = plot_gs(X_train, y_train, X_val, y_val, method="svr", param_grid=param_grid, filename="68_vcv_6.png")

재미있는 현상이 나타났습니다.
- validation set의 r2가 가장 큰 지점(점선)을 기준으로,
- 왼쪽에선 train과 val 곡선이 비슷합니다
- 오른쪽에선 두 곡선이 반대 경향입니다
- validation r2가 증가하다 감소하는걸 볼 때 underfitting에서 overfitting으로 꺾이는 지점이 관측되었다고 볼 수 있습니다.

최적조건으로 학습시켜 test set 평가까지 봅니다.

1
2
3

model = get_model(method="svr", param=best_params)
plot_parities(model, X_train, y_train, X_val, y_val, X_test, y_test, 
              title="SVR: rbf (deg=2)", train=True)

![](SVR_ rbf _deg=2_.png)

test set의 R2가 0.7을 넘었습니다!
- train set과 val set의 R2도 비슷하네요.
- 층화추출 덕에 안정적인 성능이 나오는 것 같습니다.

7.2.2. Bayesian Search

hyperopt
optuna
scikit-optimize
medium: hyperparameter tuning using bayesian optimisation code

그런데 모든 변수를 다 탐색하는 과정이 번거롭습니다.
scikit-optimzie를 사용해서 베이지안 탐색을 시도합니다.
다음 명령어로 설치할 수 있습니다.
1
!pip install scikit-optimize

필요한 모듈을 불러옵니다.

# hyperparameter 탐색 범위 설정에 사용합니다.
from skopt.space import Real, Integer, Categorical

# objective function에 들어갈 parameter를 keyword arguments로 입력하게 해줍니다.
from skopt.utils import use_named_args

탐색 공간을 정의합니다.

space = [Integer(1, 2, name="preprocessor__num__polynomial__degree"),
         Categorical(["rbf"], name="svr__kernel"),
         Real(0.01, 100, "log-uniform", name="svr__C"),
         Real(0.01, 0.1, "uniform", name="svr__gamma"),
         Integer(0, 1, name="svr__coef0")
        ]

목표 함수(objective function)을 정의합니다.
@use_named_args를 사용해서 keyword argument로 입력합니다.
제가 7.1.1.pipeline에서 만든 get_model()을 사용하도록 했습니다.

출력은 r2_val 값으로 하고, 마이너스를 붙여 더 큰 값이 더 작게 출력되도록 했습니다.

@use_named_args(space)
def objective(**params):
    model = get_model(method="svr", param=params)
    model.fit(X_train, y_train)
    y_pred_val, mae_val, rmse_val, r2_val = get_metrics(model, X_val, y_val)
    
    return -r2_val

gaussian process로 최적화합니다.

gp_minimize()명령을 사용합니다.

from skopt import gp_minimize

model_gp = gp_minimize(objective, space, n_calls=50, random_state=0)

print(f"best score = {model_gp.fun:.4f}")

실행 결과:
1
best score = -0.6193

최적 파라미터는 model_gp.x에 저장됩니다.
1
model_gp.x
- 실행 결과:
  1
  [2, 'rbf', 0.7740303218260096, 0.1, 1]

제법 괜찮은 결과를 얻은 것 같긴 한데, 수렴했는지 확인해봅니다.

plot_converge()를 사용합니다.

from skopt.plots import plot_convergence

ax = plot_convergence(model_gp)
fig = ax.figure
fig.set_facecolor("w")
fig.set_figheight(5)
fig.set_figwidth(12)
fig.savefig("68_vcv_7.png")

약 20회만에 최적 조건에 수렴했습니다.

해당 조건이 테스트셋에선 어떤 결과를 내는지 확인해봅니다.

# 최적 파라미터 key와 value 결합
param_keys = [s.name for s in space]
best_params = dict(zip(param_keys, model_gp.x))
print(best_params)

# 최적 파라미터로 모델 학습, 시각화
model = get_model(method="svr", param=best_params)
plot_parities(model, X_train, y_train, X_val, y_val, X_test, y_test, 
              title="SVR: scikit-learn opt.", train=True)

![](SVR_ scikit-learn opt..png)

R2가 다시 0.7을 넘었습니다
이번 업무의 목표가 0.7인데 SVR에서 0.7이 넘어서 상향 조정해도 될 것 같습니다.

자주 사용할 수 있도록 앞에서 파편화된 함수들을 하나로 모읍니다.
local minima에 빠지지 않도록 seed를 흔들어 여러 번 시도합니다.
Andrew Ng 교수님이 Caviar approach라고 말씀하신 방법입니다.

뭐 하나 잘 걸리라는 느낌입니다.

def run_skopt(objective, space, method="svr", n_calls=30, iternum=10, random_state_base=0,
              filename_conv=None, filename_parity=None, figsize=(12, 5)):
    
    fig, ax = plt.subplots(figsize=figsize)
    fig.set_facecolor("w")
    
    best_score = np.inf
    
    # scikit optimization
    for i in range(iternum):
        model_gp = gp_minimize(objective, space, n_calls=n_calls, random_state=i*100+random_state_base)
        best_score_ = model_gp.fun
        print(f"best score #{i+1} = {best_score_:.4f}")

    # convergence plot
        ax = plot_convergence(model_gp, ax=ax)

    # best parameters
        if best_score_ < best_score:
            best_score = best_score_
            param_keys = [s.name for s in space]
            best_params = dict(zip(param_keys, model_gp.x))
            print(f"best parameters= {best_params}")
    
    fig.savefig(filename_conv)
    
    # train, val and test result 
    best_model = get_model(method=method, param=best_params)
    plot_parities(best_model, X_train, y_train, X_val, y_val, X_test, y_test, 
                  title=filename_parity, train=True)
    
    with open(f"{filename_parity}.pkl", 'wb') as f:
        pickle.dump(best_model, f)
    
    return best_model, best_params

사용할 때는 위의 space, objective와 함께 세트로 사용합니다.

@use_named_args(space) 데커레이터로 인해 space를 먼저 정의해야 합니다.

#space
space = [Integer(1, 2, name="preprocessor__num__polynomial__degree"),
         Categorical(["rbf"], name="svr__kernel"),
         Real(0.001, 1000, "log-uniform", name="svr__C"),
         Real(1e-3, 10, "log-uniform", name="svr__gamma"),
        ]

#objective
@use_named_args(space)
def objective(**params):
    model = get_model(method="svr", param=params)
    model.fit(X_train, y_train)
    y_pred_val, mae_val, rmse_val, r2_val = get_metrics(model, X_val, y_val)
    
    return -r2_val		
    
# optimize
best_svr_rbf, best_params = run_skopt(objective, space, method="svr", n_calls=50, 
                                      filename_conv="68_vcv_8.png", 
                                      filename_parity="SVR_rbf_opt", figsize=(12, 5))

이제 마음껏 실전에 투입합니다. :)

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

PythonData Science

6. Validation set 고정

6.1. 랜덤추출

6.2. 층화추출: stratified sampling

6.3. 더 층화추출

7. 머신러닝

7.1. 사전 준비

7.1.1. pipeline

7.1.2. evaluation

7.1.3. parity plots

7.2. hyperparameter optimization

7.2.1. grid search

7.2.2. Bayesian Search