机器学习实战笔记

第一章 — 端到端的机器学习项目
数据预处理常做的操作：

子图设置坐标轴标签及刻度 .set_xlabel .set_xticks
–数据映射—>data[col_name == 原值 ,col_name]=映射值
–获取列名列表—>col_names = data.columns.tolist()

–去掉一些无关列—>todrop=[’’,’’] data.drop(todrop,axis=1)
–同等重要的两列特征差值较大—>标准化
–选取某一些符合条件的行，先遍历将符合条件的索引存在列表中，然后data.loc[list,:]

下载数据
写一个获取数据的函数

def fetch_housing_data(housing_url=url,housing_path=path):
    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)
    housing_tgz = tarfile.open(tgz_path)
    housing_tgz.extractall(path=housing_path)
    housing_tgz.close()

写一个函数加载数据

import pandas
def load_housing_data(housing_path=HOUSING_PATH)：
    csv_path = os.path.join(housing_path,"housing.csv")
    return pd.read_csv(csv_path)

观察大局
快速查看数据结构
info() 可以快速获取数据集的简单描述，特别是总行数，每个属性的类型和非空值的数量
value_counts() 查看多少种分类存在，每种分类可以显示数值属性的摘要
describe() 显示数值属性的摘要

整个数据集上调用hist()方法，绘制每个属性的直方图
例：

import matplotlib.pyplot as plt
      housing.hist(bins=50,figsize(20,15))
      plt.show()

创建测试集
（纯随机抽样方法）

from sklearn.model_selection import train_test_split
predictors = ["col1", "col2"]
x_train, x_test, y_train, y_test = train_test_split(data[predictors], data["target"], test_size=0.4, random_state=0)

（分层抽样）
col列为分层基于的列

from sklearn.model_selection import StratifiedShuffleSplit
split = StratiffiedShuffleSplit(n_splits=1, test_size=0.2, random_state=42)
for train_index,test_index in split.split(data,data["col"]):
    start_train_set = data.loc[train_index]
    start_test_set = data.loc[test_index]

如需删除训练集和测试集同一属性：

for set in (start_train_set, start_test_set):
    set.drop(["clo"], axis=1, inplace=True)

数据探索和可视化
①地理数据可视化：

housing.plot(kind="scatter", x="longtitude", y="latitude", alpha=xxx
                    s=housing["population"]/100,label="population"
                    c="median_house_value",cmap=plt.get_cmap("jet"),colorbar=True)
                    #同样可以刻画 X与Y属性之间的相关性
                    import matplotlib.pyplot as plt
                    plt.show()

②寻找相关性：
(col列与其他列的相关性)
corr_matrix = data.corr()
corr_matrix[“col”].sort_values(ascendsing=False)
皮尔逊相关系数： 越接近1，表示有越强的正相关， 越接近-1，表示有越强的负相关

绘制每个数值属性相对于其他数值属性的相关性。

from pandas.tools.plotting import scatter_matrix
attributes = ["col1","col2","col3","col4"]
scatter_matrix(housing[attribute],figsize=(12,8))

实验不同属性的组合
例：housing[“rooms_per_household”] = housing[“total_rooms”]/housing[“households”]

③数据准备：
data = train_set.drop(“col”, axis=1)
label = train_set[“col”].copy
drop（）会创建一个数据副本，但不影响data

数据清理：
col列属性有部分值缺失，解决办法：
-放弃相应值：data.dropna(subset=[“col”])
-放弃这个属性：data.drop(“col”,axis=1)
-将缺失的值设置为某个值：data[“col”].fillna(median)

处理缺失值：
from sklearn.preprocessing import Imputer
imputer = Imputer(strategy=“median”)
使用fit()方法将imputer实例适配到训练集：
imputer.fit(housing_num)
这里imputer只计算了每个属性的中位数值，并将结果存储在其实例变量statistics_
X=imputer.transform(housing_num)

处理文本和分类属性
skikit-learn为这类任务提供了一个转换器 LabelEncoder:

from sklearn.preprocessing import LabelEncoder
encoder = LabelEncoder()
housing_cat = housing["ocean_proximity"]
housing_cat_encoded = encoder.fit_transform(housing_cat)
housing_cat_encoded

由此产生的问题：机器学习算法会以为两个相近的数字比两个离得较远的数字更为近似一些
为解决这个问题，常见的解决方案是给每个类别创建一个二进制的属性，独热编码
Scikit-learn提供了一个OneHotEncoder编码器，可以将整数分类值转换为独热向量

from sklearn.preprocessing import OneHotEncoder
encoder = OneHotEncoder()
housing_cat_1hot = encoder.fit_transform(housing_cat_encoded.reshape(-1,1))

这里输出的是一个Scipy稀疏矩阵
使用LabelBinarizer类可以一次性完成两个转换（从文本类别转化为整数类别，再从整数类别转换为独热向量）

from sklearn.preprocessing import LabelBinarizer
encoder = LabelBinarizer()
housing_cat_1hot = encoder.fit_transform(housing_cat)

通过发送sparse_output=True给LabelBinarizer构造函数，可以得到稀疏矩阵

计算RMSE

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)

使用交叉验证来更好地进行评估

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)

