[Hands On ML] 2. 一个完整的机器学习项目（加州房价预测）

本文为《机器学习实战：基于Scikit-Learn和TensorFlow》的读书笔记。
中文翻译参考

1. 项目介绍

利用加州普查数据，建立一个加州房价模型。

数据包含每个街区组的人口、收入中位数、房价中位数等指标。

利用这个数据进行学习，然后根据其它指标，预测任何街区的的房价中位数。

2. 性能指标

均方根误差（RMSE）:

$$\mathrm{RMSE}(\mathbf{X},h)=\sqrt{\frac{1}{m}\sum _{i=1}^m{\left(h\left({\mathbf{x}}^{(i)}\right)-y^{(i)}\right)}^2}$$

平均绝对误差（MAE）

$$\mathrm{MAE}(\mathbf{X},h)=\frac{1}{m}\sum _{i=1}^m\left|h\left({\mathbf{x}}^{(i)}\right)-y^{(i)}\right|$$

范数的指数越高，就越关注大的值而忽略小的值。这就是为什么 RMSE 比 MAE 对异常值更敏感。但是当异常值是指数分布的（类似正态曲线），RMSE 就会表现很好。

3. 确定任务类型

是分类？（房子便宜、中等、昂贵）

是回归？（预测房子价格），本任务是回归。

4. 查看数据

import pandas as pd
data = pd.read_csv("housing.csv")
data.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 20640 entries, 0 to 20639
Data columns (total 10 columns):
longitude             20640 non-null float64
latitude              20640 non-null float64
housing_median_age    20640 non-null float64
total_rooms           20640 non-null float64
total_bedrooms        20433 non-null float64
population            20640 non-null float64
households            20640 non-null float64
median_income         20640 non-null float64
median_house_value    20640 non-null float64
ocean_proximity       20640 non-null object
dtypes: float64(9), object(1)
memory usage: 1.6+ MB

total_bedrooms 20433 non-null float64 有缺失数据

data['ocean_proximity'].value_counts()
查看 ocean_proximity 特征 有多少种值

<1H OCEAN     9136
INLAND        6551
NEAR OCEAN    2658
NEAR BAY      2290
ISLAND           5
Name: ocean_proximity, dtype: int64

data.describe()
数字特征统计

data.head()
数据前5行

%matplotlib inline
import matplotlib.pyplot as plt
data.hist(bins=50,figsize=(20,15))
直方图

数据有不同的量纲，一些数据左右分布不均匀。一般将其变为正态分布，一些模型会工作的比较好。

5. 创建测试集

from sklearn.model_selection import train_test_split
train_set, test_set = train_test_split(data, test_size=0.2, random_state=1)
train_set.info()

<class 'pandas.core.frame.DataFrame'>
Int64Index: 16512 entries, 15961 to 235
Data columns (total 10 columns):
longitude             16512 non-null float64
latitude              16512 non-null float64
housing_median_age    16512 non-null float64
total_rooms           16512 non-null float64
total_bedrooms        16349 non-null float64
population            16512 non-null float64
households            16512 non-null float64
median_income         16512 non-null float64
median_house_value    16512 non-null float64
ocean_proximity       16512 non-null object
dtypes: float64(9), object(1)
memory usage: 1.4+ MB

这种随机的切分方法，在数据量小的时候可能会出现，分出来的数据某些特征比例不再是原有的比例，后序预测可能造成误差

import numpy as np
data['income_cat'] = np.ceil(data['median_income']/1.5)
data['income_cat']
data['income_cat'].where(data['income_cat'] < 5, 5.0, inplace=True)
# pd.where() Where cond is True, keep the original value. 
# Where False, replace with corresponding value from other
大于等于 5 的， 替换成 5， 把收入分成几类
data['income_cat'].hist()
data['income_cat'].value_counts()/len(data)

3.0    0.350581
2.0    0.318847
4.0    0.176308
5.0    0.114438
1.0    0.039826
Name: income_cat, dtype: float64

• 使用 Scikit-Learn 的StratifiedShuffleSplit类，分层采样

from sklearn.model_selection import StratifiedShuffleSplit
# help(StratifiedShuffleSplit)
splt = StratifiedShuffleSplit(n_splits=1, test_size=0.2, random_state=1)
for train_idx, test_idx in splt.split(data, data['income_cat']): 
											# 按照后者分层抽样
    strat_train_set = data.loc[train_idx]
    strat_test_set = data.loc[test_idx]

# 查看分布
strat_train_set['income_cat'].value_counts()/len(strat_train_set)
strat_test_set['income_cat'].value_counts()/len(strat_test_set)

查看抽样结果，跟上面原始数据的分布很接近

3.0    0.350533
2.0    0.318798
4.0    0.176357
5.0    0.114583
1.0    0.039729
Name: income_cat, dtype: float64

分层采样的收入分类比例与总数据集几乎相同，而随机采样数据集偏差严重

删除新增列，回到初始数据状态

for set in (strat_train_set, strat_test_set):
    set.drop('income_cat',axis=1, inplace=True)
