hyerimir_archive

# KNN 알고리즘의 원리
# 새로운 데이터의 클래스를 해당 데이터와 가장 가까운 k개 데이터들의 클래스로 결정
# k의 선택은 학습의 난이도와 데이터의 개수에 따라 결정되며, 일반적으로는 훈련데이터 개수의 제곱근으로 설정
# 보통 짝수보다는 홀수로 설정

import pandas as pd
from sklearn.model_selection import train_test_split

credit = pd.read_csv('../data/credit_fianl.csv')
X = credit[credit.columns.difference(['credit.rating'])]
y = credit['credit.rating']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, stratify = y, random_state = 48)

import numpy as np
from sklearn.neighbors import KNeighborsClassifier

clf = KNeighborsClassifier() # k = 5 가 default값
clf.fit(X_train, y_train)

y_pred = clf.predict(X_test)

from sklearn.metrics import confusion_matrix, plot_roc_curve, roc_auc_score
confusion_matrix(y_test, y_pred)

plot_roc_curve(clf, X_test, y_test)

roc_auc_score(y_test, clf.predict_proba(X_test)[:,1])

# 최적의 k 찾기
k_range = range(1, 200)
k_scores = []

for k in k_range:
	knn = KNeighborsClassifier(k)
    knn.fit(X_train, y_train)
    scores = roc_auc_score(y_test, knn.predict_proba(X_test)[:, 1])
    k_scores.append(scores.mean())
    
import matplotlib.pyplot as plt
plt.plot(k_range, k_scores)
plt.xlabel('Value of k for KNN')
plt.ylabel('roc_auc_score')
plt.show()

max(k_scores)
k_scores.index(max(k_scores))

# 나이브베이즈 분류
# 베이즈 정리
# 두 확률 변수의 사전 확률과 사후 확률 사이의 관계를 나타내는 정리

# 정규분포 나이브베이즈 : 독립변수가 연속형일때
# 베르누이분포 나이브베이즈 : 독립변수가 이산형일때
# 다항분포 나이브베이즈 : 독립변수가 이산형이 아닌 범주형 변수일때

# 나이브베이즈 분류는 하나의 속성 값을 기준으로 다른 속성이 독립적이라 전제했을 때,
# 해당 속성 값이 클래스 분류에 미치는 영향을 측정

# 베이지안 접근을 선택할 수 있는 두 가지 경우
# 1. 과거의 빈도를 보여주는 데이터가 많지 않거나 자주 일어나지 않는 사건이어서
# 빈도주의적 추론의 사용이 마땅치 않을 때
# 2. 추정의 목적이 모수 자체의 추정보다는 미래의 예측에 있는 경우
# 베이지안 접근은 하나의 추정치를 고집하는 것이 아니라 계속해서 값을 수정하면서 현실적인
# 추정치를 찾아나가기 때문에 예측의 목적에 맞는 방법, 예를 들어 스팸 분류

# GaussianNB
import pandas as pd
from sklearn.model_selection import train_test_split
credit = pd.read_csv('../data/credit_final.csv')
X = credit[credit.columns.difference(['credit.rating'])]
y = credit['credit.rating']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, stratify = y, random_state = 48)
X_train.head()

from sklearn.naive_bayes import GaussianNB
gnb = GaussianNB()
gnb.fit(X_train, y_train)
y_pred = gnb.predict(X_test)
gnb.score(X_test, y_test)

gnb.class_prior_  # 사전확률값

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

confusion_Naive = pd.DataFrame(confusion_matrix(y_test, y_pred))

import matplotlib.pyplot as plt
form sklearn.netrics import plot_roc_curve, roc_auc_score
plot_roc_curve(gnb, X_test, y_test)
plt.show()
roc_auc_score(y_test, gnb.predict_proba(X_test)[:,1])

# BernoulliNB naive bayes
df_t = pd.read_csv('../data/titanic.csv')

