SW정리: KFold

1. 들어가기에 앞서

이번 예제는 pytorch를 이용하여 XOR 데이터를 넣어서 학습한뒤 결과를 보는 예제입니다. XOR함수는 X1, X2 두개의 입력을 가지는데 두개의 값이 같은 경우에 Y값이 1 이 되는 함수 입니다. 이 부분은 lightGBM, XGBoost 예제에서도 동일하기 때문에 해당 내용을 그대로 복사하였습니다.

pytorch를 이용한 Deep learning 예제 (이 문서)
https://swlock.blogspot.com/2019/02/deep-learning-pytorch-kfold-example.html

XGBoost 예제
https://swlock.blogspot.com/2019/02/xgboost-stratifiedkfold-kfold.html

lightGBM 설치 및 예제 (How to install Lightgbm and example)
https://swlock.blogspot.com/2019/01/lightgbm-how-to-install-lightgbm-and.html

교차검증에 대해잘 모르겠으면 아래 링크에서 추가 확인이 가능합니다.
scikit-learn 이용한 (cross-validation) 교차 검증 iterators StratifiedKFold, KFold 사용법
https://swlock.blogspot.com/2019/01/scikit-learn-cross-validation-iterators.html

2. XOR data로 pytorch에서 사용하기
XOR함수는 입력을 2개를 받고 두개의 값이 같으면 1이되고 다르면 0이 되는 함수 입니다.
0,1 정수만 넣어서 예제를 만들면 test와 train 데이터가 겹치는 부분도 있고 해서 여기에서는 random 을 이용해서 실수 형태로 만들었습니다. 또한 Y가 한개인것보다 복잡한 sample을 만들기 위해 y1, y2는 서로 반대가 되는 값을 넣었습니다.

2.1 XOR data 만들기

파일명 : makexordata.py

import numpy as np
import pandas as pd

np.random.seed(0)

def get_int_rand(min, max):
 value = np.random.randint(min, high=max+1, size=1)
 return int(value[0])

def get_rand(min, max):
 value = np.random.rand(1)*(max-min)+min
 return float(value[0])

#make train set
df = pd.DataFrame([],columns=['x1', 'x2', 'y1', 'y2'])

for i in range(1000):
 x1 = get_int_rand(0,1)
 x2 = get_int_rand(0,1)
 if x1 == x2 :
  y1 = 0
  y2 = 1
 else  :
  y1 = 1
  y2 = 0
 x1 = get_rand(x1-0.3, x1+0.3)
 x2 = get_rand(x2-0.3, x2+0.3)

 df = df.append(pd.DataFrame(np.array([x1,x2,int(y1),int(y2)]).reshape(1,4),columns=['x1', 'x2', 'y1', 'y2']))
 
df.reset_index(inplace=True,drop=True)
print(df.head())

df.to_csv("train.csv", encoding='utf-8', index=False)


# make test set
df = pd.DataFrame([],columns=['x1', 'x2'])

for i in range(100):
 x1 = get_int_rand(0,1)
 x2 = get_int_rand(0,1)
 x1 = get_rand(x1-0.3, x1+0.3)
 x2 = get_rand(x2-0.3, x2+0.3)

 df = df.append(pd.DataFrame(np.array([x1,x2,int(0),int(0)]).reshape(1,4),columns=['x1', 'x2', 'y1', 'y2']))
 
df.reset_index(inplace=True,drop=True)
print(df.head())

df.to_csv("test.csv", encoding='utf-8', index=False)

실행결과는 아래와 같습니다. 위 코드는 데이터를 만들기 위한 용도이므로 자세한 설명은 생략합니다. 결과는 아래와 같고 train.csv, test.csv 파일을 생성해 냅니다. 형태는 아래 결과 와 같습니다. test.csv파일의 y1, y2는 0으로 가득차 있으며, 해당값을 예측해야 합니다.

(base) E:\>python makexordata.py
         x1        x2   y1   y2
0  0.129114  1.061658  1.0  0.0
1  0.954193  1.087536  0.0  1.0
2  0.235064  1.278198  1.0  0.0
3  0.175035  1.017337  1.0  0.0
4  0.255358  0.742622  1.0  0.0
e:\ProgramData\Anaconda3\lib\site-packages\pandas\core\frame.py:6211: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version
of pandas will change to not sort by default.

