机器学习工程师纳米学位

模型评价与验证

项目 1: 预测波士顿房价

欢迎来到机器学习工程师纳米学位的第一个项目！在此文件中，有些示例代码已经提供给你，但你还需要实现更多的功能来让项目成功运行。除非有明确要求，你无须修改任何已给出的代码。以编程练习开始的标题表示接下来的内容中有需要你必须实现的功能。每一部分都会有详细的指导，需要实现的部分也会在注释中以TODO标出。请仔细阅读所有的提示！

除了实现代码外，你还必须回答一些与项目和实现有关的问题。每一个需要你回答的问题都会以'问题 X'为标题。请仔细阅读每个问题，并且在问题后的'回答'文字框中写出完整的答案。你的项目将会根据你对问题的回答和撰写代码所实现的功能来进行评分。

提示：Code 和 Markdown 区域可通过 Shift + Enter 快捷键运行。此外，Markdown可以通过双击进入编辑模式。

第一步. 导入数据

在这个项目中，你将利用马萨诸塞州波士顿郊区的房屋信息数据训练和测试一个模型，并对模型的性能和预测能力进行测试。通过该数据训练后的好的模型可以被用来对房屋做特定预测---尤其是对房屋的价值。对于房地产经纪等人的日常工作来说，这样的预测模型被证明非常有价值。

此项目的数据集来自UCI机器学习知识库(数据集已下线)。波士顿房屋这些数据于1978年开始统计，共506个数据点，涵盖了麻省波士顿不同郊区房屋14种特征的信息。本项目对原始数据集做了以下处理：

有16个'MEDV' 值为50.0的数据点被移除。这很可能是由于这些数据点包含遗失或看不到的值。
有1个数据点的 'RM' 值为8.78. 这是一个异常值，已经被移除。
对于本项目，房屋的'RM'， 'LSTAT'，'PTRATIO'以及'MEDV'特征是必要的，其余不相关特征已经被移除。
'MEDV'特征的值已经过必要的数学转换，可以反映35年来市场的通货膨胀效应。

运行下面区域的代码以载入波士顿房屋数据集，以及一些此项目所需的Python库。如果成功返回数据集的大小，表示数据集已载入成功。



In [1]:

    
# 载入此项目所需要的库
import numpy as np
import pandas as pd
import visuals as vs # Supplementary code

# 检查你的Python版本
from sys import version_info
if version_info.major != 2 and version_info.minor != 7:
    raise Exception('请使用Python 2.7来完成此项目')
    
# 让结果在notebook中显示
%matplotlib inline



In [2]:

    
# 载入波士顿房屋的数据集
data = pd.read_csv('housing.csv')
prices = data['MEDV']
features = data.drop('MEDV', axis = 1)
    
# 完成
print "Boston housing dataset has {} data points with {} variables each.".format(*data.shape)









    



Boston housing dataset has 489 data points with 4 variables each.

第二步. 分析数据

在项目的第一个部分，你会对波士顿房地产数据进行初步的观察并给出你的分析。通过对数据的探索来熟悉数据可以让你更好地理解和解释你的结果。

由于这个项目的最终目标是建立一个预测房屋价值的模型，我们需要将数据集分为特征(features)和目标变量(target variable)。

特征 'RM'， 'LSTAT'，和 'PTRATIO'，给我们提供了每个数据点的数量相关的信息。
目标变量：'MEDV'，是我们希望预测的变量。

他们分别被存在features和prices两个变量名中。

编程练习 1：基础统计运算

你的第一个编程练习是计算有关波士顿房价的描述统计数据。我们已为你导入了numpy，你需要使用这个库来执行必要的计算。这些统计数据对于分析模型的预测结果非常重要的。在下面的代码中，你要做的是：

计算prices中的'MEDV'的最小值、最大值、均值、中值和标准差；
将运算结果储存在相应的变量中。



In [3]:

    
#TODO 1

#目标：计算价值的最小值
minimum_price = np.amin(data['MEDV'])

#目标：计算价值的最大值
maximum_price = np.amax(data['MEDV'])

#目标：计算价值的平均值
mean_price = np.mean(data['MEDV'])

#目标：计算价值的中值
median_price = np.median(data['MEDV'])

#目标：计算价值的标准差
std_price = np.std(data['MEDV'])

#目标：输出计算的结果
print "Statistics for Boston housing dataset:\n"
print "Minimum price: ${:,.2f}".format(minimum_price)
print "Maximum price: ${:,.2f}".format(maximum_price)
print "Mean price: ${:,.2f}".format(mean_price)
print "Median price ${:,.2f}".format(median_price)
print "Standard deviation of prices: ${:,.2f}".format(std_price)









    



Statistics for Boston housing dataset:

Minimum price: $105,000.00
Maximum price: $1,024,800.00
Mean price: $454,342.94
Median price $438,900.00
Standard deviation of prices: $165,171.13

问题 1 - 特征观察

如前文所述，本项目中我们关注的是其中三个值:'RM'、'LSTAT' 和'PTRATIO'，对每一个数据点:

'RM' 是该地区中每个房屋的平均房间数量；
'LSTAT' 是指该地区有多少百分比的房东属于是低收入阶层（有工作但收入微薄）；
'PTRATIO' 是该地区的中学和小学里，学生和老师的数目比（学生/老师）。

凭直觉，上述三个特征中对每一个来说，你认为增大该特征的数值，'MEDV'的值会是增大还是减小呢？每一个答案都需要你给出理由。

提示：你预期一个'RM' 值是6的房屋跟'RM' 值是7的房屋相比，价值更高还是更低呢？

问题 1 - 回答：

直觉上来讲： RM房间数量越大，房屋价值越高 LStat房东是低收入阶层的百分比越高，则该地区越有可能属于整体收入较低的群体，则价格会更低 PtRatio 学生老师数目比，表示当地学生的数目，代表房子有可能是处于学区，这个比值越高则房价越高

编程练习 2: 数据分割与重排

接下来，你需要把波士顿房屋数据集分成训练和测试两个子集。通常在这个过程中，数据也会被重排列，以消除数据集中由于顺序而产生的偏差。在下面的代码中，你需要

使用 sklearn.model_selection 中的 train_test_split，将features和prices的数据都分成用于训练的数据子集和用于测试的数据子集。

分割比例为：80%的数据用于训练，20%用于测试；
选定一个数值以设定 train_test_split 中的 random_state ，这会确保结果的一致性；



In [4]:

    
# TODO 2

# 提示： 导入train_test_split
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(features,prices,test_size=0.2,random_state=42)

问题 2 - 训练及测试

将数据集按一定比例分为训练用的数据集和测试用的数据集对学习算法有什么好处？

如果用模型已经见过的数据，例如部分训练集数据进行测试，又有什么坏处？

提示： 如果没有数据来对模型进行测试，会出现什么问题？

问题 2 - 回答:

区分训练用和测试用数据集，可以有效在训练过程中得到及时反馈，我们可以使用训练测试集进行训练算法，然后通过测试集进行测试得分，一般情况下通过得分高低来评价算法优化的优劣，观察算法拟合程度。

如果使用训练数据测试，由于算法就是这堆数据产生的，但我们无法了解此算法对未知数据的表现如何。

第三步. 模型衡量标准

在项目的第三步中，你需要了解必要的工具和技巧来让你的模型进行预测。用这些工具和技巧对每一个模型的表现做精确的衡量可以极大地增强你预测的信心。

编程练习3：定义衡量标准

如果不能对模型的训练和测试的表现进行量化地评估，我们就很难衡量模型的好坏。通常我们会定义一些衡量标准，这些标准可以通过对某些误差或者拟合程度的计算来得到。在这个项目中，你将通过运算决定系数 R² 来量化模型的表现。模型的决定系数是回归分析中十分常用的统计信息，经常被当作衡量模型预测能力好坏的标准。

R²的数值范围从0至1，表示目标变量的预测值和实际值之间的相关程度平方的百分比。一个模型的R² 值为0还不如直接用平均值来预测效果好；而一个R² 值为1的模型则可以对目标变量进行完美的预测。从0至1之间的数值，则表示该模型中目标变量中有百分之多少能够用特征来解释。模型也可能出现负值的R²，这种情况下模型所做预测有时会比直接计算目标变量的平均值差很多。