strat_train_set

6. 数据可视化

housing = strat_train_set.copy() # 复制避免损坏
housing.plot(kind='scatter',x='longitude',y='latitude')

# 调整alpha，可以看出密度差异
housing.plot(kind='scatter',x='longitude',y='latitude',alpha=0.1)

housing.plot(kind='scatter',x='longitude',y='latitude',alpha=0.4,
            s=housing['population']/100, label='population',
            c='median_house_value',cmap=plt.get_cmap('jet'))
每个圈的半径表示街区的人口（选项s），颜色代表价格（选项c）

可以看出，距离海岸近的房价较高，但是北边海岸边的价格又不是很高

7. 查找数据关联

相关系数

corr_mat = housing.corr()
corr_mat

corr_mat['median_house_value'].sort_values(ascending=False)

median_house_value    1.000000
median_income         0.684828
total_rooms           0.133566
housing_median_age    0.107684
households            0.065778
total_bedrooms        0.049941
population           -0.025008
longitude            -0.043824  # 经度，东西
latitude             -0.146748	# 纬度，南北
Name: median_house_value, dtype: float64

可以看到纬度越大（北边），房价（越低），呈负相关

attributes = ["median_house_value", "median_income", "total_rooms", "housing_median_age"]
pd.plotting.scatter_matrix(housing[attributes],figsize=(12,8))

挑几个可能跟房价先关的特征出来，画出相关性图

可以看出收入的中位数特征，最有可能用来预测房价，将该子图放大

housing.plot(kind='scatter',x='median_income',y='median_house_value',alpha=0.1)

8. 特征组合

数据在交给算法之前，最后一件事是尝试多种属性组合

例如，如果你不知道某个街区有多少户，该街区的总房间数就没什么用。你真正需要的是每户有几个房间。
相似的，总卧室数也不重要：你可能需要将其与房间数进行比较。每户的人口数也是一个有趣的属性组合。

# 每家的房间数
housing["rooms_per_household"] = housing["total_rooms"]/housing["households"]
# 每家的卧室数量比
housing["bedrooms_per_room"] = housing["total_bedrooms"]/housing["total_rooms"]
# 每家的人口
housing["population_per_household"]=housing["population"]/housing["households"]

corr_mat = housing.corr()
corr_mat['median_house_value'].sort_values(ascending=False)

median_house_value          1.000000
median_income               0.684828
rooms_per_household         0.171947  # 新特征1
total_rooms                 0.133566  # 1a  3b
housing_median_age          0.107684
households                  0.065778  # 1b  2b
total_bedrooms              0.049941  # 3a
population                 -0.025008  # 2a
population_per_household   -0.026596  # 新特征2
longitude                  -0.043824
latitude                   -0.146748
bedrooms_per_room          -0.256396  # 新特征3
Name: median_house_value, dtype: float64

可以看出新的特征比原特征，与房价之间有更高的相关性

9. 为算法准备数据

尽量写一些函数来处理，以便复用，代码也更清晰

分离 特征 与 标签
housing = strat_train_set.drop('median_house_value',axis=1)
housing_label = strat_train_set['median_house_value'].copy()

9.1 数据清洗

total_bedrooms有缺失，可以：

• 删除对应街区（删除行）
• 丢弃该特征（删除列）
• 填补数据（0，中位数，平均数等）

housing.dropna(subset=["total_bedrooms"])    # 选项1
housing.drop("total_bedrooms", axis=1)       # 选项2
median = housing["total_bedrooms"].median()	 记得保存，后序填补test集
housing["total_bedrooms"].fillna(median)    # 选项3

from sklearn.impute import SimpleImputer
impter = SimpleImputer(strategy='median')
# 数值属性才能计算中位数
housing_num = housing.drop('ocean_proximity',axis=1)
impter.fit(housing_num)
impter.statistics_

array([-118.49   ,   34.26   ,   29.     , 2122.5    ,  434.     ,
       1163.     ,  409.     ,    3.52945])

housing_num.median().values

跟上面一样
array([-118.49   ,   34.26   ,   29.     , 2122.5    ,  434.     ,
       1163.     ,  409.     ,    3.52945])

应用转换，填补确实数据为中位数

X = impter.transform(housing_num)
type(X) # numpy.ndarray

转换完为 numpy 数组，再转回 DataFrame

housing_tr = pd.DataFrame(X, columns=housing_num.columns)
type(housing_tr)  # pandas.core.frame.DataFrame

9.2 处理文本特征

LabelEncoder

from sklearn.preprocessing import LabelEncoder
encoder = LabelEncoder() # 只能对第一文本列，多文本列使用pd.factorize()
housing_cat = housing['ocean_proximity']
housing_cat_encoded = encoder.fit_transform(housing_cat)
housing_cat_encoded
print(encoder.classes_)

['<1H OCEAN' 'INLAND' 'ISLAND' 'NEAR BAY' 'NEAR OCEAN']

这样做，标签对应于 0，1，2，算法在计算距离相似度的时候，会产生偏差：（0,4显然比0,1更相似）

