机器学习笔记_aoc曲线

数据集获取

sklearn.datasets.

load_*()获取小规模数据集

fetch_*(data_home=None)获取大规模数据集，data_home表示目录，可不指定

实例1：获取鸢尾花数据集

sklearn.datasets.load_iris()

实例2：获取大规模数据集

sklearn.datasets.fetch_20newsgroups(data_home=None,subset=’train’)

subset:’train’=训练集；’test’=测试集；’all’=全部

数据集的返回值为：dataset.base.Bunch（继承自字典），

获取数据的两种方法：dict[‘key’]=values bunch.key=values

data：特征数据数组

target：标签数组

DESCR：数据描述

feature_names：特征名，新闻数据、手写数学、回归数据集没有

target_names：标签名

数据集划分

sklearn.model_selection.train_test_split(arrays,*options)

x------数据集的特征值

y------数据集的标签值

test_size------测试集的大小，一般为float

random_state------随机种子

return------返回数的顺序需要特别留意：训练集特征值(x_train)、测试集特征值(x_test)、训练集目标值(y_train)、测试集目标值(y_test)

实例：x_train,x_test, y_train, y_test = train_test_split(iris.data, iris.target,test_size=0.2, random_state=22)

特征工程

特征提取sklearn.feature_extraction

1.字典特征提取--->one-hot编码

sklearn.feature_extraction.Dictvectorizer(spares=True,…)

spares=true返归的是一个稀疏矩阵，false返回的是一个二维数组

应用场景：

1）pclas，sex数据集中类别特征比较多

2）本身拿到的数据就是字典类型

2.文本特征提取

方法1：sklearn.feature_extraction.CountVectorizer(stop_words=[])

统计每个样本特征值出现的个数

方法2：sklearn.feature_extraction.TfidfVectorizer()

TF-IDF 衡量重要程度，等于TF乘以IDF

TF：词频；次数/总词数

DF：逆向文档频率，由总文件数除以包含该词语的文件的数目，再将得到的商取以10位底的对数得到

特征预处理

无量纲化

调用API：sklearn.preprocessing

对数据进行归一化/标准化，实现无量纲化

归一化：把数据映射到0-1之间

使用sklearn.preprocessing.MinMaxScaler(feature_range=(0,1))

存在的问题:有异常值影响到了最大值/最小值，鲁棒性较差

标准化：sklearn.preprocessing.StandardScaler()

(x-mean)/std

降维

降维是指在某些限定条件下，降低随机变量(特征)个数，得到一组“不相关”主变量的过程。主要的方法有以下两种：

（1）特征降维sklearn.feature_selection

filter（过滤式）主要探究特征本身特点、特征与特征和目标值之间关联

1.方差选择法：低方差特征过滤

调用API：sklearn.feature_selection.VarianceThreshold(threshold=1)

相关系数法：衡量特征与特征之间的相关程度

皮尔逊相关系数调用API：scipy.stats.pearsonr

斯皮尔曼相关系数调用API：scipy.stats.spearmanr

2.Embedded（嵌入式）

调用API：sklearn.feature_selection.SelectFromModel(estimator, threshold=None, prefit=False, norm_order=1,max_features=None)

决策树：信息熵、信息增益

正则化：L1、L2

深度学习：卷积等

（2）主成分分析PCA

定义：高维数据转化为低维数据的过程，在此过程中可能会舍弃原有数据、创造新的变量

作用：是数据维数压缩，尽可能降低原数据的维数（复杂度），损失少量信息。

应用：回归分析或者聚类分析当中

调用API：sklearn.decomposition.PCA(n_components=None)

注：n_components-小数表示保留百分之几的信息，整数表示减少到多少特征

分类算法

目标值- 类别

1.sklearn转换器和预估器

转换器Transormer

1.实例化Transormer

2.调用fit_transform

估计器estimator

1.实例化estimator

2.调用estimator.fit(x_train,y_train)计算---调用完毕相当于生成了模型

3.模型评估：

1）直接比对

求知预估y_predict= estimator.predict(x_test)

判断y_test ==y_predict

2）计算准确率

accuracy= estimator.score(x_test , y_test)

2.KNN算法

sklearn.neighbors.KNeighborsClassifier (n_neighbors=3)

1）K值过小，容易受到异常值影响；K值过大，容易受到样本不均衡影响

2）简单、易于理解、易于实现、无需训练；需要指定K值，设之不当精度无法保障；懒惰算法，计算量大内存开销大

补充：距离计算方式有欧氏距离、曼哈顿距离、明可夫斯基距离。其中，KNeighborsClassifier定义了使用明可夫斯基距离，当P=1时为曼哈顿距离，P=2时为欧氏距离，所以欧氏距离和曼哈顿距离是明可夫斯基距离的一个特例。

3.模型选择与调优

sklearn.model_selection.GridSearchCV

1）定义一个字典集param_dict = {"n_neighbors": [1, 3, 5, 7, 9, 11]}

2）导入estimator，字典集、多少折交叉验证estimator = GridSearchCV(estimator, param_grid=param_dict, cv=10)

附带函数:

print("最佳参数\n", estimator.best_params_)

print("最佳结果\n", estimator.best_score_)

print("最佳估算器\n", estimator.best_estimator_)

print("交叉验证结果\n", estimator.cv_results_)

4.朴素贝叶斯算法

朴素+贝叶斯sklearn.naive_bayes.MultinomialNB(alpha=1.0)

alpha---拉普拉斯平滑系数

朴素---假设：特征与特征之间是相互独立的

贝叶斯公式：

PCW=PWCP(C)P(W)

联合概率：P(A,B) 条件概率：P(A|B)

样本量小的时候容易出现概率为0，所以引入拉普拉斯平滑系数。

优点：

1.朴素贝叶斯模型发源于古典数学理论，有稳定的分类效率

2.对缺失数据不太敏感，算法也比较简单，常用于文本分类

3.分类准确度高，速度快

缺点：

1.由于使用了样本属性独立性的假设，所以如果特征属性有关联时效果不好

2.需要计算先验概率，而先验概率很多时候取决于假设，假设的模型可以有很多种，因此在某些时候会由于假设的先验模型的原因导致预测效果不佳。

5.决策树（分类）

sklearn.tree.DecisionTreeClassifier

高效决策：特征的先后顺序---引入信息熵、信息增益

可以不做标准化

DecisionTreeClassifier(criterion=’gini’, ,max_depth=None,random_state=None)

criterion---默认gini，也可使用entropy。

（1）通常就使用基尼系数

（2）数据维度很大，噪音很大时使用基尼系数

（3）维度低，数据比较清晰的时候，信息熵和基尼系数没区别

（4）当决策树的拟合程度不够的时候，使用信息熵

min_samples_split---内部节点再划分所需最小样本数，默认是2。如果数量级非常大则推荐增大这个数值（例，10万样本取10）。

min_samples_leaf---叶子结点最小样本数，默认是1。如果数量级非常大则推荐增大这个数值（例，10万样本取5）

max_depth---树的深度，过大则泛化程度低，训练集数据过拟合导致测试集拟合低。样本量多、特征也多的情况下，推荐限制这个数值。常用可取值10-100。

random_state---随机数种子

决策树更适合运用在数据量比较大的场所。

决策树是可以可视化的。

信息增益---ID3算法，只能处理离散属性的数据集构造决策树；

信息增益率---C4.5算法，是ID3的改进，可以处理连续数值型数据，采用后剪枝方法，可以处理缺失值，产生的分类规则易于理解，准确率较高，但是，在构造树的过程中需要对数据集进行多次的顺序扫描和排序所以效率低，此外C4.5只适合于能够驻留于内存的数据集，当训练集大得无法在内存容纳时程序无法运行；

基尼指数---CART算法，采用了简化的二叉树模型（ID3、C4.5不一定是二叉树，而CART一定是二叉树），同时基尼系数简化了计算。

信息熵公式：

