프로젝트_중간점검(데이터정제과정)
201303017_김인우_빅데이터기술 중간발표자료
목차
1. 데이터셋 설명
2. 데이터 분석
3. 분석 진행도
4. 앞으로 해야 할 작업
데이터셋 설명
è 데이터셋의 head(10)까지만 보면 위와같다. 칼럼들은 다음과 같다.
è Game_name(게임이름) game_positive(게임의 긍정적인 평가 점수) game_negative(게임의 부정적인 평가 점수) game_owners(게임 소유한 사람 수) game_price(게임 현재 가격) game_initialprice(게임 초기 가격) game_discount(게임 할인 가격) game_languages(게임이 지원하는 언어) game_tags(게임 태그들)
위 데이터셋은 Steamspiapi를 이용해서 python으로 데이터를 모았으며, Steamspyapi에서 제공하는 칼럼중 쓸만하다고 생각되는 칼럼들만 최대한 추출한 것이다.
위 데이터를 기반으로 game_price와 game_name을 예측하기로 하였다.
많은 예측 중 왜 게임가격인가?
가격은 사용자들에게 민감한 정보 중 하나이다. 그만큼 흥미로운 주제이기도 했다.
가격 예측에 성공을 한다면 가격예측에 영향을 미치는 특성들도 궁금했다.
많은 예측 중 왜 게임이름인가?
게임이름을 예측해야 겠다고 생각한 것은 졸업작품으로 게임추천사이트를 구축하고 있었는데
기존에 구축해 놓은 사이트는 사용자의 질문을 입력 받아서, 단순히 태그를 분류한 다음 상위 몇개의 게임을 추천해 주는 것이였다.
게임이름을 예측해 줄 수 있다면, 이 단순한 혹은 머신러닝처럼 보이는 작업으로 추천을 해주는것이 아니라 나름 정확한 데이터 정제와 알고리즘을 통해서 게임추천을 해 줄 수 있겠다 라고 생각했기 때문이다.
데이터 분석
이제 본격적으로 코드를 통해서 지금까지 진행했던 부분을 확인해 보겠다.
다음 과정은 game_price를 예측한다는 가정하에 데이터 분석을 해보았습니다.
아직 one-hot-encoding을 완벽하게 해결하지 못했기 때문입니다.
먼저, 내가 가지고 있는 데이터셋의 데이터 구조를 확인해야 했다.
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
import seaborn as sb
import matplotlib.pyplot as plt
기본적인 데이터 구조를 확인하기 위해서 위와 같은 library를 import 해준다.
pd.set_option('display.max_columns', None)
#
DATA_PATH ="C:/Users/user/Desktop/Data/Data.xlsx"
Y_NAME ="game_price"
#
full_dataframe = pd.read_excel(DATA_PATH, sep=',',dtype={'game_owners':int})
#
print(type(full_dataframe))
print("\n* Data Shape : ", full_dataframe.shape)
print("\n* class : ", set(full_dataframe["game_price"].values))
그런 다음 위 코드를 통해서 엑셀파일을 불러와서 데이터의 행과 열을 확인했다.
그리고 내가 예측하고자 하는 game_price의 값들을 class로써 나타내 보았다.
결과값
Data Shape : (29304, 6)
class : {0, 519, 524, 3599, 1039, 529, 1049, ….(중략생략)….1529, 509}
그런 다음 데이터의 구조를 파악해야 했다.
그러기 위해서는 데이터의 null or 공백 or 오탈자를 수정해야 했다.
모든 작업을 노트북으로 작업을 했기 때문에 코드로 돌리는 것이 번거로웠다.
그래서 null or 공백 or 오탈자수정은 엑셀에서 작업을 마쳤다.
그런뒤에 다음 코드를 통해서 null 값을 확인해 보았다.
# # 결측치 확인
print("결측치 확인")
print(full_dataframe[full_dataframe.isnull().any(1)])
결과값
결측치 확인
Empty DataFrame
위 과정이 끝났다고 생각을 하여서 내가 예측하고자 하는 game_price의 class들의 비중을 확인해 보았다.
# # Data balance 확인 ( price의 비중을 시각화해서 확인해 보인다 )
sb.countplot(x=Y_NAME, data=full_dataframe)
plt.show()
결과값
시각화를 하였는데 정확한 수치를 알 수 없었기 때문에 수치로 알아보고자 다음 코드로 확인해 보았다.
# # Data balance 확인2 ( 카운트별로 갯수와 비중확인 )
labels_count = dict(game_price=0)
labels_count2 = {}
#
count = []
total = 0
print(labels_count)
print(*np.unique(full_dataframe[Y_NAME], return_counts=True))
for label in full_dataframe[Y_NAME].values:
if label in labels_count2:
labels_count2[label] +=1
else:
labels_count2[label] =1
for count in labels_count2.values():
total += count
print(total)
for label in labels_count2.items():
print("{0: <15} 개수:{1}개\t데이터비중:{2:.3f}".format(*label, label[1]/total))
del labels_count2
위 코드는 game_price의 각 값에 따른 데이터비중을 수치화로 나타내 본 것이다.
결과값은 다음과 같았다.
0 개수:3678개 데이터비중:0.126
2999 개수:383개 데이터비중:0.013
999 개수:3767개 데이터비중:0.129
499 개수:3432개 데이터비중:0.117
1999 개수:1461개 데이터비중:0.050
3959 개수:2개 데이터비중:0.000
1499 개수:1648개 데이터비중:0.056
799 개수:812개 데이터비중:0.028
3499 개수:49개 데이터비중:0.002
299 개수:1877개 데이터비중:0.064
399 개수:1514개 데이터비중:0.052
1299 개수:381개 데이터비중:0.013
2499 개수:283개 데이터비중:0.010
위 결과값을 통해서 각 game_price의 각각의 값들의 데이터비중을 알 수 있었다
데이터의 비중을 확인하였고, Resampling을 하다가 잘 해결되지 않아서 Resampling은 진행하지 않았다.
그리고 feature selection 을 통해서 내게 주어진 데이터셋중 어떤 것을 택해서 해야할지 고민을 해보았다.
Feature_selection도 종류가 다양했는데 나는 다 해보았다.
각각의 feature_selection을 확인해 본다.
Feature_selection(1)
# Feature selection with correlation and random forest classificatio (1)
f,ax = plt.subplots(figsize=(18,18))
sns.heatmap(full_dataframe.corr(), annot=True, linewidths=.5, fmt='.1f',ax=ax)
plt.show()
결과값
데이터의 비중을 눈으로 쉽게 확인할 수 있었다.
눈으로 확인이 되었으니까 수치로 보고싶었다.
다음 코드를 통해서 수치를 확인했다.
# split data train 70% and test 30%
# X_train, X_test, y_train, y_test = train_test_split(full_dataframe, full_dataframe[Y_NAME], test_size=0.3, random_state=42)
# random forest clssifier with n_estimators=10 (default)
clf_rf = RandomForestClassifier(random_state=43)
clr_rf = clf_rf.fit(X_train,y_train)
ac = accuracy_score(y_test,clf_rf.predict(X_test))
print("random forest clssifier")
print('Accuracy is: ',ac)
RandomForestClassifier를 통해서 정확도를 다음처럼 구할 수 있었다.
결과값
random forest clssifier
Accuracy is: 0.9783894449499545
높은 점수처럼 보이지만, 썩 신뢰가 가진 않는다.
그래서 다른 feature selection을 해보았다.
feature_selection(2)
# Univariate feature selection and random forest classification (2)
# find best scored 5 features
select_feature = SelectKBest(chi2, k=5).fit(X_train, y_train)
print("find best scored 5 features")
print('Score list : ', select_feature.scores_)
print('Feature list : ', X_train.columns)
# best 5 features
x_train2 = select_feature.transform(X_train)
x_test2 = select_feature.transform(X_test)
# random forest classifier with n_estimators=10 (default)
clf_rf_2 = RandomForestClassifier()
clr_rf_2 = clf_rf_2.fit(x_train2,y_train)
ac_2 = accuracy_score(y_test,clf_rf_2.predict(x_test2))
print("Accuracy is : ", ac_2)cm_2 = confusion_matrix(y_test,clf_rf_2.predict(x_test2))
sns.heatmap(cm_2,annot=True,fmt="d")
plt.show()
결과값
Score list : [4.32081632e+07 2.55317959e+07 2.51462733e+09 3.04421518e+07
3.13432396e+07 6.54490938e+05]
Feature list : Index(['game_positive', 'game_negative', 'game_owners', 'game_price',
'game_initialprice', 'game_discount'],
dtype='object')
Accuracy is : 0.9740673339399454
위 결과값을 통해서 정확도와 feature_list와 score_list를 알 수 있었다.
그렇지만 이정보로는 부족하다.
feature_selection(3)
# Recursive feature elimination (RFE) with random forest ( 3 )
# Create the RFE object and rank each pixel
clf_rf_3 = RandomForestClassifier()
rfe = RFE(estimator=clf_rf_3, n_features_to_select=5, step=1)
rfe = rfe.fit(X_train, y_train)
print("RFE")
print("Chosen best 5 feature by rfe : ", X_train.columns[rfe.support_])
결과값
RFE
Chosen best 5 feature by rfe : Index(['game_positive', 'game_negative', 'game_price', 'game_initialprice',
'game_discount'],
dtype='object')
è By rfe에 의해서 선별되어진 best 5를 알 수 있었다.
feature_selection(4)
# Recursive feature elimination with cross validation and random forest classification ( 4 )
# The "accuracy" scoring is proportional to the number of correct classifications
clf_rf_4 = RandomForestClassifier()
rfecv = RFECV(estimator=clf_rf_4, step=1, cv=5, scoring='accuracy')
rfecv = rfecv.fit(X_train, y_train)
#
print("Recursive feature elimination")
print('Optimal number of features :', rfecv.n_features_)
print('Best features :', X_train.columns[rfecv.support_])
결과값
Recursive feature elimination
Optimal number of features : 1
Best features : Index(['game_price'], dtype='object')
è Recursive feature elimination에 의한 결과값은 game_price 1개가 나왔다.
feature_selection(5)
# Tree based feature selection and random forest classification ( 5 )
clf_rf_5 = RandomForestClassifier()
clr_rf_5 = clf_rf_5.fit(X_train,y_train)
importances = clr_rf_5.feature_importances_
std = np.std([tree.feature_importances_ for tree in clf_rf.estimators_], axis=0)
indices = np.argsort(importances)[::-1]
# Print the feature ranking
print("Feature ranking:")
for f in range(X_train.shape[1]):
print("%d. feature %d (%f)" % (f + 1, indices[f], importances[indices[f]]))
# Plot the feature importances of the forest
print("Plot the feature importance")
plt.figure(1, figsize=(14, 13))
plt.title("Feature importances")
plt.bar(range(X_train.shape[1]), importances[indices],
color="g", yerr=std[indices], align="center")
plt.xticks(range(X_train.shape[1]), X_train.columns[indices], rotation=90)
plt.xlim([-1, X_train.shape[1]])
plt.show()
결과값
Feature ranking:
1. feature 4 (0.498833)
2. feature 3 (0.434810)
3. feature 5 (0.027699)
4. feature 0 (0.018487)
5. feature 1 (0.015815)
6. feature 2 (0.004356)
Plot the feature importance
è 개인적으로 이 feature_selection이 제일 좋았다. 그래프로 찍음으로써 데이터의 중요도를 쉽게 볼 수 있으며 , 수치로도 확인이 가능하기 때문이다.
è game_initialprice가 feature 중요도가 제일 높았다.
Feature_selection은 이렇게 5가지를 해보았으며 마지막 5번이 제일 좋았다. 눈으로 보기 제일 쉽고, 수치로도 나오기 때문이다.
이제 scaling을 해보겠다.
나는 scaling 4가지 ( Minmax,standard,Robust,Normalizer ) 를 다해보았으며 각각을 코드를 통해서 확인해 보겠다.
(1) StandardScaler Code
# (1) StandardScaler code
scaler = StandardScaler()
X_train_scale = scaler.fit_transform(X_train)
print("StandardScaler code")
print('스케일 조정 전 feature Min value : \n {}'.format(X_train.min(axis=0)))
print('스케일 조정 전 feature Max value : \n {}'.format(X_train.max(axis=0)))
print('스케일 조정 후 feature Min value : \n {}'.format(X_train_scale.min(axis=0)))
print('스케일 조정 후 feature Max value : \n {}'.format(X_train_scale.max(axis=0)))
결과값
StandardScaler code
스케일 조정 전 feature Min value :
game_positive 0
game_negative 0
game_owners 10000
game_price 0
game_initialprice 0
game_discount 0
dtype: int64
C:\Users\user\PycharmProjects\machinelearning\venv\lib\site-packages\sklearn\base.py:464: DataConversionWarning: Data with input dtype int32, int64 were all converted to float64 by StandardScaler.
return self.fit(X, **fit_params).transform(X)
스케일 조정 전 feature Max value :
game_positive 2648605
game_negative 487368
game_owners 150000000
game_price 39999
game_initialprice 39999
game_discount 90
dtype: int64
스케일 조정 후 feature Min value :
[-0.04886008 -0.04601326 -0.08081543 -0.71240348 -0.70940402 -0.25357541]
스케일 조정 후 feature Max value :
[124.88592683 100.37860636 116.56060055 37.1192881 34.72217609
5.79918511]
à 위를 통해 스케일 조정 후 값의 변화가 생긴 것을 확인 할 수 있다.
(2) Robustscaler code
# RobustScaler code
scaler = RobustScaler()
X_train_scale2 = scaler.fit_transform(X_train)
print("RobustScaler code")
print('스케일 조정 전 feature Min value : \n {}'.format(X_train.min(axis=0)))
print('스케일 조정 전 feature Max value : \n {}'.format(X_train.max(axis=0)))
print('스케일 조정 후 feature Min value : \n {}'.format(X_train_scale2.min(axis=0)))
print('스케일 조정 후 feature Max value : \n {}'.format(X_train_scale2.max(axis=0)))
결과값
스케일 조정 전 feature Min value :
game_positive 0
game_negative 0
game_owners 10000
game_price 0
game_initialprice 0
game_discount 0
dtype: int64
스케일 조정 전 feature Max value :
game_positive 2648605
game_negative 487368
game_owners 150000000
game_price 39999
game_initialprice 39999
game_discount 90
dtype: int64
스케일 조정 후 feature Min value :
[-0.2 -0.21052632 0. -0.62375 -0.62375 0. ]
스케일 조정 후 feature Max value :
[23031.14782609 12825.26315789 9999.33333333 49.375
49.375 90. ]
(3) Minmaxscaler code
scaler = MinMaxScaler()
X_train_scale3 = scaler.fit_transform(X_train)
print("MinMaxScaler code")
print('스케일 조정 전 features Min value : \n {}'.format(X_train.min(axis=0)))
print('스케일 조정 전 features Max value : \n {}'.format(X_train.max(axis=0)))
print('스케일 조정 후 features Min value : \n {}'.format(X_train_scale3.min(axis=0)))
print('스케일 조정 후 features Max value : \n {}'.format(X_train_scale3.max(axis=0)))
결과값
스케일 조정 전 features Min value :
game_positive 0
game_negative 0
game_owners 10000
game_price 0
game_initialprice 0
game_discount 0
dtype: int64
스케일 조정 전 features Max value :
game_positive 2648605
game_negative 487368
game_owners 150000000
game_price 39999
game_initialprice 39999
game_discount 90
dtype: int64
스케일 조정 후 features Min value :
[0. 0. 0. 0. 0. 0.]
스케일 조정 후 features Max value :
[1. 1. 1. 1. 1. 1.]
(4) Normalizer
scaler = Normalizer()
X_train_scale4 = scaler.fit_transform(X_train)
print("Normalizer code")
print('스케일 조정 전 feature Min value : \n {}'.format(X_train.min(axis=0)))
print('스케일 조정 전 feature Max value : \n {}'.format(X_train.max(axis=0)))
print('스케일 조정 후 feature Min value : \n {}'.format(X_train_scale4.min(axis=0)))
print('스케일 조정 후 feature Max value : \n {}'.format(X_train_scale4.max(axis=0)))
결과값
스일 조정 전 feature Min value :
game_positive 0
game_negative 0
game_owners 10000
game_price 0
game_initialprice 0
game_discount 0
dtype: int64
스일 조정 전 feature Max value :
game_positive 2648605
game_negative 487368
game_owners 150000000
game_price 39999
game_initialprice 39999
game_discount 90
dtype: int64
스일 조정 후 feature Min value :
[0. 0. 0.17408188 0. 0. 0. ]
스일 조정 후 feature Max value :
[0.15103973 0.12033541 1. 0.6963101 0.93654483 0.00898835]
이렇게 각각의 scaling을 적용시켜봄으로써 전과 후의 데이터값의 변화를 살펴 보았다.
SVC모델을 적용시켜서 어떤 scaling이 정확도의 차이가 큰지 확인해 보았다.
svc = SVC()
svc.fit(X_train, y_train)
print("적용전")
print('test accuracy : %3f' %(svc.score(X_test, y_test)))
# # 적용 시킨 후 (1)
scaler_min = StandardScaler()
X_train_scale5 = scaler_min.fit_transform(X_train)
X_test_scale = scaler_min.transform(X_test)
svc.fit(X_train_scale5, y_train)
print("적용후 ")
print('Scaled test accuracy : %.3f' %(svc.score(X_test_scale,y_test)))
내가 가지고 있는 데이터셋에는 StandardScaler가 SVC 모델을 통해 적용시키기 전과 후의 값의 차이가 제일 컸으며 제일 score가 높았다. 그래서 나는 standardScaler를 사용해야 겠다라고 생각하였다.
# MinMaxScaler : 0.640 --> 0.262
# StandardScaler : 0.640 --> 0.932
# RobustScaler : 0.640 --> 0.843
# Normalizer : 0.640 --> 0.294
분석진행도
|
Data 구조 확인 |
100% |
|
Feature_selection |
100% |
|
scaling |
100% |
|
One-hot-encoding |
30% |
|
알고리즘 적용하기 |
0% |
|
추가 Feature 수집하기 |
20% |
앞으로 해야할 작업
1. One-hot-encoding을 적용시켜서 데이터셋에 존재하는 문자열들을 처리한다.
2. 문자열처리가 된다면 문자열처리가 되어진 데이터셋을 기반으로 다시 처음으로 돌아가서 데이터 전처리를 시작한다.
3. 전처리가 처리된다면 알고리즘에 적용해 본다
4. 알고리즘 적용이 끝나고 시간이 남는다면 혹은 결과가 정확하게 나오지 못한다면 feature을 더 모은다.