采用 独热编码（One-Hot Encoding），只有一个属性会等于 1（热），其余会是 0（冷），计算距离相似度的时候更合理

from sklearn.preprocessing import OneHotEncoder
encoder = OneHotEncoder()
housing_cat_1hot = encoder.fit_transform(housing_cat_encoded.reshape(-1,1))
注意：需要单列数据需要 reshape(-1,1)，转成矩阵

housing_cat_1hot
<16512x5 sparse matrix of type 'numpy.float64'>'
	with 16512 stored elements in Compressed Sparse Row format>

输出结果是一个 SciPy 稀疏矩阵，而不是 NumPy 数组。

• 使用大量内存来存储这些 0 非常浪费，所以稀疏矩阵只存储非零元素的位置
• 想将其转变成一个（密集的）NumPy 数组，只需调用toarray()方法

housing_cat_1hot.toarray()

array([[0., 0., 0., 1., 0.],
       [0., 1., 0., 0., 0.],
       [1., 0., 0., 0., 0.],
       ...,
       [1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 1., 0., 0., 0.]])

• 上面步骤的简化操作：使用类LabelBinarizer，一步执行这两个转换（从文本分类到整数分类，再从整数分类到独热向量）

from sklearn.preprocessing import LabelBinarizer
encoder = LabelBinarizer()
 		向构造器LabelBinarizer传递 sparse_output=True，就可以得到一个稀疏矩阵
housing_cat_1hot = encoder.fit_transform(housing_cat)
housing_cat_1hot

array([[0, 0, 0, 1, 0],
       [0, 1, 0, 0, 0],
       [1, 0, 0, 0, 0],
       ...,
       [1, 0, 0, 0, 0],
       [0, 1, 0, 0, 0],
       [0, 1, 0, 0, 0]])

10. 自定义转换器

创建一个类并执行三个方法：fit()（返回self），transform()，和fit_transform()

• 通过添加TransformerMixin作为基类，可以很容易地得到最后一个。
• 添加BaseEstimator作为基类（且构造器中避免使用*args和**kargs），你就能得到两个额外的方法（get_params() 和set_params()），二者可以方便地进行超参数自动微调
• 尽量给函数设置默认参数值

from sklearn.base import BaseEstimator, TransformerMixin
rooms_ix, bedrooms_ix, population_ix, household_ix = 3, 4, 5, 6

class CombinedAttributesAdder(BaseEstimator, TransformerMixin):
    def __init__(self, add_bedrooms_per_room = True): # no *args or **kargs
        self.add_bedrooms_per_room = add_bedrooms_per_room
    def fit(self, X, y=None):
        return self  # nothing else to do
    def transform(self, X, y=None):
        rooms_per_household = X[:, rooms_ix] / X[:, household_ix]
        population_per_household = X[:, population_ix] / X[:, household_ix]
        if self.add_bedrooms_per_room:
            bedrooms_per_room = X[:, bedrooms_ix] / X[:, rooms_ix]
            return np.c_[X, rooms_per_household, population_per_household,
                         bedrooms_per_room]
        else:
            return np.c_[X, rooms_per_household, population_per_household]

attr_adder = CombinedAttributesAdder(add_bedrooms_per_room=False)
housing_extra_attribs = attr_adder.transform(housing.values)
housing_extra_attribs

array([[-122.13, 37.67, 40.0, ..., 'NEAR BAY', 5.514195583596215,
        2.8832807570977916],
       [-120.98, 37.65, 40.0, ..., 'INLAND', 6.698412698412699,
        2.507936507936508],
       [-118.37, 33.87, 23.0, ..., '<1H OCEAN', 5.137640449438202,
        2.502808988764045],
       ...,
       [-117.69, 33.58, 5.0, ..., '<1H OCEAN', 6.80040733197556,
        2.9297352342158858],
       [-117.3, 34.1, 49.0, ..., 'INLAND', 4.615384615384615,
        5.846153846153846],
       [-121.77, 37.99, 4.0, ..., 'INLAND', 7.853351955307263,
        3.392458100558659]], dtype=object)

11. 特征缩放

不同的特征量纲不一样，在基于距离的机器学习算法中，特征的权重不一样，会造成误差

• 线性函数归一化（Min-Max scaling）
• 标准化（standardization）

线性函数归一化（归一化（normalization））很简单：通过减去最小值，然后再除以最大值与最小值的差值，来进行归一化。

• Scikit-Learn 提供了一个转换器MinMaxScaler来实现这个功能。它有一个超参数feature_range，可以让你改变范围，如果不希望范围是 0 到 1。

标准化：先减去平均值（所以标准化值的平均值总是 0），然后除以方差，使得到的分布具有单位方差。

• 与归一化不同，标准化不会限定值到某个特定的范围，这对某些算法可能构成问题（比如，神经网络常需要输入值得范围是 0 到 1）
• 但是，标准化受到异常值的影响很小。例如，假设一个街区的收入中位数由于某种错误变成了100，归一化会将其它范围是 0 到 15 的值变为 0-0.15，但是标准化不会受什么影响。
  Scikit-Learn 提供了一个转换器StandardScaler来进行标准化。

