from sklearn.datasets import load_boston
import numpy as np

boston = load_boston()

X = boston.data

y = boston.target

for i in range(5):
    print(X[i] ,'-->', y[i])

print(len(boston))

print(X.shape)

print(y.shape)

import matplotlib.pyplot as plt

X_labels = boston.feature_names

for i,name in enumerate(X_labels):
    X_i = X[:,i]
    plt.figure(i+1)
    plt.scatter(X_i,y)
    plt.xlabel(name)
    plt.ylabel('MEDV')
    plt.title(name)
plt.show()

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=13)

print("Train test split success!")

from sklearn import linear_model
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import AdaBoostRegressor
from sklearn.ensemble import GradientBoostingRegressor

from sklearn.metrics import mean_squared_error

from sklearn import preprocessing

import matplotlib.pyplot as plt

# features_new2 = preprocessing.PolynomialFeatures().fit_transform(features)

linear = linear_model.LinearRegression(normalize=True)

methods=[
    linear_model.LinearRegression(normalize=True),
#     linear_model.Ridge(),# 岭回归 这个不适合这种欠拟合场景
    linear_model.Lasso(alpha = 0.01), # lasso
    linear_model.LassoLars(alpha=.1),
    linear_model.BayesianRidge(),
#     linear_model.Lars(), # 最小角回归
#     linear_model.LogisticRegression(),
    DecisionTreeRegressor(),
    AdaBoostRegressor(n_estimators=200, learning_rate=0.01), # adaboost 默认使用cart 回归树
    GradientBoostingRegressor(alpha=0.01),
#     linear_model.PassiveAggressiveRegressor()
]

for method in methods:
    method.fit(X_train, y_train)
    y_pred = method.predict(X_test)
    y_pred_all = method.predict(X)
    print(str(method)[:20], '...', method.score(X_test, y_test), mean_squared_error(y_test, y_pred))
    if method :
        for i in range(5):
            print(y_test[i],'-->',y_pred[i])
        plt.figure()
        plt.scatter(y_test,y_pred)
        plt.plot(y_test, y_test, color='red', linewidth=3)
        plt.show()
#     print(str(method)[:20], '_all...', method.score(features, label), mean_squared_error(label, y_pred_all))

from sklearn.metrics import r2_score

def performance_metric(y_true, y_predict):
    """计算并返回预测值相比于预测值的分数"""
    score = r2_score(y_true, y_predict, sample_weight=None, multioutput=None)
    return score

from sklearn.model_selection import KFold
from sklearn.metrics import make_scorer
from sklearn.tree import DecisionTreeRegressor
from sklearn.model_selection import GridSearchCV

def fit_model(X, y):

    """ 基于输入数据 [X,y]，利于网格搜索找到最优的决策树模型"""

    cross_validator = KFold(n_splits=10, shuffle=False, random_state=None)

    regressor = DecisionTreeRegressor()

    params = {'max_depth':[1,2,3,4,5,6,7,8,9,10]}

    scoring_fnc = make_scorer(performance_metric)

    grid = GridSearchCV(estimator=regressor, param_grid=params, scoring=scoring_fnc, cv=cross_validator)

    # 基于输入数据 [X,y]，进行网格搜索
    grid = grid.fit(X, y)
    print("best param" + str(grid.best_params_))
    print("best score" + str(grid.best_score_))
    # 返回网格搜索后的最优模型
    return grid.best_estimator_ 

# 基于训练数据，获得最优模型
optimal_reg = fit_model(X_train, y_train)

# 输出最优模型的 'max_depth' 参数
print("Parameter 'max_depth' is {} for the optimal model.".format(optimal_reg.get_params()['max_depth']))

from sklearn.model_selection import learning_curve, validation_curve
from sklearn.model_selection import ShuffleSplit