To accept the future behavior, pass 'sort=False'.

To retain the current behavior and silence the warning, pass 'sort=True'.

  sort=sort)
         x1        x2   y1   y2
0  1.077771  0.167151  0.0  0.0
1  0.189848 -0.200354  0.0  0.0
2 -0.264823  0.820102  0.0  0.0
3 -0.231184  0.062009  0.0  0.0
4  0.957680  0.889091  0.0  0.0

데이터를 보는 방법은 다음과 같습니다.
x1값이 0.5 보다 작으면 0으로, 0.5 보다 크면 1로 생각하고 두개 값이 (대략)0이면 y1=0, y2=1, 0,1또는 1,0으로 다를 경우 y1=1, y2=0 이 됩니다.(XOR은 입력값이 배타적일때 참이 됩니다.) 결과 값 또한 0~1 사이의 binary 형태의 데이터입니다.
만들려고 하는 예제는 위 데이터(train.csv)를 가지고 학습한뒤 test.csv 에 주어지는 x1, x2를 이용하여 y1, y2를 예측하는 예제입니다.

2.2 pytorch 예제 코드 작성

이제 본론입니다. 해당 코드는 KFold 교차 검증 이용한 반복 훈련, Feature Select, MinMaxScaler, StandardScaler 내용을 포함하는 예제입니다.
전반적인 흐름은 train.csv 파일을 읽어서 MinMaxScaler, StandardScaler 를 할 수도 있으며, 훈련 후 그 결과를 result.csv 파일에 저장하는 코드입니다.

EPOCHS_TO_TRAIN = 300
FOLD_COUNT = 2
RUNNING_RATE = 0.1
DROPOUT = 0.2
LAYER1 = 50
LAYER2 = 30
EPOCHS_FOR_DISPLAY = 1

STD_ALL = False
NOR_ALL = True
PREFIX = __file__[:-3]
BASE_PATH = "./"

SELECT_NEED = False
Y1_SELECT_LEVEL = 0
Y2_SELECT_LEVEL = 0

Y1_FEATURE_LIST_FOR_SELECT=[
 ('x1',1),
 ('x2',0)
]

Y2_FEATURE_LIST_FOR_SELECT=[
 ('x1',1),
 ('x2',0)
]

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
import time
import pandas as pd
import numpy as np
from sklearn.model_selection import KFold
from sklearn import preprocessing
from sklearn.metrics import mean_squared_error
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.autograd import Variable

np.random.seed(1000)

class writeLog():
 def write(self, fileName, text):
  print(text)
  f=open(fileName,'a')
  f.write(text)
  f.write("\n")
  f.close()
 def writeWithoutCR(self, fileName, text):
  f=open(fileName,'a')
  f.write(text)
  f.close()

log = writeLog()
log.write(PREFIX+"log.txt","start")

train_df = pd.read_csv(BASE_PATH+'train.csv', header=0, encoding='utf8')
test_df = pd.read_csv(BASE_PATH+'test.csv', header=0, encoding='utf8')

#drop Y
Y1train_df = train_df.pop('y1')
Y2train_df = train_df.pop('y2')

Y1test_df = test_df.pop('y1')
Y2test_df = test_df.pop('y2')

allX = pd.concat([train_df, test_df], axis=0)
train_size = train_df.shape[0]
test_size = test_df.shape[0]
log.write(PREFIX+"log.txt","train size:"+str(train_df.shape))
log.write(PREFIX+"log.txt","test size:"+str(test_df.shape))
log.write(PREFIX+"log.txt","all size:"+str(allX.shape))
del (train_df, test_df)

allX = pd.get_dummies(allX)
allX = allX.fillna(value=0)

if NOR_ALL == True:
 names = allX.columns
 scaler = preprocessing.MinMaxScaler()
 allX = scaler.fit_transform(allX)
 allX = pd.DataFrame(allX, columns=names)

if STD_ALL == True:
 names = allX.columns
 scaler = preprocessing.StandardScaler()
 allX = scaler.fit_transform(allX)
 allX = pd.DataFrame(allX, columns=names)

