综合模块111

一．简介

1.明确任务，收集数据

2.数据预处理和特征工程

3.模型训练

4.模型评估与超参数调优

5.模型融合

6.模型应用

• 线性回归

需要了解：（P39）

特征变换：

1. y=df['sales']
2. X=df.drop(['sales','Unnamed:0'],axis=1)

随机选择其中80%的样本作为训练数据，其余20%的数据作为测试样本

1. X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=33, test_size=0.2)

用训练数据训练最小二乘线性回归（无正则）、岭回归（L2正则）和Lasso（L1正则），注意岭回归和Lasso的正则超参数调优，性能指标为RMSE：

比较上述三种模型得到的各特征的回归系数，以及各模型在测试集上的性能。

回归系数：岭回归、Lasso得到的回归系数绝对值均比最小二乘线性回归小，即起到了权值收缩的效果（不全，具体回归系数分析看P36页最上行）

性能：最小二乘线性回归在训练集上的性能最好，但在测试集上的性能最差；Lasso模型在测试集上的性能最好

1. # 导入pandas工具包
2. import pandas as pd
3. # 读取数据
4. dpath="./data/"
5. df=pd.read_csv(dpath+"Advertising.csv")
6. # 从原始数据中分离输入特征x和输出y
7. y=df['sales']
8. X=df.drop(['sales','Unnamed:0'],axis=1)
9. # 将数据分割为训练数据与测试数据，随机采样20%的数据构建测试样本，其余作为训练样本
10. from sklearn.model_selection import train_test_split
11. X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=33, test_size=0.2)
13. # 方法一：
14. # 最小二乘线性回归
15. from sklearn.linear_model import LinearRegression
16. # (1)使用默认配置初始化学习器实例
17. lr=LinearRegression()
18. # (2)使用训练数据训练模型参数
19. lr.fit(X_train,y_train)
20. # (3)用训练好的模型对测试集进行预测
21. y_test_pred_lr = lr.predict(X_test)
22. y_train_pred_lr = lr.predict(X_train)
23. # (4)性能评估，R方分数
24. print("The r2 score of LinearRegression on test is %f" % (r2_score(y_test, y_test_pred_lr)))
25. print("The r2 score of LinearRegression on train is %f" % (r2_score(y_train, y_train_pred_lr)))
26. # (5)在训练集上观察预测残差的分布，看是否符合模型假设：噪声为0均值的高斯噪声
27. res = y_train_pred_lr - y_train
30. # 方法二：
31. # L1正则的线性回归模型
32. from sklearn.linear_model import LassoCV
33. # (1)设置超参数搜索范围（默认超参数搜索范围）
34. # 在LassoCV(alpha= )设置alpha的值
35. # (2)生成LassoCV实例（用交叉验证确定最佳超参数）
36. lasso=LassoCV()
37. # (3)训练（内含CV）
38. lasso.fit(X_train,y_train)
39. # (4) 测试
40. y_test_pred_lasso = lasso.predict(X_test)
41. y_train_pred_lasso = lasso.predict(X_train)
42. # (5)评估，使用r2_score评价模型在测试集和训练集上的性能
43. print("The r2 score of lasso on test is %f" % (r2_score(y_test, y_test_pred_lasso)))
44. print("The r2 score of lasso on train is %f" % (r2_score(y_train, y_train_pred_lasso)))
45. #lasso.mese_path 每次交叉验证的均方误差,随着alpha值的变化，均方误差的变化曲线
46. mses = np.mean(lasso.mse_path_, axis=1)
48. # 方法三：
49. # 岭回归的线性回归模型
50. from sklearn.linear_model import Ridge
51. # (1)设置超参数搜索范围（默认超参数搜索范围）
52. # 在Ridge(alpha= )设置alpha的值
53. # (2)生成Ridge实例
54. ridg10=Ridge()
55. # (3)训练（内含CV）
56. ridg10.fit(X_train,y_train)

• Logistic回归（未添加画图部分代码）

