고정 헤더 영역
상세 컨텐츠
본문 제목
[코드 분석 스터디] Multi-class classification : Costa risan household poverty prediction
본문
대회 소개
kaggle 대회 링크
https://www.kaggle.com/c/costa-rican-household-poverty-prediction
Costa Rican Household Poverty Level Prediction | Kaggle
www.kaggle.com
대회의 목적
: 미국을 비롯한 여러 나라의 은행들과 기관들은 도움이 필요한 사람들에게 금전적인 지원을 하고 있다. 하지만 이러한 단체들은 수많은 사람들 중 과연 누가 이러한 지원이 필요한 사람인지를 정확히 판별함에 있어서 어려움을 겪고 있다. 이 대회는 이러한 어려움을 해소하기 위해서 다양한 변수들을 제공하고 이를 통해 도움이 필요한 사람들을 분류하는 모델링을 진행하는 것이 이 대회의 목적이다.
사용하는 데이터 셋의 특징
: 142개의 column 23856개 value가 있는 데이터셋으로 categorical 형의 변수가 많다. 또한 이 커널에서는 굉장히 많은 변수들을 새로 만들어 모델링에 사용한다. 다양한 categorical 변수들에 대해서 변환을 진행하는 것을 확인할 수 있다.
커널 소개
커널 링크
https://www.kaggle.com/skooch/xgboost
XGBoost
Explore and run machine learning code with Kaggle Notebooks | Using data from Costa Rican Household Poverty Level Prediction
www.kaggle.com
커널의 특징
- VotingClassifier 와 XGBoost, RandomForest의 ensembling을 이용하여 학습 모델을 만들었다.
- 새로운 변수들을 추가하여 모델링을 진행하였다.
- 몇몇의 변수들에 대해서는 제거를 하여 설명력을 높였다.
- 기존의 train test split을 진행할 때 학습을 진행하기 전에 분할을 하고 진행하는 방법이 아닌 학습 도중에 분할을 진행하여 전체 train data를 학습에 이용할 수 있도록 하였다.
- 이 커널에서는 가족 구성원 중 가장에 해당하는 사람의 데이터만을 추출하여 사용하였다.
- 이 커널은 macro F1 Score를 학습에 사용하였다.
- 트리 기법을 이용한 모델링의 경우 One hot encoding을 label encoding으로 뒤집었을 때 설명력이 더 올라간다. 그러기에 이런 방법을 이용할 것이다.
- 한 가정에 속해 있는 사람들을 묶어서 학습에 사용할 것이다.
중요 변수 설명
- Target - the target is an ordinal variable indicating groups of income levels.
- 1 - extreme poverty
- 2 - moderate poverty
- 3 - vulnerable households
- 4 - non vulnerable households
- idhogar - 한 가정에 대해서는 이를 구별할 수 있도록 유일하게 부여되는 값으로 이 변수를 이용하여 같은 가정의 사람들을 식별할 수 있다.
- parentesco1 - 한 가정에 있어서 가장의 역할을 하는 사람을 식별시켜주는 변수이다.
코드 분석
from sklearn.preprocessing import LabelEncoder
# this only transforms the idhogar field, the other things this function used to do are done elsewhere
def encode_data(df):
df['idhogar'] = LabelEncoder().fit_transform(df['idhogar'])
# plot feature importance for sklearn decision trees
def feature_importance(forest, X_train, display_results=True):
ranked_list = []
zero_features = []
importances = forest.feature_importances_
indices = np.argsort(importances)[::-1]
if display_results:
# Print the feature ranking
print("Feature ranking:")
for f in range(X_train.shape[1]):
if display_results:
print("%d. feature %d (%f)" % (f + 1, indices[f], importances[indices[f]]) + " - " + X_train.columns[indices[f]])
ranked_list.append(X_train.columns[indices[f]])
if importances[indices[f]] == 0.0:
zero_features.append(X_train.columns[indices[f]])
return ranked_list, zero_features위 코드는 idhogar 변수에 대해서 Label Encoding을 해주는 함수와 모델 학습시에 변수 중요도를 보여주는 함수이다. 이렇듯 이 커널에서는 다양한 함수들을 먼저 디자인을 하고 분석을 진행하는 모습을 보여준다.
def do_features(df):
feats_div = [('children_fraction', 'r4t1', 'r4t3'),
('working_man_fraction', 'r4h2', 'r4t3'),
('all_man_fraction', 'r4h3', 'r4t3'),
('human_density', 'tamviv', 'rooms'),
('human_bed_density', 'tamviv', 'bedrooms'),
('rent_per_person', 'v2a1', 'r4t3'),
('rent_per_room', 'v2a1', 'rooms'),
('mobile_density', 'qmobilephone', 'r4t3'),
('tablet_density', 'v18q1', 'r4t3'),
('mobile_adult_density', 'qmobilephone', 'r4t2'),
('tablet_adult_density', 'v18q1', 'r4t2'),
]
feats_sub = [('people_not_living', 'tamhog', 'tamviv'),
('people_weird_stat', 'tamhog', 'r4t3')]
for f_new, f1, f2 in feats_div:
df['fe_' + f_new] = (df[f1] / df[f2]).astype(np.float32)
for f_new, f1, f2 in feats_sub:
df['fe_' + f_new] = (df[f1] - df[f2]).astype(np.float32)
# aggregation rules over household
#aggregation rules over household 가정을 집합시키는 기준
aggs_num = {'age': ['min', 'max', 'mean'],
'escolari': ['min', 'max', 'mean']
}
aggs_cat = {'dis': ['mean']}
for s_ in ['estadocivil', 'parentesco', 'instlevel']:
for f_ in [f_ for f_ in df.columns if f_.startswith(s_)]:
aggs_cat[f_] = ['mean', 'count']
# aggregation over household
for name_, df_ in [('18', df.query('age >= 18'))]:
df_agg = df_.groupby('idhogar').agg({**aggs_num, **aggs_cat}).astype(np.float32)
df_agg.columns = pd.Index(['agg' + name_ + '_' + e[0] + "_" + e[1].upper() for e in df_agg.columns.tolist()])
df = df.join(df_agg, how='left', on='idhogar')
del df_agg
# Drop id's
df.drop(['Id'], axis=1, inplace=True)
return df위 함수에서 볼 수 있듯이 기존의 데이터 셋에 있는 변수들을 조합하고 연산하여 새로운 변수를 만들고 이를 추가하여 학습을 진행한다. 또한 한 가정에 대해서는 묶어서 적용하는 것을 알 수 있다.
# convert one hot encoded fields to label encoding
def convert_OHE2LE(df):
tmp_df = df.copy(deep=True)
for s_ in ['pared', 'piso', 'techo', 'abastagua', 'sanitario', 'energcocinar', 'elimbasu',
'epared', 'etecho', 'eviv', 'estadocivil', 'parentesco',
'instlevel', 'lugar', 'tipovivi',
'manual_elec']:
if 'manual_' not in s_:
cols_s_ = [f_ for f_ in df.columns if f_.startswith(s_)]
elif 'elec' in s_:
cols_s_ = ['public', 'planpri', 'noelec', 'coopele']
sum_ohe = tmp_df[cols_s_].sum(axis=1).unique()
#deal with those OHE, where there is a sum over columns == 0
if 0 in sum_ohe:
print('The OHE in {} is incomplete. A new column will be added before label encoding'
.format(s_))
# dummy colmn name to be added
col_dummy = s_+'_dummy'
# add the column to the dataframe
tmp_df[col_dummy] = (tmp_df[cols_s_].sum(axis=1) == 0).astype(np.int8)
# add the name to the list of columns to be label-encoded
cols_s_.append(col_dummy)
# proof-check, that now the category is complete
sum_ohe = tmp_df[cols_s_].sum(axis=1).unique()
if 0 in sum_ohe:
print("The category completion did not work")
tmp_cat = tmp_df[cols_s_].idxmax(axis=1)#최대 값을 가지는 인덱스 레이블을 따로 꺼내 저장한다
tmp_df[s_ + '_LE'] = LabelEncoder().fit_transform(tmp_cat).astype(np.int16)
if 'parentesco1' in cols_s_:
cols_s_.remove('parentesco1')
tmp_df.drop(cols_s_, axis=1, inplace=True)
return tmp_df
위에서 말했듯이 트리 기반의 모델링을 진행할 경우 One hot encoding의 결과에 Label encoding을 적용할 경우 모델의 성능이 향상된다는 것을 이용하는 코드이다.
# some dependencies are Na, fill those with the square root of the square
train['dependency'] = np.sqrt(train['SQBdependency'])
test['dependency'] = np.sqrt(test['SQBdependency'])
# fill "no"s for education with 0s
train.loc[train['edjefa'] == "no", "edjefa"] = 0
train.loc[train['edjefe'] == "no", "edjefe"] = 0
test.loc[test['edjefa'] == "no", "edjefa"] = 0
test.loc[test['edjefe'] == "no", "edjefe"] = 0
# if education is "yes" and person is head of household, fill with escolari
train.loc[(train['edjefa'] == "yes") & (train['parentesco1'] == 1), "edjefa"] = train.loc[(train['edjefa'] == "yes") & (train['parentesco1'] == 1), "escolari"]
train.loc[(train['edjefe'] == "yes") & (train['parentesco1'] == 1), "edjefe"] = train.loc[(train['edjefe'] == "yes") & (train['parentesco1'] == 1), "escolari"]
test.loc[(test['edjefa'] == "yes") & (test['parentesco1'] == 1), "edjefa"] = test.loc[(test['edjefa'] == "yes") & (test['parentesco1'] == 1), "escolari"]
test.loc[(test['edjefe'] == "yes") & (test['parentesco1'] == 1), "edjefe"] = test.loc[(test['edjefe'] == "yes") & (test['parentesco1'] == 1), "escolari"]
# this field is supposed to be interaction between gender and escolari, but it isn't clear what "yes" means, let's fill it with 4
train.loc[train['edjefa'] == "yes", "edjefa"] = 4
train.loc[train['edjefe'] == "yes", "edjefe"] = 4
test.loc[test['edjefa'] == "yes", "edjefa"] = 4
test.loc[test['edjefe'] == "yes", "edjefe"] = 4
# convert to int for our models
train['edjefe'] = train['edjefe'].astype("int")
train['edjefa'] = train['edjefa'].astype("int")
test['edjefe'] = test['edjefe'].astype("int")
test['edjefa'] = test['edjefa'].astype("int")
# create feature with max education of either head of household
train['edjef'] = np.max(train[['edjefa','edjefe']], axis=1)
test['edjef'] = np.max(test[['edjefa','edjefe']], axis=1)
# fill some nas
train['v2a1']=train['v2a1'].fillna(0)
test['v2a1']=test['v2a1'].fillna(0)
test['v18q1']=test['v18q1'].fillna(0)
train['v18q1']=train['v18q1'].fillna(0)
train['rez_esc']=train['rez_esc'].fillna(0)
test['rez_esc']=test['rez_esc'].fillna(0)
train.loc[train.meaneduc.isnull(), "meaneduc"] = 0
train.loc[train.SQBmeaned.isnull(), "SQBmeaned"] = 0
test.loc[test.meaneduc.isnull(), "meaneduc"] = 0
test.loc[test.SQBmeaned.isnull(), "SQBmeaned"] = 0
# fix some inconsistencies in the data - some rows indicate both that the household does and does not have a toilet,
# if there is no water we'll assume they do not
train.loc[(train.v14a == 1) & (train.sanitario1 == 1) & (train.abastaguano == 0), "v14a"] = 0
train.loc[(train.v14a == 1) & (train.sanitario1 == 1) & (train.abastaguano == 0), "sanitario1"] = 0
test.loc[(test.v14a == 1) & (test.sanitario1 == 1) & (test.abastaguano == 0), "v14a"] = 0
test.loc[(test.v14a == 1) & (test.sanitario1 == 1) & (test.abastaguano == 0), "sanitario1"] = 0또한 데이터 셋에 있는 다양한 변수들 중 그 수치가 의미하는 바와 컴퓨터가 받아들이는 의미가 서로 통하지 않는 경우가 있다는 것을 확인하고 이를 맞춰주는 작업을 진행하였다. 그 예시로 0시간을 no라고 표현하는 등의 상황을 loc 방식을 이용하여 일일이 변환시켜주고 있다. (엄청난 수작업... 괜히 1등을 하는게 아니라는 것을 알 수 있었다.)
def train_test_apply_func(train_, test_, func_):
test_['Target'] = 0
xx = pd.concat([train_, test_])
xx_func = func_(xx)
train_ = xx_func.iloc[:train_.shape[0], :]
test_ = xx_func.iloc[train_.shape[0]:, :].drop('Target', axis=1)
del xx, xx_func
return train_, test_
cols_2_ohe = ['eviv_LE', 'etecho_LE', 'epared_LE', 'elimbasu_LE',
'energcocinar_LE', 'sanitario_LE', 'manual_elec_LE',
'pared_LE']
cols_nums = ['age', 'meaneduc', 'dependency',
'hogar_nin', 'hogar_adul', 'hogar_mayor', 'hogar_total',
'bedrooms', 'overcrowding']
def convert_geo2aggs(df_):
tmp_df = pd.concat([df_[(['lugar_LE', 'idhogar']+cols_nums)],
pd.get_dummies(df_[cols_2_ohe],
columns=cols_2_ohe)],axis=1)#더미 변수로 변환해준다
geo_agg = tmp_df.groupby(['lugar_LE','idhogar']).mean().groupby('lugar_LE').mean().astype(np.float32)
geo_agg.columns = pd.Index(['geo_' + e for e in geo_agg.columns.tolist()])
del tmp_df
return df_.join(geo_agg, how='left', on='lugar_LE')
# add some aggregates by geography
train, test = train_test_apply_func(train, test, convert_geo2aggs)지리적인 요건에 대해서도 그룹핑을 시켜주었다는 것을 알 수 있다.
# add the number of people over 18 in each household
train['num_over_18'] = 0
train['num_over_18'] = train[train.age >= 18].groupby('idhogar').transform("count")
train['num_over_18'] = train.groupby("idhogar")["num_over_18"].transform("max")
train['num_over_18'] = train['num_over_18'].fillna(0)
test['num_over_18'] = 0
test['num_over_18'] = test[test.age >= 18].groupby('idhogar').transform("count")
test['num_over_18'] = test.groupby("idhogar")["num_over_18"].transform("max")
test['num_over_18'] = test['num_over_18'].fillna(0)
# add some extra features, these were taken from another kernel
def extract_features(df):
df['bedrooms_to_rooms'] = df['bedrooms']/df['rooms']
df['rent_to_rooms'] = df['v2a1']/df['rooms']
df['tamhog_to_rooms'] = df['tamhog']/df['rooms'] # tamhog - size of the household
df['r4t3_to_tamhog'] = df['r4t3']/df['tamhog'] # r4t3 - Total persons in the household
df['r4t3_to_rooms'] = df['r4t3']/df['rooms'] # r4t3 - Total persons in the household
df['v2a1_to_r4t3'] = df['v2a1']/df['r4t3'] # rent to people in household
df['v2a1_to_r4t3'] = df['v2a1']/(df['r4t3'] - df['r4t1']) # rent to people under age 12
df['hhsize_to_rooms'] = df['hhsize']/df['rooms'] # rooms per person
df['rent_to_hhsize'] = df['v2a1']/df['hhsize'] # rent to household size
df['rent_to_over_18'] = df['v2a1']/df['num_over_18']
# some households have no one over 18, use the total rent for those
df.loc[df.num_over_18 == 0, "rent_to_over_18"] = df[df.num_over_18 == 0].v2a1
extract_features(train)
extract_features(test)추가적인 변수를 더해준 것을 확인할 수 있다. 이러한 변수들을 생각해내고 추가하기 위해서는 데이터 셋에 대한 확실한 이해와 문제상황에 대해 정확히 인지하고 있어야한다.
# drop duplicated columns
needless_cols = ['r4t3', 'tamhog', 'tamviv', 'hhsize', 'v18q', 'v14a', 'agesq',
'mobilephone', 'female', ]
instlevel_cols = [s for s in train.columns.tolist() if 'instlevel' in s]
needless_cols.extend(instlevel_cols)
train = train.drop(needless_cols, axis=1)
test = test.drop(needless_cols, axis=1)복제된 데이터에 대해서는 중복이 일어날 수 있기 때문에 제거해준다.
Split the data
Note that after splitting the data we overwrite the train data with the entire data set so we can train on all of the data. The split_data function does the same thing without overwriting the data, and is used within the training loop to (hopefully) approximate a K-Fold split.
def split_data(train, y, sample_weight=None, households=None, test_percentage=0.20, seed=None):
# uncomment for extra randomness
# np.random.seed(seed=seed)
train2 = train.copy()
# pick some random households to use for the test data
cv_hhs = np.random.choice(households, size=int(len(households) * test_percentage), replace=False)
# select households which are in the random selection
cv_idx = np.isin(households, cv_hhs)
X_test = train2[cv_idx]
y_test = y[cv_idx]
X_train = train2[~cv_idx] #cv_idx 빼고 전부
y_train = y[~cv_idx]
if sample_weight is not None:
y_train_weights = sample_weight[~cv_idx]
return X_train, y_train, X_test, y_test, y_train_weights
return X_train, y_train, X_test, y_test우리는 머신러닝을 진행할 경우 주로 sklearn에서 제공하는 train_test_split 패키지를 이용하여 train set 과 validation set을 나누어 학습을 진행하였다. 하지만 이 경우 전체 데이터에서 학습을 진행하는 것이 아닌 어느정도의 데이터의 손해가 일어난 생태에서 진행하게 된다. 이러한 점을 보완하고자 모델링 과정 내에서 분할을 진행하는 방식을 사용하였다.
X = train.query('parentesco1==1') # query : 조건식을 만족하는 행을 추출한다
# X = train.copy()
# pull out and drop the target variable
y = X['Target'] - 1
X = X.drop(['Target'], axis=1)
np.random.seed(seed=None)
train2 = X.copy()
train_hhs = train2.idhogar
households = train2.idhogar.unique()
cv_hhs = np.random.choice(households, size=int(len(households) * 0.15), replace=False)
cv_idx = np.isin(train2.idhogar, cv_hhs)
X_test = train2[cv_idx]
y_test = y[cv_idx]
X_train = train2[~cv_idx]
y_train = y[~cv_idx]
# train on entire dataset
X_train = train2
y_train = y
train_households = X_train.idhogar# figure out the class weights for training with unbalanced classes
y_train_weights = class_weight.compute_sample_weight('balanced', y_train, indices=None)# drop some features which aren't used by the LGBM or have very low importance
extra_drop_features = [
'agg18_estadocivil1_MEAN',
'agg18_estadocivil6_COUNT',
'agg18_estadocivil7_COUNT',
'agg18_parentesco10_COUNT',
'agg18_parentesco11_COUNT',
'agg18_parentesco12_COUNT',
'agg18_parentesco1_COUNT',
'agg18_parentesco2_COUNT',
'agg18_parentesco3_COUNT',
'agg18_parentesco4_COUNT',
'agg18_parentesco5_COUNT',
'agg18_parentesco6_COUNT',
'agg18_parentesco7_COUNT',
'agg18_parentesco8_COUNT',
'agg18_parentesco9_COUNT',
'geo_elimbasu_LE_4',
'geo_energcocinar_LE_1',
'geo_energcocinar_LE_2',
'geo_epared_LE_0',
'geo_hogar_mayor',
'geo_manual_elec_LE_2',
'geo_pared_LE_3',
'geo_pared_LE_4',
'geo_pared_LE_5',
'geo_pared_LE_6',
'num_over_18',
'parentesco_LE',
'rez_esc']모델링에 있어서 방해가 되는 변수들은 의도적으로 제거함으로서 설명력을 높였다.
모델링 VotingClassification
VotingClassification 이란?
'다수결 분류'라는 의미이며 hard voting 과 soft voting 기법이 있다.
1. Hard Voting Classifier
: 여러 모델들로 학습을 진행하고 그 결과값을 평가하여 가장 많은 표를 받은 모델을 선택하고 그 모델의 예측값을 최종값으로 선정하는 방식이다.
2. Soft Voting Classifier
: 각 class 별로 모델을 학습시키고 모델들이 예측한 probability를 합산하여 가장 높은 class를 선택한다.
다음 코드들은 앞서 가공한 데이터 셋에 VotingClassifier를 적용함과 동시에 macro fl_score를 기준으로 최적의 파라미터를 찾는 과정을 보여준다.
# 4
opt_parameters = {'max_depth':35, 'eta':0.1, 'silent':0, 'objective':'multi:softmax', 'min_child_weight': 1, 'num_class': 4, 'gamma': 2.0, 'colsample_bylevel': 0.9, 'subsample': 0.84, 'colsample_bytree': 0.88, 'reg_lambda': 0.40 }
# 5
opt_parameters = {'max_depth':35, 'eta':0.15, 'silent':1, 'objective':'multi:softmax', 'min_child_weight': 2, 'num_class': 4, 'gamma': 2.5, 'colsample_bylevel': 1, 'subsample': 0.95, 'colsample_bytree': 0.85, 'reg_lambda': 0.35 }
# 6
# opt_parameters = {'max_depth':35, 'eta':0.15, 'silent':0, 'objective':'multi:softmax', 'min_child_weight': 2, 'num_class': 4, 'gamma': 2.75, 'colsample_bylevel': 0.95, 'subsample': 0.95, 'colsample_bytree': 0.85, 'reg_lambda': 0.35 }
# # 7
# opt_parameters = {'max_depth':35, 'eta':0.12, 'silent':0, 'objective':'multi:softmax', 'min_child_weight': 2, 'num_class': 4, 'gamma': 3.25, 'colsample_bylevel': 0.95, 'subsample': 0.88, 'colsample_bytree': 0.88, 'reg_lambda': 0.35 }
def evaluate_macroF1_lgb(predictions, truth):
# this follows the discussion in https://github.com/Microsoft/LightGBM/issues/1483
pred_labels = predictions.argmax(axis=1)
truth = truth.get_label()
f1 = f1_score(truth, pred_labels, average='macro')
return ('macroF1', 1-f1)
fit_params={"early_stopping_rounds":500,
"eval_metric" : evaluate_macroF1_lgb,
"eval_set" : [(X_train,y_train), (X_test,y_test)],
'verbose': False,
}
def learning_rate_power_0997(current_iter):
base_learning_rate = 0.1
min_learning_rate = 0.02
lr = base_learning_rate * np.power(.995, current_iter)
return max(lr, min_learning_rate)
fit_params['verbose'] = 50np.random.seed(100)
def _parallel_fit_estimator(estimator1, X, y, sample_weight=None, threshold=True, **fit_params):
estimator = clone(estimator1)
# randomly split the data so we have a test set for early stopping
if sample_weight is not None:
X_train, y_train, X_test, y_test, y_train_weight = split_data(X, y, sample_weight, households=train_households)
else:
X_train, y_train, X_test, y_test = split_data(X, y, None, households=train_households)
# update the fit params with our new split
fit_params["eval_set"] = [(X_test,y_test)]
# fit the estimator
if sample_weight is not None:
if isinstance(estimator1, ExtraTreesClassifier) or isinstance(estimator1, RandomForestClassifier):
estimator.fit(X_train, y_train)
else:
_ = estimator.fit(X_train, y_train, sample_weight=y_train_weight, **fit_params)
else:
if isinstance(estimator1, ExtraTreesClassifier) or isinstance(estimator1, RandomForestClassifier):
estimator.fit(X_train, y_train)
else:
_ = estimator.fit(X_train, y_train, **fit_params)
if not isinstance(estimator1, ExtraTreesClassifier) and not isinstance(estimator1, RandomForestClassifier) and not isinstance(estimator1, xgb.XGBClassifier):
best_cv_round = np.argmax(estimator.evals_result_['validation_0']['mlogloss'])
best_cv = np.max(estimator.evals_result_['validation_0']['mlogloss'])
best_train = estimator.evals_result_['train']['macroF1'][best_cv_round]
else:
best_train = f1_score(y_train, estimator.predict(X_train), average="macro")
best_cv = f1_score(y_test, estimator.predict(X_test), average="macro")
print("Train F1:", best_train)
print("Test F1:", best_cv)
# reject some estimators based on their performance on train and test sets
if threshold:
# if the valid score is very high we'll allow a little more leeway with the train scores
if ((best_cv > 0.37) and (best_train > 0.75)) or ((best_cv > 0.44) and (best_train > 0.65)):
return estimator
# else recurse until we get a better one
else:
print("Unacceptable!!! Trying again...")
return _parallel_fit_estimator(estimator1, X, y, sample_weight=sample_weight, **fit_params)
else:
return estimator
class VotingClassifierLGBM(VotingClassifier):
'''
This implements the fit method of the VotingClassifier propagating fit_params
'''
def fit(self, X, y, sample_weight=None, threshold=True, **fit_params):
if isinstance(y, np.ndarray) and len(y.shape) > 1 and y.shape[1] > 1:
raise NotImplementedError('Multilabel and multi-output'
' classification is not supported.')
if self.voting not in ('soft', 'hard'):
raise ValueError("Voting must be 'soft' or 'hard'; got (voting=%r)"
% self.voting)
if self.estimators is None or len(self.estimators) == 0:
raise AttributeError('Invalid `estimators` attribute, `estimators`'
' should be a list of (string, estimator)'
' tuples')
if (self.weights is not None and
len(self.weights) != len(self.estimators)):
raise ValueError('Number of classifiers and weights must be equal'
'; got %d weights, %d estimators'
% (len(self.weights), len(self.estimators)))
names, clfs = zip(*self.estimators)
self._validate_names(names)
n_isnone = np.sum([clf is None for _, clf in self.estimators])
if n_isnone == len(self.estimators):
raise ValueError('All estimators are None. At least one is '
'required to be a classifier!')
self.le_ = LabelEncoder().fit(y)
self.classes_ = self.le_.classes_
self.estimators_ = []
transformed_y = self.le_.transform(y)
self.estimators_ = Parallel(n_jobs=self.n_jobs)(
delayed(_parallel_fit_estimator)(clone(clf), X, transformed_y,
sample_weight=sample_weight, threshold=threshold, **fit_params)
for clf in clfs if clf is not None)
return selfclfs = []
for i in range(15):
clf = xgb.XGBClassifier(random_state=217+i, n_estimators=300, learning_rate=0.15, n_jobs=4, **opt_parameters)
clfs.append(('xgb{}'.format(i), clf))
vc = VotingClassifierLGBM(clfs, voting='soft')
del(clfs)
#Train the final model with learning rate decay
_ = vc.fit(X_train.drop(xgb_drop_cols, axis=1), y_train, sample_weight=y_train_weights, threshold=False, **fit_params)
clf_final = vc.estimators_[0]앞서 만들어 놓은 함수들을 이용하여 코드를 전개해나가는 것을 확인할 수 있다.
[0] validation_0-merror:0.464646 validation_0-macroF1:0.646101
Multiple eval metrics have been passed: 'validation_0-macroF1' will be used for early stopping.
Will train until validation_0-macroF1 hasn't improved in 500 rounds.
[50] validation_0-merror:0.377104 validation_0-macroF1:0.578445
[100] validation_0-merror:0.367003 validation_0-macroF1:0.570407
[150] validation_0-merror:0.373737 validation_0-macroF1:0.583402
[200] validation_0-merror:0.37037 validation_0-macroF1:0.583715
[250] validation_0-merror:0.368687 validation_0-macroF1:0.583333
[299] validation_0-merror:0.368687 validation_0-macroF1:0.583474
Train F1: 0.9153725233385168
Test F1: 0.4355385068644192
[0] validation_0-merror:0.469697 validation_0-macroF1:0.640044
Multiple eval metrics have been passed: 'validation_0-macroF1' will be used for early stopping.
Will train until validation_0-macroF1 hasn't improved in 500 rounds.
[50] validation_0-merror:0.380471 validation_0-macroF1:0.583417해당 코드의 결과이다. 이를 이용하여 VotingClassifier를 적용하였을 때(hard, soft), 단독적으로 LGBM을 사용했을 때를 비교해보면
다음과 같다.
# params 4 - 400 early stop - 15 estimators - l1 used features - weighted
global_score = f1_score(y_test, clf_final.predict(X_test.drop(xgb_drop_cols, axis=1)), average='macro')
vc.voting = 'soft'
global_score_soft = f1_score(y_test, vc.predict(X_test.drop(xgb_drop_cols, axis=1)), average='macro')
vc.voting = 'hard'
global_score_hard = f1_score(y_test, vc.predict(X_test.drop(xgb_drop_cols, axis=1)), average='macro')
print('Validation score of a single LGBM Classifier: {:.4f}'.format(global_score))
print('Validation score of a VotingClassifier on 3 LGBMs with soft voting strategy: {:.4f}'.format(global_score_soft))
print('Validation score of a VotingClassifier on 3 LGBMs with hard voting strategy: {:.4f}'.format(global_score_hard))Validation score of a single LGBM Classifier: 0.8059
Validation score of a VotingClassifier on 3 LGBMs with soft voting strategy: 0.9107
Validation score of a VotingClassifier on 3 LGBMs with hard voting strategy: 0.9345보이는 것과 같이 VotingClassifier를 적용하였을 때 성능이 더 증가하는 것을 알 수 있다.
이렇게 모델링한 과정에 있어서의 변수 중요도를 확인해보자
# see which features are not used by ANY models
useless_features = []
drop_features = set()
counter = 0
for est in vc.estimators_:
ranked_features, unused_features = feature_importance(est, X_train.drop(xgb_drop_cols, axis=1), display_results=False)
useless_features.append(unused_features)
if counter == 0:
drop_features = set(unused_features)
else:
drop_features = drop_features.intersection(set(unused_features))
counter += 1
drop_features{'agg18_estadocivil4_COUNT',
'agg18_estadocivil5_COUNT',
'geo_energcocinar_LE_0',
'geo_epared_LE_2',
'geo_manual_elec_LE_3'}ranked_features = feature_importance(clf_final, X_train.drop(xgb_drop_cols, axis=1))이 코드를 실행하면 145개의 변수들의 변수중요도의 순위를 알 수 있다.
RandomForest 에 대해서도 불필요한 변수를 제거하고 하이퍼 파라미터를 찾고 변수중요도를 확인하고 VotingClassifier에 적용시킨다.
et_drop_cols = ['agg18_age_MAX', 'agg18_age_MEAN', 'agg18_age_MIN', 'agg18_dis_MEAN',
'agg18_escolari_MAX', 'agg18_escolari_MEAN', 'agg18_escolari_MIN',
'agg18_estadocivil1_COUNT', 'agg18_estadocivil1_MEAN',
'agg18_estadocivil2_COUNT', 'agg18_estadocivil2_MEAN',
'agg18_estadocivil3_COUNT', 'agg18_estadocivil3_MEAN',
'agg18_estadocivil4_COUNT', 'agg18_estadocivil4_MEAN',
'agg18_estadocivil5_COUNT', 'agg18_estadocivil5_MEAN',
'agg18_estadocivil6_COUNT', 'agg18_estadocivil6_MEAN',
'agg18_estadocivil7_COUNT', 'agg18_estadocivil7_MEAN',
'agg18_parentesco10_COUNT', 'agg18_parentesco10_MEAN',
'agg18_parentesco11_COUNT', 'agg18_parentesco11_MEAN',
'agg18_parentesco12_COUNT', 'agg18_parentesco12_MEAN',
'agg18_parentesco1_COUNT', 'agg18_parentesco1_MEAN',
'agg18_parentesco2_COUNT', 'agg18_parentesco2_MEAN',
'agg18_parentesco3_COUNT', 'agg18_parentesco3_MEAN',
'agg18_parentesco4_COUNT', 'agg18_parentesco4_MEAN',
'agg18_parentesco5_COUNT', 'agg18_parentesco5_MEAN',
'agg18_parentesco6_COUNT', 'agg18_parentesco6_MEAN',
'agg18_parentesco7_COUNT', 'agg18_parentesco7_MEAN',
'agg18_parentesco8_COUNT', 'agg18_parentesco8_MEAN',
'agg18_parentesco9_COUNT', 'agg18_parentesco9_MEAN'] #+ ['parentesco_LE', 'rez_esc']
et_drop_cols.extend(["idhogar", "parentesco1", 'fe_rent_per_person', 'fe_rent_per_room',
'fe_tablet_adult_density', 'fe_tablet_density'])# do the same thing for some extra trees classifiers
ets = []
for i in range(10):
rf = RandomForestClassifier(max_depth=None, random_state=217+i, n_jobs=4, n_estimators=700, min_impurity_decrease=1e-3, min_samples_leaf=2, verbose=0, class_weight="balanced")
ets.append(('rf{}'.format(i), rf))
vc2 = VotingClassifierLGBM(ets, voting='soft')
_ = vc2.fit(X_train.drop(et_drop_cols, axis=1), y_train, threshold=False)Train F1: 0.8995785797400715
Test F1: 0.41644760797490754
Train F1: 0.8974057100172891
Test F1: 0.4173294959009245
Train F1: 0.8929947876700697
Test F1: 0.380791318982666
Train F1: 0.8897229006999118
Test F1: 0.43258661725401276
Train F1: 0.8894013811159895
Test F1: 0.46517518214144904
Train F1: 0.8963246456113938
Test F1: 0.426575122901441
Train F1: 0.890822628612706
Test F1: 0.41104823629263454
Train F1: 0.8958771082511664
Test F1: 0.46546114892390233
Train F1: 0.9064600301011827
Test F1: 0.4286664637370844
Train F1: 0.8948837246950454
Test F1: 0.41037179469569823# w/ threshold, extra drop cols
vc2.voting = 'soft'
global_rf_score_soft = f1_score(y_test, vc2.predict(X_test.drop(et_drop_cols, axis=1)), average='macro')
vc2.voting = 'hard'
global_rf_score_hard = f1_score(y_test, vc2.predict(X_test.drop(et_drop_cols, axis=1)), average='macro')
print('Validation score of a VotingClassifier on 3 LGBMs with soft voting strategy: {:.4f}'.format(global_score_soft))
print('Validation score of a VotingClassifier on 3 LGBMs with hard voting strategy: {:.4f}'.format(global_score_hard))Validation score of a VotingClassifier on 3 LGBMs with soft voting strategy: 0.9107
Validation score of a VotingClassifier on 3 LGBMs with hard voting strategy: 0.9345# see which features are not used by ANY models
useless_features = []
drop_features= set()
counter = 0
for est in vc2.estimators_:
ranked_features, unused_features = feature_importance(est, X_train.drop(et_drop_cols, axis=1),display_results=False)
useless_features.append(unused_features)
if counter == 0:
drop_features = set(unused_features)
else:
drop_features = drop_features.intersection(set(unused_features))
counter += 1
drop_features최종적으로 RandomForest와 LGBM을 묶어서 VotingClassifier를 진행하여 최종 결과를 이끌어낸다.
def combine_voters(data, weights=[0.5, 0.5]):
# do soft voting with both classifiers
vc.voting='soft'
vc1_probs = vc.predict_proba(data.drop(xgb_drop_cols, axis=1))
vc2.voting = 'soft'
vc2_probs = vc2.predict_proba(data.drop(et_drop_cols, axis=1))
final_vote = (vc1_probs * weights[0]) + (vc2_probs * weights[1])
predictions = np.argmax(final_vote, axis=1)
return predictionscombo_preds = combine_voters(X_test, weights=[0.6,0.4])
global_combo_score_soft = f1_score(y_test, combo_preds, average='macro')
global_combo_score_soft커널은 이렇게 마무리를 한다.
댓글 영역