🤍

러닝스푼즈 수업 정리 

<이전 글>

https://silvercoding.tistory.com/71

1. 데이터 소개 & 데이터 불러오기 

[ Home Credit Data ]

원본 데이터: 캐글 

학습용 데이터: 러닝스푼즈 제공 

• 고객의 대출 상환능력 예측: 고객의 인적 정보, 거래 데이터를 바탕으로 해당 고객에게 돈을 빌려주었을 때 이를 상환할지 여부를 예측

train.csv - 학습 데이터
test.csv - 예측해야 할 test 데이터
loan_before.csv - 각 사람이 이전에 진행했던 대출에 대한 상세 정보

import pandas as pd
import os

os.chdir('../data')

lb = pd.read_csv("loan_before.csv")
train = pd.read_csv("train.csv")
test = pd.read_csv("test.csv")

train.head()

lb.head()

- loan before 컬럼 정보 

- train, test 컬럼 정보 

1. 문제 정의 

질문 1 - 어떤 요소가 대출금 상환 여부에 큰 영향을 주는가? 

질문 2 - 그 요소들이 상환여부에 어떤 영향을 주는가? 

2. 방법론 

- 분석 과정 

질문에 대한 해답을 얻기 위해 해석가능한 머신러닝 (xAI) 활용 

(1) Feature Engineering

- AMT_CREDIT_TO_ANNUITY_RATIO 변수 생성: 해당 사람이 몇개월에 걸쳐 돈을 갚아야 하는지 

train['AMT_CREDIT_TO_ANNUITY_RATIO'] = train['AMT_CREDIT']/train['AMT_ANNUITY']
test['AMT_CREDIT_TO_ANNUITY_RATIO'] = test['AMT_CREDIT']/test['AMT_ANNUITY']

- lb데이터: groupby 후 평균 

• AMT_CREDIT_SUM (이전 대출의 금액) 
• DAYS_CREDIT (train, test의 대출로부터 며칠 전에 이전 대출을 진행했는지) 
• CNT_CREDIT_PROLONG (대출연장을 몇 번 했는지) 

train = pd.merge( train,lb.groupby(['SK_ID_CURR'])['AMT_CREDIT_SUM'].mean().reset_index(),on='SK_ID_CURR',how='left' )
test = pd.merge( test,lb.groupby(['SK_ID_CURR'])['AMT_CREDIT_SUM'].mean().reset_index(),on='SK_ID_CURR',how='left' )

train = pd.merge( train,lb.groupby(['SK_ID_CURR'])['DAYS_CREDIT'].mean().reset_index(),on='SK_ID_CURR',how='left' )
test = pd.merge( test,lb.groupby(['SK_ID_CURR'])['DAYS_CREDIT'].mean().reset_index(),on='SK_ID_CURR',how='left' )

train = pd.merge( train,lb.groupby(['SK_ID_CURR'])['CNT_CREDIT_PROLONG'].mean().reset_index(),on='SK_ID_CURR',how='left' )
test = pd.merge( test,lb.groupby(['SK_ID_CURR'])['CNT_CREDIT_PROLONG'].mean().reset_index(),on='SK_ID_CURR',how='left' )

- lb 데이터: groupby 후 갯수 

• count 컬럼 생성: 해당 사람이 이전에 대출을 몇 번 진행했는지

train = pd.merge(train , lb.groupby(['SK_ID_CURR']).size().reset_index().rename(columns={0:'count'}),on='SK_ID_CURR', how='left')
test = pd.merge(test , lb.groupby(['SK_ID_CURR']).size().reset_index().rename(columns={0:'count'}),on='SK_ID_CURR', how='left')

- 변수 제거 

해당 프로젝트의 목적은 모델 해석이기 때문에, 이에 방해를 주는 변수는 모두 제거

제거 변수목록

• CODE_GENDER : 범주형 변수
• FLAG_OWN_CAR : 범주형 변수
• NAME_TYPE_SUITE : 범주형 변수
• NAME_INCOME_TYPE : 범주형 변수
• NAME_EDUCATION_TYPE : 범주형 변수
• NAME_HOUSING_TYPE : 범주형 변수
• ORGANIZATION_TYPE : 범주형 변수
• EXT_SOURCE_1 : 변수의 의미를 정확히 모름
• EXT_SOURCE_2 : 변수의 의미를 정확히 모름
• EXT_SOURCE_3 : 변수의 의미를 정확히 모름

del_list = ['CODE_GENDER','FLAG_OWN_CAR','NAME_TYPE_SUITE','NAME_INCOME_TYPE','NAME_EDUCATION_TYPE','NAME_HOUSING_TYPE','ORGANIZATION_TYPE',
'EXT_SOURCE_1','EXT_SOURCE_2','EXT_SOURCE_3']

train = train.drop(del_list,axis=1)
test = test.drop(del_list,axis=1)

train.columns

(2) 모델링 

- 상관관계가 높은 input변수는 삭제한다. 

: Input 변수가 높은 상관성을 띌 때 shap value는 제대로 된 설명력을 발휘하지 못함. 

input_var = ['FLAG_OWN_REALTY', 'CNT_CHILDREN',
       'AMT_INCOME_TOTAL', 'AMT_CREDIT', 'AMT_ANNUITY',
       'REGION_POPULATION_RELATIVE', 'DAYS_BIRTH', 'DAYS_EMPLOYED',
       'DAYS_ID_PUBLISH', 'OWN_CAR_AGE', 'CNT_FAM_MEMBERS',
       'HOUR_APPR_PROCESS_START', 'DAYS_LAST_PHONE_CHANGE',
       'AMT_REQ_CREDIT_BUREAU_YEAR', 'AMT_CREDIT_TO_ANNUITY_RATIO',
       'AMT_CREDIT_SUM', 'DAYS_CREDIT', 'CNT_CREDIT_PROLONG', 'count']

타겟변수인 TARGET  을 제외한 변수들을 input_var 에 저장해준다. 

corr = train[input_var].corr()
corr.style.background_gradient(cmap='coolwarm')

위와 같은 형태의 시각화 그래프가 그려지고, 높은 상관성을 띄는 변수들을 나열하면 다음과 같다. 

[ 높은 상관성을 띄는 변수 목록 ]  

• CNT_FAM_MEMBERS & CNT_CHILDREN 0.883051
• AMT_CREDIT_TO_ANNUITY_RATIO & AMT_CREDIT 0.656337
• AMT_ANNUITY & AMT_CREDIT 0.770938

cf) 피어슨 상관계수의 해석 

r이 -1.0과 -0.7 사이이면, 강한 음적 선형관계,

r이 -0.7과 -0.3 사이이면, 뚜렷한 음적 선형관계,

r이 -0.3과 -0.1 사이이면, 약한 음적 선형관계,

r이 -0.1과 +0.1 사이이면, 거의 무시될 수 있는 선형관계,

r이 +0.1과 +0.3 사이이면, 약한 양적 선형관계,

r이 +0.3과 +0.7 사이이면, 뚜렷한 양적 선형관계,

r이 +0.7과 +1.0 사이이면, 강한 양적 선형관계

타겟 변수와의 상관성이 더 낮은 변수를 제거한다. 

print(train['CNT_FAM_MEMBERS'].corr(train['TARGET']))
print(train['CNT_CHILDREN'].corr(train['TARGET']))

0.018876651698723705

0.025357359317615676

del train['CNT_FAM_MEMBERS']
del test['CNT_FAM_MEMBERS']

CNT_FAM_MEMBERS가 TARGET과의 상관계수가 더 낮으므로 제거해 준다. 

print(train['AMT_CREDIT_TO_ANNUITY_RATIO'].corr(train['TARGET']))
print(train['AMT_CREDIT'].corr(train['TARGET']))

-0.024740288335190132

-0.02255843084934759

del train['AMT_CREDIT']
del test['AMT_CREDIT']

AMT_CREDIT과 TARGER의 상관계수가 더 낮으므로 제거해 준다. 

input_var = ['FLAG_OWN_REALTY', 'CNT_CHILDREN',
       'AMT_INCOME_TOTAL', 'AMT_ANNUITY', 'REGION_POPULATION_RELATIVE',
       'DAYS_BIRTH', 'DAYS_EMPLOYED', 'DAYS_ID_PUBLISH', 'OWN_CAR_AGE',
       'HOUR_APPR_PROCESS_START', 'DAYS_LAST_PHONE_CHANGE',
       'AMT_REQ_CREDIT_BUREAU_YEAR', 'AMT_CREDIT_TO_ANNUITY_RATIO',
       'AMT_CREDIT_SUM', 'DAYS_CREDIT', 'CNT_CREDIT_PROLONG', 'count']

제거한 변수들을 제외한 나머지 변수들을 input_var에 다시 저장해 준다. 

-xgboost 모델링 

: shap value를 활용하기 위해서는 모델이 랜덤 포레스트 형태의 tree형 모델이어야 한다. 이 중 xgboost가 속도가 빠르면서 높은 성능을 유지하므로 선택. 

from xgboost import XGBClassifier

model = XGBClassifier(n_estimators=100, learning_rate=0.1)
model.fit(train[input_var],train['TARGET'])

(3) shap value 

import shap

shap_values = shap.TreeExplainer(model).shap_values(train[input_var])

shap.summary_plot(shap_values, train[input_var], plot_type='bar')

타겟값에 가장 큰 영향을 미치는 상위 5가지 변수 목록

