# 패키지
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
from scipy import stats
from sklearn.datasets import load_boston
%matplotlib inline

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score # MSE

# boston 주택 가격 데이터 세트 로드
boston = load_boston()

# boston 데이터 세트 DataFrame으로 변환
df = pd.DataFrame(boston.data, columns=boston.feature_names)

# target값 추가
df["PRICE"] = boston.target
print("boston 데이터 크기 :", df.shape)
df.head(3)

# train test split
y_target = df["PRICE"]
X_data = df.drop("PRICE", axis=1,inplace=False)

X_train, X_test, y_train, y_test = train_test_split(X_data, y_target, test_size=0.3, random_state=156)

from sklearn.linear_model import Ridge
from sklearn.model_selection import cross_val_score

# alpha=10
ridge = Ridge(alpha = 10)
neg_mse_scores = cross_val_score(ridge, X_data, y_target, scoring="neg_mean_squared_error", cv=5)
rmse_scores = np.sqrt(-1 * neg_mse_scores)
avg_rmse = np.mean(rmse_scores)

# 결과
print("개별 Negative MSE :", np.round(neg_mse_scores, 2))
print("개별 RMSE :", np.round(rmse_scores,2))
print("rmse 평균 :", np.round(avg_rmse,2))

# alpha를 변경하며 수행
alphas = [0,0.1,1,10,100]

for i,alpha in enumerate(alphas):
    ridge = Ridge(alpha = alpha)
    neg_mse_scores = cross_val_score(ridge, X_data, y_target, scoring="neg_mean_squared_error", cv=5)
    rmse_scores = np.sqrt(-1 * neg_mse_scores)
    avg_rmse = np.mean(rmse_scores)
    print(f"alhpa = {alphas[i]}일 때, rmse 평균 :", np.round(avg_rmse,2))

fig, axs = plt.subplots(figsize=(18,6), nrows=1, ncols=5)

coeff_df = pd.DataFrame()

for pos, alpha in enumerate(alphas):
    ridge = Ridge(alpha = alpha)
    ridge.fit(X_data, y_target)
    coeff = pd.Series(ridge.coef_, index=X_data.columns)
    col_name = "alpha : "+ str(alpha)
    coeff_df[col_name] = coeff
    # 막대그래프
    coeff = coeff.sort_values(ascending=False)
    axs[pos].set_title(col_name)
    axs[pos].set_xlim(-10,10)
    sns.barplot(x=coeff.values, y=coeff.index, ax=axs[pos])

plt.show()

from sklearn.linear_model import Lasso, ElasticNet

def get_linear_reg_eval(model_name, params=None, X_data_n=None, y_target_n=None, verbose=True, return_coeff=True):
    coeff_df = pd.DataFrame()
    if verbose : print("#####", model_name, "#####")
    for param in params:
        if model_name == "Ridge" : model = Ridge(alpha=param)
        elif  model_name == "Lasso" : model = Lasso(alpha=param)
        elif  model_name == "ElasticNet" : model = ElasticNet(alpha=param, l1_ratio=0.7)
        neg_mse_scores = cross_val_score(model, X_data_n,y_target_n, scoring = "neg_mean_squared_error", cv = 5)
        avg_rmse = np.mean(np.sqrt(-1 * neg_mse_scores))
        print(f"alpha {param}일 때 평균 RMSE = {avg_rmse:.3f}")
        
        # cross_val_score는 evaluation metric만 반환하므로 모델을 재학습하여 회귀계수 추출
        model.fit(X_data_n, y_target_n)
        if return_coeff:
            coeff = pd.Series(data=model.coef_, index=X_data.columns)
            colname="alpha : "+str(param)
            coeff_df[colname] = coeff
    
    return coeff_df

lasso_alphas = [0.01,0.07,0.1,0.5,1,3,5,10]
coeff_lasso_df = get_linear_reg_eval("Lasso", params=lasso_alphas, X_data_n=X_data, y_target_n=y_target)

sort_column = "alpha : "+str(lasso_alphas[0])
coeff_lasso_df.sort_values(by=sort_column, ascending=False)

elastic_alphas = [0.07, 0.1, 0.5, 1, 3]
coeff_elastic_df = get_linear_reg_eval("ElasticNet", params=elastic_alphas, X_data_n=X_data, y_target_n=y_target)

# method는 Standar, Minax, Log 결정
from sklearn.preprocessing import StandardScaler, MinMaxScaler # Scaler
from sklearn.preprocessing import PolynomialFeatures

def get_scaled_data(method="None", p_degree=None, input_data=None):
    if method == "Standard":
        scaled_data = StandardScaler().fit_transform(input_data)
    elif method == "MinMax":
        scaled_data = MinMaxScaler().fit_transform(input_data)
    elif method == "Log":
        scaled_data = np.log1p(input_data)
    else:
        scaled_data = input_data
    
    if p_degree != None:
        scaled_data = PolynomialFeatures(degree=p_degree, include_bias=False).fit_transform(scaled_data)
    
    return scaled_data

alphas = [0.1, 1, 10, 100]

scale_methods = [(None, None), ("Standard",None), ("Standard",2), ("MinMax", None), ("MinMax", 2), ("Log", None)]

for scale_method in scale_methods:
    X_data_scaled = get_scaled_data(method=scale_method[0], p_degree=scale_method[1], input_data=X_data)
    print("\n ## 변환 유형 : {0}, Polynomial Degree:{1}".format(scale_method[0], scale_method[1]))
    get_linear_reg_eval("Ridge", params=alphas, X_data_n=X_data_scaled, y_target_n=y_target, verbose=False, return_coeff=False)