分割数据将数据分为训练集和测试集,使用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]])
另外一种标准化方法是将数据缩放至给定的最小值与最大值之间,通常是0与1之间,可用MinMaxScaler实现。或者将最大的绝对值缩放至单位大小,可用MaxAbsScaler实现。
使用这种标准化方法的原因是,有时数据集的标准差非常非常小,有时数据中有很多很多零(稀疏数据)需要保存住0元素。
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]。这意味着数据已经以0为中心或者是含有非常非常多0的稀疏数据
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.]