• AMT_CREDIT_TO_ANNUITY_RATIO
• DAYS_EMPLOYED
• DAYS_CREDIT
• DAYS_BIRTH
• DAYS_LAST_PHONE_CHANGE

(4) 5개의 예측변수와 타겟변수(대출금 상환 여부) 와의 관계 

-1. AMT_CREDIT_TO_ANNUITY_RATIO: 대출 상환 기간

shap.dependence_plot('AMT_CREDIT_TO_ANNUITY_RATIO', shap_values, train[input_var])

해당 그래프는 세로축의 값이 낮을 수록 대출 상환을 잘 한다고 해석(TARGET이 0일 확률이 높음)할 수 있다. 기간이 12-20개월일 때 상환을 잘 하지 못하며, 12개월 이하, 20개월 이상일 때는 비교적 상환을 잘 하는 것으로 보인다. 

- 2. DAYS_EMPLOYED: 언제 취업했는지

shap.dependence_plot('DAYS_EMPLOYED', shap_values, train[input_var])

대출일 기준으로 9000일 보다 전에 취업했을 때 대출 상환 능력이 급 상승하는 것을 볼 수 있다. 

- 3. DAYS_CREDIT: 해당 대출이 home credit으로부터 받은 대출보다 며칠 이전에 일어났는지

shap.dependence_plot('DAYS_CREDIT', shap_values, train[input_var])

-3000일 부터 -2000일까지 대출 상환 능력이 상승하다가 그 이후부터 하락하는 것을 볼 수 있다. 즉 너무 오래 전에 대출을 받았거나, 최근에 대출을 받았을 때 대출 상환 능력이 떨어진다고 할 수 있다. 

- 4. DAYS_BIRTH: 나이

shap.dependence_plot('DAYS_BIRTH', shap_values, train[input_var])

태어난지 오래 되었을 수록(나이가 많을 수록) 대출상환을 잘하는 경향을 보인다. 

- 5. DAYS_LAST_PHONE_CHANGE: 마지막 핸드폰을 바꾼 시기

shap.dependence_plot('DAYS_LAST_PHONE_CHANGE', shap_values, train[input_var])

핸드폰을 오래 전에 바꾸었을 수록 대출 상환을 잘하는 경향이 보인다. 

3. 결론 

• 대출 상환 기간이 상환여부에 가장 큰 영향을 준다. 해당 영향은 비선형적 관계이다. (영향이 크다고 해서 인과관계가 있다고 단정짓기는 어렵다. )
• 주택 보유 여부와 자식의 수는 대출 상환능력에 영향을 거의 미치지 않는다.
• 최근에 취업했을 수록, 최근에 대출을 받았을 수록, 최근에 핸드폰을 바꿨을 수록, 나이가 어릴수록 대출금 상황 가능성이 낮다.  

train['DAYS_EMPLOYED'].quantile(0.75)

-748.0

위와 같은 방법으로 상위 25%의 값을 구할 수 있다. 이를 이용하여 4개의 변수의 상위 25% 이상 그룹과 하위 25%미만 그룹을 나누어 시각화 결과를 확인 해 본다. 

- 상위 25%

group1 = train.loc[ (train['DAYS_EMPLOYED'].quantile(0.75)< train['DAYS_EMPLOYED']) &
           (train['DAYS_CREDIT'].quantile(0.75)< train['DAYS_CREDIT']) &
           (train['DAYS_LAST_PHONE_CHANGE'].quantile(0.75)< train['DAYS_LAST_PHONE_CHANGE']) &
           (train['DAYS_BIRTH'].quantile(0.75)< train['DAYS_BIRTH']) ]

- 하위 25 %

group2 = train.loc[ (train['DAYS_EMPLOYED'].quantile(0.25)> train['DAYS_EMPLOYED']) &
           (train['DAYS_CREDIT'].quantile(0.25)> train['DAYS_CREDIT']) &
           (train['DAYS_LAST_PHONE_CHANGE'].quantile(0.25)> train['DAYS_LAST_PHONE_CHANGE']) &
           (train['DAYS_BIRTH'].quantile(0.25)> train['DAYS_BIRTH']) ]

group1['group'] = 1
group2['group'] = 0

group1은 group변수에 1을, group2는 group 변수에 0을 넣어 준다. 

full = pd.concat([group1,group2],axis=0)

group1과 group2를 합쳐준다. 

import seaborn as sns

sns.barplot('group','TARGET',data=full)

group2 (group=0, 하위 25%)  의 Target값이 낮은 것을 볼 수 있다(0이 많다=정상 상환). 각 변수들의 값이 작을 수록 대출 상환 가능성이 높다는 결론과 같음을 알 수 있다. 

러닝스푼즈 수업 정리 

<이전 글>

https://silvercoding.tistory.com/70

1. 데이터 소개 & 데이터 불러오기 

<Rossmann Store Sales> 

https://www.kaggle.com/c/rossmann-store-sales/data?select=test.csv 

해당 링크의 캐글 대회에서 사용되었던 로스만 데이터이다. 

• train.csv - historical data including Sales
• test.csv - historical data excluding Sales
• sample_submission.csv - a sample submission file in the correct format
• store.csv - supplemental information about the stores

본 포스팅에서는 축소된 데이터를 사용하여 상점의 매출 예측을 진행한다.  

(데이터: 러닝스푼즈 제공)

import os
import pandas as pd

os.chdir('../data')

train = pd.read_csv("lspoons_train.csv")
test = pd.read_csv("lspoons_test.csv")
store = pd.read_csv("store.csv")

lspoons_train.csv - 학습 데이터
lspoons_test.csv - 예측해야 할 test 데이터

store.csv - 상점에 대한 정보가 담긴 보조 데이터

train.head()

컬럼 정보 

• id
• Store: 각 상점의 id
• Date: 날짜
• Sales: 날짜에 따른 매출
• Promo: 판매촉진 행사 진행 여부
• StateHoliday: 공휴일 여부/ 공휴일 X-> 0, 공휴일-> 공휴일의 종류(a, b, c)
• SchoolHoliday: 학교 휴일인지 여부

위의 컬럼들을 사용하여 Sales(매출) 을 예측하는 모델을 생성한다. 

- 분석 절차 수립 

1. 베이스 모델링 ( feature engineering - 변수선택 - 모델링 ) 

2. 2차 모델링 ( store 데이터 merge - feature engineering - 변수 선택 - 모델링 )

3. 파라미터 튜닝 

... 모델링 반복 ( 이 후 모델링은 자율, 깃헙 정리 ) 

1. 베이스 모델링 

: 가장 기본적인 모델을 만든다. (결측값 처리, 원핫 인코딩) 

피쳐 엔지니어링이란? 

• 예측을 위해 기존의 input 변수를 이용하여 새로운 input 변수 생성
• 머신러닝 예측 성능 올릴 수 있는 방법

train.info()

결측값은 없는 것을 알 수 있고, object 타입인 Date, StateHoliday 컬럼을 전처리 해준다. 

- StateHoliday column one-hot encoding 

train = pd.get_dummies(columns=['StateHoliday'],data=train)
test = pd.get_dummies(columns=['StateHoliday'],data=test)

get_dummies 함수를 사용하여 StateHoliday 컬럼을 원핫인코딩 해준다. 

print("train_columns: ", train.columns, end="\n\n\n")
print("test_columns: ", test.columns)

새로 생성된 칼럼을 보면 train에는 b, c 가 있지만 test에는 b, c 가 존재하지 않는다. 이 경우 학습 과정에서 문제가 발생할 수 있다. 

test['StateHoliday_b'] = 0
test['StateHoliday_c'] = 0

따라서 같은 칼럼을 test 데이터셋에 생성해 준다.

- feature engineering using Date column

train['Date']

Date 칼럼은 날짜형 형태로 되어 있지만 dtype이 object이므로 날짜로서의 의미가 없다. 

train['Date'] = pd.to_datetime( train['Date'] )
test['Date'] = pd.to_datetime( test['Date'] )

따라서 pandas에서 날짜 계산을 편리하게 해주는 to_datetime 함수를 사용하여 날짜형 변수로 변환해 준다. 

# 요일 컬럼 weekday 생성 

train['weekday'] = train['Date'].dt.weekday
test['weekday'] = test['Date'].dt.weekday

# 년도 컬럼 year 생성 

train['year'] = train['Date'].dt.year
test['year'] = test['Date'].dt.year

# 월 컬럼 month 생성 

train['year'] = train['Date'].dt.year
test['year'] = test['Date'].dt.year

- 베이스라인 모델링 

from xgboost import XGBRegressor

train.columns

xgb = XGBRegressor( n_estimators= 300 , learning_rate=0.1 , random_state=2020 )
xgb.fit(train[['Promo','SchoolHoliday','StateHoliday_0','StateHoliday_a','StateHoliday_b','StateHoliday_c','weekday','year','month']],
        train['Sales'])

XGB 모델을 사용하여 학습을 시켜 준다. 

from sklearn.model_selection import cross_val_score
cross_val_score(xgb, train[['Promo', 'weekday', 'month','year', 'SchoolHoliday']], train['Sales'], scoring="neg_mean_squared_error", cv=3)

cross validation 으로 오류율을 구해보았더니 위와 같이 나왔다.  추가 작업으로 오류율을 줄여나가 보자! 

cf.  캐글 제출 파일 만들기 