EntD=-k=1nCkDlogCkD=-k=1npklog2pk

信息增益采用的是：整体信息增益-各类别信息熵。

信息增益率采用的是：各类别信息熵÷各个属性的分裂信息度量。

基尼值公式：

GiniD=k=1|y|k’≠kpkpk’=1-k=1|y|pk2

扩展：ID3、C4.5或者是CART都是选择最优的一个特征来做分类决策，但是大多数分类决策不应该是由一个特征决定，而是一组特征决定的。这样的决策树叫做“多变量决策树（multi-variate decision tree）”，代表算法是OC1。略。

决策树剪枝：

预剪枝与后剪枝：后剪枝保留了更多的分支，后剪枝的欠拟合风险很小，泛化性能优于预剪枝，但是后剪枝是在生成完全决策树后进行的，所以训练时间开销会大得多。

剪枝原因：噪声、样本冲突，即错误的样本数据；特征不能完全作为分类标准；巧合的规律性，数据量不够大。

预剪枝：在构建树的过程中同时剪枝，实现：限制节点最小样本数；制定数据高度；指定熵值的最小值。

后剪枝：把一棵树构建完成后，再进行从下往上的剪枝。

6.随机森林（分类）

包含多个决策树的分类器sklearn.ensemble.RandomForestClassifier

随机=训练集随机bootstrap+特征随机

RandomForestClassifier(n_estimators=10,criterion=’gini’,max_depth=None,bootstrap=True,random_state=None,min_samples_split=2)

n_estimators森林里数目数量

max_features=’auto’决策树最大特征数量（auto=sqrt=√M；log2=log2M;None=M）

min_samples_split：节点划分最小样本数

min_samples_leaf：叶子结点的最小样本数

线性回归算法

目标值- 连续性数值

找到一种函数关系，来表示特征值和目标值的关系

线性模型 - 线性关系、非线性关系

线性回归的损失和优化原理

目标：求模型参数

损失函数/cost/成本函数/目标函数，又称，最小二乘法

优化方法：

正规方程：sklearn.linear_model.LinearRegression

直接求解W=(XTX)-1XTy

推导过程：

把损失函数写成矩阵乘法：

Jw=(hx1-y1)2 +(hx2-y2)2+∙∙∙∙∙∙+hxm-ym2 =i=1mhxi-yi2=(Xw-y)2

进行求导：

2Xw-y×X=02Xw-y×XXT=0XT2Xw-y×XXTXXT-1=0XTXXT-12Xw-y=0Xw=yXXTw=XTyXXT-1XXT×w=XXT-1×XTyw=XXT-1×XTy

sklearn.linear_model.LinearRegression(fit intercept=True)

fit_intercept:是否计算偏置

LinearRegression.coef :回归系数

LinearRegression.intercept :偏置

梯度下降：sklearn.linear_model.SGDRegressor()

不断地试错、改进，递归到合适的位置.

1.单变量梯度下降：

假设单变量函数：Jθ=θ2

函数的微分：J'θ=2θ

初始化设置起点θ0=1，学习率α=0.4

则开始迭代后：

θ0=1

θ1=θ0-α×J'θ0=1-0.4×2×1=0.2

θ2=θ1-α×J'θ1=0.2-0.4×2×0.2=0.04

θ3=0.008

θ4=0.0016

2.多变量梯度下降：

假设目标函数为Jθ=θ12+θ22

函数的梯度为：∇Jθ=<2θ1,2θ2>

初始化设置起点θ0=1,3，学习率α=0.1

则开始迭代后：

θ0=1

θ1=θ0-α∇Jθ=1,3-0.12,6=(0.8,2.4)

θ2=θ1-α∇Jθ=0.8,2.4-0.11.6,4.8=(0.64,1.92)

θ3=(0.512,1.536)

θ4=(0.4096,1.2288000000000001)

sklearn.linearmodel.SGDRegressor(loss="squared loss",fitintercept=True,learning_rate ='invscaling', eta0=0.01)

loss:损失类型loss="squared_loss”:普通最小二乘法

fit intercept:是否计算偏置

learning_rate :学习率填充

'constant': eta = eta0;

'optimal': eta=1.0/(alpha*(t +t0))（默认）;

'invscaling':eta=eta0/pow(t, power_t)，其中power_t=0.25存在父类当中

属性：

SGDRegressor.coef_回归系数

SGDRegressor.intercept_偏置

梯度下降的优化方法：

1.GD-梯度下降（Gradient Descent），原始的梯度下降法，需要计算所有样本的值才能够得出梯度，计算量大。

2.SGD-随机梯度下降（Stochastic Gradient Descent），在一次迭代时只考虑一个训练样本.

SGD的优点：高效、容易实现

SGD的缺点：需要许多超参数，比如正则项参数、迭代数；对于特征标准化是敏感的

3.SAG-随机平均梯度法（Stochastic Average Descent），由于收敛的速度太慢，有人提出了SAG等基于梯度下降的算法，在Scikit-learn中，岭回归、逻辑回归等都有SAG优化

算法选择：

小规模数据：正规方程LinearRegression、岭回归

大规模数据：梯度下降SGDRegressor

线性回归的过拟合与欠拟合

欠拟合-数据特征过少，增加特征数量、添加多项式特征

过拟合-特征过多，存在嘈杂特征，解决方法：①重新清洗数据，减少数据不纯导致的过拟合；②增加数据的训练量，增大训练数据占比；③正则化以减少高次项影响；④减少特征维度，防止维灾难。

正则化方法：

L1正则化:

Jw=12mi=1m(hwxi-yi)2+j=1n|wj|

L1正则化后面的惩罚项，还有一个名字叫做LASSO回归

L2正则化（更常用）:

Jw=12mi=1m(hwxi-yi)2+j=1nwj2

L2正则化后面的惩罚项，还有一个名字叫做Ridge（岭回归）

正则化力度越大，权重系数越小；正则化力度越小，权重系数越大。

岭回归

就是一个带惩罚系数的线性回归，解决过拟合问题

sklearn.linear_model. Ridge (alpha=1.0,fit_intercept=True,solver=’auto’,normalize=False)

alpha---正则化力度λ，取0~1,1~10

solver---会根据数据自动选择优化方法

normalize---数据是否进行标准化，当Flase时，可以在fit之前调用preprocessing.StandardScaler进行数据标准化处理

属性：

Ridg.coef_回归权重

intercept_回归偏置

注：Ridge方法相当于SGDRegressor(penalty=’l2’,loss="squaredloss")，只不过SGD实现了一个普通的随机梯度下降学习，建议使用Ridge（实现了SAG）

使用的时候可以使用sklearn.linear_model.RidgeCV (_BaseRidgeCV,RegressorMixin),具有L2正则化的线性回归可以进行交叉验证。

正则化力度越大，权重系数越小；正则化力度越小，权重系数越大。

Lasso回归

sklearn.linear_model.Lasso(alpha=1.0, *, fit_intercept=True,normalize=‘deprecated’, precompute=False, copy_X=True, max_iter=1000,tol=0.0001, warm_start=False, positive=False, random_state=None,selection=‘cyclic’)

Lasso Regression性质：倾向于完全消除不重要的权重。

当α取值较大的时候，高阶多项式退化为二项式甚至是线性，自动进行特征选择并输出一个稀疏模型（即，只有少数特征的权重是非零）

Lasso对系数绝对值进行处理，由于绝对值在顶点处不可导，所以进行计算过程中产生很多0，最后得到一个稀疏矩阵。

ElasticNet

弹性网络在岭回归和Lasso回归中进行了折中，混合了r进行控制：

代价函数：

Jθ=MSEθ+rαj=1nθj+1-r2αj=1nθj2

所以有：r=0，弹性网络变岭回归；r=1，弹性网络变Lasso回归。

小结：常用岭回归；只有少部分特征使用弹性网络或者Lasso，但是Lasso回归的表现不太稳定所以少用。