if SELECT_NEED :
 Y1sel_feature = []
 for feature, count in Y1_FEATURE_LIST_FOR_SELECT :
  if count>=Y1_SELECT_LEVEL :
   Y1sel_feature.append(feature)
 log.write(PREFIX+"log.txt","Y1 selected:%d"%(len(Y1sel_feature)))
 
 Y2sel_feature = []
 for feature, count in Y2_FEATURE_LIST_FOR_SELECT :
  if count>=Y2_SELECT_LEVEL :
   Y2sel_feature.append(feature)
 log.write(PREFIX+"log.txt","Y2 selected:%d"%(len(Y2sel_feature)))
 
 Ysel_feature = []
 Ysel_feature = Y1sel_feature + Y2sel_feature
 Ysel_feature = list(set(Ysel_feature))
 log.write(PREFIX+"log.txt","Y selected:%d"%(len(Ysel_feature)))
else:
 Ysel_feature = []
 Y1sel_feature = []
 Y2sel_feature = []
 if len(Ysel_feature)==0:
  Ysel_feature = allX.columns
 if len(Y1sel_feature)==0:
  Y1sel_feature = allX.columns
 if len(Y2sel_feature)==0:
  Y2sel_feature = allX.columns

#분리
trainX = allX[0:int(train_size)]
predictX = allX[int(train_size):int(allX.shape[0])]
log.write(PREFIX+"log.txt","train size:"+str(trainX.shape))
log.write(PREFIX+"log.txt","test size:"+str(predictX.shape))
del (allX)

def OutputData(filename,Y1,Y2):
 test_csv = pd.read_csv(BASE_PATH+'test.csv', header=0, encoding='utf8')
 test_csv.pop('y1')
 test_csv.pop('y2')
 predAll = pd.concat([test_csv,pd.DataFrame(Y1, columns=['y1'])], axis=1)
 predAll = pd.concat([predAll,pd.DataFrame(Y2, columns=['y2'])], axis=1)
 predAll.to_csv(path_or_buf=PREFIX+filename, index=False)
 del predAll

def initialize_weights(model):
 if type(model) in [nn.Linear]:
  nn.init.xavier_normal(model.weight.data)
 elif type(model) in [nn.LSTM, nn.RNN, nn.GRU]:
  nn.init.xavier_normal(model.weight_hh_10)
  nn.init.xavier_normal(model.weight_ih_10)

class Net(nn.Module):
 def __init__(self):
  super(Net, self).__init__()
  self.fc1 = nn.Linear(len(Ysel_feature), LAYER1, True)
  self.fc2 = nn.Linear(LAYER1, LAYER2, True)
  self.fc3 = nn.Linear(LAYER2, 2, True)
  self.drop = nn.Dropout(p=DROPOUT)
  self.LeakyReLU = nn.LeakyReLU(negative_slope=0.01)

 def forward(self, x):
  x = self.fc1(x)
  x = self.LeakyReLU(x)
  x = self.drop(x)
  x = self.fc2(x)
  x = self.LeakyReLU(x)
  x = torch.sigmoid(self.fc3(x))
  return x
 
 def name(self):
  return "Net"