# 이산형 변수들만
X = pd.get_dummies(data = df_t[['class', 'sex', 'embark_town']], columns = ['class', 'sex', 'embark_town'])
y = df_t['survived']

from sklearn.naive_bayes import BernoulliNB
bernoulli = BernoulliNB()
bernoulli.fit(X, y)

bernoulli.class_log_prior_

import numpy as np
np.exp(bernoulli.class_log_prior_)

# 1등석, 여성, 셰르부르인 사람의 생존율 예측
X_test = [[1, 0, 0, 0, 1, 1, 0, 0]]
bernoulli.predict_proba(X_test)

# Multinomial naive bayes
from sklearn.naive_bayes import MultinomialNB
import numpy as np

X = np.random.randint(5, size = (6, 100))
y = np.array([1,2,3,4,5,6])

clf = MultinomialNB()
clf.fit(X, y)

np.exp(clf.class_log_prior_)
clf.predict_proba((X[3]])

# 부스팅
# 예측력이 약한 모형들을 결합하여 강한 예측 모형을 만드는 방법
# 붓스트랩을 병렬로 수행하는 배깅과 달리 순차방식으로 학습을 진행
# 훈련 단계에서 알고리즘은 각 결과 모델에 가중치를 할당
# train 데이터에 과적합할 위험 있음

from sklearn.ensemble import AdaBoostRegressor # Ada 부스팅
reg = AdaBoostRegressor()
reg = reg.fit(X_train, y_train)
y_pred = reg.predict(X_test)

reg.get_params()

# train 정확도
reg.score(X_train, y_train)

# test 정확도
reg.score(X_test, y_test)

from sklearn.model_selection import GridSearchCV
param_grid = {'learning_rate' : np.arrange(0.01, 0.1, 0.02)}
model_grid_boost = GridSearchCV(AdaBoostRegressor(), param_grid, cv = 5)
model_grid_boost.fit(X_train, y_train)

model.grid_boost.best_estimator_

model_grid_boost.best_estimator_.score(X_train, y_train)
model_grid_boost.best_estimator_.score(X_test, y_test)

# 변수 중요도 확인해보면, 추출이 골고루 잘 안된다
# 가중치가 극단적으로 부여되었기 때문

# 부스팅 분류
from sklearn.ensemble import AdaBoostClassifier
from xgboost import XGBClassifier

adab = AdaBoostClassifier()
adab.fit(X_train, y_train)

xgb = XGBClassifier(eval_metric = 'mlogloss', use_label_encoder = False)
xgb = xgb.fit(X_train, y_train)

y_pred_adab = adab.predict(X_test)
adab.score(X_train, y_train)
adab.score(X_test, y_test)

y_pred_xgb = xgb.predict(X_test)
xgb.score(X_train, y_train)
xgb.score(X_test, y_test)

# 배깅과 부스팅보다 더 많은 무작위성을 주어 약한 학습기들을 생성한 후 이를 선형 결합하여
# 최종 결합기를 만드는 방법
# 수천 개의 변수를 변수 제거 없이 모델링하므로 정확도 측면에서 좋은 성과를 보임

import pandas as pd
df = pd.read_csv('../data/kc_house_data.csv')
df = df.drop(['id', 'date'], axis = 1)

X = df.drop('price', axis = 1)
y = df['price']

X = pd.get_dummies(data = X, columns = ['waterfront'])

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

from sklearn.ensemble import RandomForestRegressor
reg = RandomForestRegressor(n_estimators=50)
reg = reg.fit(X_train, y_train)

Y_pred = reg.predict(X_test)

# train 정확도
reg.score(X_train, y_train)

# test 정확도
reg.score(X_test, y_test)

# 변수 중요도 확인
import numpy as np
importnaces = pd.DataFrame(np.mean([tree.feature_importances_ for tree in reg.estimators_], axis = 0))
feature_importances = pd.concat([pd.DataFrame(X.columns), importances], axis = 1)
feature_importances.columns = ['col_name', 'feature_importance']
feature_importances = feature_importances.sort_values(by = 'feature_importance', ascending = True)
feature_importances

