a)下载tgz文件,在本地解压为csv格式文件
import os
import tarfile
from six.moves import urllib
#远程网站根目录
DOWNLOAD_ROOT = "https://raw.githubusercontent.com/ageron/handson-ml/master/"
#存放csv文件的目录,同时作为本地存放csv文件的目录
HOUSING_PATH = "datasets/housing"
#远程压缩文件全路径=网站根目录+存放csv文件的目录+压缩文件名
HOUSING_URL = DOWNLOAD_ROOT + HOUSING_PATH + "/housing.tgz"
def fetch_housing_data(housing_url=HOUSING_URL, housing_path=HOUSING_PATH):
#将压缩文件全路径 和 本地存放csv文件目录 作为参数传入函数
#本地存放csv文件目录不存在,则创建
if not os.path.isdir(housing_path):
os.makedirs(housing_path)
#本地压缩文件相对路径
tgz_path = os.path.join(housing_path, "housing.tgz")
#从远程压缩文件全路径 取回压缩文件,存放到 本地压缩文件相对路径
urllib.request.urlretrieve(housing_url, tgz_path)
#打开文件,并提取(解压)到 本地存放csv文件目录,然后关闭文件
housing_tgz = tarfile.open(tgz_path)
housing_tgz.extractall(path=housing_path)
housing_tgz.close()
fetch_housing_data()
b) 用pandas.read_csv()读取csv数据,返回一个pandas.DataFrame对象
import pandas as pd
def load_housing_data(housing_path=HOUSING_PATH):
csv_path = os.path.join(housing_path, "housing.csv")
return pd.read_csv(csv_path)
housing = load_housing_data()
c) 查看pandas.DataFrame对象信息:
housing.head()#查看前5条记录
housing.info()#查看每列信息,包括column name,number of non-null values,datatype
housing.describe()#每列数据的详细统计信息,包括count, mean, std, min, 25%, 50%, 75%, max of each column
housing["ocean_proximity"].value_counts()#查看每列不同值的统计信息
d)可视化,以对数据有个初步的感性认识
%matplotlib inline
import matplotlib.pyplot as plt
#为每个数值属性绘制直方图,50个数据刻度,每张图的大小是(20,15)
#housing数据集有9个数值属性
housing.hist(bins=50,figsize=(20,15));
e) 分割数据,得到训练集和测试集
Scikit-Learn 提供了一些函数,可以用多种方式将数据集分割成多个子集。最简单的函数
是sklearn.model_selection.train_test_split()函数,将原始数据集分割为训练集和测试集。其中,
test_size指示测试集占原始数据集的比例,
random_state=42指示随机参数(指定相同的种子参数,则每次分割得到相同结果)
from sklearn.model_selection import train_test_split
train_set,test_set = train_test_split(housing,test_size=0.2,random_state=42)
根据收入分类,进行分层采样。可以使用 Scikit-Learn的 StratifiedShuffleSplit 类:
#先为数据集增加一列income_cat,值为median_income/1.5取整,值超过5.0的取5.0
housing["income_cat"]=np.ceil(housing["median_income"]/1.5)
housing["income_cat"].where(housing["income_cat"]<5, 5.0, inplace=True)
#然后根据income_cat列的不同值所占比例采样,避免采样偏差
from sklearn.model_selection import StratifiedShuffleSplit
#n_splits=1表示shuffle的次数
split = StratifiedShuffleSplit(n_splits=1, test_size=0.2, random_state=42)
for train_index, test_index in split.split(housing, housing["income_cat"]):
strat_train_set = housing.loc[train_index]
strat_test_set = housing.loc[test_index]
#最后,把income_cat列从训练集和测试集中删掉,inplace=True表示在原始数据集上直接操作
for set in (strat_train_set,strat_test_set):
set.drop(["income_cat"],axis=1, inplace=True)
a) 绘制散点图,从直观上猜测数据属性之间的关联
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"),colorbar=True)
plt.legend();
b) 查找关联
使用 corr() 方法计算出每对属性间的标准相关系数(standard correlation coefficient,也称作皮尔逊相关系数) :
corr_matrix = housing.corr()
corr_matrix["median_house_value"].sort_values(ascending=False)
另一种检测属性间相关系数的方法是使用 Pandas 的 scatter_matrix 函数,它能画出一个数
值属性集合中每对数值属性的关系图。
from pandas.tools.plotting import scatter_matrix
attributes = ["median_house_value", "median_income", "total_rooms",
"housing_median_age"]
scatter_matrix(housing[attributes], figsize=(12, 8))
c) 属性组合实验
尝试衍生属性,即从现存属性的组合中得到新的相关属性,再计算这些属性与原来属性之间的关联。
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_matrix = housing.corr()
corr_matrix["median_house_value"].sort_values(ascending=False)
a) 将训练集分割为预测量和标签,即X和y
housing = strat_train_set.drop("median_house_value", axis=1)
housing_labels = strat_train_set["median_house_value"].copy()
b) 处理缺失值
属性total_bedroom存在缺失值,三种解决方式:
housing.dropna(subset=["total_bedrooms"]) # 选项1,如果在原始数据集上修改,加上inplace=True选项
housing.drop("total_bedrooms", axis=1) # 选项2
median = housing["total_bedrooms"].median()#先计算中位数
housing["total_bedrooms"].fillna(median) # 选项3
更简便的方式是Scikit-Learn的类Imputer,可以以多种策略strategy来填充缺失值
from sklearn.preprocessing import Imputer
imputer = Imputer(strategy="median")
麻烦的地方是,需要把非数值属性ocean_proximity剔除,填充之后,再合并回来。
housing_num = housing.drop("ocean_proximity", axis=1)#剔除
imputer.fit(housing_num) #拟合
X = imputer.transform(housing_num) #转换为Numpy数组
housing_tr = pd.DataFrame(X, columns=housing_num.columns) #将数组转换为数据集的原始类型DataFrame
事实上,imputer.statistics_中存放了所有(数值)属性的中位数
>>>imputer.statistics_
array([ -118.51 , 34.26 , 29. , 2119. , 433. , 1164. , 408. , 3.5414])
>>>housing_num.median().values
array([ -118.51 , 34.26 , 29. , 2119. , 433. , 1164. , 408. , 3.5414])
c) 将非数值(文本和分类)属性值转化为数值
利用Scikit-Learn的LabelEncoder类可以实现,但缺点是只能处理一个非数值属性,多个非数值属性需要分别处理,再合并。顾名思义,LabelEncoder设计目的也是处理数据集中的标签label。
from sklearn.preprocessing import LabelEncoder
encoder = LabelEncoder()
housing_cat = housing["ocean_proximity"]
housing_cat_encoded = encoder.fit_transform(housing_cat)
>>> housing_cat_encoded
array([1, 1, 4, ..., 1, 0, 3])
可以通过LabelEncoder的classes_属性查看学习到的映射(<1H OCEAN 被映射为 0, INLAND 被映射为 1,等等),将n个不同的非数值属性值转化为0到n-1之间的数字。
>>> print(encoder.classes_)
['<1H OCEAN' 'INLAND' 'ISLAND' 'NEAR BAY' 'NEAR OCEAN']
缺点是映射为数字之后,数字之间的距离不一定能反映出非数值属性值之间的近似度。例如,0和4所代表的分类'<1H OCEAN'
和'NEAR OCEAN'
之间的近似度远大于0和1所代表的的分类'<1H OCEAN'
和'INLAND'
。
One-Hot编码可以部分解决这个问题:将不同的非数值属性值对应的数字映射为向量,向量之间彼此正交,不存在哪两个向量更近似(近似度都为0),但没有解决相似非数值属性值之间语义近似的问题(可以通过训练embedding解决)。
from sklearn.preprocessing import OneHotEncoder
encoder = OneHotEncoder()
housing_cat_1hot = encoder.fit_transform(housing_cat_encoded.reshape(-1,1))
>>> housing_cat_1hot
<16513x5 sparse matrix of type 'numpy.float64'>'
with 16513 stored elements in Compressed Sparse Row format>
>>> housing_cat_1hot.toarray()
array([[ 0., 1., 0., 0., 0.],
[ 0., 1., 0., 0., 0.],
[ 0., 0., 0., 0., 1.],
...,
[ 0., 1., 0., 0., 0.],
[ 1., 0., 0., 0., 0.],
[ 0., 0., 0., 1., 0.]])
使用类 LabelBinarizer ,我们可以用一步执行这两个转换(从文本分类到整数分类,再从整
数分类到独热向量) :
from sklearn.preprocessing import LabelBinarizer
encoder = LabelBinarizer()
housing_cat_1hot = encoder.fit_transform(housing_cat)
>>> housing_cat_1hot
array([[0, 1, 0, 0, 0],
[0, 1, 0, 0, 0],
[0, 0, 0, 0, 1],
...,
[0, 1, 0, 0, 0],
[1, 0, 0, 0, 0],
[0, 0, 0, 1, 0]])
注意默认返回的结果是一个密集 NumPy 数组。向构造器 LabelBinarizer 传递 sparse_output=True ,就可以得到一个稀疏矩阵。
d) 自定义转换器
可以自定义转换器(transformer)来执行前面提到的一些任务,例如缺失值填充、组合属性得到新属性,将非数值属性转换为数值属性。
如果希望自定义的转换器可以与现有的Scikit-Learn组件(例如pipeline)无缝连接,就需要创建一个类,并实现fit(),transfrom()和fit_transform()方法。实现fit()用于与前一个组件连接,实现transfrom()用于与下一个组件相连。将TransformerMixin 作为基类,自动得到fit_transform()方法。添加 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是numpy.ndarray类型。下面代码将其转换为DataFrame类型
housing_extra_dataframe= pd.DataFrame(housing_extra_attribs,
columns=housing.columns.append(Index( ["rooms_per_household","population_per_household"])))
#查看转换是否成功
housing_extra_dataframe.head()
e) 特征缩放
目的是让每个特征具有相同的量纲(**问题是,one-hot向量如何缩放才能与其他属性值量纲相同?**答案是one-hot向量占据多列,每一列或是1或是0。也就是说,把向量的每个分量看作一个单独的属性)。两种方式:线性函数归一化(Min-Max scaling)和
标准化(standardization)。
线性函数归一化(或归一化normalization):通过减去最小值,然后再除以最大值与最小值的差值,来进行归一化。Scikit-Learn 提供了一个转换器 MinMaxScaler来实现这个功能。如果不希望范围是 0 到 1,可以利用超参数 feature_range指定范围。
from sklearn.preprocessing import MinMaxScaler
scaler=MinMaxScaler(feature_range=(0,2))#可以指定特征的值的范围
scaler.fit_transform(np.array(housing["total_rooms"]).reshape(-1,1))
#只接受二维ndarry,而housing["total_rooms"]是Series类型
标准化:减去平均值,除以方差。标准化不会限定值到某个特定的范围,这对某些算法可能构成问题(比如,神经网络常需要输入值得范围是 0 到 1) 。但是,标准化受到异常值的影响很小。例如,假设一个街区的收入中位数由于某种错误变成了100,归一化会将其它范围是 0 到 15 的值变为 0-0.15,但是标准化不会受什么影响。Scikit-Learn 提供了一个转换器 StandardScaler 来进行标准化。
f) 转换流水线
许多数据转换由一系列子转换构成。Scikit-Learn 提供了Pipeline类来完成这一任务。
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
num_pipeline = Pipeline([
('imputer',SimpleImputer(strategy="median")),
('attribs_adder',CombinedAttributesAdder()),
('std_scaler',StandardScaler())
])
#type(housing_num)是numpy.ndarray
housing_num_tr=num_pipeline.fit_transform(housing_num)
Pipeline 构造器的list类型参数定义了名字/估计器对序列。除了最后一个估计器,其余还必须是转换器(如前所述,转换器都是估计器)。调用流水线的 fit() 方法,就会对所有转换器顺序调用 fit_transform() 方法,将每次调用的输出作为参数传递给下一个调用,一直到最后一个估计器,它只执行 fit() 方法。上面例子中最后的估计器是一个 StandardScaler ,它也是一个转换器,因此这个流水线有一个 transform() 方法,可以顺序对数据做所有转换。
这个流水线用于处理数值型属性,还需要一个Pipeline处理分类型属性。
然后,使用Scikit-Learn中FeatureUnion类将两个Pipeline的输出合并起来。一个完整的处理数值和类别属性的流水线如下所示:
from sklearn.pipeline import FeatureUnion
from sklearn.preprocessing import OneHotEncoder
num_attribs = list(housing_num)
cat_attribs = ["ocean_proximity"]
num_pipeline = Pipeline([
('selector', DataFrameSelector(num_attribs)),
('imputer', SimpleImputer(strategy="median")),
('attribs_adder', CombinedAttributesAdder()),
('std_scaler', StandardScaler()),
])
cat_pipeline = Pipeline([
('selector', DataFrameSelector(cat_attribs)),
('1hot_encoder', OneHotEncoder()),
])
full_pipeline = FeatureUnion(transformer_list=[
("num_pipeline", num_pipeline),
("cat_pipeline", cat_pipeline),
])
其中,
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
>>> housing_prepared = full_pipeline.fit_transform(housing)
>>> housing_prepared
array([[ 0.73225807, -0.67331551, 0.58426443, ..., 0. ,
0. , 0. ],
[-0.99102923, 1.63234656, -0.92655887, ..., 0. ,
0. , 0. ],
[...]
>>> housing_prepared.shape
(16513, 17)
与书上结果不同,我的结果是(16512,16)
a) 在训练集上训练和评估
#导入线性回归模型
from sklearn.linear_model import LinearRegression
#初始化一个模型实例
lin_reg=LinearRegression()
#模型训练
lin_reg.fit(housing_prepared,housing_labels)
#这里用训练集中的部分数据测试训练效果
some_data=housing.iloc[:5]
some_labels=housing_labels.iloc[:5]
#用pipeline预处理测试数据
some_data_prepared=full_pipeline.transform(some_data)
#打印出测试结果,与标签对比
print("Predictions:\t", lin_reg.predict(some_data_prepared))
print("Labels:\t\t", list(some_labels))
#计算模型的RMSE(Root Mean Squared Error)
from sklearn.metrics import mean_squared_error
housing_predictions=lin_reg.predict(housing_prepared)
lin_mse= mean_squared_error(housing_labels,housing_predictions)
lin_rmse=np.sqrt(lin_mse)
lin_rmse
#导入决策树回归模型
from sklearn.tree import DecisionTreeRegressor
tree_reg=DecisionTreeRegressor()
tree_reg.fit(housing_prepared,housing_labels)
housing_predictions=tree_reg.predict(housing_prepared)
tree_mse=mean_squared_error(housing_labels,housing_predictions)
tree_mse
b) 交叉验证
K 折交叉验证(K-fold cross-validation):
Scikit-Learn 交叉验证功能期望的是效用函数(越大越好) 而不是损失函数(越低越好) ,因此得分函数实际上与 MSE 相反(即负值) ,这就是为什么前面的代码在计算平方根之前先计算 -scores 。
from sklearn.model_selection import cross_val_score
scores=cross_val_score(tree_reg,housing_prepared,housing_labels,
scoring="neg_mean_squared_error",cv=10)
rmse_scores=np.sqrt(-scores)
#定义一个显示结果的函数
def display_scores(scores):
print("Scores:",scores)
print("Mean:",scores.mean())
print("Standard deviation:",scores.std())
display_scores(rmse_scores)
#导入随机森林回归模型
from sklearn.ensemble import RandomForestRegressor
forest_reg=RandomForestRegressor()
forest_reg.fit(housing_prepared,housing_labels)
forest_predictions=forest_reg.predict(housing_prepared)
forest_mse=mean_squared_error(housing_labels,forest_predictions)
forest_rmse=np.sqrt(forest_mse)
print(forest_rmse)
forest_scores=cross_val_score(forest_reg,housing_prepared,
housing_labels,
scoring="neg_mean_squared_error",cv=10)
forest_rmse_scores = np.sqrt(-forest_scores)
display_scores(forest_rmse_scores)
c) 保存和载入模型
from sklearn.externals import joblib
joblib.dump(forest_reg,"forest_reg.pkl")
forest_reg=joblib.load("forest_reg.pkl")
d) 模型微调
#网格搜索
from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestRegressor
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_labels)
#结论
grid_search.best_params_
grid_search.best_params_
cvres=grid_search.cv_results_
for mean_score, params in zip(cvres["mean_test_score"],cvres["params"]):
print(np.sqrt(-mean_score),params)
#分析最佳模型和它们的误差
feature_importances=grid_search.best_estimator_.feature_importances_
extra_attribs = ["rooms_per_hhold", "pop_per_hhold", "bedrooms_per_room"]
cat_one_hot_attribs=list(encoder.classes_)
attributes=num_attribs+extra_attribs+cat_one_hot_attribs
#将所有属性按重要性排序,可以据此去除不重要的属性
sorted(zip(feature_importances,attributes),reverse=True)
#随机搜索
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import RandomizedSearchCV
param_rand = {
'n_estimators':range(30,200,4),
'max_features':range(2,16,2),
'bootstrap':[False,True]
}
ran_search=RandomizedSearchCV(forest_reg, param_rand,
scoring='neg_mean_squared_error',
cv=10,n_iter=300)
ran_search.fit(housing_prepared,housing_labels)
#集成方法
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_predictions= final_model.predict(X_test_prepared)
final_mse=mean_squared_error(y_test,final_predictions)
final_rmse=np.sqrt(final_mse)