随机森林

from sklearn.ensemble import RandomForestRegressor
forest_reg = RandomForestRegressor()
forest_reg.fit(housing_prepared,housing_labels)

微调模型
网格搜索
可以用scikit-learn的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_labels)

param_grid 告诉scikit-learn 首先评估第一个dict中n_estimator和max_features的所有34=12种超参数组合
接着 尝试第二个dict中超参数值所有的23=6种组合，但这次超参数bootstrap需要设置为False而不是True
最佳参数组合：grid_search.best_params_

随机搜索
当超参数的搜索范围较大时，通常会优先选择RandomizedSearchCV
如果运行随机搜索1000个迭代，将会探索每个超参数的1000个不同的值。

分析最佳模型及其错误
randomforestregressor可以指出每个属性的相对重要程度
feature_importances = grid_search.best_estimator_.feature_importances_
将这些重要性分数显示在对应属性名称旁边：
sorted( zip(feature_importances,attributes),reverse=True )

通过测试集评估系统

final_model = grid_search.best_estimator_

x_test = start_test_set.drop("median_house_value",axis=1)
y_test = start_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)

二.分类
MNIST数据集，每张图片都用其代表的数字标记。
x,y = minst[“data”],minst[“target”]
x.shape
y.shape
每张图片有784个特征。因为图片是28*28像素，每个特征代表一个像素点的强度，从0（白色）到255（黑色）
显示图片

import matplotlib
import matplotlib.pyplot as plt
some_digit = X[36000]
some_digit_image = some_digit.reshape(28,28)
plt.imshow(some_digit_image, cmap = matplotlib.cm.binary,interpolation="nearest")
plt.axis("off")
plt.show()

训练集数据洗牌

x_train,x_test,y_train,y_test = X[:60000],X[60000:],Y[:60000],Y[60000:]
import numpy as np
shuffle_index = np.random.permutation(60000)
x_train,y_train =x_train[shuffle_index],y_train[shuffle_index]

训练一个二元分类器
先为此分类任务创建目标向量：
y_train_5 = (y_train == 5)
y_test_5 = (y_test == 5)

训练：
from sklearn.linear_model import SGDClassifier
sgd_clf = SGDClassifier(random_state=42)
sgd_clf.fit(x_train,y_train_5)

sgd_clf.predict([some_digit])

实施交叉验证：
from sklearn.model_selection import StratifiedKFold
from sklearn.base import clone

skfolds = StratifiedKFold(n_split=3, random_state=42)

for train_index,test_index in skfolds.split(x_train,y_train_5):
clone_clf = clone(sgd_clf)
x_train_folds = x_train[train_index]
y_train_folds = (y_train_5[train_index])
x_test_fold = x_train[test_index]
y_test_fold = (y_train_5[test_index])

clone_clf.fit(x_train_folds,y_train_folds)
y_pred = clone_clf.predict(x_test_fold)
n_correct = sum(y_pred == y_test_fold)
print(n_correct / len(y_pred)

每个折叠由StratifiedKFold执行分层抽样产生，其所包含的各个类的比例符号整体比例。

混淆矩阵
评估分类器性能的更好方法是混淆矩阵
from sklearn.model_selection import cross_val_predict
y_train_pred = cross_val_predict(sgd_clf,x_train,y_train_5,cv=3)
与cross_val_score()函数一样，cross_val_predict()函数同样执行K-fold交叉验证，但返回的不是评估分数，而是每个
折叠的预测。

from sklearn.metrics import confusion_matrix #使用此函数获取混淆矩阵
confusion_matrix(目标类别，预测类别)
混淆矩阵中的行表示实际类别，列表示预测类别。
一个完美的分类器只有真正类和真负类，所以它的混淆矩阵只会在其对角线上有非零值

精度：TP/（TP+FP） 预测出来的有多少是准确的
召回率=TP/（TP+FN）
scikit-learn提供了计算多种分类器指标的函数，精度和召回率也是其一
from sklearn.metrics import precision_score,recall_score
precison_score(y_train,y_pred)
recall_score(y_train,y_train_pred)

将精度和召回率组合成一个单一的指标，称为F1分数，F1是精度和召回率的谐波平均值
要计算F1分数，只需要调用f1_score()
from sklearn.metrics import f1_score
某些情况下，更关心精度，另一些情况下，更关心召回率

多标签分类
为每个实例产出多个类别，比如：既是大数，又是奇数

from sklearn.neighbors import KNeightborsClassifier
y_train_large = (y_train >= 7)
y_train_odd = (y_train %2 ==1)
y_multilabel = np.c_[y_train_large,y_train_odd]
knn_clf = KNeighborsClassifier()
knn_clf.fit(X_train,y_multilabel)

多输出分类
使用Numpy的randint()函数为MNIST图片的像素强度增加噪声。目标是将图片还原为原始图片：

noise = rnd.randint( 0,100,(len(x_train),784) )
noise = rnd.randint( 0,100,(len(x_test),784) )
x_train_mod = x_train + noise
x_test_mod = x_test +noise
knn_clf.fit(x_train_mod, y_train_mod)
clean_digit = knn_clf.predict( [x_test_mod[some_index]] )
plot_digit(clean_dight)