def Train(trainX, trainY, predictX, Ystr, ysize, EPOCHS, sel_feature, fold_count, early_stopping_rounds=3):
 
 kfold = KFold(n_splits=fold_count, random_state=0, shuffle=True)
 
 features = trainX.columns.tolist()
 if len(sel_feature)==0:
  sel_feature = features
 
 cv_pred = np.zeros(ysize)
 cv_rmse1 = 0
 cv_rmse2 = 0

 trainXnp = trainX.as_matrix(columns=sel_feature)
 trainYnp = trainY.as_matrix()
 
 i = 0
 for train_index, validate_index in kfold.split(trainXnp):
  i = i + 1
  log.write(PREFIX+"log.txt","[%d]Fold"%(i))
  X_train, X_validate = trainXnp[train_index], trainXnp[validate_index]
  y_train, y_validate = trainYnp[train_index], trainYnp[validate_index]
  
  train_inputs = (torch.from_numpy(X_train))
  train_inputs = train_inputs.float()
  train_targets = (torch.from_numpy(y_train))
  train_targets = train_targets.float()
  val_inputs = (torch.from_numpy(X_validate))
  val_inputs = val_inputs.float()
  val_targets = (torch.from_numpy(y_validate))
  val_targets = val_targets.float()
  
  model = Net()
  criterion = nn.BCELoss()
  optimizer = optim.SGD(model.parameters(), lr = RUNNING_RATE)
  
  min_loss = 100000000000.0
  min_epoch = -1
  min_count = 0
  break_true = False
  train_loss = 0.0
  for epoch in range(0,EPOCHS):
   for phase in ['train','valid']:
    if epoch % EPOCHS_FOR_DISPLAY == 0 :
     printlog = True
    else:
     printlog = False
    if phase == 'train' :
     running_loss = 0.0
     model.train(True)
     for input, target in zip(train_inputs, train_targets):
      optimizer.zero_grad()
      input = Variable(input)
      taregt = Variable(target)
      output = model(input)
      loss = criterion(output, target)
      loss.backward()
      optimizer.step()
      running_loss += loss.data.numpy()
      train_loss = running_loss
    else:
     running_loss = 0.0
     model.train(False)
     y_pred = []
     for input, target in zip(val_inputs, val_targets):
      input = Variable(input)
      target = Variable(target)
      output = model(input)
      loss = criterion(output, target)
      y_pred.append(output.detach().numpy())
      running_loss += loss.data.numpy()
     y_pred = np.array(y_pred)
     rmse1 = mean_squared_error(y_validate[:,0], y_pred[:,0])
     rmse2 = mean_squared_error(y_validate[:,1], y_pred[:,1])
     if printlog:
      log.write(PREFIX+"log.txt","vald:%d loss:%f rmse:%f %f=%f tloss:%f"%
      (epoch, running_loss, rmse1, rmse2, (rmse1+rmse2)/2, train_loss))
     if min_loss > running_loss :
      min_loss = running_loss
      min_epoch = epoch
      min_rmse1 = rmse1
      min_rmse2 = rmse2
      log.write(PREFIX+"log.txt","min epoch:%d"%(epoch))
      torch.save(model.state_dict(), model.name())
      min_count = 0
     else:
      min_count += 1
      if early_stopping_rounds < min_count :
       log.write(PREFIX+"log.txt","early_stopping_rounds:%d %d"%(epoch,early_stopping_rounds))
       break_true = True
    if break_true :
     break
   if break_true:
    break
  
  model.load_state_dict(torch.load(model.name()), strict = False)
  model.train(False)
  
  test_inputs = torch.from_numpy(predictX.as_matrix(columns=sel_feature))
  test_inputs = test_inputs.float()
  test_out = []
  for input in test_inputs:
   input = Variable(input)
   output = model(input)
   test_out.append(output.detach().numpy())
  cv_rmse1 += min_rmse1
  cv_rmse2 += min_rmse2
  cv_pred += np.array(test_out)
 cv_rmse1 /= fold_count
 cv_rmse2 /= fold_count
 cv_pred /= fold_count


 return (cv_pred, cv_rmse1, cv_rmse2)

trainY = pd.concat([Y1train_df, Y2train_df], axis=1)
predictY = pd.concat([Y1test_df, Y2test_df], axis=1)

y_pred, rmse1, rmse2 = Train(trainX, trainY, predictX, "All", predictY.shape, EPOCHS_TO_TRAIN, Y1sel_feature, FOLD_COUNT)

log.write(PREFIX+"log.txt","Total rmse %e + %e = %e"%(rmse1,rmse2,(rmse1+rmse2)/2))

OutputData("Result.csv",y_pred[:,0],y_pred[:,1])

2.3 코드 설명

코드는 lightGBM,.xgboost과 50%정도는 중복되기 때문에 일부 설명을 복사하였습니다.
아래 값은 EPOCH 을 반복하는 값입니다. EPOCH 은 전체 데이터를 한번 훈련하는 것을 1 epoch라고 합니다. 여기에서는 300번 훈련한다는 의미 입니다.
EPOCHS_TO_TRAIN = 300