test['Sales'] = xgb.predict(test[['Promo','SchoolHoliday','StateHoliday_0','StateHoliday_a','StateHoliday_b','StateHoliday_c','weekday','year','month']])

test 데이터셋으로 학습된 모델에 넣어 예측을 진행한다. 

test[['id','Sales']].to_csv("submission.csv",index=False)

- 변수 선택 

xgb.feature_importances_

feature_importances_ 를 사용하여 변수의 중요도를 알 수 있다. 

input_var = ['Promo','SchoolHoliday','StateHoliday_0','StateHoliday_a','StateHoliday_b','StateHoliday_c','weekday','year','month']

input_var에 Sales를 제외한 인풋 변수를 저장해 준다. 

imp_df = pd.DataFrame({"var": input_var,
                       "imp": xgb.feature_importances_})

imp_df = imp_df.sort_values(['imp'],ascending=False)
imp_df

변수 중요도 데이터프레임을 생성한 후 높은 순서대로 정렬을 해 준다. Promo가 압도적으로 변수중요도가 높은 것을 볼 수 있다. State_Holiday는 대체적으로 낮은 것으로 보인다. 

import matplotlib.pyplot as plt
plt.bar(imp_df['var'],imp_df['imp'])
plt.xticks(rotation=90)
plt.show()

한눈에 보기위해 그래프를 그려 보았더니 SchoolHoliday 이후 컬럼들은 별 의미가 없어 보인다. 

cross_val_score(xgb, train[['Promo', 'weekday', 'month','year', 'SchoolHoliday']], train['Sales'], scoring="neg_mean_squared_error", cv=3)

모든 컬럼을 사용했을 때 보다 오류율이 줄어들었다. 그렇다면 컬럼을 몇개 사용하는 것이 가장 오류율을 줄게 하는지 실험해 본다. 

import numpy as np
score_list=[]
selected_varnum=[]

for i in range(1,10):
    selected_var = imp_df['var'].iloc[:i].to_list()
    scores = cross_val_score(xgb, 
                             train[selected_var], 
                             train['Sales'], 
                             scoring="neg_mean_squared_error", cv=3)
    score_list.append(-np.mean(scores))
    selected_varnum.append(i)
    print(i)

plt.plot(selected_varnum, score_list)

변수의 개수 별로 cross validation을 수행한 결과 2개일 때 가장 낮은 것을 볼 수 있다. 

예측변수가 2개일 때 cross validation을 수행한다. 

cross_val_score(xgb, train[['Promo', 'weekday']], train['Sales'], scoring="neg_mean_squared_error", cv=3)

두번째 빼고는 모두 줄어든 것을 볼 수 있다. 예측변수가 2개일 때 모델 학습을 한 후, 테스트 데이터로 제출한 캐글 스코어도 더 줄어들었다. (반복작업이므로 포스팅에서 생략) 

2. 2차 모델링 

- store 데이터 합병 

store

store 데이터셋: 각 상점에 대한 특징을 정리한 것 

컬럼 의미

• Store: 상점의 유니크한 id
• Store Type: 상점의 종류
• Assortment: 상점의 종류
• CompetitionDistance: 가장 가까운 경쟁업체 상점과의 거리
• CompetitionOpenSinceMonth: 가장 가까운 경쟁업체 오픈 월
• CompetitionOpenSinceYear: 오픈 년도
• Promo2: 지속적인(주기적인) 판매촉진 행사 여부
• Promo2SinceWeek/ promo2SinceYear: 해당 상점이 promo2를 하고있다면 언제 시작했는지
• PromoInterval: 주기가 어떻게 되는지

train = pd.merge(train, store, on=['Store'], how='left')
test = pd.merge(test, store, on=['Store'], how='left')

Store 컬럼을 기준으로 train, test 데이터셋과 store 데이터셋을 합병해 준다. 

- CompetitionOpen 컬럼 생성

: 경쟁업체가 언제 개장했는지 (해당 가게 이전 개장: 양수, 이후 개장: 음수) 

train['CompetitionOpen'] = 12*( train['year'] - train['CompetitionOpenSinceYear'] ) + \
                             (train['month'] - train['CompetitionOpenSinceMonth'])

test['CompetitionOpen'] = 12*( test['year'] - test['CompetitionOpenSinceYear'] ) + \
                             (test['month'] - test['CompetitionOpenSinceMonth'])

해당 가게가 개장한 년도에서 경쟁업체가 개장한 년도를 뺀 후 12를 곱하면 개월 수로 변환할 수 있다. 이를 해당 가게 개장 달에서 경쟁업체 개장 달의 차이와 더해주면 해당 가게를 기준으로 언제 개장했는지 알 수 있다. 

- PromoOpen 컬럼 생성 

: 해당 가게 개장 후 몇개월 후에 프로모션2가 시작되었는지 

train['WeekOfYear'] = train['Date'].dt.weekofyear # 현재 날짜가 몇번째 주인지
test['WeekOfYear'] = test['Date'].dt.weekofyear

프로모션2에 대한 날짜 정보가 년도(Year)와 주(Week)로 되어있기 때문에 Date컬럼에서 날짜가 몇번째 주인지 계산하여 WeekOfYear 컬럼에 저장해 준다. 

train['PromoOpen'] = 12* ( train['year'] - train['Promo2SinceYear'] ) + \
                        (train['WeekOfYear'] - train['Promo2SinceWeek']) / 4

test['PromoOpen'] = 12* ( test['year'] - test['Promo2SinceYear'] ) + \
                        (test['WeekOfYear'] - test['Promo2SinceWeek']) / 4

이전과 같이 년도를 개월수로 바꿔주고, 주를 4로 나누어 개월수로 변환해 준것을 더하여 개장 후 몇개월 뒤에 프로모션2가 진행되었는지에 대한 개월 수가 나오게 된다. 

- 원핫인코딩 ( get_dummies() ) 

train.dtypes

데이터타입을 확인 해 보면 object인 컬럼이 3가지 있다. 3개의 컬럼을 get_dummies를 이용하여 원핫인코딩 해준다. 

train = pd.get_dummies(columns=['StoreType'],data=train)
test = pd.get_dummies(columns=['StoreType'],data=test)

train = pd.get_dummies(columns=['Assortment'],data=train)
test = pd.get_dummies(columns=['Assortment'],data=test)

train = pd.get_dummies(columns=['PromoInterval'],data=train)
test = pd.get_dummies(columns=['PromoInterval'],data=test)

train.columns

test.columns

train column과 test column 이 동일한 것을 확인하였다. 

- 모델링 

input_var = ['Promo', 'SchoolHoliday',
       'StateHoliday_0', 'StateHoliday_a', 'StateHoliday_b', 'StateHoliday_c',
       'weekday', 'year', 'month', 'CompetitionDistance',
       'Promo2',
       'CompetitionOpen', 'WeekOfYear',
       'PromoOpen', 'StoreType_a', 'StoreType_b', 'StoreType_c', 'StoreType_d',
       'Assortment_a', 'Assortment_b', 'Assortment_c',
       'PromoInterval_Feb,May,Aug,Nov', 'PromoInterval_Jan,Apr,Jul,Oct',
       'PromoInterval_Mar,Jun,Sept,Dec']

필요없는 컬럼은 삭제하고 input_var에 저장해 준다. 

set(train) - set(input_var)

(참고) input_var에 들어가지 않은 컬럼들 목록이다. 

xgb = XGBRegressor( n_estimators=300, learning_rate= 0.1, random_state=2020)
xgb.fit(train[input_var],train['Sales'])

앞과 동일하게 xgb 모델을 사용한다.  

cross_val_score(xgb, train[input_var], train['Sales'], scoring="neg_mean_squared_error", cv=3)

store 데이터셋을 합병하여 전처리 후 모델링을 했더니 오류율이 대폭 하락하였다. 

- 변수중요도 

imp_df = pd.DataFrame({'var':input_var,
                       'imp':xgb.feature_importances_})
imp_df = imp_df.sort_values(['imp'],ascending=False)

plt.bar(imp_df['var'],
        imp_df['imp'])
plt.xticks(rotation=90)
plt.show()

변수중요도를 시각화 해보았더니, 모든 변수를 사용하는 것보다 선택해서 학습하는 것이 좋을 것 같다고 판단된다. 

score_list=[]
selected_varnum=[]

for i in range(1,25):
    selected_var = imp_df['var'].iloc[:i].to_list()
    scores = cross_val_score(xgb, 
                             train[selected_var], 
                             train['Sales'], 
                             scoring="neg_mean_squared_error", cv=3)
    score_list.append(-np.mean(scores))
    selected_varnum.append(i)
    print(i)

plt.plot(selected_varnum, score_list)

지속적으로 하락하는 경향을 보이지만 17개 이후로 비슷한 것 같이 보인다. 따라서 17개까지 선택하여 학습을 진행해 본다. 

input_var = imp_df['var'].iloc[:17].tolist()
xgb.fit(train[input_var],
        train['Sales'])

cross_val_score(xgb, train[input_var], train['Sales'], scoring="neg_mean_squared_error", cv=3)

전체적으로 오류율이 줄어들었다. 

3. 파라미터 튜닝 

estim_list = [100,200,300,400,500,600,700,800,900]
score_list = []

