python学习

Share

最近用到的一些python sklearn机器学习干货知识整理

生成训练集和测试集：

1
X_train,X_test,y_train,y_test=train_test_split(data[feature],data[colum_names[7]],random_state=10,test_size=0.2)

线性回归模型：

线性回归：通过拟合线性模型的回归系数W =（w_1，…，w_p）来减少数据中观察到的结果和实际结果之间的残差平方和，并通过线性逼近进行预测。

1
2
3
4
5
6
7
8
9
10
from sklearn.linear_model import LinearRegression
lr = LinearRegression()  #线性回归模型
lr.fit(X_train,y_train)
lr_y_predict = lr.predict(X_test)
linear_result = []
linear_result = [metrics.mean_absolute_error(y_test,lr_y_predict),metrics.mean_squared_error(y_test,lr_y_predict),np.mean(np.abs((y_test - lr_y_predict) / y_test))]
print 'use LinearRegression predict:'
#print 'the mean_absolute_error of is ',linear_result[0]
#print 'the mean_squared_error of is ',linear_result[1]
print 'the MAPE of is ',linear_result[2]

梯度下降：

梯度下降的目标是最小化代价函数，当代价函数是凸函数的时候，梯度下降会有唯一解，权重更新的公式为：

学习率太大，容易发生震荡，学习率太小，达到最优解的速度太慢，需要根据情况选择合适的学习率
如果使用上面的梯度下降方法(批量梯度下降BGD)进行训练，则每次训练的时候会使用全部的训练集数据，对于数据量很大的训练集来说，这种训练方法过于耗时，因此可以采用一种随机梯度下降(SGD)的方法，每次只采用一个训练样本进行梯度下降
如果代价函数有局部最小值，而不是全局最小值，则BGD一般难以跳出局部最优，而SGD常常可以跳出全局最优
BGD一般到达最优解之后很少跳动，而SGD一般在到达最优解之后仍然会小幅跳动，即它可以保证解较好，但是不一定是最优的

1
2
3
4
5
6
7
8
9
10
11
12
from sklearn.linear_model import SGDRegressor
sgdr=SGDRegressor()
sgdr.fit(X_train,y_train)
sgdr_y_predict=sgdr.predict(X_test)
print sgdr.score(X_test,y_test)
SGD_result = []
SGD_result = [metrics.mean_absolute_error(y_test,sgdr_y_predict),metrics.mean_squared_error(y_test,sgdr_y_predict),np.sqrt(metrics.mean_squared_error(y_test, sgdr_y_predict))]
print 'use SGDRegressor predict:'
print 'the mean_absolute_error of is ',SGD_result[0]
print 'the mean_squared_error of is ',SGD_result[1]
print 'the MAPE of is ',SGD_result[2]
print 'y_test-y_predict = ',(y_test-sgdr_y_predict)

集成回归模型

集成回归模型综合考量多个回归器的预测结果从而做出决策，这种“综合考量”的方式大体上分为两种：

（1）利用相同的训练数据同时搭建多个独立的回归模型，然后通过投票的方式，以少数服从多数的原则作出最终的回归决策。比较有代表性的是随机森林分类器

（2）按照一定次序搭建多个分类模型，这些模型之间存在依赖关系，一般而言，每一个后续模型的加入都需要对现有的集成模型的综合性能有所贡献，进而不断提升更新过后的集成模型的性能。比较有代表性的是梯度提升回归模型。