在下方代码的 performance_metric 函数中，你要实现：

使用 sklearn.metrics 中的 r2_score 来计算 y_true 和 y_predict的R²值，作为对其表现的评判。
将他们的表现评分储存到score变量中。

或

(可选) 不使用任何外部库，参考决定系数的定义进行计算，这也可以帮助你更好的理解决定系数在什么情况下等于0或等于1。



In [5]:

    
# TODO 3

# 提示： 导入r2_score
from sklearn.metrics import r2_score
def performance_metric(y_true, y_predict):
    """计算并返回预测值相比于预测值的分数"""
    
    score = r2_score(y_true, y_predict)  

    return score



In [6]:

    
# TODO 3 可选

# 不允许导入任何计算决定系数的库
# R_square = 1- SSE / SST

def performance_metric2(y_true, y_predict):
    """计算并返回预测值相比于预测值的分数"""
    
    sum = 0
    SSE = 0
    SST = 0
    for i in range(len(y_true)):
        SSE = SSE + (y_true[i] - y_predict[i])**2
        sum = sum + y_true[i]
    average = sum/len(y_true)
    for i in range(len(y_true)):
        SST = SST + (y_true[i] - average)**2
    score = 1 - (SSE/SST)

    return score

问题 3 - 拟合程度

假设一个数据集有五个数据且一个模型做出下列目标变量的预测：

真实数值	预测数值
3.0	2.5
-0.5	0.0
2.0	2.1
7.0	7.8
4.2	5.3

你觉得这个模型已成功地描述了目标变量的变化吗？如果成功，请解释为什么，如果没有，也请给出原因。

提示：运行下方的代码，使用performance_metric函数来计算模型的决定系数。



In [7]:

    
# 计算这个模型的预测结果的决定系数
score = performance_metric([3, -0.5, 2, 7, 4.2], [2.5, 0.0, 2.1, 7.8, 5.3])
print "Model has a coefficient of determination, R^2, of {:.3f}.".format(score)









    



Model has a coefficient of determination, R^2, of 0.923.

问题 3 - 回答:

非常成功，因为R方已经很大，而且从图中数据来看，每个预测数据都几乎接近实际数据

第四步. 分析模型的表现

在项目的第四步，我们来看一下不同参数下，模型在训练集和验证集上的表现。这里，我们专注于一个特定的算法（带剪枝的决策树，但这并不是这个项目的重点），和这个算法的一个参数 'max_depth'。用全部训练集训练，选择不同'max_depth' 参数，观察这一参数的变化如何影响模型的表现。画出模型的表现来对于分析过程十分有益，这可以让我们看到一些单看结果看不到的行为。

学习曲线

下方区域内的代码会输出四幅图像，它们是一个决策树模型在不同最大深度下的表现。每一条曲线都直观得显示了随着训练数据量的增加，模型学习曲线的在训练集评分和验证集评分的变化，评分使用决定系数R²。曲线的阴影区域代表的是该曲线的不确定性（用标准差衡量）。

运行下方区域中的代码，并利用输出的图形回答下面的问题。



In [8]:

    
# 根据不同的训练集大小，和最大深度，生成学习曲线
vs.ModelLearning(X_train, y_train)

问题 4 - 学习曲线

选择上述图像中的其中一个，并给出其最大深度。随着训练数据量的增加，训练集曲线的评分有怎样的变化？验证集曲线呢？如果有更多的训练数据，是否能有效提升模型的表现呢？

提示：学习曲线的评分是否最终会收敛到特定的值？随着数据量增加，训练集平分平缓下降，验证集平分平缓上升验证曲线会趋于一致，且更平缓如果有更多数据集，并不能对其表现有很大提升

问题 4 - 回答:

复杂度曲线

下列代码内的区域会输出一幅图像，它展示了一个已经经过训练和验证的决策树模型在不同最大深度条件下的表现。这个图形将包含两条曲线，一个是训练集的变化，一个是验证集的变化。跟学习曲线相似，阴影区域代表该曲线的不确定性，模型训练和测试部分的评分都用的 performance_metric 函数。

运行下方区域中的代码，并利用输出的图形并回答下面的两个问题。



In [9]:

    
# 根据不同的最大深度参数，生成复杂度曲线
vs.ModelComplexity(X_train, y_train)

问题 5 - 偏差（bias）与方差（variance）之间的权衡取舍

当模型以最大深度 1训练时，模型的预测是出现很大的偏差还是出现了很大的方差？当模型以最大深度10训练时，情形又如何呢？图形中的哪些特征能够支持你的结论？

提示： 你如何得知模型是否出现了偏差很大或者方差很大的问题？深度为1时是经典的欠拟合，会出现很大的偏差。深度为10时时过拟合，会出现很大的方差 R方的值在深度为1时很低，表示当前集合处于欠拟合 R方的值在深度为10时，训练集很高，测试集反而下降，所以表现为过拟合

问题 5 - 回答:

深度为1时是经典的欠拟合，会出现很大的偏差。深度为10时时过拟合，会出现很大的方差 R方的值在深度为1时很低，表示当前集合处于欠拟合 R方的值在深度为10时，训练集很高，测试集反而下降，所以表现为过拟合

问题 6- 最优模型的猜测

结合问题 5 中的图，你认为最大深度是多少的模型能够最好地对未见过的数据进行预测？你得出这个答案的依据是什么？

问题 6 - 回答:

3，因为此时R方值最大，而且训练集和测试集的差距比较小，说明此时拟合程度合适，且泛化能力比较强

第五步. 选择最优参数

问题 7- 网格搜索（Grid Search）

什么是网格搜索法？如何用它来优化模型？

问题 7 - 回答:

网格搜索法是交叉验证的一种方法，通过遍历组合来实现模型优化。用各个参数可能的取值来构造GridSearchCV，列出所有可能组合结果生成网格，然后使用这些组合进行训练，再进行评估，会得出一个最佳结果。

问题 8 - 交叉验证

什么是K折交叉验证法（k-fold cross-validation）？
GridSearchCV是如何结合交叉验证来完成对最佳参数组合的选择的？
GridSearchCV中的'cv_results_'属性能告诉我们什么？
网格搜索时如果不使用交叉验证会有什么问题？交叉验证又是如何解决这个问题的？

提示： 在下面 fit_model函数最后加入 print pd.DataFrame(grid.cv_results_) 可以帮你查看更多信息。

问题 8 - 回答：

K折交叉验证是交叉验证中的一种方法，在我们划分训练集合测试集时，使用K折交叉验证可以将训练数据集分为K份，每次用一份做验证集，其余为训练集，因此可以重复验证K此，并将结果汇总平均。默认情况下会对数据顺序切分，所以如果数据是排好序或聚类的（比如视频中的作者都聚集在还一起），那训练出来的算法很有可能只fit了部分数据，导致得分有偏差。 GridSearchCV的重要作用是自动调参，在网格搜索中，如果共有m组参数，假设每组参数都是n个值，那么一共有mn组参数，再对每组参数进行交叉验证，有K次训练和验证，然后取K次平均分为最终评分结果，最终评分结果分数最高的是最佳参数组合的选择

'cvresults'能够输出一个词典，包含每个参数组合的train_score，test_score,还有每个参数组合的mean_fit_time，mean_score_time，mean_test_score ，mean_train_score以及std_fit_time，std_score_time，std_test_score ，std_train_score,可作为最佳参数组合的依据

网格搜索时，如果不适用交叉验证，可能会导致因为偶然的测试集的划分，导致的训练不准确的问题。交叉验证使用了多次尝试来获取最优值，降低误差，提升数据利用率。

编程练习 4：训练最优模型

在这个练习中，你将需要将所学到的内容整合，使用决策树算法训练一个模型。为了得出的是一个最优模型，你需要使用网格搜索法训练模型，以找到最佳的 'max_depth' 参数。你可以把'max_depth' 参数理解为决策树算法在做出预测前，允许其对数据提出问题的数量。决策树是监督学习算法中的一种。

在下方 fit_model 函数中，你需要做的是：

