[Scikit learn] 머신러닝 기초 잡기 - 2. 머신러닝

 

https://prlabhotelshoe.tistory.com/44

[Scikit learn] 머신러닝 기초 잡기 - 1. 데이터 분석

지난 챕터에 이어 본격적으로 skikit learn을 활용한 심화된 통계분석 및 머신러닝을 해본다.

---

# 0_데이터셋 로드

import pandas as pd
import numpy as np
filename = 'diabetes.csv'

data = pd.read_csv(filename)
data.columns = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
array = data.values # pandas frame을 numpy array 형태로 변환

마찬가지로 데이터셋을 로드한다. 출력은 생략

 

# 1_심화통계분석

# 1-1_SelectKBest

타겟 변수와 그외 변수 사이의 상관관계를 계산하여 가장 상관관계가 높은 변수 k개를 선정

from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2
X = array[:, 0:8]
Y = array[:,-1]
test = SelectKBest(score_func = chi2, k=4) # 카이제곱검정 적용, 자유도 4
fit = test.fit(X,Y)
np.set_printoptions(precision=3)
print(fit.scores_)
print('---------------------------------------------------------------------------')
features = fit.transform(X)
print(features[0:5,:])

SelectKBest

사실 카이제곱검정에 대한 개념이 완전히 이해되진 않았다..

직관적으로 느낀바로는 해당 수치가 class(Y)와 얼마나 연관이 있는지에 대한 정도를 나타낸 듯 하다.

 

# 1-2_PCA

PCA(Principal Component Analysis, 주성분분석)

이 역시도 잘 이해되진 않았지만, 이해한 바로는 변수간의 상관관계를 '축약'해서 나타내는 듯 하다.

(여러 참고자료를 보았으나 https://m.blog.naver.com/tjdrud1323/221720259834 해당 블로그가 가장 잘 이해되었다.)

from sklearn.decomposition import PCA
X = array[:, 0:8]
Y = array[:,-1]

pca = PCA(n_components=3) # 주성분 개수 = 3
fit = pca.fit_transform(X)
pcaDF = pd.DataFrame(data = fit, columns = ['pc1', 'pc2', 'pc3'])

print(pcaDF.head(5))

PCA

 

# 2_머신러닝

# 2-1_feature_importances

각 머신러닝 알고리즘을 통해 컬럼별 중요도를 나타내본다.

 

a) RandomForestClassifier

from sklearn.ensemble import RandomForestClassifier

X = array[:, 0:8]
Y = array[:,-1]

model = RandomForestClassifier(n_estimators=100) # 트리 개수 = 100
model.fit(X,Y)
print(model.feature_importances_)

 

b) ExtraTreesClassifier

from sklearn.ensemble import ExtraTreesClassifier

X = array[:, 0:8]
Y = array[:,-1]

model = ExtraTreesClassifier()
model.fit(X,Y)
print(model.feature_importances_)

적용된 알고리즘의 경우 모두 Glucose 컬럼에 대해 가장 큰 중요도를 출력한다.

 

# 2-2_Machine Learning

a) LogisticRegression

(LogisticRegression, 로지스틱 회귀): 회귀를 사용하여 데이터가 어떤 범주에 속할 확률을 0에서 1 사이의 값으로 예측하고 그 확률에 따라 가능성이 더 높은 범주에 속하는 것으로 분류해주는 지도 학습 알고리즘.

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from time import time

X = array[:, 0:8]
Y = array[:, -1]

X_train, X_test, Y_train, Y_test = train_test_split(X,Y, test_size = 0.2, random_state = 42)
model = LogisticRegression(max_iter = 1000) # 1000번 반복
start = time()
model.fit(X_train, Y_train)
end = time()
result = model.score(X_test,Y_test)
print("Time: %.3f" % (end-start), "Accuracy: %.3f%%" %(result*100))
print(model.fit(X_train, Y_train))

LogisticRegression

 

b) LogisticRegression + k-fold 적용

k-fold 검증을 통해 5번 검증하도록 한다.

from sklearn.model_selection import KFold
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score

k = 5

kf = KFold(n_splits=k, random_state=None, shuffle = False)
model=LogisticRegression(max_iter=1000)
start = time()
result = cross_val_score(model, X, Y, cv = kf)
end = time()
print(result)
print("Time: %.3f" % (end-start), "Accuracy: %.3f%%" % (result.mean()*100), "STD: %.3f%%" % (result.std()*100))

LogisticRegression

 

c) LogisticRegression + roc_auc + confusion matrix + classification_report

roc_auc를 통해 검증 및 classification_report를 활용하여 f1-score등 출력

(*roc_auc: roc curve의 area under the curve를 의미. 숫자가 클수록 예측을 더 잘하는 모델임을 나타냄. 타깃이 되는 특성의 클래스 레이블 분포가 불균형할 때, accuracy의 단점을 보완하면서, decision boundary에 덜 민감하게 안정적으로 label을 더 잘 분류-예측할 수 있다는 장점이 있음)

from sklearn.metrics import accuracy_score
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split
from sklearn import metrics

X = array[:, 0:8]
Y = array[:, -1]

X_train, X_test, Y_train, Y_test = train_test_split(X,Y, test_size = 0.2, random_state = 42)

model = LogisticRegression(max_iter = 1000)
model.fit(X_train, Y_train)
predicted = model.predict(X_test)
matrix = confusion_matrix(Y_test, predicted)
print(matrix)
print('---------------------------------------------------------------------------')
print("Accuracy: %.3f" % accuracy_score(Y_test, predicted))
print('---------------------------------------------------------------------------')