for i in estim_list:
    xgb = XGBRegressor( n_estimators=i, learning_rate= 0.1, random_state=2020)
    scores = cross_val_score(xgb, train[input_var], train['Sales'], scoring="neg_mean_squared_error", cv=3)
    score_list.append(-np.mean(scores))
    print(i)

plt.plot(estim_list,score_list)
plt.xticks(rotation=90)
plt.show()

n_estimators를 바꿔가며 오류율을 계산한 것을 시각화 해보았고, n_estimators=400으로 하는 것이 적당해 보인다.  

xgb = XGBRegressor( n_estimators=400, learning_rate= 0.1, random_state=2020)

xgb.fit(train[input_var],
        train['Sales'])

cross_val_score(xgb, train[input_var], train['Sales'], scoring="neg_mean_squared_error", cv=3)

400으로 변경하였더니 오류율이 낮아졌다. 

아쉽게도 파라미터 튜닝을 한 이후로 캐글에서 테스트 데이터셋은 오류율이 더 높게 나왔다. 이외에 결측값, 이상치 등 feature engineering을 지속적으로 시도해 보아야겠다. (추후 github 업로드 예정) 

러닝스푼즈 수업 정리 

< 이전 글 > 

https://silvercoding.tistory.com/69

Menchester United 팀에서 2013년 Alex Ferguson 감독이 은퇴를 하고, 하락세를 타다가 솔샤르 감독이 팀을 맡게되었을 때 2020년 3월 기준 2019/2020 시즌 겨울 시장에서 두명의 선수를 영입하여 하락세를 반전시킬 수 있었다. 

이를 선수들의 데이터 분석을 통해 방출과 영입을 결정한다면, 어떤 결과가 나올까? 

데이터 : FIFA 데이터 (러닝스푼즈 강의 제공)

1. 데이터 불러오기 

import pandas as pd

import warnings 

warnings.filterwarnings(action='ignore')  # 경고문 제거

data = pd.read_csv("./data/FIFA_data.csv")

pd.set_option('display.max_columns', 80)

column이 많으면 ... 으로 생략되어있기 때문에 데이터의 컬럼 수인 80개로 설정해준다. 

data.head()

모든 컬럼을 확인해볼 수 있다. 

2. 데이터 확인, 분석계획 

컬럼 별 의미 확인 

분석 절차 수립 

1. Manchester United 선수 분석 (어떤 선수들이 존재하는가?) 

2. Manchester United 지역라이벌 Manchester City 선수들과 비교 분석 

3. 부족한 포지션 2가지 선택 

4. 다른팀의 선수들 중 2명의 영입 선수 선택 (재정, 현실가능성, 영입방침 고려) 

3. Manchester United 선수들 분석 

(1) EDA 

- 맨유 선수 추출

mu = data[data['Club'] == 'Manchester United']
mu.head()

Club이 Manchester United인 행만 뽑아 mu에 저장해준다.  

mu['Club'].unique()

unique() 함수를 사용하여 확인해 보니 맨유만 잘 뽑힌 것을 볼 수 있다. 

- 맨유 선수들 간략한 정보 출력 

print(f"인원: {mu.shape[0]}")
print(f"맨유 선수들의 포지션: {mu['Position'].unique()}")
print(f"평균 능력치: {mu['Overall'].mean()}")
print(f"평균 잠재 능력치: {mu['Potential'].mean()}")

- 시각화 

import seaborn as sns 
sns.countplot(mu['Age'])

선수들의 나이 분포이다. 19살이 가장 많고, 그다음으론 25살, 28살, 22살인 것을 알 수 있다. 

sns.countplot(mu['Position'])

ㅍ

선수들의 포지션 중 가장 많은 것은 CM, CB 이다. 

sns.boxplot(data=mu, x='Position', y='Overall')

Position별 능력치 boxplot 을 그려보았더니 CB 포지션에서 이상치가 발견되었다. 

* 이상치 & 결측치 처리 

이상치

• 정상 범주에서 크게 벗어난 값
• 이상치를 포함하여 분석을 진행할 경우 분석 결과가 왜곡될 가능성이 있음 

결측치

• 누락값, 비어있는 값 
• 데이터 수집 당시 기록되지 않았거나, 누락된 값

이상치와 결측치 처리법

• 제거: 이상치 및 결측치가 포함되어 있는 행, 혹은 열을 제거한다. (최후의 수단, 데이터 하나하나가 소중하기 때문) 
• 대체: 이상치 및 결측치를 해당 컬럼의 최댓값, 평균값, 중앙값 등으로 대체 (추천하는 방법은 아님.)
• 예측: 이상치 및 결측치가 포함된 컬럼의 특성을 고려하여 예측 값으로 채워 넣음 (추천) 

mu[mu['Overall']>100]

능력치가 100이상인 row를 확인해 본다. 

이상치 처리 - 예측 사용 

mu[mu['Position'] == 'CB'][['Position', 'Overall', 'CB']]

같은 포지션 선수들끼리 비교를 해본다. CB가 비슷한 선수들끼리의 능력치가 같은 것을 알 수 있다. 이상치를 갖고 있는 선수는 11081 번째 선수와 CB가 같으므로 75로 예측할 수 있다. 

mu['Overall'][11422] = 75

11422 번째 선수의 능력치를 75로 바꾸어준다. 

sns.boxplot(data=mu, x='Position', y='Overall')

다시 boxplot을 그려보니 이상치 없이 그려진 것을 볼 수 있다. 

sns.boxplot(data=mu, x='Position', y='Potential')

potential에 대한 boxplot도 그려준다. potential에는 이상치가 나오지 않았다. 

mu.info()

mu는 총 33개의 row인데, 19~44 번째 컬럼에 3개의 결측값이 있는 것이 확인되었다. 

mu[mu.isnull()['LS']]

포지션이 GK인 선수들만 결측값이 있는 것으로 보인다. GK는 골키퍼이고, 골키퍼는 다른 포지션에 대한 능력치를 부여할 필요가 없기 때문에 결측값으로 둔 것으로 예상할 수 있다. 

mu = mu.fillna(-1)

결측값을 -1로 채워준다. (값을 측정할 수 없다는 의미에서 임의의 값 -1, 다른값을 넣어주어도 됨) 

mu.info()

결측값이 모두 채워졌다. 

4. Manchester United vs Manchester City 

(1) 전처리 

df = data[(data['Club'] == 'Manchester United') | (data['Club']=='Manchester City')]

Manchester United와 Manchester City만 뽑아 df 에 저장해준다. 

df['Club'].unique()

df['Value'].head()

이적료 Value가 기호로 써져있으므로, 기호 삭제, 소수점 삭제를 진행한다. 

df['Value'] = df['Value'].str.replace('M', '000000')
df['Value'] = df['Value'].str.replace('K', '000')

M이 써져있으면 0을 6개, K가 써져있으면 0을 3개 붙여 준다. 

df['Value']

df['Value'] = df['Value'].str.slice(1,)

그다음 str.slice를 이용하여 기호를 없애준다. 

df['Value'].iloc[3]

'64.5000000'

이렇게 소수점이 있는 것이 존재하므로, 점을 없애고 뒤의 0을 하나 삭제한다. 

for i in df["Value"]:
    if '.' in i:
        df['Value'] = df['Value'].str.replace('.', '')
        df['Value'] = df['Value'].str.slice(0,-1)

df['Value']

적용이 잘 된 것을 볼 수 있다. 

df['Value'] = df['Value'].astype('int')

이제 데이터 타입을 object -> int로 바꿔준다. 

df.head()

- mu, mc 선수 분리 

mu = df[df['Club'] == "Manchester United"]
mc = df[df['Club'] == "Manchester City"]

df에서 Manchester United, Manchester City 선수들을 분리해 준다. 

mc.head()

df['Position'].unique()

위의 포지션을 골기퍼, 수비수, 미드필더, 공격수, 총 4가지로 분류하여 분석을 진행한다. 포지션을 나누면 다음과 같다. 

• 골키퍼 리스트 GK= GK (골키퍼)
• 수비수 리스트 CB = CB(중앙 수비수), LB(왼쪽 수비수), RB(오른쪽 수비수), RCB(오른쪽/중앙 수비수), LCB(왼쪽/중앙 수비수) 
• 미드필더 리스트 MF = RCM(오른쪽/중앙 미드필더), LCM(왼쪽/중앙 미드필더), RDM(오른쪽 수비형 미드필더), CDM(중앙 수비형 미드필더), CM(중앙 미드필더), RM(오른쪽 미드필더), CAM(중앙 공격형 미드필더)
• 공격수 리스트 ST = ST(전방 공격수), LW(왼쪽 공격수), RW(오른쪽 공격수)

* GK(공격수) : 1명, CB(수비수) : 4명, MF(미드필더) : 4명, ST(공격수) : 2명 선발

-> 선발의 기준은 현재능력치(Overall 컬럼)

gk_list = ['GK']
cb_list = ['CB', 'LCB', 'RCB', 'RB', 'LB']
mf_list = ['RCM', 'LCM', 'RDM', 'CDM', 'CM', 'RM', 'CAM']
st_list = ['ST', 'LW', 'RW']

포지션을 분류한대로 리스트를 작성해준다. 

gk_count = 1
cb_count = 4
mf_count = 4
st_count = 2



mu_id = []