1. # 读取数据的代码，输出命名为df
2. dpath = "./data/"
3. df = pd.read_csv(dpath + "iris.csv", names=feat_names)
4. # 通过观察前5行，了解数据每列（特征）的概况
5. df.head()
6. # 类别提取
7. unique_Class = df['Class'].unique()
8. # 只考虑两类分类：setosa vs. non_setosa
9. target_map = {'Iris-setosa': 0,  # 山鸢尾
10.               'Iris-versicolor': 1,  # 变色鸢尾
11.               'Iris-virginica': 1}  # 2，弗吉尼亚鸢尾
12. # 使用pandas应用方法对我们的流失目标变量进行数字编码
13. df['Class'] = df['Class'].apply(lambda x: target_map[x])
14. df.head()

1. # 从原始数据中分离输入特征x和输出y
2. y = df['Class']
3. X = df.iloc[:, 0:2]  # 只取前两维特征
4. # 特征X标准化，特征缩放
5. scaler = StandardScaler()
6. scaler.fit(X)
7. X = scaler.transform(X)
8. # 随机采样20%的数据构建测试样本，其余作为训练样本的代码
9. X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=33, test_size=0.2)
10. # 设置超参数搜索范围
11. Cs = [0.1, 1, 10, 100, 1000]
12. tuned_parameters = dict(C=Cs)
13. 调用逻辑回归API函数，输出为lt
14. lr = LogisticRegression()
15. # 生成GridSearchCV实例
16. grid = GridSearchCV(lr, tuned_parameters, cv=10, scoring='neg_log_loss', n_jobs=4)
17. # 训练数据
18. grid.fit(X_train, y_train)
19. lr_best = grid.best_estimator_

1. # 计算auc面积值
2. roc_auc = auc(false_positive_rate, true_positive_rate)
4. # 调用plot_roc函数,输出ROP曲线图
5. scores = lr_best.decision_function(X)
6. plt.figure(figsize=(6, 6))
7. result=plot_roc(label,scores)
8. print(result)

• SVM

1. # 输入准确的绝对或相对路径，读取FE_day.csv，输出为df
2. dpath = "./data/"
3. # df是DataErame 的缩写，表示读进来的数据，读取csv文件，列名加入第一行
4. df = pd.read_csv(dpath + "FE_day.csv")
5. # cnt是给定日期（天）时间（每小时）总租车人数，我们根据其他特征来推测cnt，所以cnt是输出y。是要预测的
6. y = df['cnt']
7. X = df.drop(['cnt'], axis=1)
8. # 用train_test_split 分割训练数据和测试数据，输出为X_train, X_test, y_train, y_test
9. # 随机采样20%的数据构建验证集，其余作为训练样本，进行33随机试验，第33组，划分数据集
10. X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=33, test_size=0.2)
11. # 输出X_train的维度
12. print("train samples:" ,X_train.shape)
13. # 保存测试样本序号
14. testID = X_test['instant']
15. # 踢出去样本序号，不参加数据训练
16. X_train.drop(['instant'], axis=1, inplace = True)
17. X_test.drop(['instant'], axis=1, inplace = True)
18. # 保存特征名字以备后用（可视化）
19. feat_names = X_train.columns