警告：与所有的转换一样，缩放器只能向训练集拟合，而不是向完整的数据集（包括测试集）。只有这样，你才能用缩放器转换训练集和测试集（和新数据）。

12. 转换流水线Pipeline

存在许多数据转换步骤，需要按一定的顺序执行。Scikit-Learn 提供了类Pipeline，来进行这一系列的转换。

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

num_pipeline = Pipeline([
    ('imputer',SimpleImputer(strategy='median')),
    ('attibs_adder',CombinedAttributesAdder()),
    ('std_scaler',StandardScaler()),
])
housing_num_tr = num_pipeline.fit_transform(housing_num)
housing_num_tr

array([[-1.27826235,  0.95445204,  0.89646428, ...,  0.04435599,
        -0.01693693, -0.49175254],
       [-0.70432019,  0.94509343,  0.89646428, ...,  0.56563549,
        -0.05135459, -0.99646009],
       [ 0.59827896, -0.82368426, -0.45394013, ..., -0.12139949,
        -0.05182477, -0.5064297 ],
       ...,
       [ 0.93765346, -0.95938413, -1.88378009, ...,  0.61053242,
        -0.01267723, -0.96392659],
       [ 1.13229471, -0.71606022,  1.61138426, ..., -0.35129083,
         0.25474742, -0.46992773],
       [-1.0985935 ,  1.10418984, -1.96321564, ...,  1.0740272 ,
         0.02975272, -1.15998515]])

Pipeline 构造器需要一个定义步骤顺序的名字/估计器对的列表
除了最后一个估计器，其余都要是转换器（它们都要有fit_transform()方法）。名字随意起

调用流水线的fit()方法，会对所有转换器顺序调用fit_transform()方法，将每次调用的输出作为参数传递给下一个调用
一直到最后一个估计器，它只执行fit()方法

流水线暴露相同的方法作为最终的估计器。在这个例子中，最后的估计器是一个StandardScaler，它是一个转换器，因此这个流水线有一个transform()方法，可以顺序对数据做所有转换（它还有一个fit_transform方法可以使用，就不必先调用fit()再进行transform()）

如果不需要手动将PandasDataFrame中的数值列转成Numpy数组的格式，而可以直接将DataFrame输入pipeline中进行处理就好了。
Scikit-Learn 没有工具来处理 PandasDataFrame，因此我们需要写一个简单的自定义转换器来做这项工作：

from sklearn.base import BaseEstimator, TransformerMixin

class DataFrameSelector(BaseEstimator, TransformerMixin):
    def __init__(self,attribute_names):
        self.attribute_names = attribute_names
    def fit(self,X,y=None):
        return self
    def transform(self,X):
        return X[self.attribute_names].values

# 报错参考 https://blog.csdn.net/jasonzhoujx/article/details/82025571
class MyLabelBinarizer(TransformerMixin):
    def __init__(self, *args, **kwargs):
        self.encoder = LabelBinarizer(*args, **kwargs)
    def fit(self, x, y=0):
        self.encoder.fit(x)
        return self
    def transform(self, x, y=0):
        return self.encoder.transform(x)

from sklearn.pipeline import FeatureUnion
num_attribs = list(housing_num)
cat_attribs = ["ocean_proximity"]

num_pipeline = Pipeline([
    ('selector',DataFrameSelector(num_attribs)),
    ('Simpleimputer', SimpleImputer(strategy="median")),
    ('attribs_adder', CombinedAttributesAdder()),
    ('std_scaler', StandardScaler()),
])

cat_pipeline = Pipeline([
    ('selector',DataFrameSelector(cat_attribs)),
    ('label_binarizer',MyLabelBinarizer())
])

full_pipeline = FeatureUnion(transformer_list=[
    ('num_pipeline',num_pipeline),
    ('cat_pipeline',cat_pipeline),
])
# help(FeatureUnion)

housing_prepared = full_pipeline.fit_transform(housing)
housing_prepared

array([[-1.27826235,  0.95445204,  0.89646428, ...,  0.        ,
         1.        ,  0.        ],
       [-0.70432019,  0.94509343,  0.89646428, ...,  0.        ,
         0.        ,  0.        ],
       [ 0.59827896, -0.82368426, -0.45394013, ...,  0.        ,
         0.        ,  0.        ],
       ...,
       [ 0.93765346, -0.95938413, -1.88378009, ...,  0.        ,
         0.        ,  0.        ],
       [ 1.13229471, -0.71606022,  1.61138426, ...,  0.        ,
         0.        ,  0.        ],
       [-1.0985935 ,  1.10418984, -1.96321564, ...,  0.        ,
         0.        ,  0.        ]])

13. 训练模型

初步选择 线性回归模型

from sklearn.linear_model import LinearRegression
lin_reg = LinearRegression()
lin_reg.fit(housing_prepared, housing_label)