for index in mu.index:
    if mu['Position'][index] in gk_list: 
        if gk_count != 0:
            mu_id.append(mu['ID'][index])
            gk_count -= 1 
    elif mu['Position'][index] in cb_list:
        if cb_count != 0:
            mu['Position'][index] = 'CB'
            mu_id.append(mu['ID'][index])
            cb_count -= 1 
    elif mu['Position'][index] in mf_list:
        if mf_count != 0:
            mu['Position'][index] = 'MF'
            mu_id.append(mu['ID'][index])
            mf_count -= 1 
    else:
        if st_count != 0:
            mu['Position'][index] = 'ST'
            mu_id.append(mu['ID'][index])
            st_count -= 1

현재능력치가 높은 순으로 정렬되어있는 데이터이기 때문에 순서대로 상위 포지션 선수들의 ID 값을 리스트에 넣어준다. 

mu[mu['ID'].isin(mu_id)]

11명의 선수가 알맞게 나온 것을 볼 수 있다. 

mu = mu[mu['ID'].isin(mu_id)]

선발된 11명의 선수들만 mu 변수에 넣어 준다. 

같은 절차로 Manchester City 또한 진행한다. 

gk_count = 1
cb_count = 4
mf_count = 4
st_count = 2


mc_id = []

for index in mc.index:
    if mc['Position'][index] in gk_list: 
        if gk_count != 0:
            mc_id.append(mc['ID'][index])
            gk_count -= 1 
    elif mc['Position'][index] in cb_list:
        if cb_count != 0:
            mc['Position'][index] = 'CB'
            mc_id.append(mc['ID'][index])
            cb_count -= 1 
    elif mc['Position'][index] in mf_list:
        if mf_count != 0:
            mc['Position'][index] = 'MF'
            mc_id.append(mc['ID'][index])
            mf_count -= 1 
    else:
        if st_count != 0:
            mc['Position'][index] = 'ST'
            mc_id.append(mc['ID'][index])
            st_count -= 1

mc = mc[mc['ID'].isin(mc_id)]

concat vs merge

merge: 좌우합병, concat: 상하합병

df = pd.concat([mu, mc])

선발된 mu, mc 선수들을 합쳐 df에 저장해준다. 

(2) EDA 

- mu vs mc 포지션별 주전선수의 현재능력치(overall) 비교 

df = pd.concat([mu, mc])

골기퍼를 뺀 타 포지션은 모두 Manchester United 팀이 낮은 것을 볼 수 있다. 

- mu vs mc 포지션별 주전선수의 예상이적료(Value) 비교

sns.boxplot(data=df, x='Position', y='Value', hue='Club')

이적료는 골기퍼를 빼고 거의 차이가 없거나 더 높은 것을 볼 수 있다.

위의 boxplot으로 두 팀을 비교해보았을 때, 이적료 대비 능력치가 떨어지는 포지션은 MF, CB로 판단하여 두 포지션에 대해 어떤 선수를 영입할지 분석을 해본다. 

5. Manchester United는 어떤 선수를 영입해야 하는가? 

(1) EDA

* 방출 선수 선정

영입일, 능력치, 잠재력, 나이를 기준으로 공식 세우기 

 Point = (Overall * 2 + Potential) / Age 

능력치(가중치를 가함)와 잠재력이 높을 수록, 나이가 낮을 수록 좋음. 

mu['Point'] = (mu['Overall'] * 2 + mu['Potential']) / mu['Age']

- MF 포지션 

mu[mu['Position'] == 'MF'][['Name', 'Overall', 'Potential', 'Age', 'Joined', 'Point']]

가장 낮은 포인트는 211번 선수이다.  

- CB 포지션 

mu[mu['Position'] == 'CB'][['Name', 'Overall', 'Potential', 'Age', 'Joined', 'Point']]

가장 낮은 포인트는 377번 선수이다. 

마타, 스몰링 두 선수를 방출하고 MF, CB 포지션을 한명씩 영입한다. 

(2) 시각화 

전체 선수 시각화 - 영입방침에 따른 영입 선수 결정 

Manchester United 영입방침 (솔샤르감독) 

- 선수의 나이는 어릴 수록 좋음

- 잠재력 보다 현재 바로 주전으로 뛸 수 있는 선수 

market = data[(data['Position']=='RM') | (data['Position']=='CB')]

포지션은 방출 선정된 두선수의 세부 포지션인 RM, CB를 선택한다. 

market.head()

import matplotlib.pyplot as plt

f, ax = plt.subplots(2, 4, figsize=(20, 10))

vs_list = ['Age', 'Overall', 'Potential', 'Weak Foot']