EarlyStopping

早停法。也是一种使用了迭代学习的方法，当错误率达到最小值的时候停止训练。可对抗过拟合的正则化方法。

决策树（回归）

处理连续型数据的算法。

sklearn.tree.DecisionTreeTegressor

要做好max_depth的控制，否则容易出现过拟合

逻辑回归

二分类问题的利器

sklearn.linear_model.LogisticRegression(solver=’liblinear’,penalty=’l2’,C=1.0)

solver:优化解决方式。可选‘liblinear’、‘sga’、’saga’、’newton-cg’、’lbfgs’；默认liblinear库实现，内部使用了坐标轴下降法来迭代优化损失函数；对于小数据来说，liblinear不错，而‘sag’、‘saga’对于大型数据集会更快；对于多类问题，只有‘newton-cg’、‘sga’、’saga’和’lbfgs’可以处理多想损失；liblinear仅限于分‘one-versus-rest’分类（即，“某一类”与“其他类”）。

sag：根据数据集自动选择，随即平均梯度下降

penalty:正则化种类

C:正则化力度

线性回归的输出 就是 逻辑回归的输入

激活函数-sigmoid函数g(θTx)=11+e-θTx，其实就是一个g(x)=11+e-x，将线性输出代入到x中，取得[0,1]的输出，默认阈值0.5。

逻辑回归的损失，称之为对数似然损失：

costhθx,y=-loghθx y=1-log1-hθx y=0

LogisticRegression方法相当于SGDClassifier(loss=’log’,penalty=’’)，SGDClassifier实现了一个普通的随机梯度下降学习，也支持平均梯度下降法（ASGD），可以通过设置average=True。而使用LogisticRegression实现了随机平均梯度下降（SAG）。

SVM支持向量机

SVM全称是supported vectormachine（支持向量机），即寻找到一个超平面使样本分成两类，并且间隔最大。SVM能够执行线性或非线性分类、回归，甚至异常值检测任务。它是机器学习领域最受欢迎的模型之一，特别适用于复杂数据的分类，是一种二分类模型。

软硬间隔

硬间隔：分割数据的过程中，如果我们严格的让所有实例都不在最大间隔之间，并且位于正确的一边，就是硬间隔分类。硬间隔分类有两个问题：只在数据是限行可分离的时候才有效；对异常值非常敏感。

软间隔：尽可能在保持最大宽度和限制间隔违例（即位于最大间隔智商，甚至在错误的一边的实例）之间找到良好的平衡。在Scikit-Learn的SVM类中，可以通过超参数C来控制这个平衡：C值越小，则间隔越宽，但是间隔违例也会越多。

损失函数

在SVM中主要讨论三种损失函数：0/1损失、SVM Hinge损失函数、Logistic损失函数

①0/1损失：当正例的点落在y=0这个超平面下面，说明分类正确，无论距离多近误差都是0；来当正例的点落在y=0这个超平面上面，说明分类错误，无论距离多近误差都是1。

②SVM Hinge损失函数：当一个正例的点落在y=1的直线上，距离超平面长度1，那么1-ɛ=1，ɛ=0，也就是说误差为0；当它落在距离超平面距离为0.5的地方，那么1-ɛ=0.5，ɛ=0.5，也就是说误差为0.5；当它落在y=0的上方，被误分到负例中，距离算出来应该是负的，比如-0.5，那么1-ɛ=-0.5，ɛ=-1.5，也就是说误差为1.5。

③Logistic损失函数：损失函数的公式为ln(1+e-yi)，当yi=0时，损失等于ln2，给损失函数除以ln2，这样当yi=0时，损失为1，函数经过(0,1)点。

核函数：从一个低维空间到高维空间的映射，这个映射可以把低维空间中线性不可分的两类点变成线性可分的。

常见的核函数

注：

1.多项式核中，当d=1时退化为线性核；

2.高斯核亦称为RBF核。

线性核和多项式核：

这两种核的作用也是首先在属性空间中找到一些点，把这些点当做base，核函数的作用就是找与该点距离和角度满足某种关系的样本点。当样本点与该点的夹角近乎垂直时，两个样本的欧式长度必须非常长才能保证满足线性核函数大于0；而当样本点与base点的方向相同时，长度就不必很长；而当方向相反时，核函数值就是负的，被判为反类。即，它在空间上划分出一个梭形，按照梭形来进行正反类划分。

RBF核：

高斯核函数就是在属性空间中找到一些点，这些点可以是也可以不是样本点，把这些点当做base，以这些base为圆心向外扩展，扩展半径即为带宽，即可划分数据。换句话说，在属性空间中找到一些超圆，用这些超圆来判定正反类。

Sigmoid核

同样地是定义一些base,核函数就是将线性核函数经过一个tanh两数进行处理，把值域限制在了-1到1上。

以上，总之，都是在定义距离，大于该距离，判为正，小于该距离，判为负。至于选择哪一种核函数，要根据貝体的样本分布情況来确定。

一般有如下指导规则：

1)如果Feature的数量很大，甚至和样本数量差不多时，往往线性可分，这时选用LR或者线性核Linear；

2)如果Feature的数量很小，样本数量正常，不算多也不算少，这时选用PBF核；

3)如果Feature的数量很小，而样本的数量很大，这时手动添加一些Feature，使得线性可分，然后选用L只或者线性核Linear;

4)多项式核一般很少使用，效率不高，结果也不优于RBF;

5)Linear核参数少，速度快；RBF核参数多，分类结果非常依赖于参数，需要交叉验证或网格搜索最佳参数，比较耗时；

6)应用最广的应该就是RBF核，无论是小样本还是大样本，高维还是低维等情况，RBF核西数均适用。

API综述

SVM可以用于分类、回归和异常值检测，具有里浪好的鲁棒性，对未知数据拥有很强的泛化能力，特别是在数据量较少的情况下，相较其他传统机器学习算法具有更优的性能。

使用SVM模型时，通常采用如下流程：

1.对数据进行归一化

2.应用核函数对样本进行映射，最常采用核函数是RBF和Linear，在线性样本可分时，Llinear效果要比RBF好

3.用cross-validation和grid-search对超参数进行优选

4.用最优参数训练得到模型

5.测试

sklearn三个SVM分类器：sklearn.svm.LinearSVR，sklearn.svm.SVR，sklearn.svm.NuSVR，对应扩展到回归分类方法：sklearn.svm.LinearSVC，sklearn.svm.SVC，sklearn.svm.NuSVC

SVC和NuSVR方法基本一致，唯一的区别就是损失函数的度量方式不同，NuSVC中的nu参数和SVC中的C参数；LinearSVC是实现线性核函数的支持向量分类，没有kernel参数。

SVC

class sklearn.svm.SVC(C=1.0,kernel=‘rbf’, degree=3, gamma=‘auto’, coef0=0.0, shrinking=True,probability=False, tol=0.001, cache_size=200, class_weight=None, verbose=False,max_iter=-1, decision_function_shape=‘ovr’, random_state=None)　

C------惩罚系数，用来控制损失函数的惩罚系数，来控制损失函数的惩罚系数。

C越大，相当于惩罚松弛变量，希望松弛变量接近0，即对误分类的惩罚增大，趋向于对训练集全分对的情况，这样会出现训练集测试时准确率很高，但泛化能力弱，容易导致过拟合；C值小，对误分类的惩罚减小，容错能力增强，泛化能力较强，但也可能欠拟合。即：惩罚因子C的取值权衡了经验风险和结构风险：C越大，经验风险越小，结构风险越大，模型复杂度越高，容易出现过拟合；C越小，模型复杂度越低，容易出现欠拟合。

kernel------算法中采用的核函数类型，核函数是用来将非线性问题转化为线性问题的一种方法。参数选择有RBF, Linear, Poly, Sigmoid，precomputed或者自定义一个核函数, 默认的是"RBF"，即径向基核，也就是高斯核函数；而Linear指的是线性核函数，Poly指的是多项式核，Sigmoid指的是双曲正切函数tanh核。