定义 'cross_validator' 变量: 使用 sklearn.model_selection 中的 KFold 创建一个交叉验证生成器对象;
定义 'regressor' 变量: 使用 sklearn.tree 中的 DecisionTreeRegressor 创建一个决策树的回归函数;
定义 'params' 变量: 为 'max_depth' 参数创造一个字典，它的值是从1至10的数组;
定义 'scoring_fnc' 变量: 使用 sklearn.metrics 中的 make_scorer 创建一个评分函数；将 ‘performance_metric’ 作为参数传至这个函数中；
定义 'grid' 变量: 使用 sklearn.model_selection 中的 GridSearchCV 创建一个网格搜索对象；将变量'regressor', 'params', 'scoring_fnc'和 'cross_validator' 作为参数传至这个对象构造函数中；

如果你对python函数的默认参数定义和传递不熟悉，可以参考这个MIT课程的视频。



In [10]:

    
# TODO 4

#提示: 导入 'KFold' 'DecisionTreeRegressor' 'make_scorer' 'GridSearchCV' 


def fit_model(X, y):
    """ 基于输入数据 [X,y]，利于网格搜索找到最优的决策树模型"""
    
    from sklearn.model_selection import KFold
    from sklearn import tree
    from sklearn.metrics import make_scorer
    from sklearn.model_selection import GridSearchCV
    
    cross_validator = KFold(n_splits = 10)
    
    regressor = tree.DecisionTreeRegressor()

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

    scoring_fnc = make_scorer(performance_metric)

    grid = GridSearchCV(regressor, params, scoring_fnc, cv=cross_validator)

    # 基于输入数据 [X,y]，进行网格搜索
    grid = grid.fit(X, y)
    
    print pd.DataFrame(grid.cv_results_)

    # 返回网格搜索后的最优模型
    return grid.best_estimator_

编程练习 4：训练最优模型（可选）

在下方 fit_model 函数中，你需要做的是：

遍历参数‘max_depth’的可选值 1～10，构造对应模型
计算当前模型的交叉验证分数
返回最优交叉验证分数对应的模型



In [18]:

    
# TODO 4 可选

'''
不允许使用 DecisionTreeRegressor 以外的任何 sklearn 库

提示: 你可能需要实现下面的 cross_val_score 函数

def cross_val_score(estimator, X, y, scoring = performance_metric, cv=3):
    """ 返回每组交叉验证的模型分数的数组 """
    scores = [0,0,0]
    return scores
'''

def cross_val_score(estimator, X, y, scoring = performance_metric, cv=3):
    """ 返回每组交叉验证的模型分数的数组 """
    scores = [0, 0, 0]
    fold = len(X) / cv
    for i in range(cv):
        X_train = np.concatenate([X[:i * fold], X[(i + 1) * fold:]])
        X_test = X[i * fold:(i + 1) * fold]
        y_train = np.concatenate([y[:i * fold], y[(i + 1) * fold:]])
        y_test = y[i * fold:(i + 1) * fold]
        estimator = estimator.fit(X_train, y_train)
        scores[i] = scoring(y_test, estimator.predict(X_test))
    return scores


def fit_model2(X, y):
    """ 基于输入数据 [X,y]，利于网格搜索找到最优的决策树模型"""
    #最优交叉验证分数对应的最优模型
    best_estimator = None
    best = 1
    best_score = 0
    for i in range(1, 11):
        regressor = DecisionTreeRegressor(max_depth=i)
        score = np.mean(cross_val_score(regressor, X, y))
        (best_score, best) = (score, i) if score > best_score else (best_score, best)
    best_estimator = DecisionTreeRegressor(max_depth=best)
    return best_estimator
    
    return best_estimator

问题 9 - 最优模型

最优模型的最大深度（maximum depth）是多少？此答案与你在问题 6所做的猜测是否相同？

运行下方区域内的代码，将决策树回归函数代入训练数据的集合，以得到最优化的模型。



In [12]:

    
# 基于训练数据，获得最优模型
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'])









    



   mean_fit_time  mean_score_time  mean_test_score  mean_train_score  \
0       0.001863         0.000608         0.299259          0.460178   
1       0.000968         0.000341         0.562190          0.725521   
2       0.000910         0.000301         0.735255          0.823905   
3       0.001165         0.000363         0.759906          0.868586   
4       0.001081         0.000321         0.728102          0.899422   
5       0.001118         0.000308         0.711349          0.926507   
6       0.001345         0.000361         0.706902          0.945358   
7       0.001358         0.000341         0.689863          0.961365   
8       0.001291         0.000330         0.688982          0.975345   
9       0.001518         0.000389         0.678138          0.984078   

  param_max_depth              params  rank_test_score  split0_test_score  \
0               1   {u'max_depth': 1}               10           0.487886   
1               2   {u'max_depth': 2}                9           0.732110   
2               3   {u'max_depth': 3}                2           0.804755   
3               4   {u'max_depth': 4}                1           0.821353   
4               5   {u'max_depth': 5}                3           0.803654   
5               6   {u'max_depth': 6}                4           0.784090   
6               7   {u'max_depth': 7}                5           0.796230   
7               8   {u'max_depth': 8}                6           0.801167   
8               9   {u'max_depth': 9}                7           0.840838   
9              10  {u'max_depth': 10}                8           0.850164   

   split0_train_score  split1_test_score       ...         split7_test_score  \
0            0.451907           0.393276       ...                  0.371648   
1            0.716888           0.541372       ...                  0.538882   
2            0.825096           0.717467       ...                  0.715567   
3            0.869006           0.754296       ...                  0.781867   
4            0.898087           0.776892       ...                  0.775345   
5            0.932973           0.678951       ...                  0.721579   
6            0.953398           0.706846       ...                  0.738171   
7            0.968435           0.733186       ...                  0.768395   
8            0.979686           0.690108       ...                  0.769205   
9            0.987785           0.715938       ...                  0.749500   

   split7_train_score  split8_test_score  split8_train_score  \
0            0.452255           0.032192            0.464305   
1            0.724182           0.353745            0.734585   
2            0.815483           0.715218            0.823006   
3            0.856730           0.700104            0.874314   
4            0.893582           0.632705            0.900806   
5            0.915605           0.627726            0.921076   
6            0.937424           0.679286            0.937046   
7            0.957279           0.549449            0.951616   
8            0.970245           0.570795            0.974567   
9            0.979021           0.550331            0.985794   

   split9_test_score  split9_train_score  std_fit_time  std_score_time  \
0           0.335204            0.469736      0.001205        0.000385   
1           0.660249            0.725304      0.000062        0.000022   
2           0.784659            0.827042      0.000044        0.000011   
3           0.850445            0.870769      0.000396        0.000133   
4           0.806423            0.898087      0.000110        0.000050   
5           0.801394            0.929003      0.000074        0.000018   
6           0.775542            0.945589      0.000489        0.000134   
7           0.768894            0.960843      0.000187        0.000045   
8           0.771044            0.974387      0.000067        0.000067   
9           0.774645            0.983332      0.000157        0.000081   

   std_test_score  std_train_score  
0        0.150506         0.006533  
1        0.113488         0.008590  
2        0.071758         0.006626  
3        0.074458         0.006250  
4        0.069637         0.005571  
5        0.068458         0.006456  
6        0.051068         0.006173  
7        0.077866         0.005726  
8        0.080448         0.004005  
9        0.091985         0.003120  

[10 rows x 31 columns]
Parameter 'max_depth' is 4 for the optimal model.

问题 9 - 回答：

4，与我猜测有些不同

第六步. 做出预测

当我们用数据训练出一个模型，它现在就可用于对新的数据进行预测。在决策树回归函数中，模型已经学会对新输入的数据提问，并返回对目标变量的预测值。你可以用这个预测来获取数据未知目标变量的信息，这些数据必须是不包含在训练数据之内的。

问题 10 - 预测销售价格

想像你是一个在波士顿地区的房屋经纪人，并期待使用此模型以帮助你的客户评估他们想出售的房屋。你已经从你的三个客户收集到以下的资讯:

特征	客戶 1	客戶 2	客戶 3
房屋内房间总数	5 间房间	4 间房间	8 间房间
社区贫困指数（％被认为是贫困阶层）	17%	32%	3%
邻近学校的学生-老师比例	15：1	22：1	12：1