교차 검증시 Fold 할 값입니다.
FOLD_COUNT = 2

그리고 running rate도 적절한 값을 넣어 줍니다.
RUNNING_RATE = 0.1

Dropout은 특정한 node를 사용안하게 하는 비율입니다. 보통 overfitting 방지 목적으로 사용하는데 숫자가 작을수록 사용안하는 노드가 줄어듭니다.
DROPOUT = 0.2

이번 예제는 liner layer 사용 하였습니다. 그때의 입출력 갯수의 값입니다. 입력과 출력 설명은 이 문서에서는 생략하겠습니다.
LAYER1 = 50
LAYER2 = 30

화면에 출력을 얼마나 할것인가를 조절하는 값입니다. 여기에서는 1 epoch 마다 출력하게 됩니다.
EPOCHS_FOR_DISPLAY = 1

평균과 표준 편차를 이용하여 -1~1 사이의 값으로 변환 합니다.
https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html
STD_ALL = False

최소값(Min)과 최대값(Max)을 사용해서 '0~1' 사이의 범위로 데이터를 변환합니다. (딥러닝에서는 많이 사용합니다. 그래서 True로 설정 하였습니다.)
수식적인 방법은 아래와 같습니다.

X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0)) X_scaled = X_std * (max - min) + min
https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MinMaxScaler.html
NOR_ALL = True

x1,x2 중 특정 x값을 선택하기 위해 만들어진 기능입니다. 여기에서는 x가 두개밖에 없어서 필요는 없습니다.
SELECT_NEED = False
랜덤 함수의 값을 고정합니다. 이것은 수행시킬때마다 값을 랜덤값을 만들기 위해 사용합니다.
np.random.seed(1000)

로그를 출력하기 위한 클래스 입니다.
class writeLog():
def write(self, fileName, text):
print(text)
f=open(fileName,'a')
f.write(text)
f.write("\n")
f.close()
def writeWithoutCR(self, fileName, text):
f=open(fileName,'a')
f.write(text)
f.close()

데이터인 train과 test용 csv 파일을 읽습니다.
train_df = pd.read_csv(BASE_PATH+'train.csv', header=0, encoding='utf8')test_df = pd.read_csv(BASE_PATH+'test.csv', header=0, encoding='utf8')

읽은 data파일은 y값이 포함되어 있으므로 제거합니다.
#drop YY1train_df = train_df.pop('y1')Y2train_df = train_df.pop('y2')Y1test_df = test_df.pop('y1')Y2test_df = test_df.pop('y2')

두개의 dataframe을 아래쪽으로 붙여서 allX를 만듭니다. 이렇게 하는 이유는 데이터 변환을 하기 위해서 그렇습니다.
allX = pd.concat([train_df, test_df], axis=0)

다음으로 앞에서 설명한 옵션에 따라서 Scaler 동작을 합니다. 일부 Machine learning에서는 효과가 좋습니다.
if NOR_ALL == True:
names = allX.columns
scaler = preprocessing.MinMaxScaler()
allX = scaler.fit_transform(allX)
allX = pd.DataFrame(allX, columns=names)

if STD_ALL == True:
names = allX.columns
scaler = preprocessing.StandardScaler()
allX = scaler.fit_transform(allX)
allX = pd.DataFrame(allX, columns=names)

그 후 X feature중에 필요한것만 선택하도록 합니다. 이름이 Y1sel_feature라고 되어있지만, 실은 해당 y값을 train할때 입력이 되는 x를 선택하기 위한 이름입니다. 이 부분은 사용자가 feature를 넣고 빼고 할때 사용하기 위함입니다. Deep learning에서 Y는 여러개 한꺼번에 입력하기 때문에 Y1sel_feature,Y2sel_feature 은 사용하지 않습니다. 의미가 없지만 예제와 소스를 같이 사용하기 위해서 그대로 두었습니다. 대신 Ysel_feature 를 사용합니다.
if SELECT_NEED :
Y1sel_feature = []
for feature, count in Y1_FEATURE_LIST_FOR_SELECT :
if count>=Y1_SELECT_LEVEL :
Y1sel_feature.append(feature)
log.write(PREFIX+"log.txt","Y1 selected:%d"%(len(Y1sel_feature)))