result = cross_val_score(model, X, Y, scoring = 'roc_auc')
print(result)
print('---------------------------------------------------------------------------')
print("AUC: %.3f" % (result.mean()), "STD: %.3f" % (result.std()))
print('---------------------------------------------------------------------------')
report = classification_report(Y_test, predicted)
print(report)

LogisticRegression

 

 

# 2-3_Machine Learning 추가 알고리즘

a) LDA

LDA(LinearDiscriminantAnalysis, 선형 판별 분석): Classification(분류모델)과 Dimensional Reduction(차원 축소)까지 동시에 사용하는 알고리즘.

from sklearn.model_selection import KFold
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis

X = array[:, 0:8]
Y = array[:, -1]

k = 5
kf= KFold(n_splits=k, random_state=None, shuffle=False) # k-fold 5겹 적용
model=LinearDiscriminantAnalysis()
start = time()
result = cross_val_score(model, X, Y, cv = kf)
end = time()
print(result)
print("Time: %.3f" % (end-start), \
      "Accuracy: %.3f" % (result.mean()), \
      "STD: %.3f" % (result.std()))

LDA

 

b) KNeighborsClassifier

(KNeighborsClassifier, k-최근접 이웃): 유사한 특징을 가진 데이터는 유사한 범주에 속하는 경향이 있다는 가정하에, 가장 가까운 훈련 데이터 하나를 최근접 이웃으로 찾아 예측에 사용.

from warnings import simplefilter
simplefilter(action='ignore', category=FutureWarning)
from sklearn.model_selection import KFold
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import cross_val_score

X = array[:, 0:8]
Y = array[:, -1]

k = 5
kf= KFold(n_splits=k, random_state=None, shuffle=False) # k-fold 5겹 적용
model= KNeighborsClassifier(n_neighbors = 5) # 이웃 5개로 설정
start = time()
result = cross_val_score(model, X, Y, cv = kf)
end = time()
print(result)
print("Time: %.3f" % (end-start), \
      "Accuracy: %.3f" % (result.mean()), \
      "STD: %.3f" % (result.std()))

KNeighborsClassifier

 

c) GaussianNB

 나이브 베이즈 분류는 대표적으로 2가지 경우가 있음.
 1. 설명변수가 연속형 변수일 때, Gaussian Naive Bayes (가우시안 나이브 베이즈)
 2. 설명변수가 범주형 변수일 때, Multinomial Naive Bayes (다항 나이브 베이즈) 

from sklearn.model_selection import KFold
from sklearn.naive_bayes import GaussianNB
from sklearn.model_selection import cross_val_score
X = array[:, 0:8]
Y = array[:, -1]

k = 5
kf= KFold(n_splits=k, random_state=None, shuffle=False) # k-fold 5겹 적용
model= GaussianNB() 
start = time()
result = cross_val_score(model, X, Y, cv = kf)
end = time()
print(result)
print("Time: %.3f" % (end-start), \
      "Accuracy: %.3f" % (result.mean()), \
      "STD: %.3f" % (result.std()))

GaussianNB

 

d) SVM

SVM(Support Vector Machine, 서포트 벡터 머신): 결정 경계(Decision Boundary), 즉 분류를 위한 기준 선을 정의하는 모델. 분류되지 않은 새로운 포인트가 나타나면 경계의 어느 쪽에 속하는지 확인해서 분류를 수행.

 

(*kernel? 선형으로 분리 할 수 없는 데이터에 대해 설정해주는 옵션이라 이해함..)

linear: 선형 값

polynomial: 2차원 값들을 3차원 값들로 변환하여 초평면을 찾는?

rbf(Radial Bias Function, 방사 기저 함수): 고차원

from sklearn.model_selection import KFold
from sklearn.svm import SVC
from sklearn.model_selection import cross_val_score
X = array[:, 0:8]
Y = array[:, -1]

k = 5
kf= KFold(n_splits=k, random_state=None, shuffle=False)
model= SVC(kernel='rbf') #kernel: linear, rbf, polynomial
start = time()
result = cross_val_score(model, X, Y, cv = kf)
end = time()
print(result)
print("Time: %.3f" % (end-start), \
      "Accuracy: %.3f" % (result.mean()), \
      "STD: %.3f" % (result.std()))

 

e) 알고리즘 별 전체 출력

from sklearn.linear_model import LogisticRegression
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import cross_val_score

X = array[:, 0:8]
Y = array[:, -1]

k = 5

models = []
models.append(('LR', LogisticRegression(max_iter=1000)))
models.append(('LDA', LinearDiscriminantAnalysis()) )
models.append(('KNN', KNeighborsClassifier(n_neighbors = 5)) )
models.append(('NB', GaussianNB()))
models.append(('SVM', SVC(kernel = 'rbf')))
models.append(('CART', DecisionTreeClassifier()))

results = []
names = []
scoring = 'accuracy'

for name, model in models:
    kf = KFold(n_splits = k, random_state=None, shuffle=False)
    result = cross_val_score(model, X, Y, cv = kf)
    results.append(result)
    names.append(name)
    msg = "%s: %f (%f)" % (name, result.mean(), result.std())
    print(msg)

결과적으로 보면 로지스틱 회귀가 가장 높은 값을 출력한다.