你会建议每位客户的房屋销售的价格为多少？从房屋特征的数值判断，这样的价格合理吗？为什么？

提示：用你在分析数据部分计算出来的统计信息来帮助你证明你的答案。

运行下列的代码区域，使用你优化的模型来为每位客户的房屋价值做出预测。



In [13]:

    
# 生成三个客户的数据
client_data = [[5, 17, 15], # 客户 1
               [4, 32, 22], # 客户 2
               [8, 3, 12]]  # 客户 3

# 进行预测
predicted_price = optimal_reg.predict(client_data)
for i, price in enumerate(predicted_price):
    print "Predicted selling price for Client {}'s home: ${:,.2f}".format(i+1, price)









    



Predicted selling price for Client 1's home: $403,025.00
Predicted selling price for Client 2's home: $237,478.72
Predicted selling price for Client 3's home: $931,636.36

问题 10 - 回答：

我会按照模型预测来给出建议。从结果来看，客户3 > 客户1 > 客户2 从输入数据来看，客户3房子数最多，非贫困社区，显然应该价格最高客户2房间数最少，很有可能是贫困阶层，所以自然价格最低。因此从排序来看预测值是正确的。

Minimum price: $105,000.00 Maximum price: $1,024,800.00 Mean price: $454,342.94 Median price $438,900.00 Standard deviation of prices: $165,171.13 客户2的报价没有低于最小值，客户3的报价没有高于最大值，三者平均值500，000左右，与统计数据差不多，因此预测没有太大问题。

编程练习 5

你刚刚预测了三个客户的房子的售价。在这个练习中，你将用你的最优模型在整个测试数据上进行预测, 并计算相对于目标变量的决定系数 R²的值**。



In [14]:

    
#TODO 5

# 提示：你可能需要用到 X_test, y_test, optimal_reg, performance_metric
# 提示：你可能需要参考问题10的代码进行预测
# 提示：你可能需要参考问题3的代码来计算R^2的值

pred = optimal_reg.predict(X_test)
r2 = performance_metric(y_test, pred)

print "Optimal model has R^2 score {:,.2f} on test data".format(r2)









    



Optimal model has R^2 score 0.84 on test data

问题11 - 分析决定系数

你刚刚计算了最优模型在测试集上的决定系数，你会如何评价这个结果？

问题11 - 回答

0.84这个分数不低，可能还可以优化。

模型健壮性

一个最优的模型不一定是一个健壮模型。有的时候模型会过于复杂或者过于简单，以致于难以泛化新增添的数据；有的时候模型采用的学习算法并不适用于特定的数据结构；有的时候样本本身可能有太多噪点或样本过少，使得模型无法准确地预测目标变量。这些情况下我们会说模型是欠拟合的。

问题 12 - 模型健壮性

模型是否足够健壮来保证预测的一致性？

提示: 执行下方区域中的代码，采用不同的训练和测试集执行 fit_model 函数10次。注意观察对一个特定的客户来说，预测是如何随训练数据的变化而变化的。



In [15]:

    
# 请先注释掉 fit_model 函数里的所有 print 语句
vs.PredictTrials(features, prices, fit_model, client_data)









    



   mean_fit_time  mean_score_time  mean_test_score  mean_train_score  \
0       0.001715         0.000678         0.393190          0.473731   
1       0.000878         0.000348         0.631778          0.737366   
2       0.000893         0.000284         0.762798          0.833799   
3       0.000933         0.000291         0.782855          0.879338   
4       0.001024         0.000307         0.772834          0.907058   
5       0.001064         0.000288         0.767216          0.930713   
6       0.001121         0.000295         0.750759          0.947671   
7       0.001181         0.000308         0.741271          0.960571   
8       0.001272         0.000315         0.720534          0.973348   
9       0.001546         0.000354         0.705663          0.981873   

  param_max_depth              params  rank_test_score  split0_test_score  \
0               1   {u'max_depth': 1}               10           0.194234   
1               2   {u'max_depth': 2}                9           0.471609   
2               3   {u'max_depth': 3}                4           0.717627   
3               4   {u'max_depth': 4}                1           0.796158   
4               5   {u'max_depth': 5}                2           0.836390   
5               6   {u'max_depth': 6}                3           0.823551   
6               7   {u'max_depth': 7}                5           0.825937   
7               8   {u'max_depth': 8}                6           0.826834   
8               9   {u'max_depth': 9}                7           0.818750   
9              10  {u'max_depth': 10}                8           0.818110   

   split0_train_score  split1_test_score       ...         split7_test_score  \
0            0.469160           0.415338       ...                  0.267559   
1            0.741135           0.710609       ...                  0.387501   
2            0.823960           0.822457       ...                  0.623715   
3            0.882243           0.809065       ...                  0.567373   
4            0.905933           0.814471       ...                  0.473878   
5            0.928771           0.765555       ...                  0.493646   
6            0.948229           0.759405       ...                  0.455188   
7            0.963058           0.721070       ...                  0.385030   
8            0.974069           0.692773       ...                  0.266900   
9            0.984353           0.709937       ...                  0.136419   

   split7_train_score  split8_test_score  split8_train_score  \
0            0.483259           0.471616            0.471746   
1            0.746803           0.597150            0.746662   
2            0.850816           0.682798            0.854881   
3            0.889232           0.737466            0.892401   
4            0.912776           0.669542            0.921774   
5            0.935707           0.639670            0.940745   
6            0.951270           0.664265            0.954095   
7            0.964522           0.677450            0.964230   
8            0.977366           0.658306            0.977137   
9            0.986401           0.653683            0.983786   

   split9_test_score  split9_train_score  std_fit_time  std_score_time  \
0           0.520221            0.463880      0.000756        0.000409   
1           0.712387            0.733332      0.000146        0.000157   
2           0.847253            0.822417      0.000064        0.000013   
3           0.847146            0.868057      0.000052        0.000019   
4           0.873941            0.892596      0.000098        0.000038   
5           0.901387            0.916308      0.000061        0.000009   
6           0.913028            0.938554      0.000055        0.000020   
7           0.897415            0.951154      0.000044        0.000036   
8           0.886351            0.965189      0.000084        0.000025   
9           0.862870            0.973816      0.000620        0.000080   

   std_test_score  std_train_score  
0        0.131937         0.008109  
1        0.137609         0.007707  
2        0.080297         0.011256  
3        0.090450         0.008642  
4        0.119410         0.007691  
5        0.118918         0.006353  
6        0.132210         0.004264  
7        0.144977         0.004495  
8        0.164946         0.003695  
9        0.204702         0.003648  

[10 rows x 31 columns]
Trial 1: $391,183.33
   mean_fit_time  mean_score_time  mean_test_score  mean_train_score  \
0       0.000903         0.000308         0.310136          0.454160   
1       0.000850         0.000306         0.590313          0.717310   
2       0.000888         0.000298         0.751535          0.826676   
3       0.001014         0.000337         0.794433          0.874191   
4       0.001010         0.000302         0.776155          0.898498   
5       0.001476         0.000413         0.775762          0.919842   
6       0.001494         0.000453         0.745552          0.942503   
7       0.001215         0.000311         0.744555          0.960146   
8       0.001296         0.000321         0.722788          0.973923   
9       0.001315         0.000311         0.707894          0.983767   

  param_max_depth              params  rank_test_score  split0_test_score  \
0               1   {u'max_depth': 1}               10           0.210119   
1               2   {u'max_depth': 2}                9           0.500780   
2               3   {u'max_depth': 3}                4           0.679404   
3               4   {u'max_depth': 4}                1           0.767350   
4               5   {u'max_depth': 5}                2           0.770766   
5               6   {u'max_depth': 6}                3           0.802380   
6               7   {u'max_depth': 7}                5           0.727040   
7               8   {u'max_depth': 8}                6           0.721435   
8               9   {u'max_depth': 9}                7           0.678070   
9              10  {u'max_depth': 10}                8           0.611838   

   split0_train_score  split1_test_score       ...         split7_test_score  \
