04. 머신러닝 핵심 알고리즘 (1)

---

출처 : https://book.naver.com/bookdb/book_detail.nhn?bid=21488029 

공개적 빅데이터분석기사 실기

*해당 글은 학습을 목적으로 위의 도서 내용 중 일부 내용만을 요약하여 작성한 포스팅입니다.

 상세 내용 및 전체 내용 확인을 원하신다면 도서 구매를 추천드립니다.

---

 

로지스틱 회귀모델

• 로지스틱 회귀분석은 종속변수가 범주형 자료일 경우 적용하는 회귀모델이다.
• 로지스틱 회귀모델은 sklearn 패키지 내 linear_model 내부에 포함되어 있다.
• 여러 파라미터들이 존재하지만 주요 하이퍼 파라미터는 C와 solver가 있다.
• C는 작을수록 모델이 단순해지고, 높을수록 모델이 복잡해진다.
• solver은 데이터양에 따른 연산 속도와 관련된 주요 하이퍼파라미터이다. 데이터가 많을 경우 solver='sag' 옵션으로 평균경사하강법을 사용하는 것이 좋다.
• 로지스틱 회귀 모델의 실습은 다음 링크 내에서 다운로드 가능한 breast-cancer-wisconsin.csv 데이터를 활용한다.

import warnings
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler

warnings.filterwarnings('ignore')

data = pd.read_csv('/breast-cancer-wisconsin.csv', encoding='utf-8')
x = data[data.columns[1:10]]
y = data[["Class"]]

x_train, x_test, y_train, y_test = train_test_split(x, y, stratify=y, random_state = 42)

mmScaler = MinMaxScaler()
mmScaler.fit(x_train)

x_train = mmScaler.transform(x_train)
x_test = mmScaler.transform(x_test)

• 로지스틱 회귀모델의 최적 파라미터인 C를 찾기 위해 그리드 탐색법을 활용하여 최적의 C를 찾아낸후 학습을 진행한다.

from sklearn.model_selection import GridSearchCV
from sklearn.linear_model import LogisticRegression

param_grid = {'C' : [0.001, 0.01, 0.1, 1, 10, 100]}
gSearch = GridSearchCV(LogisticRegression(), param_grid, cv=5)

gSearch.fit(x_train, y_train)
bestC = gSearch.best_params_['C']

model = LogisticRegression(C=bestC)

model.fit(x_train, y_train)

print('Train Result:', model.score(x_train, y_train))
print('Test Result:', model.score(x_test, y_test))

• 학습, 테스트 결과 모두 좋은 결과를 보여준다.
• 추가로 오차행렬과 정밀도, 재현율 등도 확인한다.

from sklearn.metrics import confusion_matrix, classification_report

y_pred = model.predict(x_test)

confusion_test = confusion_matrix(y_test, y_pred)
print('오차행렬:\n', confusion_test)

cfReport = classification_report(y_test, y_pred)
print('분류 예측 레포트:\n', cfReport)

• 정밀도와 재현율 모두 준수한 수치를 보여주고 있음을 확인할 수 있다.

 

 

KNN (K-최근접이웃법)

• KNN은 각 데이터 간 거리를 측정하여 가까운 K개의 다른 데이터의 레이블을 참조하여 분류하는 방법이다.
• 거리는 주로 유클리디안 방법 혹은 민코브스키 방법을 사용한다.
• 중요한 하이퍼파라미터는 K(n_neighbors)로 몇 개의 케이스들을 기준으로 동일 범주, 값을 분류 혹은 예측할 것인가를 의미하고, 디폴트는 5이다.
• K는 일반적으로 3~10 범위 내에서 찾는다.
• K가 작을수록 과적합 문제가 발생할 수 있고, 클수록 과소적합 문제가 발생할 수 있으니 유의해야 한다.
• KNN은 sklearn 패키지의 neighbors 라이브러리 내 KNeighborsClassifier 혹은 KNeighborsRegressor을 사용한다.
• 분류와 회귀용 라이브러리가 전부 있어 상황에 따라 적용하면 된다.

import warnings
import pandas as pd
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import MinMaxScaler
from sklearn.neighbors import KNeighborsClassifier

warnings.filterwarnings('ignore')