for i in range(8):
    if i < 4:
        colors = ['firebrick' if x > market[market['Position']=='CB'][:13][vs_list[i]].mean() else 'gray' for x in market[market['Position']=='CB'][:13][vs_list[i]]]
        sns.barplot(x=vs_list[i], y='Name', data=market[market['Position']=='CB'][:13], ax=ax[i//4, i%4], palette=colors)
        ax[i//4, i%4].axvline(market[market['Position']=='CB'][:13][vs_list[i]].mean(), ls = '--', color='k')
   
    else:
        colors = ['firebrick' if x > market[market['Position']=='RM'][:13][vs_list[i%4]].mean() else 'gray' for x in market[market['Position']=='RM'][:13][vs_list[i%4]]]        
        sns.barplot(x=vs_list[i%4], y='Name', data=market[market['Position']=='RM'][:13], ax=ax[i//4, i%4], palette=colors)        
        ax[i//4, i%4].axvline(market[market['Position']=='RM'][:13][vs_list[i%4]].mean(), ls='--', color='k')

데이터 분석으로 다른 것을 배제하고 나이, 현재 능력치, 잠재력으로만 따진다고 했을 때, 영입방침에 따라 영입을 결정한다면 S. Umtiti, K. Mbappé 선수가 될 것이라 판단하였다. 

러닝스푼즈 수업 정리 

< 이전 글 > 

https://silvercoding.tistory.com/67

'결론이 무엇인지' 를 설명하는 것은 데이터사이언티스트로서의 중요한 업무이다. 

예측 결과만 보고는 모델이 어떤 패턴을 이용하여 예측을 실행하게 되었는지, 왜 그렇게 예측했는지 설명할 수 없다. 그렇게 되면 다른 분야의 협업자들은 신뢰를 잃게될 것이다. 

비즈니스의 관점에서 예를 들어본다. 머신러닝을 통하여 영화 흥행성적을 예측하는 프로젝트에서 흥행 실패라는 예측이 나왔다고 했을 때, 어떻게 흥행실패를 막을 것이냐고 질문이 들어올 수도 있다. 기존의 취약점을 보완하지 못한다면 비즈니스의 관점에서 의미가 없다. 

따라서 결과를 설명할 수 있는 것은 아주 중요하다. 이 때 변수중요도를 활용할 수 있다. 예측에 큰 영향을 미친 변수와, 특정 변수가 어떻게 영향을 미쳤는지 섬세하게 확인해볼 수 있다. 

변수중요도

- 모델에 활용한 input 변수 중에서 어떤 것이 target 값에 가장 큰 영향을 미쳤나? 
- 해당 중요도를 수치화시킨 것
- tree형 모델 (의사결정나무, 랜덤포레스트) 에서 계산 가능 

이전 글의 tree형 모델인 random forest와 xgboost에서 변수중요도 계산을 실행했었다.  

(참고)  배깅  부스팅

의사결정나무에서의 변수중요도

- 해당 input 변수가 의사결정나무의 구축에서 얼마나 많이 쓰이나 
- 해당 변수를 기준으로 분기를 했을 때 각 구간의 복잡도가 얼마나 줄어드는가? 

shapley 값 

: 각 변수가 예측 결과물에 주는 영향력의 크기

: 해당 변수가 어떤 영향을 주는가 

(예) 축구 선수 A , 속한 팀 B 

- 각 선수가 팀 성적에 주는 영향력 크키

- 해당 선수가 어떠한 영향을 주는가 

- (선수 A가 있는 팀 B의 승률) - (선수 A가 없는 팀 B의 승률 = 7% 

 shap value 실습 

shap value 실습에 중점을 두기 위해  Xgboost 학습까지 전에 했던 그대로 실행해준다. 

데이터 불러오기

import os
import pandas as pd
import numpy as np

os.chdir('./data') # 본인 경로 
data = pd.read_csv("bank-additional-full.csv", sep = ";")

이전 글에서 사용하였던 예금 가입 여부 데이터셋이다. 

data = pd.get_dummies(data, columns = ['job','marital','education','default','housing','loan','contact','month','day_of_week','poutcome'])

범주형 변수를 get_dummies를 이용하여 원핫인코딩 해준다. 

data['y'].value_counts()

분류 모델이기 때문에 목표변수도 당연히 범주형 변수로 되어있다. 

data['y'] = np.where( data['y'] == 'no', 0, 1)

하지만 shap value 패키지는 목표변수가 수치형이어야 잘 작동하기 때문에 수치화 시켜준다. 

Xgboost 학습 

input_var = ['age', 'duration', 'campaign', 'pdays', 'previous', 'emp.var.rate',
       'cons.price.idx', 'cons.conf.idx', 'euribor3m', 'nr.employed',
       'job_admin.', 'job_blue-collar', 'job_entrepreneur', 'job_housemaid',
       'job_management', 'job_retired', 'job_self-employed', 'job_services',
       'job_student', 'job_technician', 'job_unemployed', 'job_unknown',
       'marital_divorced', 'marital_married', 'marital_single',
       'marital_unknown', 'education_basic.4y', 'education_basic.6y',
       'education_basic.9y', 'education_high.school', 'education_illiterate',
       'education_professional.course', 'education_university.degree',
       'education_unknown', 'default_no', 'default_unknown', 'default_yes',
       'housing_no', 'housing_unknown', 'housing_yes', 'loan_no',
       'loan_unknown', 'loan_yes', 'contact_cellular', 'contact_telephone',
       'month_apr', 'month_aug', 'month_dec', 'month_jul', 'month_jun',
       'month_mar', 'month_may', 'month_nov', 'month_oct', 'month_sep',
       'day_of_week_fri', 'day_of_week_mon', 'day_of_week_thu',
       'day_of_week_tue', 'day_of_week_wed', 'poutcome_failure',
       'poutcome_nonexistent', 'poutcome_success']

y 컬럼을 제외한 인풋변수를 리스트에 모두 담아준다. 

from xgboost import XGBRegressor

수치형으로 예측을 진행하기 위해 XBGRegressor 회귀모델을 임포트 해준다. 

xgb = XGBRegressor( n_estimators = 300, learning_rate=0.1 )

xgb.fit(data[input_var], data['y'])

Xgboost 학습을 진행한다. 

Shap Value 예제 

import shap

shap 라이브러리를 import 해준다. 

(1) 변수중요도

explainer = shap.TreeExplainer(xgb)
shap_values = explainer.shap_values( data[input_var] )

shap.TreeExplainer의 인자에 학습한 모델 xgb를 넣어 객체를 저장해준다. 그다음 explainer.shap_values의 인자에 데이터셋의 인풋값을 넣어준다. 

shap.summary_plot( shap_values , data[input_var] , plot_type="bar" )

shap.summary_plot을 사용하여 변수중요도 그래프를 그려준다. 가장 높은 변수는 duration이다. duration은 전화시간이다. 전화시간의 길이가 이 모델의 예측에 가장 영향을 많이 미친다는 의미이다. 

(2) dependence plot 

: 특정 input 변수와 target 변수와의 관계를 표현하는 것 

: 점은 각각의 row를 의미(데이터 한개), 타겟변수에 미친 영향 = y 

: 해당 변수가 어떻게 영향을 미쳤는지 섬세하게 볼 수 있다. 

shap.dependence_plot( 'duration' , shap_values , data[input_var] )

duration의 그래프를 보면 duration의 대부분이 3000 미만에 존재하고, 그 중에서는 duration이 50이상쯤 되면 좋은 영향력을 끼쳐 1일 가능성이 높아진다고 해석된다. (shpa value for duration이 0보다 큰 데이터가 많음) 

shap.dependence_plot( 'nr.employed' , shap_values , data[input_var] )

5020쯤 되는 지점에서 영향력이 음수가 된다. 그리고 5100이 넘어가고는 음수의 영향력밖에 없다. (-> 0일 가능성이 높음) 그 이전에는 영향력이 높으므로 좋은 영향력을 끼친다. (-> 1일 가능성이 높음) 

shap.dependence_plot( 'euribor3m' , shap_values , data[input_var] )

음수와 양수가 비슷하게 분포되어있는 것 같아 보인다. 이 중에서 음수가 얼마 없고 양수가 많은 구간을 찾아보면 1.3~1.4 - 2, 4-5 가 있다. 해당 구간일 때 1일 가능성이 높다고 해석할 수 있다. 

shap.dependence_plot( 'cons.conf.idx' , shap_values , data[input_var] )

전체적으로 음수를 이루고 있음을 알 수 있다. -45이하일 때는 1일 가능성이 높아진다고 해석할 수 있다. 

shap.dependence_plot( 'pdays' , shap_values , data[input_var] )

pdays가 0일때 대다수의 데이터가 1일 가능성이 높아질 것이라 예상할 수 있다. 

(3) force plot

: 특정 값이 어떻게 예측되었는지를 시각화 

prediction = xgb.predict(data[input_var])
data['pred'] = prediction

shap.initjs()
shap.force_plot( explainer.expected_value , shap_values[41187] , data[input_var].iloc[41187] )

411187번째 데이터는 0.09가 나왔는데, 떨어뜨리는 변수와 올리는 변수가 골고루 분포되어 있다. 

shap.force_plot( explainer.expected_value , shap_values[0] , data[input_var].iloc[41187] )

0에 거의 가깝게 예측된 0번째 데이터는 거의 모든 변수가 음수의 영향력을 끼친 것을 볼 수 있다. 

41183번째 데이터는 양의 영향력이 훨씬 높은 것을 볼 수 있다. 따라서 0.88의 결과가 나왔고, 정답은 1로, 근접하게 맞혔다. 

이렇게 shap 라이브러리를 사용하여 각 변수가 예측에 어떠한 영향을 미쳤는지 섬세하게 알아볼 수 있었다.  

러닝스푼즈 수업 정리 

< 이전 글 > 

https://silvercoding.tistory.com/66

부스팅 Boosting

각 모델의 다양성 확보 (부스팅 절차) 

• 이전 모델에서 오분류한 객체에 가중치를 높여 새로운 데이터(가중치가 부여된)로 모델 학습
• 각 데이터셋으로 모델 만듦
• 모델별로 학습하는 데이터셋의 다양성으로 인해 모델의 다양성 확보

최종 결과물 결합

• 각 모델로부터 나온 예측치를 가중평균

n_estimators 설정 

(n_estimators : 몇 개의 의사결정나무를 만들 것인지) 

• n_estimators 가 너무 높으면 노이즈에 민감한 오버피팅 우려 
• n_estimators가 너무 낮으면 언더피팅 우려 
• 적절한 n_estimators를 찾아내는 것이 관건 

데이터 불러오기 

import os
import pandas as pd

os.chdir('../data')   # 본인 파일이 존재하는 폴더 경로
data = pd.read_csv("bank-additional-full.csv", sep = ';')

data.head()

data.info()

전처리 - 범주형 변수 원핫인코딩

data = pd.get_dummies(data,columns=['job','marital','education','default','housing','loan','contact','month','day_of_week','poutcome'])

dtype이 object인 범주형 변수를 get_dummies를 사용하여 원핫인코딩 해준다. 

train & test 데이터셋 분리 

data['id']=range(len(data))

데이터를 구분하기 위하여 각 row에 id를 부여한다. 

train = data.sample(30000,replace=False,random_state=2020).reset_index().drop(['index'],axis=1)

test = data.loc[ ~data['id'].isin(train['id']) ].reset_index().drop(['index'],axis=1)

이전글과 동일하게 train, test 데이터셋을 분리해 준다.

인풋변수 저장 

data.columns

input_var = ['age', 'duration', 'campaign', 'pdays', 'previous', 'emp.var.rate',
       'cons.price.idx', 'cons.conf.idx', 'euribor3m', 'nr.employed',
       'job_admin.', 'job_blue-collar', 'job_entrepreneur', 'job_housemaid',
       'job_management', 'job_retired', 'job_self-employed', 'job_services',
       'job_student', 'job_technician', 'job_unemployed', 'job_unknown',
       'marital_divorced', 'marital_married', 'marital_single',
       'marital_unknown', 'education_basic.4y', 'education_basic.6y',
       'education_basic.9y', 'education_high.school', 'education_illiterate',
       'education_professional.course', 'education_university.degree',
       'education_unknown', 'default_no', 'default_unknown', 'default_yes',
       'housing_no', 'housing_unknown', 'housing_yes', 'loan_no',
       'loan_unknown', 'loan_yes', 'contact_cellular', 'contact_telephone',
       'month_apr', 'month_aug', 'month_dec', 'month_jul', 'month_jun',
       'month_mar', 'month_may', 'month_nov', 'month_oct', 'month_sep',
       'day_of_week_fri', 'day_of_week_mon', 'day_of_week_thu',
       'day_of_week_tue', 'day_of_week_wed', 'poutcome_failure',
       'poutcome_nonexistent', 'poutcome_success']

data의 컬럼에서 y를 제외한 컬럼을 input_var에 저장해 준다. 

XGBoost 모델학습 

XGBoost 

- 특징 

• 해석이 어려움 
• 대체적으로 랜덤포레스트에 비해 빠르고 성능이 좋음

- xgb = XGBClassifier( n_estimators = 300, learning_rate = 0.1 )

• n_estimators : 몇 개의 의사결정나무를 만들 것인지 
• learning_rate : 얼마나 빠르게 학습할 것인지 

-설치 

!pip install xgboost

우선 xgboost가 설치되어있지 않다면 설치해 준다. 

from xgboost import XGBClassifier

xgb = XGBClassifier( n_estimators = 300, learning_rate = 0.1 )
xgb.fit(train[input_var], train['y'])

객체 생성을 하고, train 데이터셋으로 학습까지 진행한다. 

predictions = xgb.predict(test[input_var])

test 데이터셋으로 예측을 수행한 후 predictions에 저장한다. 

(pd.Series(predictions)==test['y']).mean()

정확도가 약 91 % 가 나왔다. 현재 모델은 n_estimators를 300으로 지정하였다. 앞에서 학습하였듯이, 오버피팅과 언더피팅을 피하기 위해서는 부스팅에서 n_estimators를 적절하게 설정하는 것이 관건이라고 하였다. 따라서 최적의 n_estimators를 찾아보도록 한다. 

최적 의사결정나무 수 ( n_estimators ) 찾기 

for n in [100,200,300,400,500,600,700,800,900]:
    xgb = XGBClassifier( n_estimators = n, learning_rate = 0.05, eval_metric='logloss' )
    xgb.fit(train[input_var], train['y'])
    predictions = xgb.predict(test[input_var])
    print((pd.Series(predictions)==test['y']).mean())

결과 : 최적의 n_estimators 는 400이다. 

변수중요도 

feature_imp = xgb.feature_importances_

feature_importances_ 를 사용하여 변수중요도를 계산할 수 있다. 

imp_df = pd.DataFrame({'var':input_var,
                       'imp':feature_imp})

imp_df.sort_values(['imp'],ascending=False)

변수중요도를 내림차순으로 정렬해보니 nr.emplyed 컬럼이 가장 중요한 변수로 나온 것을 볼 수 있다. 

러닝스푼즈 수업 정리 

< 이전 글 > 

https://silvercoding.tistory.com/65

배깅 bagging 

- 배깅의 철학 

1. 많을수록 좋다. 

2. 다양할수록 좋다. 

(ex) 남성 1명 < 남성 10명 (수가 많음) < 남성 5명 , 여성 5명 (수가 많고 다양함) 

- 각 모델의 다양성 확보를 어떻게 하는가? (배깅 프로세스)  

1. 전체 데이터셋에서 랜덤 샘플링 ( 복원 추출 / 중복 데이터가 나올수도, 아예 뽑히지 않은 데이터가 있을수도. ) -> 여러 데이터셋 생성 

2. 각 데이터셋으로 모델 생성 

3. 모델별로 학습하는 데이터셋이 다르므로 모델의 다양성 확보 

- 최종 결과물의 결합? 

: 각 모델로부터 나온 예측치의 단순 평균을 구한다. 

- 랜덤포레스트 (본 포스팅에서 사용할 모델) 

: 배깅의 프로세스를 따르면서 의사결정나무를 사용하는 알고리즘 

 데이터 살펴보기 

사용할 데이터는 캐글의 Dataset 에서 받을 수 있다. 

< Bank Marketing dataset > 

https://www.kaggle.com/volodymyrgavrysh/bank-marketing-campaigns-dataset

import os
import pandas as pd

os.chdir('../data')  # 본인의 파일 폴더 경로 
data = pd.read_csv("bank-additional-full.csv", sep = ';')

데이터를 불러올 때 주의할 점은 sep=';' 을 설정해 주어야 한다는 것이다. 이 파일은 csv 파일이지만 콤마(,) 가 아닌 세미콜론(;) 으로 구분이 되어있기 때문이다. 

data.head()

나이, 직업, 결혼여부, 대출여부 등의 예측변수를 사용하여 해당 고객의 예금 가입여부를 맞히는 학습을 진행한다. 

data.info()

dtype이 object인 변수는 범주형 변수로 ,  원핫인코딩을 해주어야 한다. 

 랜덤포레스트 사용 

전처리 - 범주형 변수 원핫인코딩

- dtype이 object인 컬럼 추출 

obj_column = []
for column in data.columns[:-1]:
    if data[column].dtype == 'object':
        obj_column.append(column)
        
obj_column

data = pd.get_dummies(data,columns=obj_column)

get_dummies를 이용하여 원핫인코딩을 진행한다. 

data

컬럼수가 많이 늘어난 것을 볼 수 있다.

data['id']=range(len(data))

데이터 구분을 위하여 id값을 부여한다. 

- train & test 데이터셋 분리 

train = data.sample(30000,replace=False,random_state=2020).reset_index().drop(['index'],axis=1)

train 데이터셋을 비복원추출로 30000개를 구성한다. 

test = data.loc[ ~data['id'].isin(train['id']) ].reset_index().drop(['index'],axis=1)

test데이터셋은 train에 없는 id값으로 총 11188개의 데이터로 구성된다. 

랜덤포레스트 모델 학습 

랜덤포레스트

- 특징 

• 해석이 어려움
• 매우 느림
• 의사결정나무보다 더 객관적인 변수 중요도를 뽑아낼 수 있음 

- RandomForestClassifier(n_estimators=m, min_samples_split=n)

• n_estimators : 몇개의 의사결정 나무를 만드는가 
• max_depth : 각 의사결정나무의 최대 깊이 
• min_samples_split : 각 의사결정나무에서 각 노드의 최소 샘플 수 

from sklearn.ensemble import RandomForestClassifier

rf = RandomForestClassifier(n_estimators=500, min_samples_split=10)

랜덤포레스트 객체를 생성한다. 

data.columns

input_var = ['age', 'duration', 'campaign', 'pdays', 'previous', 'emp.var.rate',
       'cons.price.idx', 'cons.conf.idx', 'euribor3m', 'nr.employed',
       'job_admin.', 'job_blue-collar', 'job_entrepreneur', 'job_housemaid',
       'job_management', 'job_retired', 'job_self-employed', 'job_services',
       'job_student', 'job_technician', 'job_unemployed', 'job_unknown',
       'marital_divorced', 'marital_married', 'marital_single',
       'marital_unknown', 'education_basic.4y', 'education_basic.6y',
       'education_basic.9y', 'education_high.school', 'education_illiterate',
       'education_professional.course', 'education_university.degree',
       'education_unknown', 'default_no', 'default_unknown', 'default_yes',
       'housing_no', 'housing_unknown', 'housing_yes', 'loan_no',
       'loan_unknown', 'loan_yes', 'contact_cellular', 'contact_telephone',
       'month_apr', 'month_aug', 'month_dec', 'month_jul', 'month_jun',
       'month_mar', 'month_may', 'month_nov', 'month_oct', 'month_sep',
       'day_of_week_fri', 'day_of_week_mon', 'day_of_week_thu',
       'day_of_week_tue', 'day_of_week_wed', 'poutcome_failure',
       'poutcome_nonexistent', 'poutcome_success']

반환된 data의 컬럼에서 y를 뺀 컬럼들을 input_var 변수에 저장해 준다. 

rf.fit(train[input_var],train['y'])

train 데이터셋으로 랜덤포레스트분류기 모델 학습을 진행한다. 

predictions = rf.predict(test[input_var])

test데이터셋으로 예측을 진행하고, predictions 변수에 저장해 준다. 

(pd.Series(predictions)==test['y']).mean()

predictions와 정답값(y) 을 비교하여 평균을 내주면 정확도는 약 91% 가 나오게 된다. 

* 의사결정나무와의 비교 

from sklearn.tree import DecisionTreeClassifier

dt = DecisionTreeClassifier(min_samples_split=10)

의사결정나무 객체를 생성한다. 

dt.fit(train[input_var], train['y'])

predictions = dt.predict(test[input_var])

학습데이터를 사용한 학습과 테스트데이터를 사용한 예측을 진행한다. 

(pd.Series(predictions) == test['y']).mean()

정확도를 비교해보니 의사결정나무보다 랜덤포레스트 모델의 정확도가 조금 더 높은 것을 알 수 있다. 

변수중요도 

feature_imp = rf.feature_importances_
imp_df = pd.DataFrame({'var':input_var,
                       'imp':feature_imp})

imp_df.sort_values(['imp'],ascending=False)

feature_importances_ 를 사용하여 변수중요도를 알아볼 수 있다. 내림차순으로 정렬을 해 보았더니 duration이 가장 높고, default_yes 컬럼이 가장 낮은 것을 볼 수 있다.  (변수중요도에 대한 개념은 다다음시간에 자세히 알아본다.) 

러닝스푼즈 수업 정리 

< 이전 글 > 

https://silvercoding.tistory.com/64

 데이터 불러오기 

이전 글과 동일한 Iris Flower Dataset 을 이용하여 실습을 진행한다. 

< Iris Flower Dataset >

https://www.kaggle.com/arshid/iris-flower-dataset

import pandas as pd
import os

os.chdir('../data')  # 데이터셋이 있는 본인 폴더 경로

iris = pd.read_csv("IRIS.csv")

iris.head()

iris['species'].value_counts()

각 종류마다 50개의 데이터가 존재한다. 

의사결정나무 사용 

train & Test 데이터셋 분리 

iris['id'] = range(len(iris))

우선 데이터를 구분하기 위해 순서대로 값을 넣어준 id 컬럼을 생성한다. 

iris = iris[['id','sepal_length','sepal_width','petal_length','petal_width','species']]

id 컬럼이 가장 앞에 오도록 정렬해준다. 

train = iris.sample(100,replace=False,random_state=7).reset_index().drop(['index'],axis=1)

랜덤으로 100개의 샘플을 추출하여 train 에 저장해 준다. 

test = iris.loc[ ~iris['id'].isin(train['id']) ]
test = test.reset_index().drop(['index'],axis=1)

train의 id값이 존재하지 않는 iris 데이터들을 test에 넣어준다. 

의사결정나무 학습 

DecisionTreeClassifier(min_samples_split = n)

---> 특징 : 해석이 쉽고 빠르다. 

---> min_samples_split : 의사결정나무에서 최종 노드의 최소 샘플 수 

from sklearn.tree import DecisionTreeClassifier

dt = DecisionTreeClassifier(min_samples_split = 10)

min_samples_split 을 10으로 설정해주어 최종 노드의 샘플수가 10미만이 되지 않도록 조정한다. 

dt.fit(train[['sepal_length','sepal_width','petal_length','petal_width']],train['species'])

생성해 놓은 dt 객체로 학습을 시켜준다. 

predictions = dt.predict(test[['sepal_length','sepal_width','petal_length','petal_width']])

예측값을 prediction에 넣어준다. 

test['pred'] = predictions

예측값 prediction을 test의 pred 컬럼에 저장한다. 

test.head()

(pd.Series(predictions)==test['species']).mean()

예측값과 정답을 비교하여 정확도를 구해보니 0.98이 나왔다. 

위의 정확도 측정 방법을 사용하면 신뢰성이 하락할 수 있다. train, test 데이터를 어떻게 나누는지에 따라 결과가 크게 달라질 수도 있기 때문이다. 따라서 cross validation을 이용하여 정확도를 구해볼 수 있다. 

from sklearn.model_selection import cross_val_score
import numpy as np

dt = DecisionTreeClassifier(min_samples_split = 10)

scores = cross_val_score(dt, iris[['sepal_length','sepal_width','petal_length','petal_width']], iris['species'], cv=5, scoring="accuracy")
np.mean(scores)

이번 예시처럼 데이터 수가 적을 경우에는 위와 같이 전체 데이터로 cross validation을 수행하는 것이 신뢰성이 높다. 5 fold cross validation을 수행한 결과 , 정확도가 약 0.97이 나온 것을 볼 수 있다. 

의사결정나무 시각화

from sklearn import tree
import matplotlib.pyplot as plt

from matplotlib.pylab import rcParams
rcParams['figure.figsize'] = 16,10

a=tree.plot_tree(dt,feature_names = ['sepal_length','sepal_width','petal_length','petal_width'],impurity=False, max_depth=2, fontsize=10, proportion=True)
plt.show(a)

max_depth를 이용하여 깊이를 조절할 수 있다. 2개 이후로는 (...) 으로 생략된 것을 볼 수 있다. 위와 같이 의사결정 나무를 사용하고, 시각화 해보면 해석을 쉽고 간편하게 해낼 수 있다. 

러닝스푼즈 수업 정리 

< 이전 글 > 

https://silvercoding.tistory.com/63?category=967543 

KNN 개념 정리

* 1그룹 vs 2그룹 KNN 분류 과정

1. k 설정 : 가장 가까운 k개의 점을 선택 

2. k 개의 점 중 1그룹이 많은지 2그룹이 많은지 확인 

3. 더 많은 그룹의 범주로 분류한다.

* K를 찾아내는 과정

1. 학습데이터를 이용하여 각 K별로 KNN 모델 학습 

2. 만들어진 모델을 이용해 검증 데이터(테스트 데이터) 에서의 에러율 측정 

3. 에러율이 가장 작은 k 선택 

* 적절한 k를 찾아내어야 한다!

- k가 매우 작으면 노이즈에 민감한 과적합 우려 

- k가 매우 크면 지역적 구조를 파악할 수 있는 능력을 잃게 됨 

 데이터 살펴보기 

본 포스팅에서 사용할 데이터셋은 캐글의 다음링크에서 다운받을 수 있다. 

< Iris Flower Dataset >

https://www.kaggle.com/arshid/iris-flower-dataset

import pandas as pd
import os

os.chdir('../data')   # 본인 데이터셋이 존재하는 폴더 경로

iris = pd.read_csv("IRIS.csv")

iris.head()

(참고) sepal : 꽃받침 / petal : 꽃잎 

꽃받침의 크기와 꽃잎의 크기를 근거로 setosa, versicolor, virginica 총 3종류를 구분해 내는 분류모델을 만들 것이다. 

iris.info()

총 150개의 데이터가 들어 가 있고 , 결측값은 존재하지 않는다. 

iris['species'].value_counts()

value_counts() 함수를 이용하여 각 종류가 몇가지씩 있는지 확인해볼 수 있다. 각 종류마다 동일하게 50개씩 존재하는 것을 볼 수 있다. 

 KNN 실습 - 분류 

(ex) KNeighborsClassifier(n_neighbors=n)

---> 데이터가 많으면 느림 

---> n_neighbors=n : k의 개수 지정 (가장 가까운 K개를 볼것이라는 의미) 

iris['id'] = range(len(iris))

데이터를 식별하기 위하여 순서대로 값을 부여하여 id 컬럼에 넣어준다. 

iris = iris[['id','sepal_length','sepal_width','petal_length','petal_width','species']]

id 컬럼이 가장 첫번째에 오도록 정렬 해 준다. 

iris.head()

train & test data 분리 

train = iris.sample(100, replace=False, random_state=7).reset_index(drop=True)
train

학습 데이터셋에 랜덤으로 100개의 데이터를 추출한다. 비복원추출이고, 뒤죽박죽된 인덱스를 초기화 시켜준다. 

test = iris.loc[ ~iris['id'].isin(train['id']) ]
# test = test.reset_index().drop(['index'],axis=1)  # 밑과 같은 코드
test = test.reset_index(drop=True)

테스트 데이터셋에는 학습데이터셋에 없는 id값이 존재하는 row만 추출하여 구성한다. 마찬가지로 인덱스를 초기화 해준다. 

KNN 학습 (k=3 일 때 학습해보기) 

from sklearn.neighbors import KNeighborsClassifier

knn = KNeighborsClassifier(n_neighbors=3) # 모델 정의

k=3으로 설정한 KNN 분류기 객체를 생성한다. 

knn.fit( train[['sepal_length','sepal_width','petal_length','petal_width']] , train['species'] )

knn.fit(train_X, train_y) 와 같이 사용한다.  

predictions = knn.predict( test[['sepal_length','sepal_width','petal_length','petal_width']] )

knn.predict(test_X) 와 같이 사용한다.  test 데이터를 이용하여 예측을 하고, predictions에 저장해 준다. 

test['pred'] = predictions

test.head()

pred 컬럼에 예측 결과인 predictions를 추가해 주었다. 위의 5개를 보니 모두 정답을 맞춘 것을 볼 수 있다.  

(test['pred'] == test['species']).mean()

정답과 예측을 비교하여 정확도를 구해보니 0.94가 나왔다. 이제 여러 k값의 정확도를 구하여 최적의 k를 결정해 본다. 

최적 K 찾기 

- train & test 데이터 사용 

for k in range(1,30):
    knn = KNeighborsClassifier(n_neighbors=k)
    knn.fit( train[['sepal_length','sepal_width','petal_length','petal_width']] , train['species'] )
    predictions = knn.predict( test[['sepal_length','sepal_width','petal_length','petal_width']] )
    print((pd.Series(predictions) == test['species']).mean())

1부터 29까지의 k 의 학습을 진행하여 얻은 정확도이다. 높은 값 중에서 가장 첫번째를 고르면 k=5 (정확도 0.98) 이다. 

---> 최적의 K : 5

하지만 위의 방법을 사용하면 신뢰성이 하락할 수 있다. train, test 데이터를 어떻게 나누는지에 따라 결과가 크게 달라질 수도 있기 때문이다. 따라서 cross validation을 이용하여 정확도를 구해볼 수 있다. 

- cross validation 사용

from sklearn.model_selection import cross_val_score
import numpy as np

for k in range(1,30):
    knn = KNeighborsClassifier(n_neighbors=k)
    scores = cross_val_score(knn, iris[['sepal_length','sepal_width','petal_length','petal_width']], iris['species'], cv=5)
    print(f"{k} : " ,np.mean(scores))

5-fold-cross validation을 진행하였다. k=6 일때 가장 첫번째로 높은 정확도가 나온 것을 알 수 있다. 

---> 최적의 K : 6

 KNN 실습 - 회귀 

회귀문제에 KNN 을 사용할 수도 있다. 이러한 KNN 회귀문제를 실습을 해보기 위해 sepal_length, sepal_width, petal_length 를 이용하여 petal_width를 예측하는 모델을 생성한다. 

del train['species']
del test['species']

간단한 실습을 위하여 범주형 변수인 species 는 삭제해 준다. 그다음 분류문제와 똑같이 학습을 진행한다. 

from sklearn.neighbors import KNeighborsRegressor

knn = KNeighborsRegressor(n_neighbors=3)

knn.fit( train[['sepal_length','sepal_width','petal_length']] , train['petal_width'] )

predictions = knn.predict( test[['sepal_length','sepal_width','petal_length']] )

test['pred'] = predictions

test.head()

학습과 예측은 동일하게 진행한다.

* Mean absolute error ( MAE ) : 회귀문제에서 모델의 성능을 평가하는 방법 중 하나. 

MAE 는 다음과 같이 구할 수 있다. 

abs(test['petal_width'] - pd.Series(predictions)).mean()

정답에서 예측값을 빼고, 절댓값을 취해준 후 각각의 오류율의 평균을 구해주면 된다. 이 평가지표는 오류율이므로 작을 수록 잘 예측한 것이라 판단되어진다. 

for k in range(1,30):
    knn = KNeighborsRegressor(n_neighbors=k)
    knn.fit( train[['sepal_length','sepal_width','petal_length']] , train['petal_width'] )
    predictions = knn.predict( test[['sepal_length','sepal_width','petal_length']] )    
    print(str(k)+' :'+str(abs(test['petal_width'] - pd.Series(predictions)).mean()))

오류율이 가장 작은 k는 7임을 알 수 있다. 

---> 최적의 K : 7