# 랜덤포레스트 분류
from sklearn.ensemble import RandomForestClassifier
clf = RandomforestClassifier() # default 값은 n_estimators = 100
clf = clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)

# 정확도
clf.score(X_test, y_test)

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

# 정밀도
precision_score(y_test, y_pred)

# 재현율
recall_score(y_test, y_pred)

# f1 스코어
f1_score(y_test, y_pred)

# 오차행렬
pd.DataFrame(confusion_matrix(y_test, y_pred))

import matplotlib.pyplot as plt
from sklearn.metrics import plot_roc_curve

plot_roc_curve(clf, X_test, y_test)
plt.show()

from sklearn.model_selection import RridSearchCV
param_grid = {'max_depth' : range(2,10,2), 'min_samples_leaf' : range(2, 10, 2)}
model_grid_rf = GridSearchCV(RandomForestClassifier(), param_grid, cv = 5)
model_grid_rf.fit(X_train, y_train)

model_grid_rf.best_estimator_.estimators_

import matplotlib.pyplot as plt
from sklearn.metrics import plot_roc_curve
plot_roc_curve(model_grid_rf.best_estimator_, X_test, y_test)
plt.show()

# 앙상블
# 배깅, 부스팅, 랜덤 포레스트가 가장 대표적

# 붓스트랩(Bootstrap)
# 랜덤 샘플링의 일종으로 가설 검증을 하거나 통계 계산을 하기 전에 단순임의복원추출법(중복허용)을
# 적용하여 여러 개의 동일한 크기의 표본 자료를 획득하는 방법

# 배깅(Bagging : Boostrap aggregation)
# 주어진 자료를 모집단으로 생각하여 주어진 자료에서 여러 개의 붓스트랩 자료를 생성하고 각 붓스트랩
# 자료에서 예측 모형을 만든 후 결합하여 최종 예측 모형을 만드는 방법
# 각 붓스트랩에 대해 붓스트래핑 및 모델링 과정이 병렬적으로 수행됨

import pandas as pd
df = pd.read_csv('../data/kc_house_data.csv')
df = df.drop(['id', 'rate'], axis = 1)

X = df.drop('price', axis = 1)
y = df['price']

X = pd.get_dummies(data = X, columns = ['waterfront'])

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

from sklearn.ensemble import BaggingRegressor
model_bag_reg = BaggingRegressor()
model_bag_reg.fit(X_train, y_train)

model_bag_reg.score(X_train, y_train)
model_bag_reg.score(X_test, y_test)

# out of bag 샘플을 활용한 성능 측정
model_bag_reg_oob = BaggingRegressor(n_estimators = 100, oob_score = True)
# 이때 홀드아웃 방법 필요 없음
model_bag_reg_oob.fit(X, y)
model_bag_reg_oob.oob_score_

from sklearn import tree
model_bag_reg.estimators_[0].feature_importances_

# 변수 중요도 확인
import numpy as np
importances = pd.DataFrame(np.mean([ree.feature_importances_ for tree in model_bag_reg.estimators_];axis = 0)
feature_importances = pd.concat([pd.DataFrame(X.columns), importances], axis = 1)
feature_importances.columns = ['col_name', 'feature_importance']

feature_importances = feature_importances.sort_values(by = 'feature_importance', ascending = False).reset_index(drop = True)

import matplotlib.pyplot as plt

plt.barh(feature_importances['col_name'], feature_importances['feature_importance'], align = 'center')
plt.xlabel('feature importance', size = 15)
plt.ylabel('feature', size = 15)
plt.show()

# 배깅(분류)
import pandas as pd
from sklearn.model_selection import train_test_split

credit = pd.read_csv('../data/credit_final.csv')
X = credit[credit.columns.difference(['credit.rating'])]
y = credit[['credit.rating']]

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state = 48)
X_train.head()