# 분류

data = pd.read_csv('/breast-cancer-wisconsin.csv', encoding='utf-8')
x = data[data.columns[1:10]]
y = data[["Class"]]

x_train, x_test, y_train, y_test = train_test_split(x, y, stratify=y, random_state = 42)

mmScaler = MinMaxScaler()
mmScaler.fit(x_train)

x_train = mmScaler.transform(x_train)
x_test = mmScaler.transform(x_test)

param_grid = {'n_neighbors': [3, 4, 5, 6, 7, 8, 9, 10]}
gSearch = GridSearchCV(KNeighborsClassifier(), param_grid, cv=5)

gSearch.fit(x_train, y_train)
best_n = gSearch.best_params_['n_neighbors']

model = KNeighborsClassifier(n_neighbors=best_n)
model.fit(x_train, y_train)

print('분류')
print('Train Result:\t', model.score(x_train, y_train))
print('Test Result:\t', model.score(x_test, y_test))

print('====================')

from sklearn.neighbors import KNeighborsRegressor

data = pd.read_csv('/house_price.csv', encoding='utf-8')
data.dropna(inplace=True)

x = data[data.columns[1:5]]
y = data[["house_value"]]

x_train, x_test, y_train, y_test = train_test_split(x, y, random_state = 42)

mmScaler = MinMaxScaler()
mmScaler.fit(x_train)

x_train = mmScaler.transform(x_train)
x_test = mmScaler.transform(x_test)

param_grid = {'n_neighbors': [3, 4, 5, 6, 7, 8, 9, 10]}
gSearch = GridSearchCV(KNeighborsRegressor(), param_grid, cv=5)

gSearch.fit(x_train, y_train)
best_n = gSearch.best_params_['n_neighbors']

model = KNeighborsRegressor(n_neighbors=best_n)
model.fit(x_train, y_train)

print('회귀')
print('Train Result:\t', model.score(x_train, y_train))
print('Test Result:\t', model.score(x_test, y_test))

 

 

 

나이브 베이즈

• 나이브베이즈란 사건 B가 주어졌을 때 사건 A가 일어날 확률인 P(A|B), 조건부 확률, 베이즈 정리를 이용한 알고리즘이다.
• 나이브란 예측에 사용되는 특성치(X)가 상호 독립적이라는 가정하에 확률 계산을 단순화하기 위해 나이브(단순, 순진한 가정)이라고 이름이 붙여진 것이다.
• 모든 특성치들이 레이블을 분류/예측하는 데 동등한 역할을 한다는 의미이고, 베이즈는 특성치(X)가 클래스 전체의 확률 분포에 대비하여 특정 클래스에 속할 확률을 베이즈 정리를 기반으로 계산한 것이다.
• 파이썬에서의 나이브 베이즈는 sklearn.naive_bayes에 있으며, GaussianNB 라이브러리가 분류 문제에 주로 사용된다.
• 주요 하이퍼 파라미터로는 var_smoothing이 있으며, 디폴트는 0.000000001이며 안정적인 연산을 위해 분산에 더해지는 모든 특성치의 최대 분산 비율이다.
• 회귀 문제에는 sklearn.linear_model의 BaysianRidge가 사용되며, 주요 하이퍼 파라미터는 alpha_1과 lambda_1이 있다.
• alpha_1은 감마분포의 알파 파라미터 사전 설정이고, lambda_1은 감마분포의 람다 파라미터 사전 설정이다. 두 파라미터 모두 디폴트는 1e-6이다.

import warnings
import pandas as pd
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import MinMaxScaler
from sklearn.naive_bayes import GaussianNB

warnings.filterwarnings('ignore')

# 분류

data = pd.read_csv('/breast-cancer-wisconsin.csv', encoding='utf-8')
x = data[data.columns[1:10]]
y = data[["Class"]]

x_train, x_test, y_train, y_test = train_test_split(x, y, stratify=y, random_state = 42)

mmScaler = MinMaxScaler()
mmScaler.fit(x_train)

x_train = mmScaler.transform(x_train)
x_test = mmScaler.transform(x_test)