1
2
3
4
5
6
7
8
9
10
11
12
# 集成-回归模型 
model_gbr_disorder=GradientBoostingRegressor()  
model_gbr_disorder.fit(X_train,y_train)    
gbr_y_predict=model_gbr_disorder.predict(X_test)
model_gbr_result = []
model_gbr_result = [metrics.mean_absolute_error(y_test,gbr_y_predict),metrics.mean_squared_error(y_test,gbr_y_predict),np.mean(np.abs((y_test - gbr_y_predict) / y_test))]
print 'use model_mlp predict:'
# print 'the mean_absolute_error of is ',model_gbr_result[0]
# print 'the mean_squared_error of is ',model_gbr_result[1]
print 'the MAPE of is ',model_gbr_result[2]
gbr_score_disorder=model_gbr_disorder.score(X_test,y_test)  
print('sklearn集成-回归模型得分',gbr_score_disorder)#准确率较高 0.853817723868
1
2
3
4
5
6
7
8
9
10
11
12
# 多层感知器-回归模型  
model_mlp = MLPRegressor(solver='lbfgs', hidden_layer_sizes=(20, 20, 20), random_state=1)  
model_mlp.fit(X_train,y_train)  
mlp_y_predict=model_mlp.predict(X_test)
model_mlp_result = []
model_mlp_result = [metrics.mean_absolute_error(y_test,mlp_y_predict),metrics.mean_squared_error(y_test,mlp_y_predict),np.mean(np.abs((y_test - mlp_y_predict) / y_test))]
print 'use model_mlp predict:'
#print 'the mean_absolute_error of is ',model_mlp_result[0]
#print 'the mean_squared_error of is ',model_mlp_result[1]
print 'the MAPE of is ',model_mlp_result[2]
mlp_score=model_mlp.score(X_test,y_test)  
print('sklearn多层感知器-回归模型得分',mlp_score)

支持向量机：

支持向量机形象理解

1
2
3
4
5
6
7
8
9
10
11
from sklearn.svm import SVR #支持向量机
linear_svr=SVR(kernel='linear')  #线性核函数配置
linear_svr.fit(X_train,y_train)
linear_svr_y_predict=linear_svr.predict(X_test)
linear_svr_result = []
linear_svr_result = [metrics.mean_absolute_error(y_test,linear_svr_y_predict),metrics.mean_squared_error(y_test,linear_svr_y_predict),np.sqrt(metrics.mean_squared_error(y_test, linear_svr_y_predict))]
  
print 'use svr predict:'
print 'the mean_absolute_error of is ',linear_svr_result[0]
print 'the mean_squared_error of is ',linear_svr_result[1]
print 'the sqrt_error of is ',linear_svr_result[2]
1
2
3
4
5
6
7
8
9
10
poly_svr=SVR(kernel='poly') #多项式核函数配置
poly_svr.fit(X_train,y_train)
poly_svr_y_predict=poly_svr.predict(X_test)
poly_svr_result = []
poly_svr_result = [metrics.mean_absolute_error(y_test,poly_svr_y_predict),metrics.mean_squared_error(y_test,poly_svr_y_predict),np.sqrt(metrics.mean_squared_error(y_test, poly_svr_y_predict))]
  
print 'use poly svr predict:'
print 'the mean_absolute_error of is ',poly_svr_result[0]
print 'the mean_squared_error of is ',poly_svr_result[1]
print 'the sqrt_error of is ',poly_svr_result[2]
1
2
3
4
5
6
7
8
9
10
rbf_svr=SVR(kernel='rbf')
rbf_svr.fit(X_train,y_train)
rbf_svr_y_predict=rbf_svr.predict(X_test)
rbf_svr_result = []
rbf_svr_result = [metrics.mean_absolute_error(y_test,rbf_svr_y_predict),metrics.mean_squared_error(y_test,rbf_svr_y_predict),np.sqrt(metrics.mean_squared_error(y_test, rbf_svr_y_predict))]
  
print 'use rbf svr predict:'
print 'the mean_absolute_error of is ',rbf_svr_result[0]
print 'the mean_squared_error of is ',rbf_svr_result[1]
print 'the sqrt_error of is ',rbf_svr_result[2]

K近邻法

K近邻(回归)模型同样是无参数模型，只是借助K个最近训练样本的目标数值，对待测样本的回归值进行决策。即根据样本的相似度预测回归值。
衡量样本待测样本回归值的不同方式：
（1）对K个近邻目标数值使用普通的算术平均算法
（2）对K个近邻目标数值考虑距离的差异进行加权平均。

1
2
3
4
5
6
7
8
9
10
11
from sklearn.neighbors import KNeighborsRegressor
uni_knr=KNeighborsRegressor(weights='uniform')#平均回归
uni_knr.fit(X_train,y_train)
uni_knr_y_predict=uni_knr.predict(X_test)
uni_knr_result = []
uni_knr_result = [metrics.mean_absolute_error(y_test,uni_knr_y_predict),metrics.mean_squared_error(y_test,uni_knr_y_predict),np.mean(np.abs((y_test - uni_knr_y_predict) / y_test))]