from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import BaggingClassifier

clf = BaggingClassifier(base_estimator = DecisionTreeClassifier(), n_estimators = 100,
	max_samples = 1.0, max_features = 1.0)

clf = clf.fit(X_train, y_train)

y_pred = clf.predict(X_test)
clf.score(X_test, y_test)

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

pd.DataFrame(confusion_matrix(y_test, y_pred), index = ['True[0]', 'True[1]'],
	columns = ['pred[0]', 'pred[1]'])

import matplotlib.pyplot as plt
from sklearn.metrics import plot_roc_curve, roc_auc_score

plot_roc_curve(clf, X_test, y_test)
plt.show()

roc_auc_score(y_test, clf.predict_proba(X_test)[:, 1]))

# 각 마디에서 적절한 최적의 분리규칙(splitting rule)을 찾아서 나무를 성장시키는 과정
# 적절한 정지규칙(stopping rule)을 만족하면 중단

# 범주형 목표변수일 때, 지니지수, 엔트로피 지수가 기준값

# 가지치기 단계 : 나무의 크기를 모형의 복잡도로 볼 수 있고, 과적합을 방지하기 위함

import pandas as pd
import numpy as np

credit = pd.read_csv('../data/credit_final.csv')

X = credit.drop(['credit.rating'], axis = 1)
y = credit['credit.rating']

X.info()

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify = y, test_size = 0.3, random_state = 48)

from sklearn.tree import DecisionTreeClassifier
dt_clf = DecisionTreeClassification()
dt_clf.fit(X_train, y_train)
dt_clf.score(X_train, y_train)
dt_clf.score(X_test, y_test)
# 과적합 이루어짐

dt_prediction = dt_clf.predict(X_test)

from sklearn.metrics import confusion_matrix, classification_report, roc_auc_score, plot_roc_curve,
	precision)score, f1_score, recall_score
confusion_matrix(y_test, dt_prediction)

precision_score(y_test, dt_prediction)
recall_score(y_test, dt_prediction)
f1_score(y_test, dt_prediction)

print(classification_report(y_test, dt_prediction))
plot_roc_curve(df_clf, X_test, y_test)

roc_auc_score(y_test, dt_clf.predict_proba(X_test)[:1])

# 가지치기
# 주요 매개변수 조정
dt_clf.get_depth()

from sklearn.model_selection import GridSearchCV
param_grid = {'max_depth' : range(2, 16, 1), 'min_samples_leaf' : range(1, 20, 1)}
model_grid_tree = GridSearch(DecisionTreeClassifier(), param_grid, cv = 5)
model_grid_tree.fit(X_train, y_train)

model_grid_tree.best_estimators_

model_grid_tree.best_score_ # train 기준

model_grid_tree.score(X_test, y_test)
y_pred = model_grid_tree.predict(X_test)

confusion_matrix(y_test, y_pred)
plot_roc_curve(model_grid_tree, X_test, y_test)
roc_auc_score(y_test, model_grid_tree.predict_proba(X_test)[:,1])

# 의사결정나무 - 회귀
# 연속형 목표변수
# 기준값은 분산분석에서 F통계량 혹은 분산의 감소량

import pandas as pd
df = pd.read_csv('../data/kc_house_data.csv')
df = df.drop(['id', 'date'], axis = 1)
X = df.drop('price', axis = 1)
y = df['price']

X.info()
X = pd.get_dummies(data = X, columns = ['wterfront'])

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state = 48)
# y값이 연속형이므로 층화추출 하지 않음

from sklearn.tree import DecisionRegressor
dt_reg = DecisionTreeRegressor()
dt_reg.fit(X_train, y_train)
dt_reg.score(X_train, y_train)
dt_reg.score(X_test, y_test)
# 과적합되었음을 확인

df_reg.get_depth()