somedata = housing.iloc[:5]
somelabel = housing_label.iloc[:5]
somedata_prepared = full_pipeline.transform(somedata)
print('predict:\t', lin_reg.predict(somedata_prepared))
print('Labels:\t',list(somelabel))

predict:	 [234956.84260842 303073.513104   327746.46204573 355932.30741583
 210220.50294171]
Labels:	 [184000.0, 172200.0, 359900.0, 258200.0, 239100.0]

from sklearn.metrics import mean_squared_error
housing_predict = lin_reg.predict(housing_prepared)
lin_mse = mean_squared_error(housing_predict, housing_label)
lin_rmse = np.sqrt(lin_mse)
lin_rmse

68860.85279166883

误差很大，效果不是很理想

模型欠拟合：

• 意味着特征没有提供足够多的信息来做出一个好的预测
• 或者模型并不强大

修复欠拟合的主要方法：

• 选择一个更强大的模型，给训练算法提供更好的特征
• 或减少模型上的限制，减少正则化强度

先让我们尝试一个更为复杂的模型，看看效果。

来训练一个DecisionTreeRegressor。这是一个强大的模型，可以发现数据中复杂的非线性关系

from sklearn.tree import DecisionTreeRegressor

tree_reg = DecisionTreeRegressor()
tree_reg.fit(housing_prepared, housing_label)

housing_predictions = tree_reg.predict(housing_prepared)
tree_mse = mean_squared_error(housing_label, housing_predictions)
tree_rmse = np.sqrt(tree_mse)
tree_rmse

误差 0.0，太强了? 错了，上面使用了全部的训练集训练，然后在训练集上预测，产生了过拟合

14. 交叉验证

K 折交叉验证（K-fold cross-validation）：

• 随机地将训练集分成十个不同的子集，成为“折”
• 训练评估决策树模型 10 次，每次选一个不用的折来做评估，用其它 9 个来做训练
• 结果是一个包含 10 个评分的数组

from sklearn.model_selection import cross_val_score
scores = cross_val_score(tree_reg,housing_prepared,housing_label,
                        scoring='neg_mean_squared_error', cv=10)
tree_rmse_scores = np.sqrt(-scores) # sklearn用的是负数
print(tree_rmse_scores)
print(tree_rmse_scores.mean())
print(tree_rmse_scores.std())

[71214.4929498  71929.79930468 70914.76077221 69550.72566912
 71042.25558966 67279.14165025 73061.35854347 71568.85256242
 71380.99149371 69504.81637098]
70744.71949063087
1522.0580698181013

再用 线性回归 模型，试下交叉验证的结果

lin_scores = cross_val_score(lin_reg, housing_prepared, housing_label,
                            scoring='neg_mean_squared_error', cv=10)
lin_rmse_scores = np.sqrt(-lin_scores)
print(lin_rmse_scores)
print(lin_rmse_scores.mean())
print(lin_rmse_scores.std())

[70987.24786319 66375.29508519 73837.53789445 69493.59584642
 69821.05544742 69047.06162451 65908.72602507 66979.33032669
 73036.00622233 67077.50225384]
69256.33585891136
2610.121268165482

再试下 随机森林 模型

from sklearn.ensemble import RandomForestRegressor
forest_reg = RandomForestRegressor()
forest_scores = cross_val_score(forest_reg,housing_prepared,housing_label,
                               scoring='neg_mean_squared_error',cv=10)
forest_rmse_scores = np.sqrt(-forest_scores)
print(forest_rmse_scores)
print(forest_rmse_scores.mean())
print(forest_rmse_scores.std())

[51968.86058788 47122.75805482 48941.3492676  50877.99429489
 51200.95320051 49198.87467112 49401.27484477 48418.53618115
 53788.16232918 49438.88539583]
50035.76488277516
1834.1856707471993

随机森林模型，比上面2个模型得到的结果的误差要小。看起来是个不错的选择。

在深入随机森林之前，应该尝试下机器学习算法的其它类型模型（不同核的支持向量机，神经网络，等等），不要在调节超参数上花费太多时间。目标是列出一个可能模型的列表（两到五个）。

提示：要保存每个试验过的模型，以便后续可以再用。
要确保有超参数和训练参数，以及交叉验证评分，和实际的预测值。
这可以让你比较不同类型模型的评分，还可以比较误差种类。
你可以用 Python 的模块 pickle，非常方便地保存 Scikit-Learn 模型，或使用 sklearn.externals.joblib，后者序列化大 NumPy 数组更有效率

from sklearn.externals import joblib
joblib.dump(forest_reg, "my_forest.pkl")
my_forest_model = joblib.load("my_forest.pkl")

15. 微调模型

假设有几个有希望的模型。现在需要对它们进行微调

15.1 网格搜索

你应该使用 Scikit-Learn 的 GridSearchCV 来做这项搜索工作

• 告诉GridSearchCV要试验有哪些超参数
• 要试验什么值
• GridSearchCV 就能用 交叉验证 试验所有可能超参数值的组合

from sklearn.model_selection import GridSearchCV