param_grid = {'var_smoothing': [1e-01, 1e-02, 1e-03, 1e-04, 1e-05, 1e-06, 1e-07, 1e-08, 1e-09]}
gSearch = GridSearchCV(GaussianNB(), param_grid, cv=5)

gSearch.fit(x_train, y_train)
best_v = gSearch.best_params_['var_smoothing']

model = GaussianNB(var_smoothing=best_v)
model.fit(x_train, y_train)

print('분류')
print('Train Result:\t', model.score(x_train, y_train))
print('Test Result:\t', model.score(x_test, y_test))

print('====================')

from sklearn.linear_model import BayesianRidge

data = pd.read_csv('/house_price.csv', encoding='utf-8')
data.dropna(inplace=True)

x = data[data.columns[1:5]]
y = data[["house_value"]]

x_train, x_test, y_train, y_test = train_test_split(x, y, random_state = 42)

mmScaler = MinMaxScaler()
mmScaler.fit(x_train)

x_train = mmScaler.transform(x_train)
x_test = mmScaler.transform(x_test)

param_grid = {'alpha_1': [1e-01, 1e-02, 1e-03, 1e-04, 1e-05, 1e-06, 1e-07, 1e-08, 1e-09], 
              'lambda_1': [1e-01, 1e-02, 1e-03, 1e-04, 1e-05, 1e-06, 1e-07, 1e-08, 1e-09]}
gSearch = GridSearchCV(BayesianRidge(), param_grid, cv=5)

gSearch.fit(x_train, y_train)
best_a = gSearch.best_params_['alpha_1']
best_l = gSearch.best_params_['lambda_1']

model = BayesianRidge(alpha_1=best_a, lambda_1=best_l)
model.fit(x_train, y_train)

print('회귀')
print('Train Result:\t', model.score(x_train, y_train))
print('Test Result:\t', model.score(x_test, y_test))

 

 

 

인공신경망

• 인공신경망은 인간의 뉴런구조와 활성화 작동원리를 근간으로 input과 output과의 연관을 구현한 알고리즘이다.
• 전통적인 알고리즘과 달리 은닉층과 노드들을 깊고 넓게 두어 특성치로부터 분류와 회귀를 더 잘할 수 있도록 특징추출 및 분류 단계를 확장하는 역할을 할 수 있도록 한 모델이다.
• 인공신경망 알고리즘은 sklearn.neural_network 내부에 있다.
• 회귀는 MLPRegressor, 분류는 MLPClassifier을 사용할 수 있다.
• 하이퍼 파라미터는 매우 다양하지만 주요 파라미터는 hidden_layer_sizes (은닉층 수), solver (옵티마이저), activation(활성화함수)가 있다.

import warnings
import pandas as pd
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import MinMaxScaler
from sklearn.neural_network import MLPClassifier

warnings.filterwarnings('ignore')

# 분류

data = pd.read_csv('/breast-cancer-wisconsin.csv', encoding='utf-8')
x = data[data.columns[1:10]]
y = data[["Class"]]

x_train, x_test, y_train, y_test = train_test_split(x, y, stratify=y, random_state = 42)

mmScaler = MinMaxScaler()
mmScaler.fit(x_train)

x_train = mmScaler.transform(x_train)
x_test = mmScaler.transform(x_test)

param_grid = {'hidden_layer_sizes': [10, 30, 50, 100], 
              'solver': ['sgd', 'adam'], 
              'activation': ['tanh', 'relu']}
gSearch = GridSearchCV(MLPClassifier(), param_grid, cv=5)

gSearch.fit(x_train, y_train)
best_p = gSearch.best_params_

model = MLPClassifier(hidden_layer_sizes=best_p['hidden_layer_sizes'], 
                      solver=best_p['solver'], 
                      activation=best_p['activation'])
model.fit(x_train, y_train)

print('분류')
print('Train Result:\t', model.score(x_train, y_train))
print('Test Result:\t', model.score(x_test, y_test))

print('====================')

from sklearn.neural_network import MLPRegressor

data = pd.read_csv('/house_price.csv', encoding='utf-8')
data.dropna(inplace=True)

x = data[data.columns[1:5]]
y = data[["house_value"]]

x_train, x_test, y_train, y_test = train_test_split(x, y, random_state = 42)

mmScaler = MinMaxScaler()
mmScaler.fit(x_train)