print 'use rbf KNeighbor predict:'
# print 'the mean_absolute_error of is ',uni_knr_result[0]
# print 'the mean_squared_error of is ',uni_knr_result[1]
print 'the sqrt_error of is ',uni_knr_result[2]
1
2
3
4
5
6
7
8
9
10
11
#距离加权回归
dis_knr=KNeighborsRegressor(weights='distance')
dis_knr.fit(X_train,y_train)
dis_knr_y_predict=dis_knr.predict(X_test)
dis_knr_result = []
dis_knr_result = [metrics.mean_absolute_error(y_test,dis_knr_y_predict),metrics.mean_squared_error(y_test,dis_knr_y_predict),np.mean(np.abs((y_test - dis_knr_y_predict) / y_test))]

print 'use dis KNeighbor predict:'
#print 'the mean_absolute_error of is ',dis_knr_result[0]
#print 'the mean_squared_error of is ',dis_knr_result[1]
print 'the MAPE of is ',dis_knr_result[2]

决策树：

决策树是一种无监督的学习方法，用于分类和回归。它对数据中蕴含的决策规则建模，以预测目标变量的值。

1
2
3
4
5
6
7
8
9
10
11
#回归树
from sklearn.tree import DecisionTreeRegressor
dtr=DecisionTreeRegressor()
dtr.fit(X_train,y_train)
dtr_y_predict=dtr.predict(X_test)
dtr_result = []
dtr_result = [metrics.mean_absolute_error(y_test,dtr_y_predict),metrics.mean_squared_error(y_test,dtr_y_predict),np.mean(np.abs((y_test - dtr_y_predict) / y_test))]
print 'use rbf DecisionTreeRegressor predict:'
# print 'the mean_absolute_error of is ',dtr_result[0]
# print 'the mean_squared_error of is ',dtr_result[1]
print 'the MAPE of is ',dtr_result[2]

普通随机森林回归模型 ：

鉴于决策树容易过拟合的缺点，随机森林采用多个决策树的投票机制来改善决策树。随机森林的生成方法：

1.从样本集中通过重采样的方式产生n个样本

2.假设样本特征数目为a，对n个样本选择a中的k个特征，用建立决策树的方式获得最佳分割点

3.重复m次，产生m棵决策树

4.多数投票机制来进行预测

（需要注意的一点是，这里m是指循环的次数，n是指样本的数目，n个样本构成训练的样本集，而m次循环中又会产生m个这样的样本集）

1
2
3
4
5
6
7
8
9
10
11
#随机森林
from sklearn.ensemble import RandomForestRegressor,ExtraTreesRegressor
rfr=RandomForestRegressor()
rfr.fit(X_train,y_train)
rfr_y_predict=rfr.predict(X_test)
rfr_result = []
rfr_result = [metrics.mean_absolute_error(y_test,rfr_y_predict),metrics.mean_squared_error(y_test,rfr_y_predict),np.mean(np.abs((y_test - rfr_y_predict) / y_test)) ]
print 'use rbf RandomForestRegressor predict:'
# print 'the mean_absolute_error of is ',rfr_result[0]
# print 'the mean_squared_error of is ',rfr_result[1]
print 'the MAPE of is ',rfr_result[2]

极端随机森林回归模型

1
2
3
4
5
6
7
8
9
etr=ExtraTreesRegressor()
etr.fit(X_train,y_train)
etr_y_predict=etr.predict(X_test)
etr_result = []
etr_result = [metrics.mean_absolute_error(y_test,etr_y_predict),metrics.mean_squared_error(y_test,etr_y_predict),np.mean(np.abs((y_test - etr_y_predict) / y_test))]
print 'use rbf ExtraTreesRegressor predict:'
#print 'the mean_absolute_error of is ',etr_result[0]
#print 'the mean_squared_error of is ',etr_result[1]
print 'the MAPE of is ',etr_result[2]
  • 极端随机森林和普通随机森林模型不同的是：极端随机森林在每当构建一棵树的分裂节点时，不会任意地选取特征，而是先随机收集一部分特征，然后利用信息熵和基尼不纯性等指标挑选最佳的节点特征。