param_grid = [
    {'n_estimators' : [3,10,30],'max_features':[2,4,6,8]},
    {'bootstrap':[False], 'n_estimators' : [3,10],'max_features':[2,3,4]},
]
forest_reg = RandomForestRegressor()
grid_search = GridSearchCV(forest_reg, param_grid, cv=5,
                          scoring='neg_mean_squared_error')
grid_search.fit(housing_prepared, housing_label)

#----------------------------------
GridSearchCV(cv=5, error_score=nan,
             estimator=RandomForestRegressor(bootstrap=True, ccp_alpha=0.0,
                                             criterion='mse', max_depth=None,
                                             max_features='auto',
                                             max_leaf_nodes=None,
                                             max_samples=None,
                                             min_impurity_decrease=0.0,
                                             min_impurity_split=None,
                                             min_samples_leaf=1,
                                             min_samples_split=2,
                                             min_weight_fraction_leaf=0.0,
                                             n_estimators=100, n_jobs=None,
                                             oob_score=False, random_state=None,
                                             verbose=0, warm_start=False),
             iid='deprecated', n_jobs=None,
             param_grid=[{'max_features': [2, 4, 6, 8],
                          'n_estimators': [3, 10, 30]},
                         {'bootstrap': [False], 'max_features': [2, 3, 4],
                          'n_estimators': [3, 10]}],
             pre_dispatch='2*n_jobs', refit=True, return_train_score=False,
             scoring='neg_mean_squared_error', verbose=0)

• param_grid告诉 Scikit-Learn 首先评估第一个dict中的 n_estimators 和max_features 的3 × 4 = 12种组合
• 然后尝试第二个dict中超参数的2 × 3 = 6种组合，这次会将超参数bootstrap设为False而不是True
• 网格搜索会探索12 + 6 = 18 种 RandomForestRegressor 的超参数组合，会训练每个模型五次（cv=5）。训练总共有18 × 5 = 90轮！

完成后，你就能获得参数的最佳组合

grid_search.best_params_

{'max_features': 8, 'n_estimators': 30}
注意到参数在边界上，可能还要继续扩大范围搜索

最佳的模型

grid_search.best_estimator_
#---------output-------------
RandomForestRegressor(bootstrap=True, ccp_alpha=0.0, criterion='mse',
                      max_depth=None, max_features=8, max_leaf_nodes=None,
                      max_samples=None, min_impurity_decrease=0.0,
                      min_impurity_split=None, min_samples_leaf=1,
                      min_samples_split=2, min_weight_fraction_leaf=0.0,
                      n_estimators=30, n_jobs=None, oob_score=False,
                      random_state=None, verbose=0, warm_start=False)

cv_result = grid_search.cv_results_
for mean_score, params in zip(cv_result['mean_test_score'], cv_result['params']):
    print(np.sqrt(-mean_score), params)

grid_search.cv_results_ 包含的内容：

cv_result = grid_search.cv_results_
for mean_score, params in zip(cv_result['mean_test_score'], cv_result['params']):
    print(np.sqrt(-mean_score), params)

18 种模型参数下的模型表现
65764.17270897377 {'max_features': 2, 'n_estimators': 3}
55028.13746266011 {'max_features': 2, 'n_estimators': 10}
53074.92097234033 {'max_features': 2, 'n_estimators': 30}
59883.77893095 {'max_features': 4, 'n_estimators': 3}
53191.69949879354 {'max_features': 4, 'n_estimators': 10}
50181.08262957352 {'max_features': 4, 'n_estimators': 30}
58994.29777449576 {'max_features': 6, 'n_estimators': 3}
52167.31741521162 {'max_features': 6, 'n_estimators': 10}
50241.45200619339 {'max_features': 6, 'n_estimators': 30}
58312.46978517355 {'max_features': 8, 'n_estimators': 3}
52411.65674754867 {'max_features': 8, 'n_estimators': 10}
49864.0026039013 {'max_features': 8, 'n_estimators': 30}
62905.486606479426 {'bootstrap': False, 'max_features': 2, 'n_estimators': 3}
54197.59949544192 {'bootstrap': False, 'max_features': 2, 'n_estimators': 10}
60303.313894870866 {'bootstrap': False, 'max_features': 3, 'n_estimators': 3}
52881.46279898861 {'bootstrap': False, 'max_features': 3, 'n_estimators': 10}
58317.06280296479 {'bootstrap': False, 'max_features': 4, 'n_estimators': 3}
51572.96293902154 {'bootstrap': False, 'max_features': 4, 'n_estimators': 10}

提示：可以像超参数一样处理数据准备的步骤。

---

例如，网格搜索可以自动判断 是否添加一个你不确定的特征（比如，使用转换器CombinedAttributesAdder 的超参数 add_bedrooms_per_room）。

它还能用相似的方法来自动找到处理异常值、缺失特征、特征选择等任务的最佳方法。

15.2 随机搜索

当探索相对较少的组合时，就像前面的例子，网格搜索还可以。
但是当超参数的搜索空间很大时，最好使用 RandomizedSearchCV。