0            0.462134           0.472819       ...                  0.496656   
1            0.716903           0.772209       ...                  0.749931   
2            0.830980           0.899792       ...                  0.846707   
3            0.876156           0.918192       ...                  0.860847   
4            0.898130           0.909956       ...                  0.847826   
5            0.919921           0.904637       ...                  0.816116   
6            0.940778           0.901450       ...                  0.812254   
7            0.958685           0.875203       ...                  0.845093   
8            0.977113           0.864551       ...                  0.861182   
9            0.985665           0.856599       ...                  0.838545   

   split7_train_score  split8_test_score  split8_train_score  \
0            0.439799           0.435258            0.450383   
1            0.710955           0.725934            0.707221   
2            0.818910           0.854603            0.820856   
3            0.866256           0.820743            0.870280   
4            0.891492           0.842257            0.896322   
5            0.910289           0.754446            0.917420   
6            0.933844           0.743192            0.943491   
7            0.955788           0.757838            0.961424   
8            0.969384           0.725337            0.977760   
9            0.979528           0.747832            0.987669   

   split9_test_score  split9_train_score  std_fit_time  std_score_time  \
0           0.285494            0.464314      0.000205        0.000034   
1           0.542213            0.723917      0.000073        0.000059   
2           0.757253            0.828578      0.000054        0.000019   
3           0.773894            0.875598      0.000135        0.000129   
4           0.699591            0.901427      0.000054        0.000019   
5           0.682354            0.923013      0.000316        0.000102   
6           0.675784            0.945123      0.000316        0.000187   
7           0.663039            0.959366      0.000081        0.000022   
8           0.613180            0.974304      0.000142        0.000038   
9           0.599807            0.986709      0.000115        0.000024   

   std_test_score  std_train_score  
0        0.232505         0.010089  
1        0.223924         0.011716  
2        0.157317         0.007172  
3        0.107188         0.004957  
4        0.110750         0.004018  
5        0.100340         0.003981  
6        0.118202         0.003761  
7        0.090496         0.003150  
8        0.118361         0.003053  
9        0.110339         0.003687  

[10 rows x 31 columns]
Trial 2: $411,417.39
   mean_fit_time  mean_score_time  mean_test_score  mean_train_score  \
0       0.000861         0.000311         0.284290          0.463208   
1       0.000887         0.000309         0.591132          0.729603   
2       0.000883         0.000310         0.724765          0.822991   
3       0.001009         0.000303         0.777001          0.873201   
4       0.001116         0.000331         0.739169          0.904909   
5       0.001141         0.000303         0.708693          0.930467   
6       0.001489         0.000436         0.695682          0.950848   
7       0.001334         0.000355         0.669941          0.964398   
8       0.001238         0.000293         0.649632          0.975578   
9       0.001308         0.000309         0.623227          0.986975   

  param_max_depth              params  rank_test_score  split0_test_score  \
0               1   {u'max_depth': 1}               10           0.265810   
1               2   {u'max_depth': 2}                9           0.543066   
2               3   {u'max_depth': 3}                3           0.656905   
3               4   {u'max_depth': 4}                1           0.736697   
4               5   {u'max_depth': 5}                2           0.655893   
5               6   {u'max_depth': 6}                4           0.651727   
6               7   {u'max_depth': 7}                5           0.673899   
7               8   {u'max_depth': 8}                6           0.670109   
8               9   {u'max_depth': 9}                7           0.669152   
9              10  {u'max_depth': 10}                8           0.650169   

   split0_train_score  split1_test_score       ...         split7_test_score  \
0            0.473114           0.293255       ...                  0.153978   
1            0.737295           0.705953       ...                  0.487443   
2            0.821185           0.729958       ...                  0.618893   
3            0.874186           0.803507       ...                  0.746409   
4            0.908080           0.771514       ...                  0.821793   
5            0.933313           0.771249       ...                  0.776398   
6            0.948397           0.724990       ...                  0.763605   
7            0.962913           0.727588       ...                  0.732713   
8            0.978919           0.680689       ...                  0.675423   
9            0.988581           0.625765       ...                  0.677270   

   split7_train_score  split8_test_score  split8_train_score  \
0            0.467318           0.439478            0.449972   
1            0.730037           0.641108            0.730154   
2            0.827069           0.743917            0.827837   
3            0.872653           0.771163            0.874649   
4            0.902459           0.712062            0.906072   
5            0.929379           0.663627            0.932952   
6            0.949116           0.615935            0.960527   
7            0.959849           0.648065            0.972976   
8            0.972046           0.664410            0.981652   
9            0.986251           0.624186            0.988465   

   split9_test_score  split9_train_score  std_fit_time  std_score_time  \
0           0.043587            0.473614      0.000147        0.000051   
1           0.308494            0.739301      0.000118        0.000054   
2           0.653696            0.822551      0.000067        0.000038   
3           0.622640            0.876750      0.000159        0.000024   
4           0.449398            0.913945      0.000193        0.000071   
5           0.389407            0.937978      0.000119        0.000022   
6           0.414382            0.953313      0.000318        0.000148   
7           0.376905            0.967112      0.000307        0.000152   
8           0.293160            0.979172      0.000101        0.000013   
9           0.140886            0.991711      0.000109        0.000021   

   std_test_score  std_train_score  
0        0.145032         0.012991  
1        0.128555         0.009404  
2        0.079010         0.006957  
3        0.072564         0.004842  
4        0.117046         0.007052  
5        0.133885         0.006856  
6        0.125648         0.007336  
7        0.129401         0.007384  
8        0.146922         0.005657  
9        0.181655         0.003217  

[10 rows x 31 columns]
Trial 3: $415,800.00
   mean_fit_time  mean_score_time  mean_test_score  mean_train_score  \
0       0.000846         0.000301         0.311342          0.466165   
1       0.000890         0.000302         0.665772          0.740494   
2       0.000906         0.000289         0.713955          0.828667   
3       0.000992         0.000315         0.730672          0.882668   
4       0.001039         0.000314         0.719068          0.908551   
5       0.001226         0.000366         0.705789          0.929668   
6       0.001375         0.000357         0.719220          0.946685   
7       0.001185         0.000299         0.689662          0.960283   
8       0.001444         0.000362         0.650559          0.971708   
9       0.001288         0.000300         0.653262          0.982084   

  param_max_depth              params  rank_test_score  split0_test_score  \
0               1   {u'max_depth': 1}               10           0.278605   
1               2   {u'max_depth': 2}                7           0.567184   
2               3   {u'max_depth': 3}                4           0.700169   
3               4   {u'max_depth': 4}                1           0.775527   
4               5   {u'max_depth': 5}                3           0.785119   
5               6   {u'max_depth': 6}                5           0.751756   
6               7   {u'max_depth': 7}                2           0.759014   
7               8   {u'max_depth': 8}                6           0.771005   
8               9   {u'max_depth': 9}                9           0.729843   
9              10  {u'max_depth': 10}                8           0.741496   

   split0_train_score  split1_test_score       ...         split7_test_score  \
0            0.472874           0.398334       ...                  0.116998   
1            0.749554           0.715457       ...                  0.565408   
2            0.834831           0.660987       ...                  0.593001   
3            0.887656           0.655981       ...                  0.681177   
4            0.907093           0.637453       ...                  0.709198   
5            0.925649           0.646655       ...                  0.733547   
6            0.943274           0.637299       ...                  0.766633   
7            0.958479           0.621481       ...                  0.730207   
8            0.967843           0.618127       ...                  0.713649   
9            0.979355           0.603927       ...                  0.714759   

   split7_train_score  split8_test_score  split8_train_score  \
0            0.484773           0.473678            0.450116   
1            0.749900           0.704611            0.734759   
2            0.835832           0.802374            0.817246   
3            0.890609           0.834427            0.872508   
4            0.918178           0.749769            0.903739   
5            0.936019           0.771798            0.924688   
6            0.952296           0.775182            0.940969   
7            0.966730           0.780085            0.958998   
8            0.975616           0.672051            0.971143   
9            0.984575           0.705028            0.982474   

   split9_test_score  split9_train_score  std_fit_time  std_score_time  \