1. #（1）需要调优的参数
2. gammas = [ 0.03]
3. Cs = [ 1, 10, 100, 1000, 10000, 100000]
4. tuned_parameters = dict(gamma = gammas, C = Cs)
6. #（2）生成学习器实例,用SVR实例化，输出为svr
7. svr= SVR()
8. #（3）参考实验三代码中“生成GridSearchCV实例” 用GridSearchCV函数，其中cv=5, scoring='neg_mean_squared_error'，网络参数搜索，输出grid
9. # 再用gid.fit 训练数据，一共写2行代码，可参考实验三
10. grid = GridSearchCV(svr, tuned_parameters, cv=5, scoring='neg_mean_squared_error', n_jobs=4)
11. grid.fit(X_train, y_train)
12. #通过交叉验证得到的最佳超参数alpha
13. # 检查最佳模型l
14. print(-grid.best_score_)
15. print("Best params: ", grid.best_params_)
16. # grid.predict分别预测训练集X_train输出为y_train_pred  预测测试集X_test输出为y_test_pred
17. y_train_pred=grid.predict(X_train)
18. y_test_pred=grid.predict(X_test)
20. # 用r2_score分别得出训练集准确率，输出为r2_score_train，测试集的准确率，输出为r2_score_test
21. r2_score_train=r2_score(y_train, y_train_pred)
22. r2_score_test=r2_score(y_test, y_test_pred)
23. print("r2_score on Training set :" ,r2_score_train)
24. print("r2_score on Test set :" ,r2_score_test)

1. #最佳模型的支持向量的数目
2. n_sv = len(grid.best_estimator_.support_)
3. print ('number of support vectors is: ', n_sv)
5. gamma = 0.001
6. C=10^8 #支持向量数目 584
7. gamma = 0.01
8. C=10^7  #支持向量数目 584
9. gamma = 0.01
10. C=10^4#支持向量数目 584
12. ## 对测试集进行测试，生成提交文件
13. y_test_pred = grid.predict(X_test)
15. #生成提交测试结果，将结果放入submission.csv文件内
16. df_test_result = pd.DataFrame({"instant":testID, 'cnt':y_test_pred})
17. df_test_result.to_csv('submission.csv')

• 生成式分类器（PCALED.py）

计算部分：

书上P103第1题（答案可参照P97页））

代码部分：

1. # 读取训练数据和测试数据
2. train = pd.read_csv('./data/MNIST_train.csv')
3. test = pd.read_csv('./data/MNIST_test.csv')
4. # 分离数据
5. y_train = train.label.values
6. X_train = train.drop("label", axis=1).values
7. X_test = test.values
9. # 将像素值[0,255]  --> [0,1]
10. X_train = X_train / 255.0
11. X_test = X_test / 255.0
12. ## PCA降维
13. pca = PCA(n_components=0.95, svd_solver='full')
14. pca.fit(X_train)
16. # 在训练集和测试集降维
17. X_train_pca = pca.transform(X_train)
18. X_test_pca = pca.transform(X_test)
20. ## LDA分类器
21. lda = LinearDiscriminantAnalysis()
22. lda.fit(X_train_pca, y_train)
24. # 用在降维后的全体训练数据集上训练的模型对测试集进行测试
25. y_predict = lda.predict(X_test_pca)
26. ##  交叉验证, 评估模型性能
27. loss = cross_val_score(lda, X_train_pca, y_train, cv=5)
28. print('accuracy of each fold is: ', loss)
29. print('cv accuracy is:', loss.mean())

• 决策树（tree.py）

计算部分：

P109页例6-1：账号真实性判断案例

代码部分：

