数据挖掘分析流程

整体流程：数据加载，预处理，特征工程，分割训练，模型调整，验证模型，分析误差原因。优化模型。

1：拿到数据后，要先熟悉数据。

远程文件保存到本地：url = DOWNLOAD_ROOT + "images/end_to_end_project/" + filename
urllib.request.urlretrieve(url, os.path.join(images_path, filename))

# 重复数据检测
file_data.duplicated()

# 删除重复数据
file_data = file_data.drop_duplicates()

# 删除缺失数据
file_data = file_data.dropna()

housing = load_housing_data()
housing.head() 可以看一些数据列，及数据类型。

housing.info()查看数据的一些特点。总条数，非空值。

housing["ocean_proximity"].value_counts()关注某一列的每个类的数量

housing.describe() 关注数值列的一些 数据分布，如平均值，标准差，中位数等

使用图表来查看数据分布情况，直方图import matplotlib.pyplot as plt
housing.hist(bins=50, figsize=(20,15))
save_fig("attribute_histogram_plots")
plt.show()

数据分割，先打乱次序

def split_train_test(data, test_ratio):
shuffled_indices = np.random.permutation(len(data))
test_set_size = int(len(data) * test_ratio)
test_indices = shuffled_indices[:test_set_size]
train_indices = shuffled_indices[test_set_size:]
return data.iloc[train_indices], data.iloc[test_indices]

数据分割from zlib import crc32
def test_set_check(identifier, test_ratio):
return crc32(np.int64(identifier)) & 0xffffffff < test_ratio * 2**32
def split_train_test_by_id(data, test_ratio, id_column):
ids = data[id_column]
in_test_set = ids.apply(lambda id_: test_set_check(id_, test_ratio))
return data.loc[~in_test_set], data.loc[in_test_set]

def test_set_check(identifier, test_ratio, hash=hashlib.md5):
return hash(np.int64(identifier)).digest()[-1] < 256 * test_ratio

直方图housing["median_income"].hist()查看数据分布

预处理前原始数据尽量保留。

2：数据预处理，将一些连续值变为几类

housing["income_cat"] = pd.cut(housing["median_income"],bins=[0., 1.5, 3.0, 4.5, 6., np.inf],labels=[1, 2, 3, 4, 5])
housing["income_cat"].value_counts()

from sklearn.model_selection import StratifiedShuffleSplit
# StratifiedShuffle()可以理解成分成抽样，考虑类别的分布
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]

数据中有一些空值处理，或增加一两个新属性。

housing.dropna(subset=["total_bedrooms"]) # option 1
housing.drop("total_bedrooms", axis=1) # option 2
median = housing["total_bedrooms"].median() # option 3
housing["total_bedrooms"].fillna(median, inplace=True)

还有一个中位数填充空值方法：

from sklearn.impute import SimpleImputer
imputer = SimpleImputer(strategy="median")
housing_num = housing.drop("ocean_proximity", axis=1)
imputer.fit(housing_num)
imputer.statistics_与housing_num.median().values 都可以求得中位数
X = imputer.transform(housing_num) 将housing_num里面的空值替换为中位数

将上面的X重新包装成DataFrame ： housing_tr = pd.DataFrame(X, columns=housing_num.columns,index=housing.index)

数据标准化，归一化处理。

文本数据处理。

from sklearn.preprocessing import OrdinalEncoder
ordinal_encoder = OrdinalEncoder() 将类别名变成0，1，2，3。。。这样的数字
housing_cat_encoded = ordinal_encoder.fit_transform(housing_cat)
housing_cat_encoded[:10]

from sklearn.preprocessing import OneHotEncoder
cat_encoder = OneHotEncoder() 哑变量处理
housing_cat_1hot = cat_encoder.fit_transform(housing_cat)
housing_cat_1hot 这个是稀疏矩阵。 housing_cat_1hot.toarray() 变成正常显示的矩阵

3：检查每两个属性之间的关系。

可以画一些散步图，还可以使用相关关系矩阵

corr_matrix = housing.corr() 找这个pd的所有属性之间的相关关系系数。
corr_matrix["median_house_value"].sort_values(ascending=False) 找与median_house_value属性相关的相关属性系数

4：特征工程，

过滤作用不大的属性，降维。 见特征工程处理文件。