0           0.328822            0.470407      0.000249        0.000030   
1           0.656162            0.743812      0.000167        0.000033   
2           0.763536            0.825098      0.000096        0.000017   
3           0.766357            0.882471      0.000149        0.000057   
4           0.788388            0.907366      0.000079        0.000049   
5           0.745191            0.928778      0.000245        0.000147   
6           0.703348            0.947040      0.000311        0.000072   
7           0.716009            0.962921      0.000046        0.000016   
8           0.683496            0.972486      0.000240        0.000077   
9           0.703697            0.981617      0.000102        0.000018   

   std_test_score  std_train_score  
0        0.119221         0.012669  
1        0.066597         0.006696  
2        0.094332         0.006379  
3        0.113117         0.005457  
4        0.104609         0.005232  
5        0.115441         0.005619  
6        0.118200         0.004610  
7        0.136362         0.004764  
8        0.122618         0.004174  
9        0.128430         0.003103  

[10 rows x 31 columns]
Trial 4: $420,622.22
   mean_fit_time  mean_score_time  mean_test_score  mean_train_score  \
0       0.000834         0.000300         0.387621          0.463021   
1       0.000889         0.000311         0.652468          0.728764   
2       0.000898         0.000301         0.725595          0.814739   
3       0.000976         0.000303         0.757313          0.861965   
4       0.001009         0.000299         0.749530          0.890038   
5       0.001154         0.000319         0.753544          0.914886   
6       0.001519         0.000439         0.694475          0.938796   
7       0.001520         0.000373         0.683578          0.956161   
8       0.001234         0.000335         0.658094          0.971236   
9       0.001372         0.000312         0.638901          0.980829   

  param_max_depth              params  rank_test_score  split0_test_score  \
0               1   {u'max_depth': 1}               10           0.384088   
1               2   {u'max_depth': 2}                8           0.688755   
2               3   {u'max_depth': 3}                4           0.827556   
3               4   {u'max_depth': 4}                1           0.866588   
4               5   {u'max_depth': 5}                3           0.873182   
5               6   {u'max_depth': 6}                2           0.865659   
6               7   {u'max_depth': 7}                5           0.878550   
7               8   {u'max_depth': 8}                6           0.835915   
8               9   {u'max_depth': 9}                7           0.825521   
9              10  {u'max_depth': 10}                9           0.840697   

   split0_train_score  split1_test_score       ...         split7_test_score  \
0            0.452975           0.273285       ...                  0.345637   
1            0.725017           0.688703       ...                  0.590021   
2            0.813401           0.798573       ...                  0.708735   
3            0.857468           0.763334       ...                  0.659508   
4            0.886493           0.799370       ...                  0.670420   
5            0.919610           0.780913       ...                  0.679271   
6            0.938504           0.781317       ...                  0.664390   
7            0.956832           0.719049       ...                  0.599928   
8            0.970890           0.657739       ...                  0.575105   
9            0.982374           0.594056       ...                  0.564828   

   split7_train_score  split8_test_score  split8_train_score  \
0            0.460046           0.459013            0.460882   
1            0.736989           0.751806            0.720219   
2            0.827812           0.782939            0.801084   
3            0.875774           0.813629            0.852994   
4            0.901122           0.830103            0.888265   
5            0.926930           0.842000            0.915782   
6            0.946800           0.853972            0.945790   
7            0.966312           0.809219            0.958358   
8            0.978033           0.786111            0.968620   
9            0.988612           0.806374            0.974651   

   split9_test_score  split9_train_score  std_fit_time  std_score_time  \
0           0.388579            0.470304      0.000193        0.000034   
1           0.740152            0.722655      0.000124        0.000056   
2           0.809892            0.814899      0.000075        0.000033   
3           0.816820            0.861828      0.000069        0.000024   
4           0.831350            0.886708      0.000069        0.000021   
5           0.845974            0.911452      0.000114        0.000043   
6           0.847183            0.939495      0.000429        0.000197   
7           0.811818            0.954067      0.000604        0.000139   
8           0.833269            0.970350      0.000099        0.000112   
9           0.813739            0.979908      0.000246        0.000028   

   std_test_score  std_train_score  
0        0.102129         0.009457  
1        0.092311         0.006256  
2        0.119136         0.007882  
3        0.091416         0.006740  
4        0.116861         0.004515  
5        0.088805         0.005929  
6        0.156911         0.005091  
7        0.118368         0.004545  
8        0.171558         0.003055  
9        0.187732         0.003511  

[10 rows x 31 columns]
Trial 5: $413,334.78
   mean_fit_time  mean_score_time  mean_test_score  mean_train_score  \
0       0.001042         0.000330         0.361176          0.466220   
1       0.000847         0.000298         0.604993          0.718059   
2       0.000937         0.000302         0.705710          0.810835   
3       0.001036         0.000315         0.777593          0.861688   
4       0.001011         0.000295         0.747146          0.891674   
5       0.001080         0.000300         0.728821          0.919992   
6       0.001269         0.000396         0.702515          0.941605   
7       0.001326         0.000319         0.683665          0.958854   
8       0.001310         0.000310         0.689327          0.972114   
9       0.001370         0.000347         0.679553          0.981763   

  param_max_depth              params  rank_test_score  split0_test_score  \
0               1   {u'max_depth': 1}               10          -0.073687   
1               2   {u'max_depth': 2}                9           0.449954   
2               3   {u'max_depth': 3}                4           0.614706   
3               4   {u'max_depth': 4}                1           0.643288   
4               5   {u'max_depth': 5}                2           0.605597   
5               6   {u'max_depth': 6}                3           0.587887   
6               7   {u'max_depth': 7}                5           0.538297   
7               8   {u'max_depth': 8}                7           0.499959   
8               9   {u'max_depth': 9}                6           0.532102   
9              10  {u'max_depth': 10}                8           0.480434   

   split0_train_score  split1_test_score       ...         split7_test_score  \
0            0.463216           0.554913       ...                  0.432296   
1            0.716189           0.705408       ...                  0.540063   
2            0.805416           0.849209       ...                  0.628525   
3            0.867852           0.841833       ...                  0.731969   
4            0.892920           0.782324       ...                  0.705585   
5            0.913731           0.735357       ...                  0.703826   
6            0.936092           0.808940       ...                  0.667884   
7            0.955259           0.772535       ...                  0.666041   
8            0.972707           0.819316       ...                  0.631750   
9            0.983542           0.810459       ...                  0.615450   

   split7_train_score  split8_test_score  split8_train_score  \
0            0.468080           0.446213            0.467832   
1            0.729791           0.722804            0.712662   
2            0.822580           0.816829            0.804646   
3            0.872094           0.840685            0.853767   
4            0.899811           0.827882            0.881137   
5            0.928465           0.746406            0.909277   
6            0.949163           0.760947            0.932796   
7            0.968554           0.718877            0.953753   
8            0.979058           0.762326            0.969333   
9            0.987165           0.770299            0.978048   

   split9_test_score  split9_train_score  std_fit_time  std_score_time  \
0           0.310872            0.471431      0.000470        0.000059   
1           0.481227            0.725851      0.000090        0.000039   
2           0.589678            0.816061      0.000118        0.000043   
3           0.825546            0.859642      0.000181        0.000066   
4           0.725896            0.892800      0.000052        0.000017   
5           0.712445            0.925993      0.000064        0.000024   
6           0.650118            0.944740      0.000215        0.000200   
7           0.661940            0.964662      0.000218        0.000036   
8           0.616852            0.976696      0.000154        0.000033   
9           0.630643            0.984862      0.000176        0.000147   

   std_test_score  std_train_score  
0        0.166050         0.006654  
1        0.141652         0.007571  
2        0.101718         0.008426  
3        0.063481         0.006671  
4        0.066115         0.005882  
5        0.068574         0.005776  
6        0.087001         0.005008  
7        0.077634         0.004784  
8        0.083308         0.003333  
9        0.095707         0.003210  

[10 rows x 31 columns]
Trial 6: $411,931.58
   mean_fit_time  mean_score_time  mean_test_score  mean_train_score  \