x_train = mmScaler.transform(x_train)
x_test = mmScaler.transform(x_test)

# 회귀 모델은 최적 하이퍼 파라미터 탐색이 큰 의미가 없다.
# 64 노드 세 개의 층으로 구성
model = MLPRegressor(hidden_layer_sizes=(64, 64, 64),
                     activation='relu',
                     random_state=1,
                     max_iter=200)
model.fit(x_train, y_train)

print('회귀')
print('Train Result:\t', model.score(x_train, y_train))
print('Test Result:\t', model.score(x_test, y_test))

# RMSE
import numpy as np
from sklearn.metrics import mean_squared_error

y_train_pred = model.predict(x_train)
y_test_pred = model.predict(x_test)

MSE_train = mean_squared_error(y_train, y_train_pred)
MSE_test = mean_squared_error(y_test, y_test_pred)

print('Train MSE:\t', np.sqrt(MSE_train))
print('Test MSE:\t', np.sqrt(MSE_test))

 

 

서포트 벡터 머신 (SVM)

• 레이블 범주를 선형적 혹은 비선형적으로 분류하는 선 혹은 초평면을 찾는 것이 핵심 과제이다.
• SVM은 어떻게 집단을 분류하는 선을 긋는 것이 최선일까가 핵심적인 문제이다.
• 선을 그어 두 집단을 구분한 후 두 집단의 떨어짐 정도를 공간의 여분(margin)이라 부른다.
• 마진은 점들이 포함되지 않은 영역을 최대화해서 카테고리(클래스)를 분리할 수 있도록 하는 것을 말한다. 그리고 SV는 결정 경계선에 가장 가까이 있는 각 클래스의 데이터를 의미한다.
• SVM에서는 모든 집단이 100% 완전하게 구분선으로 분리되지 않는다. 따라서 어느정도의 오류를 허용해야 하고, 소프트 마진이란 잘못 분류된 데이터를 본래 속하는 카테고리로 비용을 들어 이동시켜야 한다.
• 이를 위해 파라미터를 조절해야 하며, 마진폭이 좁아지면 과대적합, 작으면 마진오류가 커지는 상황이 올 수 있다.
• 파이썬의 SVM은 sklearn.svm 패키지 안에 있으며, 분류는 SVC, 회귀는 SVR을 사용한다.
• 두 라이브러리 모두 모델 복집도인 C(디폴트는 1), kernel(디폴트는 rbf)가 파라미터로 사용된다.
• kernel은 rbf, linear, poly, sigmoid, precomputed를 사용할 수 있다.

import warnings
import pandas as pd
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import MinMaxScaler
from sklearn.svm import SVC

warnings.filterwarnings('ignore')

# 분류

data = pd.read_csv('/breast-cancer-wisconsin.csv', encoding='utf-8')
x = data[data.columns[1:10]]
y = data[["Class"]]

x_train, x_test, y_train, y_test = train_test_split(x, y, stratify=y, random_state = 42)

mmScaler = MinMaxScaler()
mmScaler.fit(x_train)

x_train = mmScaler.transform(x_train)
x_test = mmScaler.transform(x_test)

param_grid = [
              {'kernel': ['rbf'], 'C': [0.001, 0.01, 0.1, 1, 10, 100], 'gamma': [0.001, 0.01, 0.1, 1, 10, 100]},
              {'kernel': ['linear'], 'C': [0.001, 0.01, 0.1, 1, 10, 100], 'gamma': [0.001, 0.01, 0.1, 1, 10, 100]}
             ]
gSearch = GridSearchCV(SVC(), param_grid, cv=5)

gSearch.fit(x_train, y_train)
best_p = gSearch.best_params_

model = SVC(kernel=best_p['kernel'], C=best_p['C'], gamma=best_p['gamma'])
model.fit(x_train, y_train)

print('분류')
print('Train Result:\t', model.score(x_train, y_train))
print('Test Result:\t', model.score(x_test, y_test))

print('====================')

from sklearn.svm import SVR

data = pd.read_csv('/house_price.csv', encoding='utf-8')
data.dropna(inplace=True)

x = data[data.columns[1:5]]
y = data[["house_value"]]