from sklearn.model_seletion import GridSearchCV
param_grid = {'max_depth' : range(1, 40, 2), 'min_samples_split' : range(2, 40, 2)}
model_grid_tree = GridSearchCV(DecisionTreeRegressor(), param_grid)
model_grid_tree.fit(X_train, y_train)

model_grid_tree.best_estimator_

model_grid_tree.score(X_train, y_train)
model_grid_tree.score(X_test, y_test)

y_pred = model_grid_tree.predict(X_test)

from sklearn.metrics import mean_squared_error
MSE = mean_squared_error(y_test, y_pred)

import numpy as np
RMSE = np.sqrt(MSE)

# 의사결정나무의 R^2값은 0.69로, 모델이 전체 데이터의 69%를 설명할 수 있음
# RMSE의 값은 202226이므로, 집값의 평균적인 차이는 202226만큼 난다고 할 수 있음

# 의사결정나무 시각화
import matplotlib.pyplot as plt
import seaborn as sns
import graphviz
from IPython.display import Image
import pydot
import pydotplus

from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix, classification_report
from sklearn.tree import DecisionTreeClassifier

import pandas as pd
import numpy as np
import os

from sklearn import datasets
iris = datasets.load_iris()

X = iris.data
y = iris.target

train_x, test_x, train_y, test_y = train_test_split(X, y, stratify = y, test_size = 0.3, random_state = 48)

iris_clf = DecisionTreeClassifier(max_depth = 5)
iris_clf = iris_clf.fit(train_x, train_y)
iris_prediction = iris_clf.predict(test_x)

feature_columns = iris.feature_names

from sklearn import tree
feature_names = feature_columns
target_name = np.array(['0', '1', '2'])

dt_dot_data = tree.export_graphivz(iris_clf, feature_names = feature_names, class_names = target_name,
		filled = True, max_depth = 5)
dt_graph = pydotplus.graph_from_dot_data(dt_dot_data)
Image(dt_graph.create_png())

# gini 지수 값을 0으로 만들어가는 방향으로 전개됨

# 분류 리포트 생성하기
class_reprot_iris = classification_report(test_y, iris_prediction)

from sklearn.metrics import roc_auc_score
iris_clf.predict_proba(test_x)

roc_auc_score(test_y, iris_clf.predict_proba(test_x), multi_class = 'ovr')

# 머신러닝 기법을 이용한 방법
from sklearn.linear_model import LinearRegression

# Ridge, L2 정규화
# Lasso, L1 정규화
# Elastic-net, L1, L2 정규화 혼합

import pandas as pd
import numpy as np
import mglearn
X, y = mglearn.datasets.load_exteded_boston()

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

# ! pip install sklearn
from sklearn.linear_model import LinearRegression
lr = LinearRegression()
lr.fit(X_train, y_train)

# 기울기
lr.coef_

# 절편
lr.intercept_

y_pred = lr.predict(X_test)

resid = y_test - y_pred

lr.score(X_train, y_train)
lr.score(X_test, y_test)

# mse
(resid**2).sum()/len(y_test)

# rmse
np.sqrt((resid**2).sum()/len(y_test))

from sklearn.metrics import mean_squared_error
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
# 과대적합이 되어, 다중공선성 문제가 있을 수 있다고 판단

from statsmodels.stats.outliers_influence import variance_inflation_factor
vif_list = []
for i in range(X_train.shape[1]):
	vif_list.append([variance_inflation_factor(X_train, i])
    
vif_df = pd.DataFrame(vif_list, columns = ['vif'])
vif_df[vif_df['vif'] < 10]

# Ridge, Lasso, Elasticnet 모두 alpha 값에 영향을 받음
# alpha 값 조정을 통해 과대적합 피할 수 있음
# alpha 값이 너무 크면 과소적합이 될 수 있으므로 최적의 값을 찾아야 함

# Ridge
import pandas as pd
import numpy as np
import mglearn
X, y = mglearn.datasets.load_exteded_boston()
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state = 48)

