我与数据科学 - [Today is sklearn] - [sklearn api]

最新推荐文章于 2022-07-18 12:29:36 发布

weixin_43409627

最新推荐文章于 2022-07-18 12:29:36 发布

阅读量136

点赞数

分类专栏：学习记录

本文链接：https://blog.csdn.net/weixin_43409627/article/details/84843300

版权

学习记录专栏收录该内容

23 篇文章 4 订阅

订阅专栏

分割数据将数据分为训练集和测试集，使用sklearn的model_selection库里面的 train_test_split

from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y, train_size=0.7, random_state=1)

决策树分类器，使用sklearn的tree库里面的DecisionTreeClassifier

model = DecisionTreeClassifier(criterion='entropy', max_depth=6)

原函数：

sklearn.tree.DecisionTreeClassifier(criterion='gini', splitter='best', max_depth=None, min_samples_split=2,min_samples_leaf =1, min_weight_fraction_leaf=0.0, max_features=None, random_state=None, max_leaf_nodes=None,class_weight=None, presort=False)

criterion：衡量分类的质量，默认为"gini",支持的标准有"gini"，代表的是gini impurity（不纯度）与"entropy"，代表的是information gain（信息增益）

splitter：一种用来在选节点中选择分类的策略，默认为"best"，代表选择最好的分类，"random"代表选择最好的随机分类

max_features：分类时最大特征数目，默认None表示最大特征数目等于样本特征数目

max_depth：表示树的最大深度，默认为None表示会一直分类到所有节点都是纯节点或者满足min_sample_leaf，忽视max_leaf_nodes是不是等于None

min_samples_split：区分一个内部节点所需要的最小样本数，默认为2

min_weight_fraction_leaf：一个叶节点的输入样本所需要的最小加权分数

max_leaf_nodes：如果是None则对叶节点的数目没有限制。如果不是None则不考虑max_depth.

随机森林分类器，使用sklearn里面ensemble库里面的RandomForestClassifer

clf = RandomForestClassifier(n_estimators=200, criterion='entropy', max_depth=3)

函数原型：

sklearn.ensemble.RandomForestClassifier(n_estimators=10, crite-rion=’gini’, max_depth=None,  
min_samples_split=2, min_samples_leaf=1,  
min_weight_fraction_leaf=0.0,  
max_features=’auto’,  
max_leaf_nodes=None, bootstrap=True,  
oob_score=False, n_jobs=1, ran-dom_state=None, verbose=0,  
warm_start=False, class_weight=None)

verbose:(default=0) 是否显示任务进程

n_estimators=10：决策树的个数，越多越好，但是性能就会越差，至少100左右（具体数字忘记从哪里来的了）可以达到可接受的性能和误差率。

bootstrap=True：是否有放回的采样

oob_score=False：oob（out of band，带外）数据，即：在某次决策树训练中没有被bootstrap选中的数据。多单个模型的参数训练，我们知道可以用cross validation（cv）来进行，但是特别消耗时间，而且对于随机森林这种情况也没有大的必要，所以就用这个数据对决策树模型进行验证，算是一个简单的交叉验证。性能消耗小，但是效果不错。

n_jobs=1：并行job个数。这个在ensemble算法中非常重要，尤其是bagging（而非boosting，因为boosting的每次迭代之间有影响，所以很难进行并行化），因为可以并行从而提高性能。1=不并行；n：n个并行；-1：CPU有多少core，就启动多少job

warm_start=False：热启动，决定是否使用上次调用该类的结果然后增加新的。

class_weight=None：各个label的权重。

bagging分类器，使用sklearn里面ensemble库中的BaggingRegressor

从样本集中重采样(有重复的)选出n个样本，在所有属性上，对这n个样本建立分类器（ID3，ID4.5， CART，SVM）等等

重复建立m个分类器，将数据放在这m个分类器上，最后根据这m个分类器的选择，决定数据属于哪一分类。