Y2sel_feature = []
for feature, count in Y2_FEATURE_LIST_FOR_SELECT :
if count>=Y2_SELECT_LEVEL :
Y2sel_feature.append(feature)
log.write(PREFIX+"log.txt","Y2 selected:%d"%(len(Y2sel_feature)))

Ysel_feature = []
Ysel_feature = Y1sel_feature + Y2sel_feature
Ysel_feature = list(set(Ysel_feature))
log.write(PREFIX+"log.txt","Y selected:%d"%(len(Ysel_feature)))
else:
Ysel_feature = []
Y1sel_feature = []
Y2sel_feature = []
if len(Ysel_feature)==0:
Ysel_feature = allX.columns
if len(Y1sel_feature)==0:
Y1sel_feature = allX.columns
if len(Y2sel_feature)==0:
Y2sel_feature = allX.columns

지금까지 X feature를 allX에서 다시 분리합니다.
#분리
trainX = allX[0:int(train_size)]predictX = allX[int(train_size):int(allX.shape[0])]

최종 출력을 위한 함수 입니다.
def OutputData(filename,Y1,Y2):
test_csv = pd.read_csv(BASE_PATH+'test.csv', header=0, encoding='utf8')
test_csv.pop('y1')
test_csv.pop('y2')
predAll = pd.concat([test_csv,pd.DataFrame(Y1, columns=['y1'])], axis=1)
predAll = pd.concat([predAll,pd.DataFrame(Y2, columns=['y2'])], axis=1)
predAll.to_csv(path_or_buf=PREFIX+filename, index=False)
del predAll

network class입니다. hidden layer가 2개 넣었고 dropout과 LeakyReLU 함수를이용하였으며, 마지막 출력단은 0~1 사이의 값이 필요하므로 sigmoid를 사용하였습니다.

class Net(nn.Module):
 def __init__(self):
  super(Net, self).__init__()
  self.fc1 = nn.Linear(len(Ysel_feature), LAYER1, True)
  self.fc2 = nn.Linear(LAYER1, LAYER2, True)
  self.fc3 = nn.Linear(LAYER2, 2, True)
  self.drop = nn.Dropout(p=DROPOUT)
  self.LeakyReLU = nn.LeakyReLU(negative_slope=0.01)

 def forward(self, x):
  x = self.fc1(x)
  x = self.LeakyReLU(x)
  x = self.drop(x)
  x = self.fc2(x)
  x = self.LeakyReLU(x)
  x = torch.sigmoid(self.fc3(x))
  return x
 
 def name(self):
  return "Net"

이제 가장 중요한 train 함수입니다. trainX는 X의 dataframe이고 trainY는 y의 dataframe입니다. predictX 는 나중에 예측하기위한 X값입니다. Ystr는 출력을 위한 문자열입니다. 즉 Y값이 여러개일때 출력시 어떤 Y값인지 구분하기 위해서 인자를 하나 더 넣었습니다. 하지만 deep learning 에서 Y는 구분하지 않기때문에 의미는 없습니다. EPOCHS 은 앞에서 설명하였습니다. sel_feature 는 앞에서 Ysel_feature로 선택된 컬럼 값입니다. fold_count는 교차 검증 Fold인자가 됩니다. early_stopping_rounds이 값은 평가값이 일정 기간동안 최저값이 되지 안되면 중단하도록 합니다.
def Train(trainX, trainY, predictX, Ystr, ysize, EPOCHS, sel_feature, fold_count, early_stopping_rounds=5):

실제 호출은 다음과 같습니다.
y_pred, rmse1, rmse2 = Train(trainX, trainY, predictX, "All", predictY.shape, EPOCHS_TO_TRAIN, Y1sel_feature, FOLD_COUNT)

train 함수 안에서는 KFold 수 만큼 루프를 돌게됩니다. 교차 검증 완료시 cv_rmse1, cv_rmse2, cv_pred 값이 발생하는데 이것을 최종 fold_count로 나누어 줍니다. 출력값은 cv_pred num array에 누적됩니다.

  cv_rmse1 += min_rmse1
  cv_rmse2 += min_rmse2
  cv_pred += np.array(test_out)
 cv_rmse1 /= fold_count
 cv_rmse2 /= fold_count
 cv_pred /= fold_count