import warnings
warning.filterwarning(action = 'ignore')

from sklearn.linear_model import Ridge
ridge = Ridge() # 여기서 alpha = 1이 디폴트 값
ridge.fit(X_train, y_train)

# 사용한 데이터 컬럼 수
np.sum(ridge.coef_ != 0)
# 훈련 데이터셋 성능
ridge.score(X_train, y_train)
# 테스트 데이터셋 성능
ridge.score(X_test, y_test)

from sklearn.model_selection import GridSearchCV
ridge = Ridge()
param_grid = {'alpha' : (0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.5, 1, 2, 3)}
model = GridSearchCV(ridge, param_grid)
model.fit(X_train, y_train)

model.best_estimators_

model = Ridge(alpha = 0.05)
model.fit(X_train, y_train)

np.sum(model.coef_ != 0)
model.score(X_train, y_train)
model.score(X_test, y_test)

lasso = Lasso()
param_grid = {'alpha' : (0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.5, 1, 2, 3)}
model = GridSearchCV(ridge, param_grid)
model_lasso = model_lasso.fit(X_train, y_train)

model_lasso.best_estimator_

from sklearn.linear_model import Lasso
lasso = Lasso(alpha = 0.002)
lasso.fit(X_train, y_train)

np.sum(lasso.coef_ != 0)
lasso.score(X_trian, y_train)
lasso.score(X_test, y_test)

# Elastic-net
from sklearn.linear_model import ElasticNet

elastic = ElasticNet()
elastic.fit(X_train, y_train)

elastic.score(X_train, y_train)
elastic.score(X_test, y_test)

lasso = Lasso()
param_grid = {'alpha' : (0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.5, 1, 2, 3)}
model = GridSearchCV(ridge, param_grid)
model_lasso = model_lasso.fit(X_train, y_train)

model_lasso.best_estimator_

from sklearn.linear_model import Lasso
lasso = Lasso(alpha = 0.002)
lasso.fit(X_train, y_train)

np.sum(lasso.coef_ != 0)
lasso.score(X_trian, y_train)
lasso.score(X_test, y_test)

# Auto ARIMA
# 자동으로 SARIMA 분석 수행

import pandas as pd
import matplotlib.pyplot as plt

data = pd.read_csv('../data/arima_data.csv', names = ['day', 'price'])
data['day'] = pd.to_datetime(data['day'], format = '%Y-%m-%d')
data.set_index('day', inplace = True)
s_data = data

# 패키지 설치
! pip install pmdarima

train_len = int(len(s_data)*0.8)
training = s_data[:train_len]
test = s_data.drop(training.index)

from pmdarima import auto_arima
# 1-5까지 그리드서치
auto_model = auto_arima(training, start_P = 1, D = 1, Q = 1, max_P = 5, max_D = 5, max_Q = 5, m=12,
	seasonal = True, information_criterion = 'aic', trace = True, stepwise = True)
    
auto_model.summary()

prediction = pd.DataFrame(auto_model.predict(n_periods=len(test)), index = test.index)
prediction.columns = ['predicted_price']

plt.figure(figsize = (10, 6))
plt.plot(training, label = 'Train')
plt.plot(prediction, label = 'Prediction')
plt.plot(test, label = 'Test')
plt.legend(loc = 'upper left')
plt.show()

from sklearn.metrics import r2_score, mean_squared_error
test['predicted_price'] = prediction
r2_score(test['price'], test['prediced_price'])

import numpy as np
import math
rmse = np.sqrt(mean_squared_error(test['price'], test['predicted_price']))
rmse

len(test['price']

# 결과해석
# 시계열 데이터 분석 결과, 1년 주기의 계절성을 가지고 있음을 확인
# 우상향하는 추세를 가지고 있음
# 추세를 가지고 있기에 1차 차분
# 계절성을 가지고 있으므로 예측 모형은 SARIMA를 사용하였음