其搜索策略如下：
（a）对于搜索范围是distribution的超参数，根据给定的distribution随机采样；
（b）对于搜索范围是list的超参数，在给定的list中等概率采样；
（c）对a、b两步中得到的n_iter组采样结果，进行遍历。
（补充）如果给定的搜索范围均为list，则不放回抽样n_iter次。
原文链接：https://blog.csdn.net/qq_36810398/java/article/details/86699842

两者的区别参考以下博文：
https://blog.csdn.net/qq_36810398/article/details/86699842
https://blog.csdn.net/juezhanangle/article/details/80051256

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint
param_distribs = {
    'n_estimators':randint(low=1, high=200),
    'max_features':randint(low=1, high=8),
}
forest_reg = RandomForestRegressor(random_state=1)
rand_search = RandomizedSearchCV(forest_reg, param_distributions=param_distribs,
                                n_iter=10, cv=5, scoring='neg_mean_squared_error',random_state=1)
rand_search.fit(housing_prepared, housing_label)

RandomizedSearchCV(cv=5, error_score=nan,
                   estimator=RandomForestRegressor(bootstrap=True,
                                                   ccp_alpha=0.0,
                                                   criterion='mse',
                                                   max_depth=None,
                                                   max_features='auto',
                                                   max_leaf_nodes=None,
                                                   max_samples=None,
                                                   min_impurity_decrease=0.0,
                                                   min_impurity_split=None,
                                                   min_samples_leaf=1,
                                                   min_samples_split=2,
                                                   min_weight_fraction_leaf=0.0,
                                                   n_estimators=100,
                                                   n_jobs=None, oob_score=Fals...
                   iid='deprecated', n_iter=10, n_jobs=None,
                   param_distributions={'max_features': <scipy.stats._distn_infrastructure.rv_frozen object at 0x0000017B8CEFFF98>,
                                        'n_estimators': <scipy.stats._distn_infrastructure.rv_frozen object at 0x0000017B8C711BE0>},
                   pre_dispatch='2*n_jobs', random_state=1, refit=True,
                   return_train_score=False, scoring='neg_mean_squared_error',
                   verbose=0)

search_result = rand_search.cv_results_
for mean_score, params in zip(search_result['mean_test_score'], search_result['params']):
    print(np.sqrt(-mean_score),params)
    
feature_importance = rand_search.best_estimator_.feature_importances_
sorted(zip(feature_importance, attributes), reverse=True)

[(0.3266343000845554, 'median_income'),
 (0.14655427173815663, 'INLAND'),
 (0.10393984611581725, 'pop_per_hhold'),
 (0.07978993056196858, 'bedrooms_per_room'),
 (0.07850738357218873, 'longitude'),
 (0.06969306682249354, 'latitude'),
 (0.05962901176048446, 'rooms_per_hhold'),
 (0.04273624791392784, 'housing_median_age'),
 (0.018322580791300728, 'total_rooms'),
 (0.017916659917498783, 'population'),
 (0.017041691466405204, 'total_bedrooms'),
 (0.015954810875574967, 'households'),
 (0.013358851743037617, '<1H OCEAN'),
 (0.0059438389065000225, 'NEAR OCEAN'),
 (0.003697096190985686, 'NEAR BAY'),
 (0.0002804115391046209, 'ISLAND')]

15.3 集成方法

另一种微调系统的方法是将表现最好的模型组合起来。
组合（集成）之后的性能通常要比单独的模型要好（就像随机森林要比单独的决策树要好），特别是当单独模型的误差类型不同时。

16. 分析最佳模型的误差

通过分析最佳模型，常常可以获得对问题更深的了解。
比如，RandomForestRegressor 可以指出每个属性对于做出准确预测的相对重要性：

feature_importances = grid_search.best_estimator_.feature_importances_
feature_importances

array([6.92844433e-02, 6.58717797e-02, 4.39855401e-02, 1.58155272e-02,
       1.54980143e-02, 1.58108677e-02, 1.41614038e-02, 3.52323623e-01,
       4.41751467e-02, 1.10901558e-01, 8.01958553e-02, 3.59928828e-03,
       1.63144911e-01, 2.10262727e-04, 1.92134774e-03, 3.10043063e-03])

把特征名字也打印出来

extra_attribs = ["rooms_per_hhold", "pop_per_hhold", "bedrooms_per_room"]
cat_one_hot_attribs = list(encoder.classes_)
cat_one_hot_attribs
# ['<1H OCEAN', 'INLAND', 'ISLAND', 'NEAR BAY', 'NEAR OCEAN']

attributes = num_attribs + extra_attribs + cat_one_hot_attribs
attributes
['longitude',
 'latitude',
 'housing_median_age',
 'total_rooms',
 'total_bedrooms',
 'population',
 'households',
 'median_income',
 'rooms_per_hhold',
 'pop_per_hhold',
 'bedrooms_per_room',
 '<1H OCEAN',
 'INLAND',
 'ISLAND',
 'NEAR BAY',
 'NEAR OCEAN']

sorted(zip(feature_importances,attributes), reverse=True)

[(0.3523236234176724, 'median_income'),
 (0.16314491099438777, 'INLAND'),
 (0.11090155811701467, 'pop_per_hhold'),
 (0.08019585526690289, 'bedrooms_per_room'),
 (0.06928444332660065, 'longitude'),
 (0.06587177968295425, 'latitude'),
 (0.04417514666849209, 'rooms_per_hhold'),
 (0.04398554014357369, 'housing_median_age'),
 (0.015815527234205994, 'total_rooms'),
 (0.015810867735057542, 'population'),
 (0.015498014277829743, 'total_bedrooms'),
 (0.014161403758405241, 'households'),
 (0.0035992882775714432, '<1H OCEAN'),
 (0.0031004306281128724, 'NEAR OCEAN'),
 (0.0019213477443202828, 'NEAR BAY'),
 (0.00021026272689858585, 'ISLAND')]

有了这个信息，你就可以丢弃一些不那么重要的特征（比如，显然只要一个ocean_proximity 的类型（INLAND）就够了，所以可以丢弃掉其它的）。

还应该看一下系统的特定误差，搞清为什么会有误差，如何改正问题（添加更多的特征，去掉没有什么信息的特征，清洗异常值等等）。

17. 用测试集评估模型

final_model = grid_search.best_estimator_

X_test = strat_test_set.drop("median_house_value", axis=1)
y_test = strat_test_set["median_house_value"].copy()

X_test_prepared = full_pipeline.transform(X_test)

final_predict = final_model.predict(X_test_prepared)

final_mse = mean_squared_error(y_test, final_predict)
final_rmse = np.sqrt(final_mse)
final_rmse # 47818.484839863646

18. 启动、监控、维护系统

• 编写监控代码，以固定间隔检测系统的实时表现，当发生下降时触发报警。

• 评估系统的表现需要对预测值采样并进行评估。

• 你还要评估系统输入数据的质量。

• 你可能想定期用新数据训练模型。你应该尽可能自动化这个过程。

• 如果你的系统是一个线上学习系统，你需要定期保存系统状态快照，好能方便地回滚到之前的工作状态。

19. 练习

19.1 pipeline加入特征选择、预测

# 选择最好的k个特征
from sklearn.base import BaseEstimator, TransformerMixin

def indices_of_topK_feature(arr, k):
    return np.sort(np.argpartition(np.array(arr), -k)[-k:])
class TopFeatureSelector(BaseEstimator,TransformerMixin):
    def __init__(self, feature_importance, k):
        self.feature_importance = feature_importance
        self.k = k
    def fit(self, X, y=None):
        self.feature_indices_ = indices_of_topK_feature(self.feature_importance, self.k)
        return self
    def transform(self,X):
        return X[:, self.feature_indices_]

k=5
topK_features = indices_of_topK_feature(feature_importance,k)
topK_features # array([ 0,  7,  9, 10, 12], dtype=int64)

np.array(attributes)[topK_features]
# array(['longitude', 'median_income', 'pop_per_hhold', 'bedrooms_per_room',
       'INLAND'], dtype=')