决策树是一个可读性很强、分类快，同时不需要对数据进行归一化还有缩放的处理。但是决策树有个不足的地方就是非常容易过

拟合，所以必须要采取一些方法进行剪枝。而bagging方法的出现，可以完美地解决了决策树过拟合的问题，同时bagging的使用

也会使分类器分类效果得到了显著的提高

bagging_ridged = BaggingRegressor(ridged, n_estimators=100, max_samples=0.3)

函数原型

sklearn.ensemble.BaggingRegressor(base_estimator=None, n_estimators=10, max_samples=1.0, max_features=1.0, bootstrap=True, bootstrap_features=False, oob_score=False, warm_start=False, n_jobs=None, random_state=None, verbose=0)

base_estimator：Object or None。None代表默认是DecisionTree，Object可以指定基估计器（base estimator）。

n_estimators：int, optional (default=10) 。要集成的基估计器的个数。

max_samples： int or float, optional (default=1.0)。决定从x_train抽取去训练基估计器的样本数量。int 代表抽取数量，float代表抽取比例

max_features : int or float, optional (default=1.0)。决定从x_train抽取去训练基估计器的特征数量。int 代表抽取数量，float代表抽取比例

bootstrap : boolean, optional (default=True) 决定样本子集的抽样方式（有放回和不放回）

bootstrap_features : boolean, optional (default=False)决定特征子集的抽样方式（有放回和不放回）

oob_score : bool 决定是否使用包外估计（out of bag estimate）泛化误差

warm_start : bool, optional (default=False) true代表

n_jobs : int, optional (default=1) 意义同上个api

机器学习中的数据预处理，使用sklearn preprocessing

scale 零均值单位方差

from sklearn import preprocessing 
import numpy as np  
X = np.array([[1., -1., 2.], [2., 0., 0.], [0., 1., -1.]])  
X_scaled = preprocessing.scale(X) 
#output :X_scaled = [[ 0.         -1.22474487  1.33630621]
 				 [ 1.22474487  0.         -0.26726124]
 				 [-1.22474487  1.22474487 -1.06904497]]
＃scaled之后的数据零均值，单位方差
X_scaled.mean(axis=0)  # column mean: array([ 0.,  0.,  0.])  
X_scaled.std(axis=0)  #column standard deviation: array([ 1.,  1.,  1.])

处理过后的数据，在列上均值为0方差为1

StandardScaler计算训练集的平均值和标准差，以便测试数据集使用相同的变换。

scaler = preprocessing.StandardScaler().fit(X) #out: StandardScaler(copy=True, with_mean=True, with_std=True)
scaler.mean_  #out: array([ 1.,  0. ,  0.33333333])  
scaler.std_ #out: array([ 0.81649658,  0.81649658,  1.24721913]) 
#测试将该scaler用于输入数据，变换之后得到的结果同上
scaler.transform(X) #out: array([[ 0., -1.22474487,  1.33630621],        [ 1.22474487, 0. , -0.26726124],  [-1.22474487,1.22474487, -1.06904497]])  
scaler.transform([[-1., 1., 0.]])  #scale the new data, out: array([[-2.44948974,  1.22474487, -0.26726124]])

另外一种标准化方法是将数据缩放至给定的最小值与最大值之间，通常是０与１之间，可用MinMaxScaler实现。或者将最大的绝对值缩放至单位大小，可用MaxAbsScaler实现。
使用这种标准化方法的原因是，有时数据集的标准差非常非常小，有时数据中有很多很多零（稀疏数据）需要保存住０元素。

MinMaxScaler(最小最大值标准化)

公式：X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0)) ;

X_scaler = X_std/ (max - min) + min，其中max，min是指定的最大最小值，默认1，0

