LightGBM
Tree 기반의 러닝 알고리즘을 사용한 gradient boosting framework 입니다.
아래와 같은 장점이 있습니다.
- Faster training speed and higher efficiency. (빠른 훈련 속도와 높은 효율)
- Lower memory usage. (적은 메모리 사용)
- Better accuracy. (높은 정확도)
- Support of parallel and GPU learning. (병렬 처리와 GPU 러닝 지원)
- Capable of handling large-scale data. (큰 scale 데이터 다룰 수 있음)
https://lightgbm.readthedocs.io/en/latest/
개인적으로 사용해본 결과는 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
1. 설치하기
두가지 방법이 있습니다. 32bit python 에서는 설치되지 않습니다. 64bit Python 혹은 Anaconda 환경에서 설치 하세요.
1.1 Conda 이용하기
https://anaconda.org/conda-forge/lightgbmconda install -c conda-forge lightgbm
conda install -c conda-forge/label/cf201901 lightgbm
1.2 PIP 이용하기
https://pypi.org/project/lightgbm/pip install lightgbm
2. XOR data로 lightGBM 사용하기
XOR함수는 입력을 2개를 받고 두개의 값이 같으면 1이되고 다르면 0이 되는 함수 입니다.0,1 정수만 넣어서 예제를 만들면 test와 train 데이터가 겹치는 부분도 있고 해서 여기에서는 random 을 이용해서 실수 형태로 만들었습니다. 또한 Y가 한개인것보다 복잡한 sample을 만들기 위해 y1, y2는 서로 반대가 되는 값을 넣었습니다.
2.1 XOR data 만들기
파일명 : makexordata.pyimport 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 lightgbm 예제 코드 작성
이제 본론입니다. 해당 코드는 StratifiedKFold 교차 검증, random seed를 이용한 반복 훈련, Feature Select, MinMaxScaler, StandardScaler 내용을 포함하는 예제입니다.전반적인 흐름은 train.csv 파일을 읽어서 MinMaxScaler, StandardScaler 를 할 수도 있으며, 훈련 후 그 결과를 result.csv 파일에 저장하는 코드입니다.
StratifiedKFold 교차검증 관련해서는 아래 게시글 참고 부탁드립니다.
https://swlock.blogspot.com/2019/01/scikit-learn-cross-validation-iterators.html
StratifiedKFold 는 사용상 주의점이 있는데 아래 소스를 바탕으로 예제를 작성하는 경우 간혹 에러가 발생할 수 있습니다. 이유는 위 링크에서도 언급이 되어있는데, y값에 따라 발생합니다. 따라서 해당 경우에는 KFold로 변경해서 사용하시면 됩니다.
lightgbm_xor_cv.py
# lightgbm example with StratifiedKFold EPOCHS_TO_TRAIN = 2 FOLD_COUNT = 2 STD_ALL = False NOR_ALL = False 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) ] param={ 'objective':'binary', 'random_seed':0, 'learning_rate':0.1 } #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ import time import pandas as pd import numpy as np from sklearn.model_selection import StratifiedKFold from sklearn import preprocessing import lightgbm as lgb from sklearn.metrics import mean_squared_error 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 = [] #분리 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 Train(trainX, trainY, Ystr, ysize, EPOCHS, sel_feature, fold_count): stratifiedkfold = StratifiedKFold(n_splits=fold_count, random_state=0, shuffle=True) features = trainX.columns.tolist() if len(sel_feature)==0: sel_feature = features final_cv_pred = np.zeros(ysize) final_cv_rmse = 0 for seed in range(EPOCHS): log.write(PREFIX+"log.txt","seed: %d"%(seed)) param['random_seed'] = seed cv_pred = np.zeros(ysize) cv_rmse = 0 trainXnp = trainX.as_matrix(columns = sel_feature) trainYnp = trainY.as_matrix() i = 0 for train_index, validate_index in stratifiedkfold.split(trainXnp, trainYnp): 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] dtrn = lgb.Dataset(X_train, label=y_train, feature_name=sel_feature) dvld = lgb.Dataset(X_validate, label=y_validate, feature_name=sel_feature) watch_list = [dvld,dtrn] model = lgb.train(param, dtrn, 10000, valid_sets=watch_list, valid_names = ['eval','train'], early_stopping_rounds=10) y_pred = model.predict(X_validate, num_iteration=model.best_iteration) rmse = mean_squared_error(y_validate, y_pred) log.write(PREFIX+"log.txt","[%d]rmse %f"%(i,rmse)) log.write(PREFIX+"log.txt","[%d]%s Feature importance"%(i,Ystr)) log.writeWithoutCR(PREFIX+"log.txt",str(model.feature_importance())) log.writeWithoutCR(PREFIX+"log.txt",",\n\n") log.write(PREFIX+"log.txt","[%d]%s Feature importance:split"%(i,Ystr)) for kv in sorted([(k,v) for k, v in zip(features, model.feature_importance("split"))], key=lambda kv: kv [1], reverse=True): log.writeWithoutCR(PREFIX+"log.txt",str(kv)) log.writeWithoutCR(PREFIX+"log.txt",",\n") log.writeWithoutCR(PREFIX+"log.txt",",\n\n") cv_rmse += rmse cv_pred += model.predict(predictX.as_matrix(columns=sel_feature), num_iteration=model.best_iteration) cv_rmse /= fold_count cv_pred /= fold_count final_cv_rmse += cv_rmse final_cv_pred += cv_pred final_cv_rmse /= EPOCHS final_cv_pred /= EPOCHS return (final_cv_pred, final_cv_rmse) y1_pred, rmse1 = Train(trainX, Y1train_df, "Y1", len(Y1test_df), EPOCHS_TO_TRAIN, Y1sel_feature, FOLD_COUNT) y2_pred, rmse2 = Train(trainX, Y2train_df, "Y2", len(Y2test_df), EPOCHS_TO_TRAIN, Y2sel_feature, FOLD_COUNT) log.write(PREFIX+"log.txt","Total rmse %f + %f = %f"%(rmse1,rmse2,(rmse1+rmse2)/2)) OutputData("Result.csv",y1_pred, y2_pred)
위코드 실행시 아래와 같은 오류가 발생한다면
(base) E:\work\lightgbm>python lightgbm_xor_cv.py
Traceback (most recent call last):
File "lightgbm_xor_cv.py", line 34, in <module>
from sklearn.model_selection import StratifiedKFold
File "e:\ProgramData\Anaconda3\lib\site-packages\sklearn\__init__.py", line 64, in <module>
from .base import clone
ModuleNotFoundError: No module named 'sklearn.base'
아래 명령으로 scikit-learn 업데이트 해줘야 합니다.
(base) E:\work\lightgbm>pip install -U scikit-learn
2.3 코드 설명
아래 값은 seed 값을 이용해서 반복할때 사용합니다.EPOCHS_TO_TRAIN = 2
교차 검증시 Fold 할 값입니다.
FOLD_COUNT = 2
평균과 표준 편차를 이용하여 -1~1 사이의 값으로 변환 합니다.
STD_ALL = False
최소값(Min)과 최대값(Max)을 사용해서 '0~1' 사이의 범위로 데이터를 변환합니다.
수식적인 방법은 아래와 같습니다.
NOR_ALL = Falsex1,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 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')
두개의 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를 넣고 빼고 할때 사용하기 위함입니다.
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 = []
지금까지 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
이제 가장 중요한 train 함수입니다. trainX는 X의 dataframe이고 trainY는 y의 dataframe입니다. Ystr는 출력을 위한 문자열입니다. 즉 Y값이 여러개일때 출력시 어떤 Y값인지 구분하기 위해서 인자를 하나 더 넣었습니다. EPOCHS seed를 이용한 반복하는 값입니다. sel_feature 는 앞에서 Y1sel_feature, Y2sel_feature 로 선택된 컬럼 값입니다. 빈 [] list일경우 전체 데이터를 선택합니다. fold_count는 교차 검증 Fold인자가 됩니다.
def Train(trainX, trainY, Ystr, ysize, EPOCHS, sel_feature, fold_count):
실자 호출은 다음과 같습니다.
y1_pred, rmse1 = Train(trainX, Y1train_df, "Y1", len(Y1test_df), EPOCHS_TO_TRAIN, Y1sel_feature, FOLD_COUNT)
y2_pred, rmse2 = Train(trainX, Y2train_df, "Y2", len(Y2test_df), EPOCHS_TO_TRAIN, Y2sel_feature, FOLD_COUNT)
train 함수 안에서는 다음코드로 EPOCHS 만큼 루프를 돌게됩니다. 그리고 prameter의 인자로 들어갑니다. 교차 검증 완료시 cv_rmse, cv_pred 값이 발생하는데 이것을 최종 final_cv_rmse, final_cv_pred 값에 넣고 다시 평균을 구합니다.
for seed in range(EPOCHS):
param['random_seed'] = seed
....
final_cv_rmse += cv_rmse
final_cv_pred += cv_pred
final_cv_rmse /= EPOCHS
final_cv_pred /= EPOCHS
내부 루프는 아래와 같은 코드로 되어있습니다. 이것은 stratifiedkfold를 위한 것입니다.
만약 KFold로 변경시 y값이 사용되지 않으므로 다음과 같이 사용해야 합니다.
kfold.split(trainXnp):
한번의 교차검증이 끝날때 마다 rmse과 model.predict(predictX.as_matrix(columns=sel_feature), num_iteration=model.best_iteration) 예측 결과 값을 더해줍니다. 그리고 교차 검증 최종에는 fold 수만큼 나누어 줍니다. 해당 부분은 다음 부분 입니다. cv_rmse /= fold_count
for train_index, validate_index in stratifiedkfold.split(trainXnp, trainYnp): i = i + 1 log.write(PREFIX+"log.txt","[%d]Fold"%(i)) ...... cv_rmse += rmse cv_pred += model.predict(predictX.as_matrix(columns=sel_feature), num_iteration=model.best_iteration)cv_rmse /= fold_countcv_pred /= fold_count
핵심중 핵심 코드입니다. lightgbm은 인자로 dataset을 필요로 합니다. dataset을 만드는 방법이 아래 코드입니다. 인자로 numpy가 필요합니다.
dtrn = lgb.Dataset(X_train, label=y_train, feature_name=sel_feature)dvld = lgb.Dataset(X_validate, label=y_validate, feature_name=sel_feature)
train 중 지켜보는 값입니다. validation, train 값을 넣어봤습니다. overfit 되는지 지켜보는 용도인데 넣지 않아도 됩니다. 10000은 전체 train 수인데, early_stopping_rounds 값에 의해서 일반적으로 해당 수치에 의해서 10000루프를 모두 돌지는 않게 됩니다.
watch_list = [dvld,dtrn]model = lgb.train(param, dtrn, 10000, valid_sets=watch_list, valid_names = ['eval','train'], early_stopping_rounds=10)
값을 예측하고, 이때 num_iteration=model.best_iteration 을 사용하면 중간에 최적의 값을 사용해서 예측이 가능합니다.
y_pred = model.predict(X_validate, num_iteration=model.best_iteration)
validation 값에 대한 rmse 평균 제곱 오류를 계산합니다.
rmse = mean_squared_error(y_validate, y_pred)
2.4 실행 결과
random seed를 이용해서 여러번 반복하는것은 EPOCHS_TO_TRAIN = 2 값에 의해서 결정됩니다. 교차 검증은 다음 값에 의해서 결정됩니다. FOLD_COUNT = 2Train 함수 호출 횟수는 EPOCHS_TO_TRAIN = 2 * FOLD_COUNT = 2, 4회인데 Y1, Y2 두개에 대해서 진행하므로 8회가 됩니다.
결과
(base) E:\lightgbm>python lightgbm_xor_cv.py start train size:(1000, 2) test size:(100, 2) all size:(1100, 2) train size:(1000, 2) test size:(100, 2) seed: 0 lightgbm_xor_cv.py:144: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead. trainXnp = trainX.as_matrix(columns = sel_feature) lightgbm_xor_cv.py:145: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead. trainYnp = trainY.as_matrix() [1]Fold [LightGBM] [Warning] Starting from the 2.1.2 version, default value for the "boost_from_average" parameter in "binary" objective is true. This may cause significantly different results comparing to the previous versions of LightGBM. Try to set boost_from_average=false, if your old models produce bad results [LightGBM] [Info] Number of positive: 258, number of negative: 241 [LightGBM] [Info] Total Bins 336 [LightGBM] [Info] Number of data: 499, number of used features: 2 [LightGBM] [Info] [binary:BoostFromScore]: pavg=0.517034 -> initscore=0.068163 [LightGBM] [Info] Start training from score 0.068163 [LightGBM] [Warning] No further splits with positive gain, best gain: -inf [1] train's binary_logloss: 0.602133 eval's binary_logloss: 0.602983 Training until validation scores don't improve for 10 rounds. [LightGBM] [Warning] No further splits with positive gain, best gain: -inf [2] train's binary_logloss: 0.527997 eval's binary_logloss: 0.529776 [LightGBM] [Warning] No further splits with positive gain, best gain: -inf ...... [86] train's binary_logloss: 0.000278811 eval's binary_logloss: 0.0209929 [LightGBM] [Warning] No further splits with positive gain, best gain: -inf [87] train's binary_logloss: 0.000253702 eval's binary_logloss: 0.0211494 Early stopping, best iteration is: [77] train's binary_logloss: 0.000644719 eval's binary_logloss: 0.0201908 [1]rmse 0.003962 [1]Y1 Feature importance [1]Y1 Feature importance:split lightgbm_xor_cv.py:172: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead. cv_pred += model.predict(predictX.as_matrix(columns=sel_feature), num_iteration=model.best_iteration) [2]Fold ....... lightgbm_xor_cv.py:172: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead. cv_pred += model.predict(predictX.as_matrix(columns=sel_feature), num_iteration=model.best_iteration) Total rmse 0.002844 + 0.002844 = 0.002844
최종 RMSE는 Total rmse 0.002844 + 0.002844 = 0.002844 가 평균값이라 더해서 2로 나누어 줍니다. 앞쪽은 Y1 rmse값이 되고 뒤쪽 값은 Y2 rmse 값이 됩니다.
2.5 결과 데이터 확인
lightgbm_xor_cvResult.csv
x1,x2,y1,y2 1.077770981623956,0.16715055841696874,0.999594684585513,0.0004053154144868683 0.1898476282284382,-0.2003537468439492,0.0014865114383550517,0.998513488561645 -0.2648225646697367,0.8201024089303411,0.9996402153722901,0.000359784627709847 -0.23118448473185735,0.06200855703372005,0.0004420196114214045,0.9995579803885786 0.9576799510927888,0.8890909020672868,0.0006624884368406149,0.9993375115631593 0.0004552517531765665,1.2781596666369324,0.9993483401341827,0.0006516598658172336 -0.11998087702972482,1.2736899004744116,0.9996482661472061,0.0003517338527939095 ......
1번째 라인
[x1=1.077770981623956(대략)1]XOR[x2=0.16715055841696874(대략)0]= 1
결과 y1=0.999594684585513 대략(1) 결과는 정상적으로 보입니다.
댓글 없음:
댓글 쓰기