pytorch 에서는 입력을 pytorch 변수로 변환해야 하는데 from_numpy함수를 이용하고 torch변수는 모두 float 형태로 변환 하였습니다.(간혹 문제가 발생하는 경우가 있어서 전체 변경하였습니다.)

  train_inputs = (torch.from_numpy(X_train))

  train_inputs = train_inputs.float()

  train_targets = (torch.from_numpy(y_train))

  train_targets = train_targets.float()

  val_inputs = (torch.from_numpy(X_validate))

  val_inputs = val_inputs.float()

  val_targets = (torch.from_numpy(y_validate))

  val_targets = val_targets.float()

pytorch의 기본적인 train은 아래와 같은 형태를 취합니다. model에 입력과 타겟값을 넣고 loss를 구하고 loss.backward()하여 optimizer.step()을 행하는 형태입니다.

optimizer.zero_grad()input = Variable(input)taregt = Variable(target)output = model(input)loss = criterion(output, target)loss.backward()optimizer.step()

validation에서는 model.train(False) 가 되며, 출력값만 있으면 되므로 간단하게 아래와 같이 됩니다.

input = Variable(input)target = Variable(target)output = model(input)

필요에 따라서 loss와 결과가 필요하기 때문에 추가 코드를 넣었습니다.

loss = criterion(output, target)y_pred.append(output.detach().numpy())running_loss += loss.data.numpy()

train중 학습을 해도 loss가 감소되지 않으면 중지하도록 코드 하였습니다. 중지하기전에 최소 loss가 될때를 저장해 두었다가 나중에 예측하는 param으로 사용합니다. xgboost의 early_stopping_rounds기능과 유사하게 구현해 보았습니다.

if min_loss > running_loss :
 min_loss = running_loss
 min_epoch = epoch
 min_rmse1 = rmse1
 min_rmse2 = rmse2
 log.write(PREFIX+"log.txt","min epoch:%d"%(epoch))
 torch.save(model.state_dict(), model.name())
 min_count = 0
else:
 min_count += 1
 if early_stopping_rounds < min_count :
  log.write(PREFIX+"log.txt","early_stopping_rounds:%d %d"%(epoch,early_stopping_rounds))
  break_true = True

train을 통해 진짜로 예측된값을 리턴받아야 하기때문에 이전에 최소로 학습된 데이터를 로딩합니다.

  model.load_state_dict(torch.load(model.name()), strict = False)

  model.train(False)

로딩된 네트워크 값을 이용해서 예측을 합니다.

  test_inputs = torch.from_numpy(predictX.as_matrix(columns=sel_feature))
  test_inputs = test_inputs.float()
  test_out = []
  for input in test_inputs:
   input = Variable(input)
   output = model(input)
   test_out.append(output.detach().numpy())
  cv_rmse1 += min_rmse1
  cv_rmse2 += min_rmse2
  cv_pred += np.array(test_out)

아래 값은 validation데이터의 rmse값을 리턴하기 위해 구현한 내용입니다.

  cv_rmse1 += min_rmse1

  cv_rmse2 += min_rmse2

2.4 실행 결과

(base) E:\work\ai\pytorch\xor>python NN_xor_cv.py
start
train size:(1000, 2)
test size:(100, 2)
all size:(1100, 2)
train size:(1000, 2)
test size:(100, 2)
NN_xor_cv.py:175: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.
  trainXnp = trainX.as_matrix(columns=sel_feature)
NN_xor_cv.py:176: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.
  trainYnp = trainY.as_matrix()