#例子：将数据缩放至[0, 1]间。训练过程: fit_transform()
X_train = np.array([[1., -1., 2.], [2., 0., 0.], [0., 1., -1.]])
min_max_scaler = preprocessing.MinMaxScaler() 
X_train_minmax = min_max_scaler.fit_transform(X_train)  
#out: array([[ 0.5       ,  0.        ,  1.        ], 
[ 1.        ,  0.5       ,  0.33333333],        
[ 0.        ,  1.        ,  0.        ]])
#将上述得到的scale参数应用至测试数据
X_test = np.array([[ -3., -1., 4.]])  
X_test_minmax = min_max_scaler.transform(X_test) #out: array([[-1.5 ,  0. , 1.66666667]])
#可以用以下方法查看scaler的属性
min_max_scaler.scale_        #out: array([ 0.5 ,  0.5,  0.33...])
min_max_scaler.min_         #out: array([ 0.,  0.5,  0.33...])

MaxAbsScaler（绝对值最大标准化）

与上述标准化方法相似，但是它通过每个特征值除以该特征最大值将训练集缩放至[-1,1]。这意味着数据已经以０为中心或者是含有非常非常多０的稀疏数据

X_train = np.array([[ 1., -1.,  2.],
                     [ 2.,  0.,  0.],
                    [ 0.,  1., -1.]])
max_abs_scaler = preprocessing.MaxAbsScaler()
X_train_maxabs = max_abs_scaler.fit_transform(X_train)
# doctest +NORMALIZE_WHITESPACE^, out: array([[ 0.5, -1.,  1. ], [ 1. , 0. ,  0. ],       [ 0. ,  1. , -0.5]])
X_test = np.array([[ -3., -1.,  4.]])
X_test_maxabs = max_abs_scaler.transform(X_test) #out: array([[-1.5, -1. ,  2. ]])
max_abs_scaler.scale_  #out: array([ 2.,  1.,  2.])

sklearn.pipeline 串行化

通过steps参数，设定数据处理流程。格式为('key','value')，key是自己为这一step设定的名称，value是对应的处理类。最后通过list将这些step传入。前n-1个step中的类都必须有transform函数，最后一步可有可无，一般最后一步为模型。pipe继承了最后一个类的所有方法。

Pipeline(steps=[('pca', PCA(copy=True, iterated_power='auto', n_components=None,
 random_state=None,
  svd_solver='auto', tol=0.0, whiten=False)), ('svc', SVC(C=1.0, cache_size=200,
 class_weight=None, coef0=0.0,
  decision_function_shape=None, degree=3, gamma='auto', kernel='rbf',
  max_iter=-1, probability=False, random_state=None, shrinking=True,
  tol=0.001, verbose=False))])

训练得到的是一个模型，可直接用来预测，预测时，数据会从step1开始进行转换，避免了模型用来预测的数据还要额外写代码实现。还可通过pipe.score(X,Y)得到这个模型在X训练集上的正确率。

make_pipeline函数是Pipeline类的简单实现，只需传入每个step的类实例即可，不需自己命名，自动将类的小写设为该step的名。

In [50]: make_pipeline(StandardScaler(),GaussianNB())
Out[50]: Pipeline(steps=[('standardscaler', StandardScaler(copy=True, with_mean=
True, with_std=True)), ('gaussiannb', GaussianNB(priors=None))])
 
In [51]: p=make_pipeline(StandardScaler(),GaussianNB())
 
In [52]: p.steps
Out[52]:
[('standardscaler', StandardScaler(copy=True, with_mean=True, with_std=True)),
 ('gaussiannb', GaussianNB(priors=None))]

同时可以通过set_params重新设置每个类里边需传入的参数，设置方法为step的name__parma名=参数值

In [59]: p.set_params(standardscaler__with_mean=False)
Out[59]: Pipeline(steps=[('standardscaler', StandardScaler(copy=True, with_mean=
False, with_std=True)), ('gaussiannb', GaussianNB(priors=None))])

网格搜索GridSearchCV,用于系统地遍历多种参数组合，通过交叉验证确定最佳效果参数。

原函数：