degree------当指定kernel为’poly’时，表示选择的多项式的最高次数，默认为三次多项式；若指定kernel不是’poly’，则忽略，即该参数只对’poly’有用。（多项式核函数是将低维的输入空间映射到高维的特征空间）

gamma------核函数系数，该参数是rbf，poly和sigmoid的内核系数；默认是’auto’，那么将会使用特征位数的倒数，即1 / n_features。（即核函数的带宽，超圆的半径）。gamma越大，σ越小，使得高斯分布又高又瘦，造成模型只能作用于支持向量附近，可能导致过拟合；反之，gamma越小，σ越大，高斯分布会过于平滑，在训练集上分类效果不佳，可能导致欠拟合。

coef0------核函数常数值(y=kx+b中的b值)，只有‘poly’和‘sigmoid’核函数有，默认值是0。

shrinking------是否进行启发式。如果能预知哪些变量对应着支持向量，则只要在这些样本上训练就够了，其他样本可不予考虑，这不影响训练结果，但降低了问题的规模并有助于迅速求解。进一步，如果能预知哪些变量在边界上(即a=C)，则这些变量可保持不动，只对其他变量进行优化，从而使问题的规模更小，训练时间大大降低。这就是Shrinking技术。Shrinking技术基于这样一个事实：支持向量只占训练样本的少部分，并且大多数支持向量的拉格朗日乘子等于C。

probability------是否使用概率估计，默认是False。必须在fit( )方法前使用，该方法的使用会降低运算速度。

tol------残差收敛条件，默认是0.0001，即容忍1000分类里出现一个错误，与LR中的一致；误差项达到指定值时则停止训练。

cache_size------缓冲大小，用来限制计算量大小，默认是200M。

class_weight------{dict, ‘balanced’}，字典类型或者balance字符串。权重设置，正类和反类的样本数量是不一样的，这里就会出现类别不平衡问题，该参数就是指每个类所占据的权重，默认为1，即默认正类样本数量和反类一样多，也可以用一个字典dict指定每个类的权值，或者选择默认的参数balanced，指按照每个类中样本数量的比例自动分配权值。如果不设置，则默认所有类权重值相同，以字典形式传入。将类i的参数C设置为SVC的class_weight[i]C。如果没有给出，所有类的weight为1。balanced模式使用y值自动调整权重，调整方式是与输入数据中类频率成反比。如n_samples / (n_classes * np.bincount(y))。（给每个类别分别设置不同的惩罚参数C，如果没有给，则会给所有类别都给C=1，即前面参数指出的参数C。如果给定参数balance，则使用y的值自动调整与输入数据中的类频率成反比的权重。）

verbose------是否启用详细输出。在训练数据完成之后，会把训练的详细信息全部输出打印出来，可以看到训练了多少步，训练的目标值是多少；但是在多线程环境下，由于多个线程会导致线程变量通信有困难，因此verbose选项的值就是出错，所以多线程下不要使用该参数。

max_iter------最大迭代次数，默认是-1，即没有限制。这个是硬限制，它的优先级要高于tol参数，不论训练的标准和精度达到要求没有，都要停止训练。

decision_function_shape------原始的SVM只适用于二分类问题，如果要将其扩展到多类分类，就要采取一定的融合策略，这里提供了三种选择。ovo，一对一，为one v one，即将类别两两之间进行划分，用二分类的方法模拟多分类的结果，决策所使用的返回的是（样本数，类别数(类别数-1)/2）；ovr，一对多，为one v rest，即一个类别与其他类别进行划分，返回的是(样本数，类别数)，或者None，就是不采用任何融合策略。默认是ovr，因为此种效果要比ovo略好一点。

random_state: 在使用SVM训练数据时，要先将训练数据打乱顺序，用来提高分类精度，这里就用到了伪随机序列。如果该参数给定的是一个整数，则该整数就是伪随机序列的种子值；如果给定的就是一个随机实例，则采用给定的随机实例来进行打乱处理；如果啥都没给，则采用默认的 np.random实例来处理。

NuSVC

class sklearn.svm.NuSVC(nu=0.5)

nu：训练误差部分的上限和⽀持向量部分的下限，取值在（0，1）之间，默认是0.5

LinearSVC

class sklearn.svm.LinearSVC(penalty='l2', loss='squared_hinge',dual=True, C=1.0)

penalty------正则化参数，L1和L2两种参数可选，仅LinearSVC有。

loss------损失函数，有hinge和squared_hinge两种可选，前者又称L1损失，后者成为L2损失，默认是squared_hinge，其中hinge是SVM的标准损失，squared_hinge是hinge的平方

dual------是否转化为对偶问题求解，默认是True。

C------惩罚系数，用来控制损失函数的惩罚系数，类似于线性回归中的正则化系数

小结

SVM是一种二分类模型，他的基本模型是在特征空间中寻找间隔最大化的分离超平面的线性分类器。

1.当训练样本线性可分时，通过硬间隔最大化，学习一个线性分类器，即线性可分支持向量机；

2.当训练数据近似线性可分，可引入松弛变量，通过软间隔最大化，学习一个线性分类器，即线性支持向量机；

3.当训练数据线性不可分时，通过使用核技巧及软间隔最大化，学习非线性支持向量机。

SVM的优点：在高维空间中非常高效；即使在数据维度比样本数量大的情况下仍然有效；在决策树（称为支持向量）中使用训练集的子集，因此它也是高效利用内存的；通用性---不同的核函数与特定的决策函数一一对应。

SVM的缺点：如果特征数量比样本数量大得多，在选择核函数时要避免过拟合；对确实函数敏感；对于核函数的高维映射解释力不强

EM算法

EM算法也称期望最大化，它是一个基础算法，是很多机器学习领域算法的基础。

EM算法是一种迭代优化策略，由于它的计算方法中每一次迭代都分为两步，期望步（E步）和极大步（M步），所以被称为EM算法（Expectation-Maximization Algorithm）。

略去马可夫链、前向后向算法评估观察序列概率、维特比算法、鲍姆-韦尔奇算法等知识。

HMM模型的API：

pip3 install hmmlearn

hmmlearn一共实现了三种HMM模型类，按照数据的观测状态是离散的还是连续的可以划分为两类。GaussianHMM（高斯HMM模型）和GMMHMM（混合高斯模型）是观测状态为连续的模型。MultinomialHMM（多项式分布HMM模型）是观测状态为离散的模型。这三种算法都可以被用来估计模型的参数。

集成学习

集成学习的调度思想

#Voting算法不同，数据相同，试图产生略有差异的结果，再基于规则整合结果

from sklearn.ensemble import VotingClassifier

from sklearn.ensemble import VotingRegressor

#stack前面类似于voting，但是结果拟合时使用模型，而不是使用人为规则，2阶段的思想

from sklearn.ensemble import StackingClassifier

from sklearn.ensemble import StackingRegressor

#bagging算法相同，数据不同，试图产生略有差异的结果，再基于规则整合结果

from sklearn.ensemble import BaggingClassifier

from sklearn.ensemble import BaggingRegressor

#boost错题本思想

from sklearn.ensemble import AdaBoostClassifier

from sklearn.ensemble import AdaBoostRegressor

建立几个模型来解决单一预测问题。它的工作原理是生成多个分类器/模型，各自独立地学习和做出预测。这些预测最后结合成组合预测，由此优于任何一个但分类的做出预测。

机器学习的两个任务：

1.优化训练数据---解决欠拟合问题---主要方法是Bosting逐步增强学习

2.提升泛化性能---解决过拟合问题---主要方法是Bagging采样学习继承，提高2%左右泛化

Bagging集成与Bosting集成的区别：

区别一：数据方面

Bagging：对数据进行采样训练。训练集是在原始集中有放回选取的，从原始集中选出的各轮训练集之间是独立的。

