1. 들어가기에 앞서
XGBoost 를 시작하기전에 설치를 안하셨다면 아래 링크로 설치 하시기 바랍니다.
https://swlock.blogspot.com/2019/01/install-xgboost-in-python-xgboost.html
XGBoost 와 비슷한 부스팅 머신러닝 알고리즘은 lightGBM이 있습니다. 동일 한 데이터로 진행한 예제이며 비교해보면 사용법상 차이점을 알 수 있습니다.
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
이번 예제는 XGBoost 에 XOR 데이터를 넣어서 학습한뒤 결과를 보는 예제입니다. XOR함수는 X1, X2 두개의 입력을 가지는데 두개의 값이 같은 경우에 Y값이 1 이 되는 함수 입니다. 이 부분은 lightGBM 예제에서도 동일하기 때문에 해당 내용을 그대로 복사하였습니다.
2. XOR data로 XGBoost 사용하기
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 XGBoost 예제 코드 작성
이제 본론입니다. 해당 코드는 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.htmlStratifiedKFold 는 사용상 주의점이 있는데 아래 소스를 바탕으로 예제를 작성하는 경우 간혹 에러가 발생할 수 있습니다. 이유는 위 링크에서도 언급이 되어있는데, y값에 따라 발생합니다. 따라서 해당 경우에는 KFold로 변경해서 사용하시면 됩니다.
xgboost_xor_cv.py
# xgboost 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:logistic', 'random_seed':0, 'eta':0.5 } #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ import time import pandas as pd import numpy as np from sklearn.model_selection import StratifiedKFold from sklearn import preprocessing import xgboost as xgb 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 = xgb.DMatrix(X_train, label=y_train, feature_names=sel_feature) dvld = xgb.DMatrix(X_validate, label=y_validate, feature_names=sel_feature) watch_list = [(dvld,'eval'),(dtrn,'train')] model = xgb.train(param, dtrn, num_boost_round=10000, evals=watch_list, early_stopping_rounds=10) y_pred = model.predict(dvld, ntree_limit=model.best_ntree_limit) 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:split"%(i,Ystr)) for kv in sorted([(k,v) for k, v in model.get_fscore().items()], 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(xgb.DMatrix(predictX.as_matrix(columns=sel_feature),feature_names=sel_feature), ntree_limit=model.best_ntree_limit) 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)
2.3 코드 설명
코드는 lightGBM과 90%정도는 중복되기 때문에 설명도 복사하였습니다.아래 값은 seed 값을 이용해서 반복할때 사용합니다.
EPOCHS_TO_TRAIN = 2
교차 검증시 Fold 할 값입니다.
FOLD_COUNT = 2
평균과 표준 편차를 이용하여 -1~1 사이의 값으로 변환 합니다.
https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html
STD_ALL = False
최소값(Min)과 최대값(Max)을 사용해서 '0~1' 사이의 범위로 데이터를 변환합니다.
수식적인 방법은 아래와 같습니다.
https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MinMaxScaler.html
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])]
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
이제 가장 중요한 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):
log.write(PREFIX+"log.txt","seed: %d"%(seed))
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(xgb.DMatrix(predictX.as_matrix(columns=sel_feature),feature_names=sel_feature), ntree_limit=model.best_ntree_limit) 예측 결과 값을 더해줍니다. 그리고 교차 검증 최종에는 fold 수만큼 나누어 줍니다. 해당 부분은 다음 부분 입니다. cv_rmse /= fold_count
XGboost은 인자로 xgb.DMatrix 을 필요로 합니다. DMatrix 을 만드는 방법이 아래 코드입니다. 인자로 numpy가 필요합니다.
dtrn = xgb.DMatrix(X_train, label=y_train, feature_names=sel_feature)
dvld = xgb.DMatrix(X_validate, label=y_validate, feature_names=sel_feature)
train 중 지켜보는 값입니다. validation, train 값을 넣어봤습니다. overfit 되는지 지켜보는 용도인데 넣지 않아도 됩니다. 10000은 전체 train 수인데, early_stopping_rounds 값에 의해서 일반적으로 해당 수치에 의해서 10000루프를 모두 돌지는 않게 됩니다. 이 부분이 ligitGBM과 다릅니다.
watch_list = [(dvld,'eval'),(dtrn,'train')]
model = xgb.train(param, dtrn, num_boost_round=10000, evals=watch_list, early_stopping_rounds=10)
값을 예측하고, 이때 ntree_limit=model.best_ntree_limit 을 사용하면(lightGBM과 다름) 중간에 최적의 값을 사용해서 예측이 가능합니다.
y_pred = model.predict(dvld, ntree_limit=model.best_ntree_limit)
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:\work\xgboost>python xgboost_xor_cv.py start 2 train size:(1000, 2) test size:(100, 2) all size:(1100, 2) train size:(1000, 2) test size:(100, 2) seed: 0 xgboost_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) xgboost_xor_cv.py:145: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead. trainYnp = trainY.as_matrix() [1]Fold [21:09:56] d:\build\xgboost\xgboost-0.81.git\src\tree\updater_prune.cc:74: tree pruning end, 1 roots, 14 extra nodes, 0 pruned nodes, max_depth=4 [0] eval-error:0.007984 train-error:0.002004 Multiple eval metrics have been passed: 'train-error' will be used for early stopping. ....... [2]rmse 0.006062 [2]Y2 Feature importance:split xgboost_xor_cv.py:169: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead. cv_pred += model.predict(xgb.DMatrix(predictX.as_matrix(columns=sel_feature),feature_names=sel_feature), ntree_limit=model.best_ntree_limit) Total rmse 0.004275 + 0.004275 = 0.004275
최종 RMSE는 Total rmse 0.004275 + 0.004275 = 0.004275 가 평균값이라 더해서 2로 나누어 줍니다. 앞쪽은 Y1 rmse값이 되고 뒤쪽 값은 Y2 rmse 값이 됩니다.
2.5 결과 데이터 확인
xgboost_xor_cvResult.csvx1,x2,y1,y2 1.077770981623956,0.16715055841696874,0.9538576304912567,0.0461423909291625 0.1898476282284382,-0.2003537468439492,0.0488235168159008,0.9511764645576477 -0.2648225646697367,0.8201024089303411,0.9523830413818359,0.04761694651097059 -0.23118448473185735,0.06200855703372005,0.04614610876888037,0.9538538455963135 0.9576799510927888,0.8890909020672868,0.04623681679368019,0.9537632167339325 0.0004552517531765665,1.2781596666369324,0.9370305836200714,0.06296937074512243
.......
1번째 라인
[x1=1.077770981623956(대략)1]XOR[x2=0.16715055841696874(대략)0]= 1
결과 y1=0.9538576304912567 대략(1) 결과는 정상적으로 보입니다.
다만 lightGBM 결과와 비교시에는 좀 큰 값입니다. 사유가 여러가지가 있겠지만, 여기에서 설명되지 않은 parameter 의 값을 변경해야하고 binary:logistic 는 많은 데이터를 필요로 하기 때문에 데이터가 부족해서 그럴수도 있습니다.
param={ 'objective':'binary:logistic', 'random_seed':0, 'eta':0.5}
XGBooster parameter 설정 아래 링크를 참고 바랍니다.
https://xgboost.readthedocs.io/en/latest/parameter.html
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
as_matrix() 함수 오류가 발생한다면 아래와 같이 values로 변경 필요
코드 변경=> trainXnp = trainX[sel_feature].values
코드 변경=> cv_pred += model.predict(xgb.DMatrix(predictX[sel_feature].values,feature_names=sel_feature), ntree_limit=model.best_ntree_limit)
