실습) adult data 분류

# 인구 조사 자료를 바탕으로 소득이 $ 50,000 / 년을 초과하는지 예측합니다
import pandas as pd
import numpy as np
import seaborn as sns
names=['age','workclass', 'fnlwgt', 'education', 'education-num', 'marital-status', 'occupation', 'relationship', 'race', 'sex', 'capital-gain', 'capital-loss', 'hours-per-week', 'native-country','target']
df_adult = pd.read_csv('adult.data.csv',names=names)
df_adult.head(5)

df_adult.shape  # 데이터 모양 파악

(32561, 15)

df_adult.info() # 데이터 정보 확인

#5만 달러 넘는 비율 찾기
print(df_adult['target'].value_counts())   

print()
print("%.2f" %(7841/32561*100))
# 5만 달러 넘는 비율

<=50K 24720

>50K 7841

Name: target, dtype: int64

24.08

df['income'] = df['income'].str.strip().replace({'<=50K': 0, '>50K': 1})

# replace()로 데이터 값 중에 ? 값 => nan 으로 바꿔주기
df_adult.replace(' ?',np.nan, inplace=True)
df_adult.isna().sum()

# dropna() 로 nan 값 없애주기
df_adult=df_adult.dropna(axis=0)
df_adult.isna().sum()

# 인덱스를 새로 배정
df_adult=df_adult.reset_index(inplace=False,drop=True)
df_adult.head(5)

df_adult.shape

(30162, 15)

# fnlwgt 컬럼은 필요없다고 판단하여 제거
# marital-status, relationship 별로 상관업는 거 같은데 영향력이 커서   제거하고 해보기로함.

df_adult.drop(['fnlwgt','marital-status','relationship'],axis=1,inplace=True)
df_adult.shape

(30162, 12)

# 레이블 인코더 사용해서 문자열=> 숫자
from sklearn.preprocessing import LabelEncoder

col=names=['workclass','education','occupation',  'race', 'sex', 'native-country','target']
le=LabelEncoder()
for k in col:
    df_adult[k]=le.fit_transform(df_adult[k])

df_adult.head()

# 데이터 비율 맞춰주기 위해  StandardScaler 적용
from sklearn.preprocessing import StandardScaler
Xdf=df_adult.loc[:,'age':'native-country']
ydf=df_adult.loc[:,'target']

scaler = StandardScaler()
scaler.fit(Xdf)
adult_scaled = scaler.transform(Xdf)

names=['age','workclass',  'education', 'education-num', 'occupation',  'race', 'sex', 'capital-gain', 'capital-loss', 'hours-per-week', 'native-country']
df_adult=pd.DataFrame(data=adult_scaled,columns=names)
df_adult.head()

df_adult['target']=ydf
df_adult.head()

X=df_adult.loc[:,'age':'native-country']
y=df_adult.loc[:,'target']

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

from sklearn.metrics import confusion_matrix, accuracy_score
from sklearn.metrics import precision_score, recall_score
from sklearn.metrics import f1_score, roc_auc_score