classsklearn.model_selection.GridSearchCV(estimator,param_grid, scoring=None, fit_params=None, n_jobs=1, iid=True, refit=True,cv=None, verbose=0, pre_dispatch='2*n_jobs', error_score='raise',return_train_score=True)

estimator：

所使用的分类器，如estimator=RandomForestClassifier(min_samples_split=100,min_samples_leaf=20,max_depth=8,max_features='sqrt',random_state=10), 并且传入除需要确定最佳的参数之外的其他参数。每一个分类器都需要一个scoring参数，或者score方法。

scoring :

准确度评价标准，默认None,这时需要使用score函数；或者如scoring=’roc_auc’，根据所选模型不同，评价准则不同。字符串（函数名），或是可调用对象，需要其函数签名形如：scorer(estimator, X, y)；如果是None，则使用estimator的误差估计函数。

cv :

交叉验证参数，默认None，使用三折交叉验证。指定fold数量，默认为3，也可以是yield训练/测试数据的生成器。

refit :

默认为True,程序将会以交叉验证训练集得到的最佳参数，重新对所有可用的训练集与开发集进行，作为最终用于性能评估的最佳模型参数。即在搜索参数结束后，用最佳参数结果再次fit一遍全部数据集。

iid:

默认True,为True时，默认为各个样本fold概率分布一致，误差估计为所有样本之和，而非各个fold的平均。

verbose：

日志冗长度，int：冗长度，0：不输出训练过程，1：偶尔输出，>1：对每个子模型都输出。

n_jobs:

并行数，int：个数,-1：跟CPU核数一致, 1:默认值。

pre_dispatch：

指定总共分发的并行任务数。当n_jobs大于1时，数据将在每个运行点进行复制，这可能导致OOM，而设置pre_dispatch参数，则可以预先划分总共的job数量，使数据最多被复制pre_dispatch次。

即便调用函数是param_grid已经填写，也可以在后面，重新setparam

model = GridSearchCV(classification, param_grid={'alpha': alpha_can}, cv=5)
m = alpha_can.size
if hasattr(classification, 'alpha'):
    model.set_params(param_grid={'alpha': alpha_can})
    m = alpha_can.size
if hasattr(classification, 'n_neighbors'):
    neighbors_can = np.arange(1, 15)
    model.set_params(param_grid={'n_neighbors': neighbors_can})
    m = neighbors_can.size

使用best_params获取最优超参数

支持向量机api使用svm库的svc函数

from sklearn import svm
clf = svm.SVC(C=0.8, kernel='rbf', gamma=20, decision_function_shape='ovr')
clf.fit(x_train, y_train.ravel())

这里kenel代表索要使用的核函数，rbf为径向基函数，还有lin表示线性核

c代表的容错率，c越大表示允许度越小，svm的缓冲区距离分割超平面越近。c特别小的时候容易造成过拟合。

gamma代表径向基函数的类似弯曲程度，可以表示为负的方差分之一，gamma越大则方差越大，方差大的时候分割超平面近似于一条直线，方差小的时候，容易造成过拟合。

decision_function_shape有两种ovo和ovr，主要是用于多分类问题，ovo代表多分类时采用一对一进行二分类，ovr代表采用1对剩下的所有进行二分类。

可以直接来查看训练模型的评分

clf.score(x_train, y_train)

可以查看每个样本对应各个类别的大小数值：

print('decision_function:\n', clf.decision_function(x_train))

decision_function:
 [
   [ 2.45540648  0.80337522 -0.2587817 ]
   [-0.4368348   2.31950945  1.11732536]
   [-0.43793789  1.00917055  2.42876733]
 ]

[0. 1. 2.]

weixin_43409627

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
我与数据科学 - [Today is sklearn] - [sklearn api]

分割数据将数据分为训练集和测试集，使用sklearn的model_selection库里面的 train_test_splitfrom sklearn.model_selection import train_test_splitx_train, x_test, y_train, y_test = train_test_split(x, y, train_size=0.7, random_...
复制链接

扫一扫