def ModelLearning(X, y):
    cv = ShuffleSplit(n_splits = 10, test_size = 0.2, random_state = 0)
    train_sizes = np.rint(np.linspace(1, X.shape[0]*0.8 - 1, 9)).astype(int)
    fig = plt.figure(figsize=(10,7))

    for k, depth in enumerate([1,3,6,10]):
        regressor = DecisionTreeRegressor(max_depth = depth)
        sizes, train_scores, valid_scores = learning_curve(regressor, X, y, \
            cv = cv, train_sizes = train_sizes, scoring = 'r2')
        train_std = np.std(train_scores, axis = 1)
        train_mean = np.mean(train_scores, axis = 1)
        valid_std = np.std(valid_scores, axis = 1)
        valid_mean = np.mean(valid_scores, axis = 1)
        ax = fig.add_subplot(2, 2, k+1)
        ax.plot(sizes, train_mean, 'o-', color = 'r', label = 'Training Score')
        ax.plot(sizes, valid_mean, 'o-', color = 'g', label = 'Validation Score')
        ax.fill_between(sizes, train_mean - train_std, \
            train_mean + train_std, alpha = 0.15, color = 'r')
        ax.fill_between(sizes, valid_mean - valid_std, \
            valid_mean + valid_std, alpha = 0.15, color = 'g')

        # Labels
        ax.set_title('max_depth = %s'%(depth))
        ax.set_xlabel('Number of Training Points')
        ax.set_ylabel('r2_score')
        ax.set_xlim([0, X.shape[0]*0.8])
        ax.set_ylim([-0.05, 1.05])

    ax.legend(bbox_to_anchor=(1.05, 2.05), loc='lower left', borderaxespad = 0.)
    fig.suptitle('Decision Tree Regressor Learning Performances', fontsize = 16, y = 1.03)
    fig.tight_layout()
    fig.show()


def ModelComplexity(X, y):
    """ Calculates the performance of the model as model complexity increases.
        The learning and validation errors rates are then plotted.
        随着模型复杂性的增加，计算模型的性能。
        然后绘制学习和验证错误的速率。 """

    # Create 10 cross-validation sets for training and testing
    cv = ShuffleSplit(n_splits = 10, test_size = 0.2, random_state = 0)

    # Vary the max_depth parameter from 1 to 10
    max_depth = np.arange(1,11)

    # Calculate the training and testing scores
    train_scores, valid_scores = validation_curve(DecisionTreeRegressor(), X, y, \
        param_name = "max_depth", param_range = max_depth, cv = cv, scoring = 'r2')

    # Find the mean and standard deviation for smoothing
    train_mean = np.mean(train_scores, axis=1)
    train_std = np.std(train_scores, axis=1)
    valid_mean = np.mean(valid_scores, axis=1)
    valid_std = np.std(valid_scores, axis=1)

    # Plot the validation curve
    plt.figure(figsize=(7, 5))
    plt.title('Decision Tree Regressor Complexity Performance')
    plt.plot(max_depth, train_mean, 'o-', color = 'r', label = 'Training Score')
    plt.plot(max_depth, valid_mean, 'o-', color = 'g', label = 'Validation Score')
    plt.fill_between(max_depth, train_mean - train_std, \
        train_mean + train_std, alpha = 0.15, color = 'r')
    plt.fill_between(max_depth, valid_mean - valid_std, \
        valid_mean + valid_std, alpha = 0.15, color = 'g')

    # Visual aesthetics
    plt.legend(loc = 'lower right')
    plt.xlabel('Maximum Depth')
    plt.ylabel('r2_score')
    plt.ylim([-0.05,1.05])
    plt.show()


def PredictTrials(X, y, fitter, data):
    """ Performs trials of fitting and predicting data. """

    # Store the predicted prices
    prices = []

    for k in range(10):
        # Split the data
        X_train, X_test, y_train, y_test = train_test_split(X, y, \
            test_size = 0.2, random_state = k)

        # Fit the data
        reg = fitter(X_train, y_train)

        # Make a prediction
        pred = reg.predict([data[0]])[0]
        prices.append(pred)

        # Result
        print("Trial {}: ${:,.2f}".format(k+1, pred))

    # Display price range
    print("\nRange in prices: ${:,.2f}".format(max(prices) - min(prices)))


ModelLearning(X_train, y_train)
ModelComplexity(X_train, y_train)