Bosting：根据前一轮学习结果调整数据的重要性。每一轮的训练集不变，只是训练集中每个样例在分类器中的权重发生变化。而权值是根据上一轮的分类结果进行调整。

区别二：投票方面

Bagging：所有学习器平权投票

Bosting：对学习器进行加权投票

区别三：学习顺序方面

Bagging的学习是并行的，每个学习期没有依赖关系

Bosting的学习是串行的，学习有先后顺序

区别四：主要作用

Bagging主要用于提高泛化性能（解决过拟合，降低方差）

Bosting主要用于提高训练精度（解决欠拟合，降低偏差）

Bagging集成

调用的API：

sklearn.ensemble.BaggingClassifier

sklearn.ensemble.BaggingRegressor

参数：

base_estimator---基学习器

n_estimators---基学习器的数量

max_samples---每次训练基学习器时使用的样本比例

max_features---每次训练基学习器时使用的特征比例

bootstrap---抽取样本后放回

bootstrap_features---抽取特征后放回

oob_score---使用包外样本做评估

warm_start---简单的说，True时新建一个模型会利用上一个模型的“经验”。False时则是纯的全新模型。

n_jobs---并行线程运算，设置为-1会使用剩余的所有内核进行运算。

random_state---随机种子

属性：

base_estimator---基学习器

n_features_---使用的特征数量

estimators_---所有的基学习器list

oob_score_---包外数据评估分数

方法：

.fit---训练

predict---预测

predict_proba---预测，返回概率

predict_log_proba---预测，返回log概率

score---返回准确率

Bagging-随机森林算法

随机森林=Bagging+决策树

抽样的过程是有放回的。这样有一部分数据会永远抽不到，即（1-1/N）N≈1/e，即36.8%。抽不到的数据集为包外数据（Out-of-bag，OOB）。包外估计是对集成分类器泛化误差的无偏估计，在随机森林算法中，数据集属性的重要性、费雷器集强度和分类器间相关性计算都是依赖于袋外数据。当基学习器是决策树时，可以使用OOB来辅助剪枝，或用于估计决策树中各结点的后验概率以辅助对零训练样本结点的处理；当基学习器是神经网络时，可以使用OOB来辅助早期停止，以减小过拟合。

sklearn.ensemble.RandomForestClassifier()

sklearn.ensemble.RandomForestClassifier(n_estimators=10, criterion='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, min_impurity_split=1e-07, bootstrap=True, oob_score=False,n_jobs=1, random_state=None,verbose=0, warm_start=False, class_weight=None)

n_estimators---建立的树的数量，可以采用网格搜寻法

max_features ---可选‘auto’、‘sqrt’（同auto）、‘log2’和None（即常熟）

min_samples_leaf---限制决策树的增长，如果结点的不纯度小雨这个阈值就不再生成子节点。默认1e-07，不建议更改。

上述的几个参数中，最大特征数max_features、最大深度max_depth、内部节点再划分所需最小样本数min_samples_split和叶子结点最小样本数min_samples_leaf是最重要的参数，可通过网格调优。

Boosting集成

随着学习的积累从弱到强，美新加入一个弱学习器，整体能力就会得到提升。

Boosting的初始化采用的是无放回抽样。

代表算法：Adaboost，GBDT，XGBoost，LightGBM

Boosting-Adaboost算法

主要步骤：训练第一个学习器->根据第一个训练器的结果放大“被错误标记的数据”，缩小“正确正确标记的数据”->根据调整好的数据分布，训练第二个学习器->再次调整数据->确定投票权重->投票。

权重分布：错误率=0.5，没有投票权；错误率>0.5，投负权重票；错误率<0.5投正权重票

调用的API：sklearn.ensemble.AdaBoostClassifier

参数：

base_estimator:基分类器，默认是决策树，在该分类器基础上进行boosting，理论上可以是任意一个分类器，但是如果是其他分类器时需要指明样本权重。

n_estimators:基分类器提升（循环）次数，默认是50次，这个值过大，模型容易过拟合；值过小，模型容易欠拟合。

learning_rate:学习率，表示梯度收敛速度，默认为1，如果过大，容易错过最优值，如果过小，则收敛速度会很慢；该值需要和n_estimators进行一个权衡，当分类器迭代次数较少时，学习率可以小一些，当迭代次数较多时，学习率可以适当放大。

algorithm:boosting算法，也就是模型提升准则，有两种方式SAMME, 和SAMME.R两种，默认是SAMME.R，两者的区别主要是弱学习器权重的度量，前者是对样本集预测错误的概率进行划分的，后者是对样本集的预测错误的比例，即错分率进行划分的，默认是用的SAMME.R。

random_state:随机种子设置。

关于Adaboost模型本身的参数并不多，但是我们在实际中除了调整Adaboost模型参数外，还可以调整基分类器的参数，关于基分类的调参，和单模型的调参是完全一样的，比如默认的基分类器是决策树，那么这个分类器的调参和我们之前的Sklearn参数详解——决策树是完全一致。

对象：

estimators_:以列表的形式返回所有的分类器。

classes_:类别标签

estimator_weights_:每个分类器权重

estimator_errors_:每个分类器的错分率，与分类器权重相对应。

feature_importances_:特征重要性，这个参数使用前提是基分类器也支持这个属性。

方法：

decision_function(X):返回决策函数值（比如svm中的决策距离）

fit(X,Y):在数据集（X,Y）上训练模型。

get_parms():获取模型参数

predict(X):预测数据集X的结果。

predict_log_proba(X):预测数据集X的对数概率。

predict_proba(X):预测数据集X的概率值。

score(X,Y):输出数据集（X,Y）在模型上的准确率。

staged_decision_function(X):返回每个基分类器的决策函数值

staged_predict(X):返回每个基分类器的预测数据集X的结果。

staged_predict_proba(X):返回每个基分类器的预测数据集X的概率结果。

staged_score(X, Y):返回每个基分类器的预测准确率。

Boosting-GBDT算法

GBDT的全称是梯度提升决策树(Gradient Boosting Decision Tree) 是一种迭代的决策树算法，该算法由多棵决策树组成，所有树的结论累加起来做最终答案。它在被提出之初就被认为是泛化能力（generalization)较强的算法。近些年更因为被用于搜索排序的机器学习模型而引起大家关注。

GBDT使用的是CART回归树，无论回归问题还是二分类多分类问题。因为GDBT每次迭代要拟合的是梯度值，是连续值所以要用回归树。

原理：

（1）初始化弱学习器

f0=arg minci=1NL(yi,c)

（2）对m=1,2,3,…,M有

(a)对每个样本i=1,2,3,…,N，计算负梯度（即残差，此步骤就是求导）

γim=-ϑL(yi,f(xi))ϑf(xi)fx=fm-1(x)

(b)将上一步得到的残差作为样本新的真实值，并将数据（xi,rim）,i=1,2,…,N作为下一棵树的训练数据，得到一颗新的回归树fm(x)其对应的叶子结点区域为Rjm,j=1,2,…,J。其中，J为回归树t的叶子结点的个数。

(c)对叶子区域j=1,2,…,J计算最佳拟合值（略）

(d)更新学习器

fmx=fm-1x+j=1JγjmI(x∈Rjm)

（3）得到最终学习器

fx=fMx=f0x+m=1Mj=1JγjmI(x∈Rjm)

在sacikit-learn中，GradientBoostingClassifier为GBDT的分类类，而GradientBoostingRegressor为GBDT的回归类。

调用API：sklearn.ensemble.GradientBoostingClassifier

参数略。

Boosting-XGBoost算法

XGBoost(eXtreme Gradient Boosting)又叫极度梯度提升树，是boosting算法的一种实现方式。针对分类或回归问题，效果非常好。在各种数据竞赛中大放异彩，而且在工业界也是应用广泛，主要是因为其效果优异，使用简单，速度快等优点。