还可以使用随机森林算法来进行降维。因为它里面有一个是特征随机，找到最好的算法参数。

5：训练模型

网格搜索处理from sklearn.model_selection import GridSearchCV
param_grid = [
# try 12 (3×4) combinations of hyperparameters
{'n_estimators': [3, 10, 30], 'max_features': [2, 4, 6, 8]},
# then try 6 (2×3) combinations with bootstrap set as False
{'bootstrap': [False], 'n_estimators': [3, 10], 'max_features': [2, 3, 4]},
]
forest_reg = RandomForestRegressor(random_state=42)
# train across 5 folds, that's a total of (12+6)*5=90 rounds of training
grid_search = GridSearchCV(forest_reg, param_grid, cv=5,scoring='neg_mean_squared_error',return_train_score=True)
grid_search.fit(housing_prepared, housing_labels)

grid_search.best_params_

grid_search.best_estimator_

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

当超参数过多时，如超过1000。 就得需要随机搜索。

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=42)
rnd_search = RandomizedSearchCV(forest_reg, param_distributions=param_distribs,
n_iter=10, cv=5, scoring='neg_mean_squared_error', random_state=42)
rnd_search.fit(housing_prepared, housing_labels)

cvres = rnd_search.cv_results_
for mean_score, params in zip(cvres["mean_test_score"], cvres["params"]):
print(np.sqrt(-mean_score), params)

5.5：误差验证

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.metrics import mean_absolute_error
lin_mae = mean_absolute_error(housing_labels, housing_predictions)
lin_mae

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)
tree_rmse_scores = np.sqrt(-scores)

6：误差分析

网格搜索可以知道最好估计器的特征重要性feature_importances = grid_search.best_estimator_.feature_importances_

置信度 from scipy import stats
confidence = 0.95
squared_errors = (final_predictions - y_test) ** 2
np.sqrt(stats.t.interval(confidence, len(squared_errors) - 1,
loc=squared_errors.mean(),
scale=stats.sem(squared_errors)))

m = len(squared_errors)
mean = squared_errors.mean()
tscore = stats.t.ppf((1 + confidence) / 2, df=m - 1)
tmargin = tscore * squared_errors.std(ddof=1) / np.sqrt(m)
np.sqrt(mean - tmargin), np.sqrt(mean + tmargin)

zscore = stats.norm.ppf((1 + confidence) / 2)
zmargin = zscore * squared_errors.std(ddof=1) / np.sqrt(m)
np.sqrt(mean - zmargin), np.sqrt(mean + zmargin)

混淆矩阵：

from sklearn.model_selection import cross_val_predict
进行k折交叉验证，返回预测结果。
y_train_pred = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3)
#混淆矩阵返回数据，行表示实际类别，列表示预测类别
from sklearn.metrics import confusion_matrix
confusion_matrix(y_train_5, y_train_pred)

7：模型保存

my_model = full_pipeline_with_predictor

import joblib

joblib.dump(my_model, "my_model.pkl") # DIFF#...

my_model_loaded = joblib.load("my_model.pkl") # DIFF

8：模型上线后维护

部署web服务，可能对外要提供接口api,返回json数据。部署完后，还需要编写监控代码以定期检查系统的实时性能，并在系统性能下降时触发警报。（各种故障，也可能是去年训练的模型不适合今年的变化）。 要定期重新训练。

a:定期收集新数据并做标记（例如，使用人工评估者）

b:编写脚本来训练模型并自动微调超参数。该脚本可以根据你的需求（例如每天或每周）自动执行。

c:编写另一个脚本，该脚本将在更新的测试集上评估新模型和旧模型，如果性能良好则将该模型部署到生产环境中（如果性能下降，请调查原因）

如果出现故障，报警系统没有及时报警，会出现一些低质量数据输入。可以再监控输入数据，如果发现越来越多的输入数据缺少某个特征，或平均值或标准差偏离训练集太远，或者分类特征中出现了新类别。及时发现异常输入。

尽量保存每个生产模型的备份，进行模型备份还可以轻松实现新模型与旧模型的对比。也要保存每个版本的数据集，以便在新数据集遭到破坏时可以回滚到先前的数据集。备份的数据集还可以针对任何先前的数据集来评估模型。