x_train, x_test, y_train, y_test = train_test_split(x, y, random_state = 42)

mmScaler = MinMaxScaler()
mmScaler.fit(x_train)

x_train = mmScaler.transform(x_train)
x_test = mmScaler.transform(x_test)


param_grid = {'kernel': ['poly'], 
              'C': [0.01, 0.1, 1, 10], 
              'gamma': [0.01, 0.1, 1, 10]
              }
gSearch = GridSearchCV(SVR(), param_grid, cv=5)

gSearch.fit(x_train, y_train)
best_p = gSearch.best_params_


model = SVR(kernel=best_p['kernel'], C=best_p['C'], gamma=best_p['gamma'])

model.fit(x_train, y_train)

print('회귀')
print('Train Result:\t', model.score(x_train, y_train))
print('Test Result:\t', model.score(x_test, y_test))

# RMSE
import numpy as np
from sklearn.metrics import mean_squared_error

y_train_pred = model.predict(x_train)
y_test_pred = model.predict(x_test)

MSE_train = mean_squared_error(y_train, y_train_pred)
MSE_test = mean_squared_error(y_test, y_test_pred)

print('Train MSE:\t', np.sqrt(MSE_train))
print('Test MSE:\t', np.sqrt(MSE_test))

 

 

의사결정나무

• 의사결정나무는 의사결정 규칙을 나무구조로 도표화하여 관심대상이 되는 집단을 몇 개의 소집단으로 분류하거나 예측하는 데 활용하는 분석 방법이다.
• 몇 가지 용어들을 알아야 하는데, 가장 상단의 노드를 root node (뿌리 마디), 마지막의 노드를 terminal node (끝 마디), 그 외의 노드들을 intermediate node (중간 마디)라고 한다.
• 의사결정나무는 직관적으로 결과를 도식화하여 볼 수 있으며, 어떻게 분류되는지 알 수 있다.
• 다만 분류되는 단계가 많을수록 이해하기 어려우며, 데이터에 따라 결과가 안정적이지 못할 수 있다는 단점이 있다.
• 주요한 분류 변수를 확인하는 데 사용하기 좋다는 장점도 있다.
• sklearn.tree 패키지 내에 있으며, 분류에는 DecisionTreeClassifier, 회귀에는 DecisionTreeRegressor가 사용된다.
• 하이퍼 파라미터로는 max_depth (최대 가지치기 수), max_leaf_node (리프 노드의 최대 개수), min_sample_leaf (리프 노드가 되기 위한 최소 샘플 수)가 있다.
• 리프노드 : 자식이 없는 노드 (끝마디)

import warnings
import pandas as pd
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import MinMaxScaler
from sklearn.tree import DecisionTreeClassifier

warnings.filterwarnings('ignore')

# 분류

data = pd.read_csv('/breast-cancer-wisconsin.csv', encoding='utf-8')
x = data[data.columns[1:10]]
y = data[["Class"]]

x_train, x_test, y_train, y_test = train_test_split(x, y, stratify=y, random_state = 42)

mmScaler = MinMaxScaler()
mmScaler.fit(x_train)

x_train = mmScaler.transform(x_train)
x_test = mmScaler.transform(x_test)

param_grid = {'max_depth': range(2, 20, 2),
              'min_samples_leaf' : range(1, 50, 2)
              }
gSearch = GridSearchCV(DecisionTreeClassifier(), param_grid, cv=5)

gSearch.fit(x_train, y_train)
best_p = gSearch.best_params_

model = DecisionTreeClassifier(max_depth=best_p['max_depth'], min_samples_leaf=best_p['min_samples_leaf'])
model.fit(x_train, y_train)

print('분류')
print('Train Result:\t', model.score(x_train, y_train))
print('Test Result:\t', model.score(x_test, y_test))

print('====================')

from sklearn.tree import DecisionTreeRegressor

data = pd.read_csv('/house_price.csv', encoding='utf-8')
data.dropna(inplace=True)

x = data[data.columns[1:5]]
y = data[["house_value"]]

x_train, x_test, y_train, y_test = train_test_split(x, y, random_state = 42)

mmScaler = MinMaxScaler()
mmScaler.fit(x_train)

x_train = mmScaler.transform(x_train)
x_test = mmScaler.transform(x_test)