目标函数由两部分组成，一是模型误差，即样本真实值和预测值之间的差值，二是模型的结构误差，即正则项，用于限制模型的复杂度。

目标函数：

objθ=inLyi,yi+k=1KΩ(fk)

XGBoost算法与GBDT的区别：

1. XGBoost生成CART树考虑了树的复杂度，GDBT未考虑，GDBT在树的剪枝步骤中考虑了树的复杂度。

2. XGBoost是拟合上一轮损失函数的二阶导展开，GDBT是拟合上一轮损失函数的一阶导展开，因此，XGBoost的准确性更高，且满足相同的训练效果，需要的迭代次数更少。

3. XGBoost与GDBT都是逐次迭代来提高模型性能，但是XGBoost在选取最佳切分点时可以开启多线程进行，大大提高了运行速度。

调用的API：

from xgboost import XGBClassifier

xgbc = XGBClassifier()

xgboost要想训练出不错的模型，必须要给参数传递合适的值。xgboost中封装了很多参数，主要由三种类型构成：通用参数（general parameters），Booster 参数（booster parameters）和学习目标参数（task parameters）

通用参数：主要是宏观函数控制；

Booster参数：取决于选择的Booster类型，用于控制每一步的booster（tree, regressiong）；

学习目标参数：控制训练目标的表现。

1、通用参数（general parameters）：

1.1.booster[缺省值=gbtree]，决定使用哪个booster，可以是gbtree，gblinear或者dart。gbtree和dart使用基于树的模型(dart主要多了Dropout，即，选择的时候有意识地删除部分节点，属于深度学习内容)，而gblinear 使用线性函数.

1.2.silent[缺省值=0]设置为0打印运行信息；设置为1静默模式不打印