# 배웠던 평가지표를 구현하는 함수
def get_clf_eval(y_test , pred):
    confusion = confusion_matrix( y_test, pred)
    accuracy = accuracy_score(y_test , pred)
    precision = precision_score(y_test , pred)
    recall = recall_score(y_test , pred)
    f1 = f1_score(y_test,pred)
    roc_auc = roc_auc_score(y_test, pred)
    print('오차 행렬')
    print(confusion)
    print('정확도: {0:.4f}, 정밀도: {1:.4f}, 재현율: {2:.4f},\\
    F1: {3:.4f}, AUC:{4:.4f}'.format(accuracy, precision, recall, f1, roc_auc))

# KNN
from sklearn.neighbors import KNeighborsClassifier
clf = KNeighborsClassifier(n_neighbors=13)
clf.fit(X_train, y_train)
print("훈련 세트 정확도: {:.3f}".format(clf.score(X_train, y_train)))
print("테스트 세트 정확도: {:.3f}".format(clf.score(X_test, y_test)))
print()
pred=clf.predict(X_test)
get_clf_eval(y_test , pred)

훈련 세트 정확도: 0.841

테스트 세트 정확도: 0.809

오차 행렬

[[5187 452]

[ 990 912]]

정확도: 0.8088, 정밀도: 0.6686, 재현율: 0.4795, F1: 0.5585, AUC:0.6997

#SVM
from sklearn import svm
clf=svm.SVC(gamma=0.01,C=50.)
clf.fit(X_train,y_train)

print("훈련 세트 정확도: {:.3f}".format(clf.score(X_train, y_train)))
print("테스트 세트 정확도: {:.3f}".format(clf.score(X_test, y_test)))

print()
pred=clf.predict(X_test)
get_clf_eval(y_test , pred)

훈련 세트 정확도: 0.831

테스트 세트 정확도: 0.821

오차 행렬

[[5369 270]

[1079 823]]

정확도: 0.8211, 정밀도: 0.7530, 재현율: 0.4327, F1: 0.5496, AUC:0.6924

#로지스틱 회귀
from sklearn.linear_model import LogisticRegression

clf = LogisticRegression(C=0.1,max_iter=5000).fit(X_train, y_train)
print("훈련 세트 점수: {:.3f}".format(clf.score(X_train, y_train)))
print("테스트 세트 점수: {:.3f}".format(clf.score(X_test, y_test)))

print()
pred=clf.predict(X_test)
get_clf_eval(y_test , pred)

훈련 세트 점수: 0.821

테스트 세트 점수: 0.812

오차 행렬

[[5306 333]

[1086 816]]

정확도: 0.8118, 정밀도: 0.7102, 재현율: 0.4290, F1: 0.5349, AUC:0.6850

#결정트리분류기
from sklearn.tree import DecisionTreeClassifier

clf=DecisionTreeClassifier(max_depth=8)
clf.fit(X_train,y_train)

print("훈련 세트 정확도: {:.3f}".format(clf.score(X_train, y_train)))
print("테스트 세트 정확도: {:.3f}".format(clf.score(X_test, y_test)))
print()
pred=clf.predict(X_test)
get_clf_eval(y_test , pred)

훈련 세트 정확도: 0.845

테스트 세트 정확도: 0.831

오차 행렬

[[5412 227]

[1048 854]]

정확도: 0.8309, 정밀도: 0.7900, 재현율: 0.4490, F1: 0.5726, AUC:0.7044

import seaborn as sns
import numpy as np
%matplotlib inline
# feature importance 추출
print("Feature importances:\\n{0}".format(np.round(clf.feature_importances_,
3)))
# feature별 importance 매핑
for name, value in zip(names , clf.feature_importances_):
    print('{0} : {1:.3f}'.format(name, value))
# feature importance를 column 별로 시각화 하기
sns.barplot(x=clf.feature_importances_ , y=names)

#랜덤포레스트
from sklearn.ensemble import RandomForestClassifier

# 최적의 파라메타 찾기 GridSearchCV
from sklearn.model_selection import GridSearchCV

params = {
    'n_estimators':[100,300],
    'max_depth' : [10, 12,14,16], 
    'min_samples_leaf' : [4, 6, 8,10],
    'min_samples_split' : [8,10,12,14]
}
# RandomForestClassifier 객체 생성 후 GridSearchCV 수행
clf = RandomForestClassifier(random_state=0, n_jobs=-1)
grid_cv = GridSearchCV(clf , param_grid=params , cv=2, n_jobs=-1 )
grid_cv.fit(X_train , y_train)

print('최적 하이퍼 파라미터:\\n', grid_cv.best_params_)
print('최고 예측 정확도: {0:.4f}'.format(grid_cv.best_score_))

최적 하이퍼 파라미터:

{'max_depth': 10, 'min_samples_leaf': 4, 'min_samples_split': 10, 'n_estimators': 300}

최고 예측 정확도: 0.8421

#랜덤포레스트
from sklearn.ensemble import RandomForestClassifier

clf=RandomForestClassifier(max_depth=10, min_samples_leaf=4, min_samples_split=10, n_estimators=300)
clf.fit(X_train,y_train)

print("훈련 세트 정확도: {:.3f}".format(clf.score(X_train, y_train)))
print("테스트 세트 정확도: {:.3f}".format(clf.score(X_test, y_test)))
print()
pred=clf.predict(X_test)
get_clf_eval(y_test , pred)

훈련 세트 정확도: 0.849

테스트 세트 정확도: 0.836

오차 행렬

[[5394 245]

[ 995 907]]

정확도: 0.8356, 정밀도: 0.7873, 재현율: 0.4769, F1: 0.5940, AUC:0.7167

import seaborn as sns
import numpy as np
%matplotlib inline
# feature importance 추출
print("Feature importances:\\n{0}".format(np.round(clf.feature_importances_,
3)))
# feature별 importance 매핑
for name, value in zip(names , clf.feature_importances_):
    print('{0} : {1:.3f}'.format(name, value))
# feature importance를 column 별로 시각화 하기
sns.barplot(x=clf.feature_importances_ , y=names)

#adaboost
from sklearn.ensemble import AdaBoostClassifier
clf=AdaBoostClassifier()
clf.fit(X_train,y_train)

print("훈련 세트 정확도: {:.3f}".format(clf.score(X_train, y_train)))
print("테스트 세트 정확도: {:.3f}".format(clf.score(X_test, y_test)))
print()
pred=clf.predict(X_test)
get_clf_eval(y_test , pred)

훈련 세트 정확도: 0.846

테스트 세트 정확도: 0.837

오차 행렬

[[5323 316]

[ 911 991]]

정확도: 0.8373, 정밀도: 0.7582, 재현율: 0.5210, F1: 0.6176, AUC:0.7325

#GBM
from sklearn.ensemble import GradientBoostingClassifier

clf=GradientBoostingClassifier(n_estimators=500,learning_rate=0.1)
clf.fit(X_train,y_train)

print("훈련 세트 정확도: {:.3f}".format(clf.score(X_train, y_train)))
print("테스트 세트 정확도: {:.3f}".format(clf.score(X_test, y_test)))
print()
pred=clf.predict(X_test)
get_clf_eval(y_test , pred)