1. # 读入数据获取路径字符串
2. dpath = "./data/"
3. # 读取csv内的数据
4. df = pd.read_csv(dpath + "FE_day.csv")
5. # 通过观察前5行，了解数据每列（特征）的概况
6. df.head()
8. #**准备训练数据**
9. # 获取列表
10. # 从原始数据中分离输入特征x和输出y
11. y = df['cnt']
12. #去掉多余的cnt
13. X = df.drop(['cnt'], axis=1)
15. # 用train_test_split 分割训练数据和测试数据
16. X_train, X_test, y_train, y_test = train_test_split(X, y, train_size = 0.8,random_state = 0)
17. # 输出训练集的维度特征
18. print("train samples:" ,X_train.shape)
19. #保存测试ID，用于结果提交
20. testID = X_test['instant']
22. #ID不参与预测
23. X_train.drop(['instant'], axis=1, inplace = True)
24. X_test.drop(['instant'], axis=1, inplace = True)
26. #保存特征名字以备后用（可视化）
27. feat_names = X_train.columns
29. #决策树：默认参数
30. #生成DecisionTreeRegressor实例，输出为DT1
31. DT1 = DecisionTreeRegressor()
32. # 训练数据拟合模型
33. DT1.fit(X_train, y_train)
34. #训练上测试，训练误差，实际任务中这一步不需要
35. #预测训练集X_train输出为y_train_pred
36. #针对数据进行预测
37. y_train_pred = DT1.predict(X_train)
38. #计算均方误差回归损失RMSE，越小越好
39. rmse_train = np.sqrt(mean_squared_error(y_train,y_train_pred))
40. ##预测训练集X_test输出为y_train_test
41. y_test_pred = DT1.predict(X_test)
42. rmse_test = np.sqrt(mean_squared_error(y_test,y_test_pred))
43. #输出训练集与测试集的RMSE结果
44. print("RMSE on Training set :", rmse_train)
45. print("RMSE on Test set :" ,rmse_test)
46. #得出训练集、测试集的准确率，并输出结果
47. r2_score_train = r2_score(y_train,y_train_pred)
48. r2_score_test = r2_score(y_test,y_test_pred)
49. print("r2_score on Training set :" ,r2_score_train)
50. print("r2_score on Test set :" ,r2_score_test)

1. #1.需要调优的参数
2. # 设置超参数的搜索范围
3. max_depth = range(2,20,1)
4. min_samples_leaf = range(1,8,1)
5. # 调优的参数集合，搜索网格为3x3在网格上的交叉点进行搜索
6. tuned_parameters = dict(max_depth=max_depth, min_samples_leaf=min_samples_leaf)
8. #2. 生成学习器实例
9. # 创建 CART 分类树
10. DT2 = DecisionTreeRegressor()
12. # 3. 用训练数据度模型进行训练
13. # 生成GridSearchCV实例
14. grid = GridSearchCV(DT2, tuned_parameters,cv=10, scoring='neg_mean_squared_error')
15. # 训练，交叉验证对超参数调优
16. grid.fit(X_train,y_train)
17. #通过交叉验证得到的最佳超参数alpha
18. # 检查最佳模型
19. print(-grid.best_score_)
20. print("Best params: ", grid.best_params_)
22. #训练上测试，训练误差，实际任务中这一步不需要
23. #预测训练集X_train输出为y_train_pred
24. y_train_pred = grid.predict(X_train)
25. #计算均方误差回归损失RMSE，越小越好
26. rmse_train = np.sqrt(mean_squared_error(y_train,y_train_pred))
27. ##预测训练集X_test输出为y_train_test，并计算均方误差回归损失
28. y_test_pred = grid.predict(X_test)
29. rmse_test = np.sqrt(mean_squared_error(y_test,y_test_pred))
30. #输出训练集与测试集的RMSE结果
31. print("RMSE on Training set :", rmse_train)
32. print("RMSE on Test set :" ,rmse_test)
33. #得出训练集、测试集的准确率，并输出结果
34. r2_score_train = r2_score(y_train,y_train_pred)
35. r2_score_test = r2_score(y_test,y_test_pred)
36. print("r2_score on Training set :" ,r2_score_train)
37. print("r2_score on Test set :" ,r2_score_test)

1. #插补删除列名，并放回原处
2. columns = X_train.columns
3. # 构建实例
4. df_importance = pd.DataFrame({"columns":list(columns), "importance":list(grid.best_estimator_.feature_importances_.T)})
5. # 对数据进行排序，使数据整洁有序，具有更强的表现性,by指定需要排序的行或者列,降序排列
6. df_importance.sort_values(by=['importance'],ascending=False)
8. # 对测试集进行测试
9. y_test_pred = grid.predict(X_test)
10. #生成提交测试结果
11. df_test_result = pd.DataFrame({"instant":testID, 'cnt':y_test_pred})
12. #保存结果至submission.csv文件中
13. df_test_result.to_csv(dpath + 'submission.csv')

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！