1.3.nthread[缺省值=设置为最大可能的线程数并行运行xgboost的线程数，输入的参数应该<=系统的CPU核心数，若是没有设置算法会检测将其设置为CPU的全部核心数

1.4.num_pbuffer[xgboost自动设置，不需要用户设置]预测结果缓存大小，通常设置为训练实例的个数。该缓存用于保存最后boosting操作的预测结果。

1.5.num_feature[xgboost自动设置，不需要用户设置]在boosting中使用特征的维度，设置为特征的最大维度

2、Booster 参数（booster parameters）

2.1、Parameters for Tree Booster：

2.1.1.eta[缺省值=0.3，别名：learning_rate] 更新中减少的步长来防止过拟合。在每次boosting之后，可以直接获得新的特征权值，这样可以使得boosting更加鲁棒。范围：[0,1]

2.1.2.gamma[缺省值=0，别名: min_split_loss]（分裂最小loss）在节点分裂时，只有分裂后损失函数的值下降了，才会分裂这个节点。Gamma指定了节点分裂所需的最小损失函数下降值。这个参数的值越大，算法越保守。这个参数的值和损失函数息息相关，所以是需要调整的，范围: [0,∞]

2.1.3.max_depth[缺省值=6]这个值为树的最大深度。这个值也是用来避免过拟合的。max_depth越大，模型会学到更具体更局部的样本。设置为0代表没有限制，范围: [0,∞]

2.1.4.min_child_weight[缺省值=1]决定最小叶子节点样本权重和。XGBoost的这个参数是最小样本权重的和。当它的值较大时，可以避免模型学习到局部的特殊样本。但是如果这个值过高，会导致欠拟合。这个参数需要使用CV来调整。范围: [0,∞]

2.1.5.subsample[缺省值=1]这个参数控制对于每棵树，随机采样的比例。减小这个参数的值，算法会更加保守，避免过拟合。但是，如果这个值设置得过小，它可能会导致欠拟合。典型值：0.5-1，0.5代表平均采样，防止过拟合，范围: (0,1]

2.1.6.colsample_bytree[缺省值=1] 用来控制每棵随机采样的列数的占比(每一列是一个特征)。典型值：0.5-1范围: (0,1]

2.1.7.colsample_bylevel [缺省值=1] 用来控制树的每一级的每一次分裂，对列数的采样的占比。#个人一般不太用这个参数，因为subsample参数和colsample_bytree参数可以起到相同的作用。但是如果感兴趣，可以挖掘这个参数更多的用处。范围: (0,1]

2.1.8.lambda[缺省值=1，别名: reg_lambda]权重的L2正则化项(和Ridge regression类似)。这个参数是用来控制XGBoost的正则化部分的。虽然大部分数据科学家很少用到这个参数，但是这个参数在减少过拟合上还是可以挖掘出更多用处的。.

2.1.9.alpha [缺省值=0，别名: reg_alpha]权重的L1正则化项。(和Lasso regression类似)。可以应用在很高维度的情况下，使得算法的速度更快。

2.1.10.scale_pos_weight[缺省值=1] 在各类别样本十分不平衡时，把这个参数设定为一个正值，可以使算法更快收敛。通常可以将其设置为负样本的数目与正样本数目的比值。

2.2、Parameters for Linear Booster：

linear booster一般很少用到。

2.2.1.lambda [缺省值=0，别称: reg_lambda]L2正则化惩罚系数，增加该值会使得模型更加保守。

2.2.2.alpha [缺省值=0，别称: reg_alpha]L1正则化惩罚系数，增加该值会使得模型更加保守。

2.2.3.lambda_bias [缺省值=0，别称: reg_lambda_bias]偏置上的L2正则化(没有在L1上加偏置，因为并不重要)

2.3学习目标参数（task parameters）

2.3.1objective [缺省值=reg:linear]

可选参数：

“reg:linear”---线性回归

“reg:logistic”---逻辑回归

“binary:logistic”---二分类逻辑回归，输出为概率

“multi:softmax”---使用softmax的多分类器，返回预测的类别(不是概率)。在这种情况下，你还需要多设一个参数：num_class(类别数目)

“multi:softprob”---和multi:softmax参数一样，但是返回的是每个数据属于各个类别的概率。

2.3.2.eval_metric [缺省值=通过目标函数选择]

可选参数：

“rmse”: 均方根误差

“mae”: 平均绝对值误差

“logloss”: 负对数似然函数值

“error”: 二分类错误率。

其值通过错误分类数目与全部分类数目比值得到。对于预测，预测值大于0.5被认为是正类，其它归为负类。

“error@t”: 不同的划分阈值可以通过‘t’进行设置

“merror”: 多分类错误率，计算公式为(wrongcases)/(all cases)

“mlogloss”: 多分类log损失

“auc”: 曲线下的面积

2.3.3seed [缺省值=0]

随机数的种子 ,设置它可以复现随机数据的结果，也可以用于调整参数

Boosting-LightGBM算法

GDBT的缺点与LightGBM的提出：

GDBT----一种预排序算法，存在缺点：

1.空间消耗大，需要消耗训练数据两倍的内存

2.时间上也有较大的开销，在遍历每一个分割点的时候，都需要进行分裂增益的计算，消耗的代价大

3.对内存(cache)优化不友好。在预排序后，特征对梯度的访问是一种随机访问，并且不同的特征访问的顺序不一样，无法对cache进行优化；同时，在每一层长树的时候，需要随机访问一个行索引到叶子索引的数组，并且不同特征访问的顺序也不一样，会造成较大的cache miss。

常用的机器学习算法，例如神经网络等算法，都可以以mini-batch的方式训练，训练数据的大小不会受到内存限制。而GBDT在每一次迭代的时候，都需要遍历整个训练数据多次。如果把整个训练数据装进内存则会限制训练数据的大小；如果不装进内存，反复地读写训练数据又会消耗非常大的时间。尤其面对工业级海量的数据，普通的GBDT算法是不能满足其需求的。

LightGBM提出的主要原因就是为了解决GBDT在海量数据遇到的问题，让GBDT可以更好更快地用于工业实践。

lightGBM是2017年1月，微软在GItHub上开源的一个新的梯度提升框架。在开源之后，就被别人冠以“速度惊人”、“支持分布式”、“代码清晰易懂”、“占用内存小”等属性。

lightGBM 主要基于以下方面优化，提升整体特特性：基于Histogram（直方图）的决策树算法；Lightgbm的Histogram（直方图）做差加速；带深度限制的Leaf-wise的叶子生长策略；直接支持类别特征；直接支持高效并行。

LightGBM的优化：

1.基于Histogram的决策树算法。

2.单边梯度采样 Gradient-based One-Side Sampling(GOSS)：使用GOSS可以减少大量只具有小梯度的数据实例，这样在计算信息增益的时候只利用剩下的具有高梯度的数据就可以了，相比XGBoost遍历所有特征值节省了不少时间和空间上的开销。

3.互斥特征捆绑 Exclusive Feature Bundling(EFB)：使用EFB可以将许多互斥的特征绑定为一个特征，这样达到了降维的目的。

4.带深度限制的Leaf-wise的叶子生长策略：大多数GBDT工具使用低效的按层生长 (level-wise)的决策树生长策略，因为它不加区分的对待同一层的叶子，带来了很多没必要的开销。实际上很多叶子的分裂增益较低，没必要进行搜索和分裂。LightGBM使用了带有深度限制的按叶子生长 (leaf-wise) 算法。

5.直接支持类别特征(Categorical Feature)

6.支持高效并行

7.Cache命中率优化

API相关：

调用的API：lightgbm.LGBMRegressor()

Control Paraments控制参数：

Core Paramentrs核心参数：

IO Paramentrs IO参数：

调参技巧：

num_leaves------应取值<=2^max_depth，超过此值会导致过拟合

min_data_in_leaf------将它设置为较大的值可以避免生长太深的树，但可能会导致underfitting，在大型数据集时就设置为数百或者数千

max_depth------可以限制树的深度

无监督学习算法

k-means聚类

K表示初始中心点个数（计划聚类数）

means即求解中心点到其他数据点距离的平均值

步骤：

1.随机设置K个特征空间内的点作为初始的聚类中心；

2.根据欧氏距离计算每个点到k个中心点的距离并进行分类；

3.求解每个聚类的新中心点；

4.对比新中心点与原中心点是否一致（质心不再移动），是则结束，否则重新第二步迭代；

5.当每次迭代结果不变时，认为算法收敛，聚类完成，K-Means停下；通常会设置某一个阈值，防止陷入一直选质心的过程。

注：由于每次都要计算所有样本与每一个质心的相似度，故在大规模数据集上，K-means算法收敛速度比较慢。

优点：原理简单，容易实现，只需要通过调整K参数，时间复杂度O(n)，空间复杂度O(IKN)（I为迭代次数，K为中心点个数，N为样本点个数）

缺点：确定K值对于初始的簌敏感，常以局部最优解结束，对孤立点敏感度不高，不适合发现差别大的簇

调用的API：sklearn.cluster.KMeans(n_clusters=8,init=’k-means++’)

参数：

n_clusters---开始的聚类中心数量，默认是8

init---初始化方法，默认为’k-means++’。也可以是"random"或者一个n维数组，如果输入了n维数组，数组的形状应该是(n_clusters，n_features)并给出初始质心。

调用.labels_可返回默认标记的类型，可以和真实值比较

方法：

estimator.fix(x)---训练

estimator.predict(x)---输出预测值

estimator.fit_predict(x)---训练+预测

其他聚类

只做了解。

（1）Canopy聚类是k-means的改进。

优点：

1.Kmeans对噪声抗干扰较弱，通过Canopy对比，将较小的NumPoint的Cluster直接去掉有利于抗干扰。

2.Canopy选择出来的每个Canopy的centerPoint作为K会更精确。

3.只是针对每个Canopy的内做Kmeans聚类，减少相似计算的数量。

缺点：

1.算法中 T1、T2的确定问题，依旧可能落入局部最优解。

网上搜到的资料都是关于Mahout实现的，也有部分通过在python中写底层实现。查阅sklearn中未找到相对应api

（2）k-means++聚类

kmeans++目的，让选择的质心尽可能的分散

（3）二分K-MEANS

BiK-MEANS，Bi就是Binary二进制，所以有时候叫这个算法为二进Kmeans算法。

因为聚类的误差平方和能够衡量聚类性能，该值越小表示数据点越接近于他们的质心，聚类效果就越好。所以需要对误差平方和最大的簇进行再一次划分，因为误差平方和越大，表示该簇聚类效果越不好，越有可能是多个簇被当成了一个簇，所以我们首先需要对这个簇进行划分。二分K均值算法可以加速K-means算法的执行速度，因为它的相似度计算少了并且不受初始化问题的影响，因为这里不存在随机点的选取，且每一步都保证了误差最小

（4）K-medoids（K-中心聚类算法）

调用API：pyclust.KMedoids

未做测试。

K-medoids对噪声鲁棒性好。

K-medoids只能对小样本起作用，样本大，速度就太慢了，当样本多的时候，少数几个噪音对k-means的质心影响也没有想象中的那么重，所以K -means的应用明显比K -medoids多。

（5）Kernelk-means

Kernel k-means实际上，就是将每个样本进行一个投射到高维空间的处理，然后再将处理后的数据使用普通的k-means算法思想进行聚类。

（6）ISODATA

类别数目随着聚类过程而变化；

对类别数会进行合并，分裂，

“合并”：当聚类结果某一类中样本数太少，或两个类间的距离太近时

“分裂”：当聚类结果中某一类的类内方差太大，将该类进行分裂

（7）Mini BatchKMeans

适合大数据的聚类算法

大数据量是什么量级？通常当样本量大于1万做聚类时，就需要考虑选用Mini Batch K-Means算法。Mini Batch KMeans使用了Mini Batch（分批处理）的方法对数据点之间的距离进行计算。

Mini Batch计算过程中不必使用所有的数据样本，而是从不同类别的样本中抽取一部分样本来代表各自类型进行计算。由于计算样本量少，所以会相应的减少运行时间，但另一方面抽样也必然会带来准确度的下降。

该算法的迭代步骤有两步：

(1)从数据集中随机抽取一些数据形成小批量，把他们分配给最近的质心

(2)更新质心

与Kmeans相比，数据的更新在每一个小的样本集上。对于每一个小批量，通过计算平均值得到更新质心，并把小批量里的数据分配给该质心，随着迭代次数的增加，这些质心的变化是逐渐减小的，直到质心稳定或者达到指定的迭代次数，停止计算。

调用API：sklearn.cluster.MiniBatchKMeans([n_clusters,init])

PCA

见前文“特种预处理”中的“降维”。

评估

均方误差

sklearn.metrics.mean_squared_error()

例：error =mean_squared_error(y_test, y_predict)

精确率与召唤率

sklearn.metrics.classification_report (y_test,y_pred,labels=[],target_names=None)

y_test---真实目标值

y_pred---预测目标值

labels---指定类别对应的数字

target_names---目标类别名称

return每个类别精确率与召回率

构成混淆矩阵

精确率：预测结果为正例的样本中真实为正例的比例

Precision=TPTP+FP

召回率：真实为正例的样本中预测结果为正例的比例

Recall=TPTP+FN

F1-score:反应模型的稳健性

F1-score=2TP2TP+FN+FP= 2*Precision*RecallPrecision +Recall

logloss多分类对数损失评分

logloss=-1NI=1NJ=1MYijlog⁡(pij)

上述公式中，

i表示样本，j表示类别，Pij代表第i个样本属于类别j的概率

最后对值进行最终处理，处理公式max(min(p,1-10-15),10-15)

调用API：sklearn.metrics.log_loss

log_loss(y_test,y_pre,eps=le-15,normalize=True)

注意：直接使用会报错，因为log_loss使用过程中，必须要求将输出用one-hot表示，需要通过OneHotEncoder修改结果

二分类评估---ROC曲线与AUC指标

TPR：所有真实累呗为1的样本中，预测类别为1的比例

TPR=TPTP+FN

FPR：所有真实类别为0的样本中，预测类别为1的比例

FPR=FPFP+TN

AOC曲线的横坐标是FPR，纵坐标是TPR，当二者相等时，表示的意义是：对于不论真实类别是1还是0的样本，分类器预测为1的概率相等，此时AUC为0.5

sklearn.metrics.roc_auc_score(y_true,y_score)

计算ROC曲线面积，即AUC值

y_true---每个样本的真是类别，必须为0（反例）或1（正例）标记

y_score---预测得分，可以是分类的估计概率、置信值或者分类方法的返回值

转化和得分：

y_test =np.where(y_test>2.5,1,0)

print(‘AUC:’,roc_auc_score(y_test,y_predict))

注：AUC只能用来评价二分类，非常适合评价样本不平衡中的分类器性能

聚类评估指标---轮廓系数SC系数

调用的API：sklearn.metrics.silhouette_score(X,labels)

计算所有样本的平均轮廓系数

X---特征值

labels---被聚类标记的目标值

轮廓系数SCi=bi-aimax⁡(bi,ai)

bi---求所有本族群中的样本到其他族群的最小值（外部距离）

ai---样本到本族群中所有样本中的最小值（内部距离）

当bi远大于ai时，SC约等于1，聚类效果好；

当bi远小于ai时，SC约等于-1，聚类效果差。

聚类评估指标---误差平方和SSE

原理公式：

SSE=i=1kp∈Ci|p-mi|2

SSE用于衡量松散度。

随着迭代次数增加，SSE值会越来越小直到最后趋于稳定；如果质心的初始值选择不好，SSE只会达到一个不怎么好的局部最优解

查看方法可调用KMeans.inertia_

聚类评估指标--- “肘”部法

K值的确定。当k==n时平方和为0，每次聚类完成后计算每个到其所属的簇中心的距离的平方和渐渐减小趋于0。在整个变化过程中，会出现一个拐点，下降率突然变缓时即认为是最佳的k值。在决定什么时候停止训练时，肘形判断同样有效，数据通常有更多的噪音，在增加分类无法带来更多回报时，我们停止增加类别。

聚类评估指标---CH系数

Calinski-Harabasz Index原理公式：

S(k)=tr(Bk)tr(Wk)m-kk-1

tr为矩阵的迹，Bk为类别之间的协方差矩阵，Wk为为别内部数据的协方差矩阵，m为训练集样本数，k为类别数。

矩阵的迹可以表示一个物体的相似性。CH需要达到的目的是：用尽量少的类别聚类尽量多的样本，同时获得较好的聚类效果

调用的API：sklearn.metrics.calinski_harabasz_score()

CH指标通过计算类中各点与类中心的距离平方和来度量类内的紧密度，通过计算各类中心点与数据集中心点距离平方和来度量数据集的分离度，CH指标由分离度与紧密度的比值得到。从而，CH越大代表着类自身越紧密，类与类之间越分散，即更优的聚类结果。

拓展知识点

类别不平衡数据集处理

两种处理方式：

过采样：减少数量较多那一类的样本数，使得正负样本比例均衡；

欠采样：增加数量较少那一类的样本数，使得正负样本比例均衡。

过采样：

1.随机过采样方法

通过“复制粘贴”的方式，扩大原始数据集中少数类的集合，获得新样本。

调用API：imblearn.over_sampling.RandomOverSampler(random_state=0)

x_resampled,y_resampled=ros.fit_resample(x,y)

缺点：1.造成样本量过多，模型训练复杂度增大；2.容易造成过拟合问题

2.过采样代表性算法-SMOTE

SMOTE=Synthetic Minority Oversampling，少数类过采样技术

3. Border-line SMOTE算法（对SMOTE的一种优化）

imblearn.over_sampling.BorderlineSMOTE这个算法会先将所有的少数类样本分成三类：

“noise”：所有的k近邻个样本都属于多数类

“danger”：超过一半的k近邻样本属于多数类

“safe”：超过一半的k近邻样本属于少数类

Border-line SMOTE算法只会从处于”danger“状态的样本中随机选择，然后用SMOTE算法产生新的样本。处于”danger“状态的样本代表靠近”边界“附近的少数类样本，而处于边界附近的样本往往更容易被误分类。因而 Border-line SMOTE 只对那些靠近”边界“的少数类样本进行人工合成样本，而 SMOTE 则对所有少数类样本一视同仁。

Border-line SMOTE 分为两种: Borderline-1 SMOTE 和 Borderline-2 SMOTE。 Borderline-1 SMOTE 在合成样本时式中的x^是一个少数类样本，而 Borderline-2 SMOTE 中的x^则是k近邻中的任意一个样本。

smo=BorderlineSMOTE(kind='borderline-1',sampling_strategy={0:700,1:200,2:150},random_state=42)

#kind='borderline-2'

X_smo, y_smo = smo.fit_sample(X, y)

欠采样

1.随机欠采样方法

直接对训练集中多数类样本进行“欠采样”，即去除一些多数类中的样本

调用API：imblearn.over_sampling.RandomUnderSampler(random_state=0)

x_resampled,y_resampled=rus.fit_resample(x,y)

缺点：由于采样的样本集要少于原来的样本集合，导致一些信息确实，即将多数类样本删除有可能会导致分类器丢失有关多数类的重要信息。

标签值转化为数字

调用API：sklearn.preprocessing.LabelEncoder

le= LabelEncoder()

y_resampled=le.fit_transform(y_resampled)

模型保存和加载

sklearn.externals.joblib

保存：joblib.dump(estimator,’test.pkl’)

加载：estimator=joblib.load(’test.pkl’)

随机样本生成

sklearn.datasets.make_classification(

n_samples=100, # 样本个数

n_features=20, # 特征个数

n_informative=2, # 有效特征个数

n_redundant=2, # 冗余特征个数（有效特征的随机组合）

n_repeated=0, # 重复特征个数（有效特征和冗余特征的随机组合）

n_classes=2, # 样本类别

n_clusters_per_class=2, # 蔟的个数

weights=None, # 每个类的权重用于分配样本点

flip_y=0.01, # 随机交换样本的一段 y噪声值的比重

class_sep=1.0, # 类与类之间区分清楚的程度

hypercube=True, # 如果为True，则将簇放置在超立方体的顶点上；如果为False，则将簇放置在随机多面体的顶点上。

shift=0.0, # 将各个特征的值移动，即加上或减去某个值

scale=1.0, # 将各个特征的值乘上某个数，放大或缩小

shuffle=True, # 是否洗牌样本

random_state=None) # 随机种子

结果可视化代码

plt.figure(figsize=(10,6),dip=100)

plt.scatter(x,y,lable=’data’)

plt.scatter(x_test,y_1,lable=’data1’)

plt.scatter(x_test,y_2,lable=’data2’)

plt.scatter(x_test,y_3,lable=’data3’)

plt.xlable(’data’)

plt.ylable(’target’)

plt.title(‘Decision Tree Regression’)

plt.legend()

plt.show()

工程数学基础知识

1.矩阵的迹

主对角线各元素之和

2.向量范数

1-范数：各个元素的绝对值之和

2-范数：每个元素的平方和再开根

无穷范数：正无穷范数---向量的所有元素的绝对值最大的；负无穷范数---向量的所有元素的绝对值最小的。

3.矩阵的范数

1-范数：矩阵的每一列上的元素的绝对值求和，从中取最大值（即列和最大）。

2-范数：矩阵的转置乘以矩阵的结果的特征根最大值的开根号

无穷范数：矩阵的每一行上的元素绝对值求和，取最大值（即行和最大）。

4.拉格朗日乘子法

拉格朗日乘子法（Largrangemultipliers）是一种寻找多元函数在一组约束下的极值的方法，通过引入拉格朗日乘子，可将有d个变量与k个约束条件的最优化问题转化为具有d+k个变量的无约束化问题求解。

算法路径图