[1]Fold
vald:0 loss:381.167028 rmse:0.295309 0.287722=0.291515 tloss:327.426832
min epoch:0
vald:1 loss:25.544507 rmse:0.007797 0.007785=0.007791 tloss:109.076330
min epoch:1
vald:2 loss:14.051988 rmse:0.004656 0.004768=0.004712 tloss:42.358824
min epoch:2
vald:3 loss:398.590590 rmse:0.199223 0.197968=0.198595 tloss:38.308674
vald:4 loss:3.552140 rmse:0.000418 0.000405=0.000412 tloss:22.012489
min epoch:4
vald:5 loss:0.980270 rmse:0.000042 0.000040=0.000041 tloss:5.295693
min epoch:5
vald:6 loss:2.086842 rmse:0.000115 0.000118=0.000117 tloss:19.377938
vald:7 loss:331.050024 rmse:0.173799 0.173541=0.173670 tloss:26.756935
vald:8 loss:2.741837 rmse:0.000602 0.000600=0.000601 tloss:9.742526
vald:9 loss:2.365121 rmse:0.000179 0.000180=0.000179 tloss:19.654218
early_stopping_rounds:9 3
NN_xor_cv.py:260: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.
  test_inputs = torch.from_numpy(predictX.as_matrix(columns=sel_feature))
[2]Fold
vald:0 loss:288.255821 rmse:0.192850 0.193520=0.193185 tloss:337.972763
min epoch:0
vald:1 loss:52.830412 rmse:0.020778 0.020908=0.020843 tloss:168.357505
min epoch:1
vald:2 loss:15.876434 rmse:0.005517 0.005562=0.005539 tloss:54.561382
min epoch:2
vald:3 loss:4.527604 rmse:0.001074 0.001117=0.001095 tloss:29.563572
min epoch:3
vald:4 loss:11.396077 rmse:0.005104 0.005100=0.005102 tloss:15.989310
vald:5 loss:1.294892 rmse:0.000076 0.000079=0.000078 tloss:10.330235
min epoch:5
vald:6 loss:0.893226 rmse:0.000037 0.000036=0.000037 tloss:28.060664
min epoch:6
vald:7 loss:3.602118 rmse:0.001702 0.001662=0.001682 tloss:33.778341
vald:8 loss:0.198577 rmse:0.000004 0.000004=0.000004 tloss:3.830715
min epoch:8
vald:9 loss:0.294545 rmse:0.000016 0.000017=0.000017 tloss:3.244088
vald:10 loss:10.637149 rmse:0.006106 0.006137=0.006122 tloss:15.555545
vald:11 loss:1.834899 rmse:0.000758 0.000777=0.000768 tloss:11.499690
vald:12 loss:0.237293 rmse:0.000003 0.000003=0.000003 tloss:2.695498
early_stopping_rounds:12 3
NN_xor_cv.py:260: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.
  test_inputs = torch.from_numpy(predictX.as_matrix(columns=sel_feature))
Total rmse 2.263878e-05 + 2.175447e-05 = 2.219662e-05

최종 RMSE는 rmse 2.263878e-05 + 2.175447e-05 = 2.219662e-05 가 평균값이라 더해서 2로 나누어 줍니다. 앞쪽은 Y1 rmse값이 되고 뒤쪽 값은 Y2 rmse 값이 됩니다.

2.5 결과 데이터 확인

x1,x2,y1,y2
1.077770981623956,0.16715055841696874,0.999789297580719,0.0002013216399063822
0.1898476282284382,-0.2003537468439492,7.648291375517147e-05,0.9999271035194397
-0.2648225646697367,0.8201024089303411,0.9999933242797852,6.2870740293874405e-06
-0.23118448473185735,0.06200855703372005,4.3045685060860706e-06,0.9999959468841553

......

1번째 라인
[x1=1.077770981623956(대략)1]XOR[x2=0.16715055841696874(대략)0]= 1

결과 y1=0.999789297580719 대략(1) 결과는 정상적으로 보입니다.

SW정리

2019년 2월 11일 월요일

deep learning pytorch KFold 예제 (example)

1. 들어가기에 앞서

2.1 XOR data 만들기

2.2 pytorch 예제 코드 작성

2.3 코드 설명

2.4 실행 결과

2.5 결과 데이터 확인

2019년 1월 20일 일요일

scikit-learn 이용한 (cross-validation) 교차 검증 iterators StratifiedKFold, KFold 사용법

0. 교차 검증 반복자(iterators)란

1. KFold

소스

실행결과

소스 설명

2. StratifiedKFold

소스

결과

소스 설명

주의점

에러 발생 예제

사유

참조 링크