0       0.000843         0.000297         0.388746          0.493674   
1       0.000899         0.000301         0.664215          0.755924   
2       0.001058         0.000301         0.730673          0.834095   
3       0.000990         0.000329         0.788214          0.879674   
4       0.001105         0.000333         0.762646          0.910109   
5       0.001188         0.000315         0.752696          0.931152   
6       0.001833         0.000428         0.725495          0.948454   
7       0.001731         0.000532         0.732375          0.965000   
8       0.001357         0.000330         0.711942          0.975663   
9       0.001552         0.000365         0.706121          0.983749   

  param_max_depth              params  rank_test_score  split0_test_score  \
0               1   {u'max_depth': 1}               10           0.237121   
1               2   {u'max_depth': 2}                9           0.482485   
2               3   {u'max_depth': 3}                5           0.649260   
3               4   {u'max_depth': 4}                1           0.761851   
4               5   {u'max_depth': 5}                2           0.756705   
5               6   {u'max_depth': 6}                3           0.701515   
6               7   {u'max_depth': 7}                6           0.681438   
7               8   {u'max_depth': 8}                4           0.663872   
8               9   {u'max_depth': 9}                7           0.649321   
9              10  {u'max_depth': 10}                8           0.657362   

   split0_train_score  split1_test_score       ...         split7_test_score  \
0            0.499565           0.418301       ...                  0.382052   
1            0.765908           0.702356       ...                  0.667657   
2            0.834852           0.734237       ...                  0.630032   
3            0.879314           0.771042       ...                  0.765592   
4            0.910099           0.775058       ...                  0.637504   
5            0.928961           0.796500       ...                  0.623742   
6            0.947146           0.758239       ...                  0.620902   
7            0.965693           0.777598       ...                  0.655606   
8            0.974467           0.798513       ...                  0.568463   
9            0.980394           0.792100       ...                  0.533266   

   split7_train_score  split8_test_score  split8_train_score  \
0            0.500281           0.401727            0.495737   
1            0.762075           0.700339            0.757123   
2            0.838272           0.745277            0.833835   
3            0.885546           0.773267            0.876003   
4            0.908673           0.790408            0.914379   
5            0.929480           0.758889            0.935423   
6            0.945491           0.730135            0.952179   
7            0.963804           0.735977            0.966631   
8            0.974718           0.711327            0.980053   
9            0.983084           0.682010            0.988879   

   split9_test_score  split9_train_score  std_fit_time  std_score_time  \
0           0.459356            0.492747      0.000165        0.000029   
1           0.686457            0.760293      0.000229        0.000035   
2           0.765833            0.835764      0.000173        0.000021   
3           0.768569            0.879881      0.000072        0.000065   
4           0.806708            0.916027      0.000172        0.000064   
5           0.799908            0.934929      0.000176        0.000039   
6           0.794363            0.951459      0.000682        0.000136   
7           0.793589            0.968453      0.000519        0.000336   
8           0.791985            0.977330      0.000161        0.000065   
9           0.771209            0.984776      0.000242        0.000093   

   std_test_score  std_train_score  
0        0.113746         0.008845  
1        0.085687         0.007885  
2        0.058388         0.003964  
3        0.030455         0.004672  
4        0.056412         0.005166  
5        0.066067         0.004969  
6        0.073249         0.005119  
7        0.069941         0.004798  
8        0.089712         0.004195  
9        0.089272         0.003772  

[10 rows x 31 columns]
Trial 7: $399,663.16
   mean_fit_time  mean_score_time  mean_test_score  mean_train_score  \
0       0.001009         0.000329         0.339337          0.462622   
1       0.001048         0.000347         0.613596          0.716349   
2       0.001858         0.001043         0.717293          0.814447   
3       0.001644         0.000445         0.764586          0.861305   
4       0.001583         0.000480         0.758869          0.890116   
5       0.001798         0.000495         0.735347          0.918907   
6       0.001661         0.000467         0.734269          0.941932   
7       0.001704         0.000469         0.705220          0.960117   
8       0.001627         0.000423         0.699323          0.975233   
9       0.001947         0.000485         0.696411          0.985248   

  param_max_depth              params  rank_test_score  split0_test_score  \
0               1   {u'max_depth': 1}               10           0.490164   
1               2   {u'max_depth': 2}                9           0.635609   
2               3   {u'max_depth': 3}                5           0.744899   
3               4   {u'max_depth': 4}                1           0.788493   
4               5   {u'max_depth': 5}                2           0.829350   
5               6   {u'max_depth': 6}                3           0.794606   
6               7   {u'max_depth': 7}                4           0.750961   
7               8   {u'max_depth': 8}                6           0.712482   
8               9   {u'max_depth': 9}                7           0.761032   
9              10  {u'max_depth': 10}                8           0.726483   

   split0_train_score  split1_test_score       ...         split7_test_score  \
0            0.453781           0.426688       ...                  0.332552   
1            0.704286           0.609303       ...                  0.498158   
2            0.819533           0.735504       ...                  0.783096   
3            0.867081           0.796597       ...                  0.841991   
4            0.890474           0.696754       ...                  0.830176   
5            0.919012           0.688930       ...                  0.698188   
6            0.941120           0.732675       ...                  0.695078   
7            0.959617           0.704754       ...                  0.722861   
8            0.972318           0.674492       ...                  0.742164   
9            0.983602           0.692510       ...                  0.711103   

   split7_train_score  split8_test_score  split8_train_score  \
0            0.466562           0.236459            0.464919   
1            0.722641           0.691006            0.728155   
2            0.808940           0.743442            0.820208   
3            0.855437           0.768066            0.867043   
4            0.883155           0.695041            0.898916   
5            0.911932           0.682866            0.929664   
6            0.936120           0.695032            0.951671   
7            0.952695           0.634945            0.969178   
8            0.970076           0.596006            0.979995   
9            0.983280           0.590996            0.989109   

   split9_test_score  split9_train_score  std_fit_time  std_score_time  \
0           0.404285            0.453689      0.000267        0.000060   
1           0.683470            0.725003      0.000222        0.000094   
2           0.768686            0.821126      0.001910        0.001528   
3           0.757520            0.870777      0.000394        0.000099   
4           0.750693            0.899928      0.000276        0.000129   
5           0.772845            0.924708      0.000512        0.000115   
6           0.735519            0.950363      0.000343        0.000141   
7           0.780131            0.968007      0.000323        0.000179   
8           0.719244            0.980670      0.000249        0.000117   
9           0.702911            0.987300      0.000284        0.000128   

   std_test_score  std_train_score  
0        0.111059         0.006304  
1        0.081193         0.007497  
2        0.077359         0.006499  
3        0.070565         0.006004  
4        0.076840         0.006040  
5        0.082276         0.005978  
6        0.049945         0.007015  
7        0.109861         0.005777  
8        0.090535         0.003517  
9        0.071030         0.002204  

[10 rows x 31 columns]
Trial 8: $407,232.00
   mean_fit_time  mean_score_time  mean_test_score  mean_train_score  \
0       0.001344         0.000495         0.424432          0.466548   
1       0.001226         0.000466         0.656331          0.721694   
2       0.001410         0.000450         0.752056          0.820508   
3       0.001389         0.000477         0.781153          0.869823   
4       0.001817         0.000512         0.747024          0.898637   
5       0.001558         0.000474         0.723929          0.922907   
6       0.001567         0.000451         0.719095          0.943675   
7       0.001622         0.000421         0.692050          0.959947   
8       0.001631         0.000452         0.679392          0.972362   
9       0.001698         0.000384         0.652586          0.980936   

  param_max_depth              params  rank_test_score  split0_test_score  \
0               1   {u'max_depth': 1}               10           0.505282   
1               2   {u'max_depth': 2}                8           0.700016   
2               3   {u'max_depth': 3}                2           0.768438   
3               4   {u'max_depth': 4}                1           0.761214   
4               5   {u'max_depth': 5}                3           0.769856   
5               6   {u'max_depth': 6}                4           0.775726   
6               7   {u'max_depth': 7}                5           0.737545   
7               8   {u'max_depth': 8}                6           0.688439   
8               9   {u'max_depth': 9}                7           0.708150   
9              10  {u'max_depth': 10}                9           0.683391   

   split0_train_score  split1_test_score       ...         split7_test_score  \