sorted(zip(feature_importance, attributes), reverse=True)[:k]

# [(0.3266343000845554, 'median_income'),
 (0.14655427173815663, 'INLAND'),
 (0.10393984611581725, 'pop_per_hhold'),
 (0.07978993056196858, 'bedrooms_per_room'),
 (0.07850738357218873, 'longitude')]

• pipeline加入特征选优模块

preparation_and_feature_selection_pipeline = Pipeline([
    ('preparation', full_pipeline),
    ('feature_selection', TopFeatureSelector(feature_importance, k))
])

housing_prepared_top_k_features = preparation_and_feature_selection_pipeline.fit_transform(housing)

• pipeline加入预测

prepare_select_and_predict_pipeline = Pipeline([
    ('preparation', full_pipeline),
    ('feature_selection', TopFeatureSelector(feature_importance, k)),
    ('forst_reg', RandomForestRegressor())
])
prepare_select_and_predict_pipeline.fit(housing, housing_label)

some_data = housing.iloc[:4]
some_label = housing_label.iloc[:4]

print("Predictions:\t", prepare_select_and_predict_pipeline.predict(some_data))
print("Labels:\t\t", list(some_label))

Predictions:	 [183259.   209045.04 375686.02 296260.05]
Labels:		 [184000.0, 172200.0, 359900.0, 258200.0]

• 数据准备的最佳参数搜索，以下找到填补缺失值的最佳选项和特征个数的最佳值

param_grid = [{
    'preparation__num__imputer__strategy': ['mean', 'median', 'most_frequent'],
    'feature_selection__k': list(range(1, len(feature_importance) + 1))
}]

grid_search_prep = GridSearchCV(prepare_select_and_predict_pipeline, param_grid, cv=5,
                                scoring='neg_mean_squared_error', verbose=2, n_jobs=4)
grid_search_prep.fit(housing, housing_label)

grid_search_prep.best_params_

》》》{'feature_selection__k': 15,
 'preparation__num__imputer__strategy': 'most_frequent'}