param_grid = {'max_depth': range(2, 20, 2),
              'min_samples_leaf' : range(1, 50, 2)
              }
gSearch = GridSearchCV(DecisionTreeRegressor(), param_grid, cv=5)

gSearch.fit(x_train, y_train)
best_p = gSearch.best_params_


model = DecisionTreeRegressor(max_depth=best_p['max_depth'], min_samples_leaf=best_p['min_samples_leaf'])

model.fit(x_train, y_train)

print('회귀')
print('Train Result:\t', model.score(x_train, y_train))
print('Test Result:\t', model.score(x_test, y_test))

# RMSE
import numpy as np
from sklearn.metrics import mean_squared_error

y_train_pred = model.predict(x_train)
y_test_pred = model.predict(x_test)

MSE_train = mean_squared_error(y_train, y_train_pred)
MSE_test = mean_squared_error(y_test, y_test_pred)

print('Train MSE:\t', np.sqrt(MSE_train))
print('Test MSE:\t', np.sqrt(MSE_test))

 

 

랜덤포레스트

• 랜덤포레스트는 여러 의사결정트리를 구성하여 분석하고 이를 종합하는 앙상블 기법이다.
• 즉 수십~수백개의 의사결정나무의 결과값을 평균내는 모델이다.
• sklearn.ensemble내에 있으며 분류는 RandomForestClassifier, 회귀는 RandomForestRegressor가 사용된다.
• 주요 하이퍼파라미터로 n_estimators (나무의 수, 디폴트는 100), max_features (선택 특성 수)가 있다.

import warnings
import pandas as pd
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import MinMaxScaler
from sklearn.ensemble import RandomForestClassifier

warnings.filterwarnings('ignore')

# 분류

data = pd.read_csv('/breast-cancer-wisconsin.csv', encoding='utf-8')
x = data[data.columns[1:10]]
y = data[["Class"]]

x_train, x_test, y_train, y_test = train_test_split(x, y, stratify=y, random_state = 42)

mmScaler = MinMaxScaler()
mmScaler.fit(x_train)

x_train = mmScaler.transform(x_train)
x_test = mmScaler.transform(x_test)

param_grid = {'n_estimators': range(100, 1000, 100),
              'max_features': ['auto', 'sqrt', 'log2']}
gSearch = GridSearchCV(RandomForestClassifier(), param_grid, cv=5)

gSearch.fit(x_train, y_train)
best_p = gSearch.best_params_

model = RandomForestClassifier(n_estimators=best_p['n_estimators'], max_features=best_p['max_features'])
model.fit(x_train, y_train)

print('분류')
print('Train Result:\t', model.score(x_train, y_train))
print('Test Result:\t', model.score(x_test, y_test))

print('====================')

from sklearn.ensemble import RandomForestRegressor

data = pd.read_csv('/house_price.csv', encoding='utf-8')
data.dropna(inplace=True)

x = data[data.columns[1:5]]
y = data[["house_value"]]

x_train, x_test, y_train, y_test = train_test_split(x, y, random_state = 42)

mmScaler = MinMaxScaler()
mmScaler.fit(x_train)

x_train = mmScaler.transform(x_train)
x_test = mmScaler.transform(x_test)


param_grid = {'n_estimators': range(100, 1000, 100),
              'max_features': ['auto', 'sqrt', 'log2']}
gSearch = GridSearchCV(RandomForestRegressor(), param_grid, cv=5)

gSearch.fit(x_train, y_train)
best_p = gSearch.best_params_


model = RandomForestRegressor(n_estimators=best_p['n_estimators'], max_features=best_p['max_features'])

model.fit(x_train, y_train)

print('회귀')
print('Train Result:\t', model.score(x_train, y_train))
print('Test Result:\t', model.score(x_test, y_test))

# RMSE
import numpy as np
from sklearn.metrics import mean_squared_error

y_train_pred = model.predict(x_train)
y_test_pred = model.predict(x_test)

MSE_train = mean_squared_error(y_train, y_train_pred)
MSE_test = mean_squared_error(y_test, y_test_pred)

print('Train MSE:\t', np.sqrt(MSE_train))
print('Test MSE:\t', np.sqrt(MSE_test))