0            0.461015           0.371609       ...                  0.341878   
1            0.722964           0.646119       ...                  0.645604   
2            0.825734           0.827089       ...                  0.761661   
3            0.867819           0.847146       ...                  0.755540   
4            0.897147           0.829430       ...                  0.701890   
5            0.929187           0.794186       ...                  0.761287   
6            0.950756           0.759218       ...                  0.754660   
7            0.967313           0.783349       ...                  0.637510   
8            0.975111           0.756059       ...                  0.769925   
9            0.981685           0.735910       ...                  0.624039   

   split7_train_score  split8_test_score  split8_train_score  \
0            0.470645           0.506933            0.461173   
1            0.726406           0.722089            0.719966   
2            0.814009           0.758390            0.826435   
3            0.868167           0.692706            0.882657   
4            0.894096           0.690997            0.910079   
5            0.918810           0.632871            0.931725   
6            0.940403           0.649276            0.950704   
7            0.956019           0.638494            0.966645   
8            0.969562           0.642226            0.976098   
9            0.979153           0.633599            0.985731   

   split9_test_score  split9_train_score  std_fit_time  std_score_time  \
0           0.438253            0.463718      0.000286        0.000136   
1           0.642030            0.718300      0.000223        0.000152   
2           0.768781            0.817209      0.000327        0.000142   
3           0.868658            0.868802      0.000270        0.000097   
4           0.840720            0.898037      0.000754        0.000219   
5           0.824471            0.921053      0.000305        0.000121   
6           0.837162            0.940947      0.000201        0.000136   
7           0.812171            0.957721      0.000309        0.000105   
8           0.773319            0.974406      0.000134        0.000153   
9           0.726399            0.980791      0.000182        0.000034   

   std_test_score  std_train_score  
0        0.080368         0.006867  
1        0.076972         0.006580  
2        0.072080         0.005208  
3        0.057146         0.005728  
4        0.089218         0.005824  
5        0.089301         0.005406  
6        0.094929         0.004341  
7        0.098898         0.004315  
8        0.105500         0.002970  
9        0.088945         0.003654  

[10 rows x 31 columns]
Trial 9: $402,531.82
   mean_fit_time  mean_score_time  mean_test_score  mean_train_score  \
0       0.001197         0.000380         0.327544          0.432948   
1       0.001134         0.000441         0.645203          0.722537   
2       0.001219         0.000437         0.746540          0.818562   
3       0.001410         0.000454         0.787722          0.867054   
4       0.001648         0.000477         0.776028          0.898615   
5       0.001827         0.000554         0.734413          0.924149   
6       0.001712         0.000509         0.711634          0.945658   
7       0.001918         0.000494         0.727869          0.959833   
8       0.002168         0.000512         0.688703          0.971504   
9       0.001920         0.000534         0.684689          0.981720   

  param_max_depth              params  rank_test_score  split0_test_score  \
0               1   {u'max_depth': 1}               10           0.329557   
1               2   {u'max_depth': 2}                9           0.638025   
2               3   {u'max_depth': 3}                3           0.767708   
3               4   {u'max_depth': 4}                1           0.831180   
4               5   {u'max_depth': 5}                2           0.813110   
5               6   {u'max_depth': 6}                4           0.824822   
6               7   {u'max_depth': 7}                6           0.760012   
7               8   {u'max_depth': 8}                5           0.744446   
8               9   {u'max_depth': 9}                7           0.675345   
9              10  {u'max_depth': 10}                8           0.599643   

   split0_train_score  split1_test_score       ...         split7_test_score  \
0            0.437292           0.450344       ...                  0.381239   
1            0.728032           0.777953       ...                  0.627461   
2            0.818748           0.840699       ...                  0.671320   
3            0.864367           0.872333       ...                  0.700030   
4            0.891803           0.836453       ...                  0.775809   
5            0.912811           0.826296       ...                  0.781772   
6            0.945236           0.803817       ...                  0.796923   
7            0.962296           0.813590       ...                  0.788288   
8            0.976009           0.799514       ...                  0.730211   
9            0.985700           0.754903       ...                  0.646487   

   split7_train_score  split8_test_score  split8_train_score  \
0            0.437358           0.510065            0.422747   
1            0.724321           0.746006            0.717614   
2            0.820646           0.825148            0.821289   
3            0.868384           0.883118            0.866220   
4            0.895304           0.869599            0.901244   
5            0.925612           0.835118            0.924793   
6            0.947003           0.657939            0.948783   
7            0.967575           0.738055            0.960623   
8            0.981491           0.688969            0.967792   
9            0.989962           0.703050            0.977648   

   split9_test_score  split9_train_score  std_fit_time  std_score_time  \
0           0.486265            0.422636      0.000281        0.000050   
1           0.704958            0.719239      0.000163        0.000121   
2           0.844835            0.819655      0.000113        0.000060   
3           0.867480            0.867142      0.000304        0.000136   
4           0.804221            0.896734      0.000301        0.000134   
5           0.741988            0.921754      0.000417        0.000287   
6           0.723999            0.945784      0.000321        0.000247   
7           0.811528            0.959339      0.000435        0.000126   
8           0.679462            0.972807      0.000621        0.000142   
9           0.780521            0.981271      0.000312        0.000167   

   std_test_score  std_train_score  
0        0.168076         0.008463  
1        0.121428         0.006418  
2        0.133180         0.005922  
3        0.100231         0.004240  
4        0.108628         0.004280  
5        0.161118         0.005715  
6        0.148942         0.003425  
7        0.142069         0.004900  
8        0.143762         0.005646  
9        0.144241         0.004749  

[10 rows x 31 columns]
Trial 10: $413,700.00

Range in prices: $29,438.89

问题 12 - 回答：

基本一致，预测数据趋势与训练数据大体相同

问题 13 - 实用性探讨

简单地讨论一下你建构的模型能否在现实世界中使用？

提示：回答以下几个问题，并给出相应结论的理由：

1978年所采集的数据，在已考虑通货膨胀的前提下，在今天是否仍然适用？
数据中呈现的特征是否足够描述一个房屋？
在波士顿这样的大都市采集的数据，能否应用在其它乡镇地区？
你觉得仅仅凭房屋所在社区的环境来判断房屋价值合理吗？

问题 13 - 回答：

如果已经考虑通货膨胀，将数据变形到当代的话，仍然适用不足以描述，如国内各种开发商、学区房等都会对数据造成干扰不适用，每个地区的训练数据不同，得出的结论不同，如果拿其他乡镇做测试集，得分应该不高不合理，以一个维度判断，会有很大局限性，且同一个小区内的房价也有不同

可选问题 - 预测北京房价

（本题结果不影响项目是否通过）通过上面的实践，相信你对机器学习的一些常用概念有了很好的领悟和掌握。但利用70年代的波士顿房价数据进行建模的确对我们来说意义不是太大。现在你可以把你上面所学应用到北京房价数据集中 bj_housing.csv。

免责声明：考虑到北京房价受到宏观经济、政策调整等众多因素的直接影响，预测结果仅供参考。

这个数据集的特征有：

Area：房屋面积，平方米
Room：房间数，间
Living: 厅数，间
School: 是否为学区房，0或1
Year: 房屋建造时间，年
Floor: 房屋所处楼层，层

目标变量：

Value: 房屋人民币售价，万

你可以参考上面学到的内容，拿这个数据集来练习数据分割与重排、定义衡量标准、训练模型、评价模型表现、使用网格搜索配合交叉验证对参数进行调优并选出最佳参数，比较两者的差别，最终得出最佳模型对验证集的预测分数。



In [16]:

    
# TODO 6

# 你的代码

问题14 - 北京房价预测

你成功的用新的数据集构建了模型了吗？他能对测试数据进行验证吗？它的表现是否符合你的预期？交叉验证是否有助于提升你模型的表现？

提示：如果你是从零开始构建机器学习的代码会让你一时觉得无从下手。这时不要着急，你要做的只是查看之前写的代码，把每一行都看明白，然后逐步构建你的模型。当中遇到什么问题也可以在我们论坛寻找答案。也许你会发现你所构建的模型的表现并没有达到你的预期，这说明机器学习并非是一项简单的任务，构建一个表现良好的模型需要长时间的研究和测试。这也是我们接下来的课程中会逐渐学到的。