机器学习算法大汇总--线性回归、逻辑回归、正则化、神经网络、SVM、K-Means、PCA、集成学习等！

本文很长~请耐心观看
另：本文主要用于本人的复习使用，欢迎大佬的指正和添加。
还有：本人也只是初出茅庐，希望大佬手下留情，谢谢！！

---

1.算法分类
机器学习算法分为： 有监督，无监督 两大阵营
1.有监督：
单变量线性回归，多变量线性回归，逻辑回归，多项式回归，神经网络，支持向量机，决策树，KNN，朴素贝叶斯，集成学习，等
2.无监督：
聚类：K-Means,K-Means++,K-means||
降维：PCA,TruncatedSVD,分别基于eig分解，SVD分解
一．线性回归
归属：有监督回归类型
库函数导包：fro sklearn.linear_modell import LinearRegression
激活函数：无
模型：
代价函数:
误差平方和
E=h-y
1.0/2m*e.T.dot(e)

梯度下降求参数：
△theta=1.0/2mx.T.dot(e)
正规方程求参数：
△theta=(x.T.dot(x))ˉ¹.dot(x.T.dot(y))
（正规方程因为有求逆的计算，而又不是所有矩阵都可以求逆，因此很少去用）
正规方程适用点：
1.特征变量数目不大
2.特征变量数量小于一万
3.只适用于线性回归
4.有些矩阵可能无法求逆
线性回归优点：
1.算法简单，易理解
2.实现简单的数据可视化
线性回归缺点：
1.并不是所有数据都是线性关系
2.精度较低，代价较大
线性回归综合介绍：
线性回归是回归算法中的基础算法，直接用一个线性预测值去拟合真实值，但因为线性原因精度较低，所以适用场景也比较少
二．多变量线性回归：
归属：有监督回归类型
库函数导包：fro sklearn.linear_modell import LinearRegression
激活函数：无
模型：
代价函数:
误差平方和
E=h-y
1.0/2m*e.T.dot(e)

批量梯度下降：
△theta=1.0/2mx.T.dot(e)
数据预处理：
标准缩放：
meanx=np.mean(x,axis=0)
Sigma=np.std(x,axis=0,ddof=1)
Sigma:方差 ddof为自由度
(x-meanx)/sigma
归一缩放：
(x-minx)/(maxx-minx)
多项式特征：
导包：from sklearn.preprocessing import PolynomialFeatures
参数：degree 次方数，假如原数据为x1,x2 defree为2的话会添加x1x2,x1^2,x22,x1^2*x2,x12x2^2…
准确率计算：
U=Sum((y-h)**2)
V=sum((y-y.mean())**2)
1-u/v
多变量线性回归优点：
1.多变量线性回归适用于所有数据，可以使用曲线来拟合数据
2.也可以使用正规方程，详见：1.单变量线性回归
3.通过特征缩放降低特征间数值都处在一个相近的范围，减小误差
4.多项式可以转回多变量线性回归问题进行求解
梯度下降与正规方程的比较：
梯度下降 正规方程
需要设定学习率α 不需要
需要多次迭代计算 一次计算得出
当特征数量n较大时也能 通常n<10000 因为计算逆矩阵的消耗巨大
的效果
适用于各种类型的模型 只适合线性模型不适合逻辑回归等模型
错误解决：

1. 获得更多的训练实例——解决高方差
2. 尝试减少特征的数量——解决高方差
3. 尝试获得更多的特征——解决高偏差
4. 尝试增加多项式特征——解决高偏差
5. 尝试减少正则化程度λ——解决高偏差
6. 尝试增加正则化程度λ——解决高方差
   三．逻辑回归
   归属：有监督分类类型
   库函数导包：from sklearn.linear_model import LogisticRegression
   激活函数：sigmoid
   模型：
   Z=x.dot(theta)
   H=sigmoid(z)
   代价函数:
   交叉熵代价：
   该代价函数是一个凸函数，所以没有局部最优值，只是接近
   该代价函数是一个凸函数，所以没有局部最优值，只是接近
   随机梯度下降：
   △theta=1.0/2mx.T.dot(e)
   代价对theta求偏导
   数据预处理：
   标准缩放：
   meanx=np.mean(x,axis=0)
   Sigma=np.std(x,axis=0,ddof=1)
   Sigma:方差 ddof为自由度
   (x-meanx)/sigma
   归一缩放：
   (x-minx)/(maxx-minx)
   逻辑回归的注意事项：
   1.逻辑回归看似与线性回归几乎一样，但是却相差甚远，其实却是线性回归加上激活函数就是逻辑回归，但是最本质的区别就是逻辑回归是处理分类问题的，线性回归是处理回归问题的。
   2.几乎所有的逻辑回归数据都需要缩放。
   3.梯度下降算法有很多，但是最常用的是小批量梯度下降
   4.模型中得到的H是一个概率，通常是表示为1的概率

四．正则化（过拟合，欠拟合）：
添加正则化的主要目的是用来防止过拟合的，当特征较多时很容易拟合过度，既训练集准确率很高，测试集准确率很低，为防止这种情况我们有三种正则化方式。
1.L0正则化
通过范数形式加大代价，防止过拟合，但因为范数的计算过于复杂所以现在几乎不再使用了，效果与L1正则化相同可以把一些特征参数直接归零，从而实现减少特征的目的。
2.L1正则化
同样可以直接把一些特征参数直接归零，实现特征选择的操作，计算方法为theta的绝对值之和，所以比L0计算方法简单很多，所以大部分需要特征选择时都会选择L1正则化

3.L2正则化
也是这个单元的主要内容，计算方法为theta的平方和的方式，但与L0,L1正则化不同的是L2正则化只会降低特征值参数，减小一些无用特征对全局的影响力，而不会归零。

4.给线性回归添加正则化：
数学：

Python：
R = (lamda1.0/(2m))np.sum(np.square(theta))
J = (1.0/(2m))np.sum(np.square(X.dot(theta)-y))+R
deltaTheta=(1.0/m)(X.T.dot(h-y)+(lamda*1.0/m)*theta)
5.给逻辑回归添加正则化：
数学：
Python:
同上
6.注意事项：
虽然逻辑回归于线性回归的梯度正则化一样，但是因为他们的H值的不同其实差别很大。
五．神经网络：
归属： 有监督
库函数导入：from sklearn.neural_network import MLPClassifier
1.神经网络的进化史：
感知机---->BP算法------->深度学习
2.神经网络的组成：
输入层---->隐藏层------->输出层
3.感知机：
感知机其实就是最简单的神经网络，也就是没有隐藏层的神经网络，只能做一些简单的逻辑运算，如：与，或，非运算
4.BP算法
也是这个时候出现了反向传播算法，通过反向传播实现判断，如：手写数字识别
自动驾驶等。
5.深度识别
完善BP算法实现深度学习，通过一系列的手段实现可以实现人脸识别，自然语
言处理等等操作
6.神经网络内容：
1.前向传播：

2.反向传播：
反向传播公式是通过链式求导计算得出


3.最后一层的deltatheta
Deltatheta=h-y
7.神经网络的总结：
1.神经网络是一个有监督的分类算法
2.逻辑回归和线性回归都有一个共同的缺点，当数据量特别大时计算负荷会非常大，但神经网络没有，因为他会把一个个特征变成一个个神经元模型，从而减小计算负荷。
3.神经网络是一个非常复杂的模型，所以大多数只在做手写数字识别，或者自然语言处理时才会使用

六．SVM 支持向量机
归属：有监督
库函数导入： from sklearn.svm import SVC
1.适用方向：
SVM分属于有监督学习，是一个集分类与回归于一身的库函数，甚至可以做异常检查，机器学习中最为主流的学习器之一，特别适合复杂但中小规模的数据的分类问题。
2.优缺点：
优点：泛化能力强，错误率低，结果容易解释，可以解决分类和回归问题
可以画出高维可视化图像，有多种核函数选择。
SVM算法的主要优点有：
1) 解决高维特征的分类问题和回归问题很有效，在特征维度大于样本数时依然有很好的效果。
2) 仅仅使用一部分支持向量来做超平面的决策，无需依赖全部数据。
3) 有大量的核函数可以使用，从而可以很灵活的来解决各种非线性的分类回归问题。
4) 样本量不是海量数据的时候，分类准确率高，泛化能力强。
缺点：对参数的调节和核函数的选择敏感，只适用于中小型数据
SVM算法的主要缺点有：
1) 如果特征维度远远大于样本数，则SVM表现一般。
2) SVM在样本量非常大，核函数映射维度非常高时，计算量过大，不太适合使用。
3) 非线性问题的核函数的选择没有通用标准，难以选择一个合适的核函数。
4) SVM对缺失数据敏感。

3.代价
SVM分类器又称为大间距分类器，如果有一个正样本，y 等于1，则只有在z 大于等于1 时，代价函数cost1(z)才等于0。
反之，如果y 是等于0 的，观察一下，函数cost0(z)，它只有在z<=-1的区间里函数值为0。
所以只有当样本落在间距中才会产生代价
4.SVM参数项
参数：sigma
σ较大时，特征值 变化非常平稳，高偏差, 低方差；
σ较小时，特征值 变化不平稳，低偏差, 高方差.
参数：lamada
C=1/lamda
所以：C 较大时，相当于λ较小，可能会导致过拟合，高方差。C 较小时，相当于λ较大，可能会导致低拟合，高偏差。
参数： kernel=‘linear’
核函数的选择，也可以使用无核SVM
多项式核函数（Polynomial Kernel）
字符串核函数（String kernel）
卡方核函数（chi-square kernel）
直方图交集核函数（histogram intersection kernel）
sigmoid核函数

5.核函数
当数据在低维线性不可分时，我们用函数将数据映射到高维度。但在高维进行矢量积运算，运算量会增大。所以有了核函数，核函数可以使用低维数据进行运算，但其结果却是映射到高维的。
在预测时，采用的特征不是训练实例本身的特征 x1,x2,x3 ，而是通过核函数计算出的新特征 f1,f2,f3。
给定x，计算新特征f，
当Fθ>=0 时，预测y=1，否则反之。
除高斯核函数之外的几个核函数：
多项式核函数（Polynomial Kernel）
字符串核函数（String kernel）
卡方核函数（chi-square kernel）
直方图交集核函数（histogram intersection kernel）
sigmoid核函数
7.支持向量机的各个使用方向：
n为特征数，m为训练样本数。下面是一些普遍使用的准则：
(1)当m< (2)当m>n时，且n较小，m中等。例如：n在1-1000 之间，而m在10-10000 之间，使用高斯核函数的支持向量机。
(3)当m>n时，且n较小，m较大。例如：n在1-1000之间，而m大于50000，则使用带有核函数的支持向量机会非常慢，解决方案是创造、增加更多的特征，然后使用逻辑回归或不带核函数的支持向量机。
可视化等高线：
#切分格网
xx,yy=np.mgrid[minx1:maxx1:200j,minx2:maxx2:200j]

#计算格网中心到超平面的距离
z=model.decision_function(np.c_[xx.ravel(),yy.ravel()])
z=z.reshape(xx.shape) #整形为200*200

#画样本数据集的类别散点图
plt.scatter(x[:,0],x[:,1],c=y,cmap=plt.cm.Paired,edgecolors=‘k’,zorder=4)
plt.scatter(testx[:,0],testx[:,1],s=100,facecolor=‘none’,edgecolors=‘k’,zorder=4)

#等值面
plt.contourf(xx,yy,z>0,cmap=plt.cm.Paired)
#等值线
plt.contour(xx,yy,z,levels=[-1,0,1],colors=[‘r’,‘g’,‘b’],linestyles=[’–’,’-’,’–’])
plt.show()
可获取参数：
测试集精度：model.score(testx,testy)
支持向量个数：model.n_support_
支持向量索引：model.support_
支持向量数组：model.support_vectors_
七．K-Means:
归属：无监督
库函数导入：from sklearn.cluster import KMeans
距离计算：欧式距离
核函数：K-Means，K-Means++，K-||
参数：N_clusters=k
运行步骤：
1.随机选择K个聚类中心。
2.计算所有样本与所有聚类中心的距离，通过样本与聚类中心的比较判断自己的归属。
3.移动聚类中心，到样本中心处
4.迭代运行
注意事项：
需要通过肘部法则获得K的取值。
model.cluster_centers_ 获得聚类中心矩阵
因为K值为随机，所以有时结果可能并不好

八．PCA 降维
归属：无监督
导入库函数：from sklearn.decomposition import PCA
参数：n_components=n
底层实现：EIG特征值分解
运行步骤：
1.在PCA中，要做的是找到一个方向向量（Vector direction），当把所有的数据都投射到该向量上时，希望投射距离均方差能尽可能地小。
2.方向向量是一个经过原点的向量，而投射误差是从特征向量向该方向向量作垂线的长度。
3.主成分分析最小化的是投射距离误差（Projected Error） 。
4.数据离散性越大，代表数据在所投影的维度上具有越高的区分度，这个区分度就是信息量。
1)计算协方差矩阵
2)求解特征向量和特征值,使其满足AU=SU ,S为特征值，U是特征向量。将原A变为除方差位置外（对角线），协方差位置都为0的矩阵。
3)选取前k个特征值较大的特征向量做数据压缩Z=XUreduc(k)
如果希望将数据从n维降至k维，只需要从U中选取前K个特征值较大的特征向量，获得一个n×k维度的矩阵，我们用Ureduce表示。
然后通过如下计算获得要求的新特征数据集Z：
Z=
数据重建：Z=

特征处理：
处理后的特征是一组新特征，是通过自主选取的前K个值进行投射计算在损失最小的情况下获得的一组新特征。
降维总结：
把高维数据降低维度便于计算，也间接的去掉了一些无用特征，实现数据可视化。但是新特征却难以解释，所以在使用中尽量先使用原始特征进行计算，尽量不要使用降维数据。

九．决策树
归属：有监督，可以分类，可以降维
导入库函数：分类树：from sklearn.tree import DecisionTreeClassifier
熵：

熵可以当做是数据量的一种表示，熵值越大说明这件事越左右摇摆不定，所以当某件事的概率为0.5时，数据量是最大的也是最不缺定的时候，而这个时候的熵也是最大的。
决策树-ID3：
1.ID3算法是决策树中最早期的算法，也是最简单的算法。
2.是通过信息增益来确定切分点的，所以分裂点很容易受到数据中值的大小的影响。
(1)信息增益越大，纯度提升越高，可以用最高信息增益选择属性。
(2)缺点：属性可取值越多，用其划分后信息增益越高，故此方法对属性可取值更多的属性有所偏好

3.不能处理连续型数据，只能通过离散化将连续性数据转化为离散型数据。
4.不能处理缺省值。
5.没有对决策树进行剪枝处理，很可能会出现过拟合的问题
6.计算简单，结果易解释
决策树-C4.5
1.通过信息增益率来确定分裂点
(1)信息增益除以属性的固有值（以属性a做随机变量，由集合中a属性各个取值所占的比例计算的信息熵），a可取数值越多，固定值越大，在一定程度上抑制了上述偏好
(2)缺点：对可取数值较小的属性有偏好。故实际上，采用先找信息增益高于平均水平的属性，再从中找增益率高的

2.可以处理连续值：
(1)将属性取值进行排序，按大于t和小于t分为两个子集，划分点t由最大化信息增益来确定，需要注意的是，对于连续属性，该属性可在决策树中多次使用。
3.可以处理缺失值
(1)判断属性优劣（如计算信息增益）只考虑没有缺省值的样本，且相应地乘以除去缺省值所占的比例做权重，以保证缺省值不要过多；
(2)对于含缺省值样本对于该属性的划分，则根据该属性各种取值的分布情况，以不同的概率划分到不同的结点（划分后样本带权）。

4.可以进行剪枝
预剪枝：在构造决策树的同时进行剪枝。所有决策树的构建方法，都是在无法进一步降低熵的情况下才会停止创建分支的过程，为了避免过拟合，可以设定一个阈值，熵减小的数量小于这个阈值，即使还可以继续降低熵，也停止继续创建分支。
优点：分支较少，减小过拟合风险，也减少了训练时间开销和测试时间开销
缺点：带来了欠拟合的风险（当前划分虽不能提升泛化能力，但继续划分呢？）
（2） 后剪枝：生成完整的决策树后自底向上对非叶结点考察，若替换为叶结点能带来泛化性能提升，则替换。
优点：比预剪枝分支多，欠拟合风险小，泛化性能往往优于预剪枝
缺点：训练时间开销大得多

决策树常用算法对比：

一．深度学习PCA 线性降维
(1)內积：A与B的内积等于A到B的投影长度乘以B的模，设向量B的模为1，则A与B的内积值等于A向B所在直线投影的矢量长度！这就是内积的一种几何解释，B的模 ：||B||=X1^2+X22在开根
(2)基坐标：从内积的意义可以看到，如果基的模是1，那么就可以方便的用向量点乘基而直接获得其在新基上的坐标了！实际上，对应任何一个向量我们总可以找到其同方向上模为1的向量，只要让两个分量分别除以模就好了
(3)优化目标：将一组N维向量降为K维（K大于0，小于N），其目标是选择K个单位（模为1）正交基，使得原始数据变换到这组基上后，各字段两两间协方差为0，而字段的方差则尽可能大（在正交的约束下，取最大的K个方差）。
(4)协方差：cov(X, Y) = E(X-EX)(Y-EY)，当 cov(X, Y)>0时，表明X与Y正相关；当 cov(X, Y)<0时，表明X与Y负相关；当 cov(X, Y)=0时，表明X与Y不相关。

(5)协方差矩阵：设我们有m个n维数据记录，将其按列排成n乘m的矩阵X，设，则C是一个对称矩阵，其对角线分别是各个字段的方差，而第i行j列和j行i列元素相同，表示i和j两个字段的协方差。等价于将协方差矩阵对角化：即除对角线外的其它元素化为0，并且在对角线上将元素按大小从上到下排列
(6)P值：我们要找的P不是别的，而是能让原始协方差矩阵对角化的P。换句话说，优化目标变成了寻找一个矩阵P，满足：，即D是一个对角矩阵，并且对角元素按从大到小依次排列，那么P的前K行就是要寻找的基，用P的前K行组成的矩阵乘以X就使得X从N维降到了K维并满足上述优化条件。
(7)降维：这是重新构造出来的k维特征，而不是简单地从n维特征中去除其余n−k维特征，因为有可能是某些新特征可能是几个原特征经过变换而来的；这也是特征选择和特征提取的根本区别。这k维特征是线性无关的。
(8)降维的基本思想：具体来说就是将n维特征映射到k维上（k (9)PCA底层使用的是EIG求出的协方差，EIG（特征值分解）所求出来的数据需要手动排序，而SVD（奇异值分解）中得到数据是已经排好序的，但SVD的底层依然是EIG
(10)EIG:输入的协方差矩阵必须是方阵，SVD可以是任何一个M*N的矩阵
(11)正交矩阵：矩阵C, 若CT =C-1，则C为正交矩阵
(12)降维后的数据不相关，降维前和降维后的数据为线性关系
(13)LDA：DA是一种监督学习的降维技术，投影后类内方差最小，类间方差最大，将每个类别的中心向直线w投影，获取投影点，计算直线上，每个类别下样本的方差，目标函数：max(均值的投影点间的距离/各类别组内方差的和)
(14)LDA：from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
(15)LDA适用场景：如果我们的数据是有类别标签的，那么优先选择LDA去尝试降维；当然也可以使用PCA做很小幅度的降维去消去噪声，然后再使用LDA降维。如果没有类别标签，那么肯定PCA是最先考虑的一个选择了。
(16)LDA算法的主要优点有：
1）在降维过程中可以使用类别的先验知识经验，而像PCA这样的无监督学习则无法使用类别先验知识。
2）LDA在样本分类信息依赖均值而不是方差的时候，比PCA之类的算法较优。
3）LDA算法的主要缺点有：
1）LDA不适合对非高斯分布样本进行降维，PCA也有这个问题。
2）LDA降维最多降到类别数k-1的维数，如果我们降维的维度大于k-1，则不能使用LDA。当然目前有一些LDA的进化版算法可以绕过这个问题。
3）LDA在样本分类信息依赖方差而不是均值的时候，降维效果不好。
4）LDA可能过度拟合数据。

LDA与PCA相同点：
　　　　1）两者均可以对数据进行降维。
　　　　2）两者在降维时均使用了矩阵特征分解的思想。
　　　　3）两者都假设数据符合高斯分布。
LDA与PCA不同点：
　　　　1）LDA是有监督的降维方法，而PCA是无监督的降维方法
　　　　2）LDA降维最多降到类别数k-1的维数，而PCA没有这个限制。
　　　　3）LDA除了可以用于降维，还可以用于分类。
　　　　4）LDA选择分类性能最好的投影方向，而PCA选择样本点投影具有最大方差的方向。

维度灾难：高维空间训练形成的分类器，相当于在低维空间的一个复杂的非线性分类器，这种分类器过多的强调了训练集的准确率甚至于对一些错误/异常的数据也进行了学习，而正确的数据却无法覆盖整个特征空间。为此，这样的分类器在对新数据进行预测时将会出现错误。这种现象称之为过拟合。这就是维度灾难的直接体现。

二．回归模型 随机梯度，小批量梯度
1.随机梯度实现：
每次只用一个数据进行计算代价，并更新theta，直到代价函数最小化后， 或者所有设定的max_iter循环完毕时跳出循环
2.随机梯度的特点：
由于每次只更新一个样本，所以代价函数跳动特别大，甚至可能跳出局 部最优点，计算速度快，但是计算精度差
3.小批量梯度下降：
每次使用 0-m个进行梯度，既比批量梯度下降的速度快，也比随机梯度 的 准确率高，这是一个折中的方法。

4.L1,L2正则化：
L1正则化为拉索回归模型，计算方式为theta的绝对值的和，可以导致一些 特征的参数为0
L2正则化为岭回归模型，计算方式为theta的平方和，只可以降低参数的影 响力，不能直接归零
5.期望风险：
期望风险表示的是全局的概念，表示的是决策函数对所有的样本(X,Y)预测能 力的大小，而经验风险则是局部的概念，仅仅表示决策函数对训练数据集里 样本的预测能力。
6.经验风险：
经验风险是局部的，基于训练集所有样本点损失函数最小化的。（无正则化）
7.结构风险最小化可以理解为：最小化目标函数（代价函数+正则化项）
8.为什么L1正则化可以把一些参数归零，L2却只能减小？

图1.为L1正则化，图2为L2正则化 图1的初次接触点为X,或Y轴上，所以一定会有 一个轴为零，而L2正则化则一定不会出现在基坐标上，所以不会归零

三：回归算法深化：评估标准
1.向量范数：
1-范数：即向量元素绝对值之和，调用函数np.linalg.norm(x, 1)
2-范数：Euclid范数（欧几里得范数，常用计算向量长度），即向量元素绝对值的 平方和再开方调用函数np.linalg.norm(x) (默认为2)
正无穷-：即所有向量元素绝对值中的最大值，调用函数np.linalg.norm (x, np.inf)
负无穷-：即所有向量元素绝对值中的最小值，调用函数np.linalg.norm (x, -np.inf)
p-范数：即向量元素绝对值的p次方和的1/p次幂，调用函数np.linalg.norm (x, p)
2.矩阵范数：
1-范数：即所有矩阵列向量绝对值之和的最大值，调用函数np.linalg.norm(x, 1)
2-范数：为ATA的最大特征值，谱范数，即ATA矩阵的最大特征值的开平方调用函 数np.linalg.norm(x)

正无穷-范数：行和范数， 即所有矩阵行向量绝对值之和的最大值，调用函数

np.linalg.norm (x, np.inf)
F-范数：Frobenius范数，即矩阵元素绝对值的平方和再开平方，调用函数 norm(A, ’fro‘)
3.Lasso回归:
使用了L1正则化的回归方程
4.Ridge岭回归:
使用了L2正则化的的回归方程
5.特征编码：
OneHotEncoder: 独热编码，只有1位是1, 其余是0(输入必须为二维数值矩阵)
LabelEncoder:自动对元素进行编码，根据首字母或数字的ASCII码顺序编号
LabelBinarizer: 自动将元素编码独热编码=LabelEncoder+OneHotEncoder
Binarizer: 以门槛值划编码为0和1(输入必须为二维数值矩阵)
*pd.get_dummies(data[‘GENDER’])：直接把字符串转成独热编码，相当于 LabelEncoder+OneHotEncoder

6.模型评估：
回归：

分类：

7.逻辑回归：
Sigmoid:预测为正例的概率，通过极大似然估值得出
极大化 => 将所有正例预测为正例的概率的累乘 * 将所有负例预测为负例的概 率的累乘
8.缺失值处理：
删除，填入平均数，众数，中位数，预测值，最精确的做法，把变量映射到高维 空间。
四．管道机制
1.导包：from sklearn.pipeline import Pipeline
2.参数：
steps : 步骤：列表(list) 被连接的（名称，变换）元组（实现拟合/变换）的列表， 按照它们被连接的顺序，最后一个对象是估计器(estimator)。
memory:内存参数,Instance of sklearn.external.joblib.Memory or string, optional (default=None)
name_steps:bunch object，具有属性访问权限的字典，只读属性以用户给定的名称 访问任何步骤参数。键是步骤名称，值是步骤参数。或者也可以直接通过”.步骤 名称”获取，如pipe.named_steps[‘anova’].get_support()
3.管道就是做一个可以直接自动有序调用库函数的一个机制，最后必须是一个学习期， 前面是各种数据处理的方法
五．交叉验证和网格搜索
交叉验证：
1.导包：from sklearn.model_selection import cross_val_score
2.运行方式：

通过切分数据寻找最优模型，其实就是把训练集再次切分出一个测试集
3.缺点：交叉验证带来一定的计算代价， 是当数据集很大的时候，计算过程会变得很慢
4.有点：可通过降低模型在一次数据分割中性能表现上的方差来保证模型性能的稳定性可用于进行参数调节、模型性能比较、特征选择等,常用于评估模型
5.参数：cv：是交叉验证的生成器或者迭代器，它决定了交叉验证的数据是如何 划分的，当cv的取值为整数的时候，使用(Stratified)KFold方法。
Scoring:还有一个参数是 scoring，决定了其中的分数计算方法(f1 score)。
estimator : 估计器(模型)
X : array-like, 用来训练的数据
y : array-like, optional, default: None，有监督学习时的目标值
Scoring值：f’accuracy’, ‘adjusted_mutual_info_score’, ‘adjusted_rand_score’, ‘average_precision’, ‘completeness_score’, ‘explained_variance’, ‘f1’, ‘f1_macro’, ‘f1_micro’,‘f1_samples’,‘f1_weighted’, ‘fowlkes_mallows_score’, ‘homogeneity_score’, ‘mutual_info_score’,‘neg_log_loss’,‘neg_mean_absolute_error’,‘neg_mean_squared_error’,‘neg_mean_squared_log_error’,‘neg_median_absolute_error’,‘normalized_mutual_info_score’, ‘precision’, ‘precision_macro’, ‘precision_micro’, ‘precision_samples’, ‘precision_weighted’, ‘r2’, ‘recall’, ‘recall_macro’, ‘recall_micro’, ‘recall_samples’, ‘recall_weighted’, ‘roc_auc’, ‘v_measure_score’]
cross_validate方法和cross_validate_score有个两个不同点：它允许传入多个评估方法，可以使用两种方法来传入，一种是列表的方法，另外一种是字典的方法。最后返回的scores为一个字典，字典的key为：dict_keys([‘fit_time’, ‘score_time’, ‘test_score’, ‘train_score’])

6.cross_val_predict ：和 cross_val_score的使用方法是一样的，但是它返回的是 个使用交叉验证以后的输出值，而不是评分标准。
网格搜索：
1.导包：sklearn.model_selection.GridSearchCV(estimator, param_grid, cv)
2.参数： estimator：估计器对象
param_grid：估计器参数，参数名称（字符串）作为key，要测试的 参数列表作为value的字典，或这样的字典构成的列表
cv：整型，指定K折交叉验证
3.方法：fit：输入训练数据
score：准确率，accuracy、f1-score、f-beta、precise、recall等
best_score_：交叉验证中测试的最好的结果
best_estimator_：交叉验证中测试的最好的参数模型
best_params_：交叉验证中测试的最好的参数
cv_results_：每次交叉验证的结果
4.网格搜索的底层： 类似于冒泡排序，如果是两个参数的话就是两个for循环 每一个参数都会与另一个所有参数进行匹配
5.网格搜索通常与交叉验证一起使用
六．KNN
1.导包：from sklearn.neighbors import KNeighborsClassifier
2.导包：from sklearn.neighbors import KNeighborsRegressor
3.评估标准：
TP: 将正类预测为正类数
FN: 将正类预测为负类数
FP: 将负类预测为正类数
TN: 将负类预测为负类数
准确率(accuracy) = 预测对的/所有 = (TP+TN)/(TP+FN+FP+TN)
精确率(precision)、查准类= TP/(TP+FP)
Precision 就是检索出来的条目中（比如：文档、网页等）有多少是准确的
召回率(recall)、查全率 = TP/(TP+FN)
Recall就是所有准确的条目有多少被检索出来了。
我们当然希望检索的结果P越高越好，R也越高越好，但事实上这两者在某些情况下是矛盾的。比如极端情况下，我们只搜出了一个结果，且是准确的，那么P就是100%，但是R就很低；而如果我们把所有结果都返回，那么必然R是100%，但是P很低。
4.混淆矩阵：
混淆矩阵(confusion_matrix)
A[i,i]: 识别出类别i的个体中，正确的个数
A[i,j]: 未识别出类别i的个体中，误识别为类别j的个数
A[k,i]: 识别出类别i的个体中，实际为类别k的个数
5.分类报告：
分类报告(classification_report):
precision:准确率p= TP/(TP+FP)
recall: 召回率r=TP/(TP+FN)
f1-score: 综合评价指标f1=2*(p*r)/(p+r)
support:支持数, 某一类别总的个体数
6.PR曲线：
PR曲线 F1 = 2 * (precision * recall) / (precision + recall)
F1值是精确度和召回率的调和平均值
如果一个学习器的P-R曲线被另一个学习器的P-R曲线完全包住，则可断言后 者的性能优于前者
可以根据曲线下方的面积大小来进行比较，但更常用的是平衡点或者是F1值。 平衡点（BEP）是查准率=查全率时的取值，如果这个值较大，则说明学习器 的性能较好。而F1 = 2 * P * R ／( P + R )，同样，F1值越大，我们可以认为该 学习器的性能较好。

7.ROC曲线：
TPR：在所有实际为阳性的样本中，被正确地判断为阳性之比率。 TPR=TP/(TP+FN) (和召回率一样)
FPR：在所有实际为阴性的样本中，被错误地判断为阳性之比率。 FPR=FP/(FP+TN)
ROC曲线: 横坐标为FPR, 纵坐标为TPR
AUC是ROC曲线下的面积
AUC越大，分类效果越好

ROC曲线越接近左上角，该分类器的性能越好。
AUC（Area Under Curve）被定义为ROC曲线下的面积，显然这个面积的数值 不会大于1
对应AUC更大的分类器效果更好。
8.ROC和PR曲线的对比：
当测试集中的正负样本的分布变化的时候，ROC曲线能够保持不变
ROC曲线和PR(Precision-Recall)曲线的对比：
(a)和©为ROC曲线，(b)和(d)为Precision-Recall曲线。(a)和(b)展示的是分类 其在原始测试集（正负样本分布平衡）的结果，©和(d)是将测试集中负样本 的数量增加到原来的10倍后，分类器的结果。可以明显的看出，ROC曲线基 本保持原貌，而Precision-Recall曲线则变化较大。

9.AUC
AUC是一个模型评价指标，只能用于二分类模型的评价，对于二分类模型还 有很多其他评价指标，比如logloss，accuracy，precision。如果你经常关注数 据挖掘比赛，比如kaggle，那你会发现AUC和logloss基本是最常见的模型评 价指标。
为什么AUC和logloss比accuracy更常用呢？
因为很多机器学习的模型对分类问题的预测结果都是概率，如果要计算 accuracy，需要先把概率转化成类别，这就需要手动设置一个阈值，如果对一 个样本的预测概率高于这个预测，就把这个样本放进一个类别里面，低于这 个阈值，放进另一个类别里面。所以这个阈值很大程度上影响了accuracy的 计算。使用AUC或者logloss可以避免把预测概率转换成类别。
AUC是指:从样本中随机抽取正负样本各1个，预测正样本的概率比负样本的 概率大的可能性!
AUC就是从所有1样本中随机选取一个样本， 从所有0样本中随机选取一个 样本，然后根据你的分类器对两个随机样本进行预测，把1样本预测为1的 概率为p1，把0样本预测为1的概率为p0，p1>p0的概率就等于AUC。所以 AUC反应的是分类器对样本的排序能力。根据这个解释，如果完全随机的对 样本分类，那么AUC应该接近0.5。另外值得注意的是，AUC对样本类别是否 均衡并不敏感，这也是不均衡样本通常用AUC评价分类器性能的一个原因。
10.sklearn评估指标

11.KNN算法 作用
K近邻法(k-NearestNeighbor)是一种基本的机器学习方法，能做分类和回归
12.KNN三要素既实现
kNN的三个基本要素：距离度量、k值的选择和决策规则
KNN与K-Means非常相似，但KNN是有监督算法，而K-Means是无监督算法
分类KNN是通过距离计算然后选择距离自己最近的K个值，通过统计频次的 方式来判断数据的分类。
计算的距离一般为欧氏距离，但也可以是其他距离如：曼哈顿距离
K值的选择：选择较大的k值，会让预测出错；选择较小的k值，会使模型变 得敏感。所以通常采用一些验证方法来选取最优的k值。经验规则:k一般低 于训练样本数的平方根。
决策规则：
分类：往往是多数表决，即由输入实例的k个邻近的训练实例中的多数类决 定待测实例的类。或带权投票
回归：取平均值。或带权取平均值
分类：带权投票：所有邻居节点的投票权重与距离成反比
回归：使用等权均值
13.KNN的实现法则：
蛮力法(brute-force)
k近邻法最简单的实现方式是线性扫描，需要计算待测实例与每个实例的距 离，在大数据上不可行。
KD树(KDTree)
为了提高k近邻搜索效率，考虑使用特殊的结构存储训练数据，以减少计算 距离的次数，可以使用kd树（kd tree）方法。kd树分为两个过程——构造kd 树（使用特殊结构存储训练集）、搜索kd树（减少搜索计算量）
14.K近邻搜索
最近邻，在最近邻搜索（k=1）中，首先存储一个自认为是“当前最近点”的节 点，然后在搜索过程中，找到更近的就替换掉。
K近邻。在KD树搜索最近邻的基础上，我们选择到了第一个最近邻样本，就 把它置为已选。在第二轮中，我们忽略置为已选的样本，重新选择最近邻， 这样跑k次，就得到了目标的K个最近邻，然后根据多数表决法，如果是KNN 分类，预测为K个最近邻里面有最多类别数的类别。如果是KNN回归，用K 个最近邻样本输出的平均值作为回归预测值

15.KNN的优缺点：
优点
思想简单，能做分类和回归
惰性学习，无需训练（蛮力法），KD树的话，则需要建树
对异常点不敏感
缺点
计算量大、速度慢
样本不平衡的时候，对稀有类别的预测准确率低
KD树，球树之类的模型建立需要大量的内存
相比决策树模型，KNN模型可解释性不强

16.KNN参数：
n_neighbors：可选参数，int, 近邻个数k，默认=5.
weights：可选参数，str or callable, 权重参数，默认为uniform。该权重用于 预测。uniform: 所有近邻的点权重相等；distance: 权重和距离成反比，距离 近的点比远的点有更大的影响力; 用户自定义的权重公式callable
algorithm：{‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’},可选参数，计算近邻的算法。 ‘ball_tree’ 使用球树; ‘kd_tree’ 使用KDTree; ‘brute‘使用蛮力法搜索; ’auto’根 据fit方法自动搜索合适的算法，注意，如果输入为稀疏矩阵，将使用蛮力法。
leaf_size：浮点型，可选参数，默认为30，它传递给BallTree或KDTree. 这可 以影响构建和查询速度，以及存储树所需的内存。
p : integer,可选参数，缺省 = 2, 闵可夫斯基(‘minkowski’)参数，当p = 1, 曼哈 顿距离(l1), p=2, 欧几里德距离(l2)
metric : string or callable, 缺省为 ‘minkowski‘, 计算距离量制，p=2等同于曼哈 顿距离
metric_params : dict, 可选参数(default = None), 距离量制的额外关键参数
n_jobs : int, 可选参数(default=1)，运行近邻搜索的并行任务个数。

七．贝叶斯分类
1.导包：from sklearn.naive_bayes import BernoulliNB 伯努利朴素贝叶斯
from sklearn.naive_bayes import GaussianNB 高斯朴素贝叶斯
from sklearn.naive_bayes import MultinomialNB 多项式朴素贝叶斯
2.概率介绍：
先验概率主观上不需要别的条件就可以得出的概率为先验概率，后验概率是 通过其他条件计算得出的概率为后验概率
3.条件概率

4.全概率：

5.贝叶斯公式：

6.朴素贝叶斯：
朴素：假设特征间是独立的（忽略肤色和发型的联系），从而变成了“低配版 的贝叶斯模型”，称为“朴素贝叶斯”。
优点：是可以减少需要估计的参数的个数；缺点：会牺牲一定的分类准确率。
详细案例查看机器学习2 PPT 第十单元第8页
7.拉普拉斯平滑：
相当于回归问题的正则化，只不过拉普拉斯平滑的效果是用来避免某个模型 参数为0的情况
在随机变量各个取值的频数上赋予一个正数，当=1时，称为拉普拉斯平滑

8.各种朴素贝叶斯使用场景：
多项式朴素贝叶斯：当特征是离散变量时，使用多项式模型
高斯朴素贝叶斯：当特征是连续变量时，使用高斯模型
伯努利朴素贝叶斯：伯努利模型和多项式模型是一致的，但要求特征是二值 化的（1，0）
注意：当特征中既有连续变量又有离散变量时，一般将连续变量离散化后使 用多项式模型
9.方法：
fit(self, X, y, sample_weight=None)：训练高斯NB模型, X : shape (n_samples, n_features)，y : shape (n_samples,), sample_weight : shape (n_samples,), optional (default=None),样本权重
partial_fit(self, X, y, classes=None, sample_weight=None)：增量批次样本训练， 该方法依次顺序调用数据集若干批次，以便执行out-of-core或online learning. 该方法会有一些性能和数值稳定的日常维护量因此最好调用尽可能大的数据 块(只要满足内存预算)以减少日常维护量。X : shape (n_samples, n_features)， y : shape (n_samples,), classes : shape (n_classes,), optional (default=None), 所 有出现在y向量的的类别list
predict(self, X),预测X的结果 X: shape = [n_samples, n_features]，返回shape [n_samples]
predict_proba(self, X)：预测X的概率，X: shape = [n_samples, n_features]，返 回shape [n_samples, n_classes]
predict_log_proba(self, X)：预测X的log概率，X: shape = [n_samples, n_features]，返回shape [n_samples, n_classes]
score(self, X, y, sample_weight=None)，返回平均准确率，X : shape (n_samples, n_features)，y : shape (n_samples,), sample_weight : shape (n_samples,), optional (default=None),样本权重
10.文本分类
语料库：语料库中存放的是在语言的实际使用中真实出现过的语言材料，因 此例句库通常不应算作语料库；
语料库是承载语言知识的基础资源，但并不等于语言知识；
真实语料需要经过加工（分析和处理），才能成为有用的资源。
中文语料库：北京大学语料库(http://icl.pku.edu.cn/ )
停用词：人类语言包含很多功能词。与其他词相比，功能词没有什么实际含 义。最普遍的功能词是限定词
Jieba：支持三种分词模式：
精确模式： 试图将句子最精确地切开，适合文本分析；
全模式：把句子中所有的可以成词的词语都扫描出来, 速度非常快，但是 不能解决歧义；
搜索引擎模式：在精确模式的基础上，对长词再次切分，提高召回率， 适合用于搜索引擎分词。
参数：
jieba.cut 方法接受三个输入参数: 需要分词的字符串；cut_all 参数用来 控制是否采用全模式；HMM 参数用来控制是否使用 HMM 模型
jieba.cut_for_search 方法接受两个参数：需要分词的字符串；是否使用 HMM 模型。该方法适合用于搜索引擎构建倒排索引的分词，粒度比较细
待分词的字符串可以是 unicode 或 UTF-8 字符串、GBK 字符串。注意： 不建议直接输入 GBK 字符串，可能无法预料地错误解码成 UTF-8
jieba.cut 以及 jieba.cut_for_search 返回的结构都是一个可迭代的 generator，可以使用 for 循环来获得分词后得到的每一个词语(unicode)， 或者用
jieba.lcut 以及 jieba.lcut_for_search 直接返回 list
jieba.Tokenizer(dictionary=DEFAULT_DICT) 新建自定义分词器，可用于同 时使用不同词典。jieba.dt 为默认分词器，所有全局分词相关函数都是该 分词器的映射。

八．集成学习：
1.集成学习的分类：
Boosting,bagging,stacking
Boosting:AdaBoost—base_estimator KNN,base_estimator 决策树
提升树-----GBDT,xgboost,LightGBM
Bagging: 随机森林
2.Bagging:
给定一个大小为n的训练集 D，Bagging算法从中均匀、有放回地选出 m个 大小为 n’ 的子集Di，作为新的训练集。在这 m个训练集上使用分类、回归 等算法，则可得到 m个模型，再通过取平均值、取多数票等方法综合产生预 测结果，即可得到Bagging的结果。
个体学习器之间不存在强依赖关系，一系列个体学习器可以并行生成，然后 使用组合策略，得到最终的集成模型，这就是Bagging的思想
3.Boosting:
加入的过程中，通常根据它们的上一轮的分类准确率给予不同的权重。加弱 学习器之后，数据通常会被重新加权，来强化对之前分类错误数据点的分类， 其中一个经典的提升算法例子是AdaBoost。

个体学习器之间存在强依赖关系，一系列个体学习器基本都需要串行生成， 然后使用组合策略，得到最终的集成模型，这就是boosting的思想

4.Bagging和Boosting 的主要区别：
样本选择：bagging采用的是Boostrap随机有放回；而boosting每一轮的训练 集是不变的，改变的只是每一个样本的权重。
样本权重:bagging使用的是均匀取样；每个样本的权重相等；boosting根据错 误率调整样本权重，错误率越大的样本权重越大。
预测函数:Bagging所有的预测函数的权重相等；boosting中误差越小的预测函 数其权重越大。
并行计算:bagging各个预测函数可以并行计算；boosting各个预测函数必须按 顺序迭代生成。

九．AdaBoost
1.导包：from sklearn.ensemble import AdaBoostClassifier
2.算法思想：
AdaBoost会为每个样本更新权重，分类错误的样本要提高权重，分类正确的 样本要降低权重，下一个学习器会更加“关注”权重大的样本；每一次得到一个 模型后，根据模型在该轮数据上的表现给当前模型设置一个权重，表现好的 权重大，最终带权叠加得到最终集成模型。
3.迭代算法：
1.初始化训练数据的权值分布。如果有N个样本，则每一个训练样本最开始 时都被赋予相同的权值：1/N。
2.训练弱分类器。具体训练过程中，如果某个样本点已经被准确地分类，那么 在构造下一个训练集中，它的权值就被降低；相反，如果某个样本点没有被 准确地分类，那么它的权值就得到提高。然后，权值更新过的样本集被用于 训练下一个分类器，整个训练过程如此迭代地进行下去。
3.将各个训练得到的弱分类器组合成强分类器。各个弱分类器的训练过程结束 后，加大分类误差率小的弱分类器的权重，使其在最终的分类函数中起着较 大的决定作用，而降低分类误差率大的弱分类器的权重，使其在最终的分类 函数中起着较小的决定作用。换言之，误差率低的弱分类器在最终分类器中 占的权重较大，否则较小。

4.前向分布学习：
加法模型、损失函数、前向分步算法
AdaBoost的二分类算法是它的一种特例。AdaBoost的二分类算法前向分 步 学习的分类算法（模型是加法模型、损失函数为指数损失、学习算法是前 向分步算法）
前向分步算法：将同时求解多个参数的问题转化为逐次求解的问题
5.学习率：
为了防止过拟合，我们通常也会加入学习率(learning rate)，定义为v，v的取 值范围为0< v ≤1，这种结合策略就是之前提过但一直没说的正则后叠加。

6.Adaboost损失函数：
采用的是指数损失

Adaboost的训练误差是以指数的速度下降的。
7.参数：
base_estimator：可选参数，默认为DecisionTreeClassifier。理论上可以选择任 何一个分类或者回归学习器，不过需要支持样本权重。我们常用的一般是CART 决策树或者神经网络MLP。默认是决策树，即AdaBoostClassifier默认使用CART 分类树
algorithm：可选参数，默认为SAMME.R。scikit-learn实现了两种Adaboost分 类算法，SAMME和SAMME.R。两者的主要区别是弱学习器权重的度量， SAMME使用对样本集分类效果作为弱学习器权重，而SAMME.R使用了对样 本集分类的预测概率大小来作为弱学习器权重。由于SAMME.R使用了概率度 量的连续值，迭代一般比SAMME快，因此AdaBoostClassifier的默认算法 algorithm的值也是SAMME.R。我们一般使用默认的SAMME.R就够了，但是 要注意的是使用了SAMME.R， 则弱分类学习器参数base_estimator必须限制 使用支持概率预测的分类器。SAMME算法则没有这个限制。

8.优缺点：
优点：
可以使用各种回归/分类模型来构建弱学习器，非常灵活
Sklearn中对AdaBoost的实现是从带权学习视角出发的，思想朴素，易于理解
控制迭代次数可以一定程度防止发生过拟合
泛化错误率低，易编码，可以应用在大部分分类器上，无参数调整。
缺点：
对异常样本敏感，异常样本在迭代中可能会获得较高的权重，影响最终预测 准确性。
对离群点敏感。
9.提升树 GBDT
1.AdaBoost思想结合决策树的基学习器，就得到提升树模型。
2.并行地训练多颗回归树，对样本进行预测时，所有回归树同时预测，取均值 作为输出

十．随机森林
1.导包：from sklearn.ensemble import RandomForestClassifier
2.导包：from sklearn.ensemble import RandomForestRegressor
3.Bagging模型：Bagging是Bootstrap Aggregating的缩写，通过并行地构造多个 个体分类器，然后以一定的方式将它们组合成一个强学习器
4.RF是基于决策树的集成模型，随机森林是机器学习中最成功的算法之一，他 能做二分类、多分类和回归任务。随机森林里集成了很多棵决策树，目的是 减小过拟合的风险（减小模型方差）。
5.优点：
像决策树一样，RF可以处理类别特征与连续特征，能扩展到多类分类，不需 要特征缩放，能捕获非线性关系和特征间的影响
算法可以并行
6.随机性：
样本随机：训练每一个决策树使用的都是bootstrapping产生的数据集
特征随机：在每一个树结点上进行结点划分时，考虑特征子空间
简单做法：从原始特征中随机不重复地抽取一些特征；
延伸做法：从原始特征中随机不重复地抽取一些特征，然后将某些特征线性 合并，产生一系列组合特征。
7.分类回归问题解决方式：
分类：投票少数服从多数。
回归：平均法，每一个树都会输出一个实数，随机森林的输出值就是所有决 策树输出值的均值
8.随机森林构建过程：
从原始训练集中使用boostrap 方法随机有放回采样选出m个样本，共进行 n_tree次采样，生成n_tree个训练集
对于n_tree个训练集，由此构建n_tree个决策树，每次未被抽到的样本组成 n_tree个袋外OOB(out of bag)数据。
对于单个决策树模型，假定训练样本特征的个数为d,那么每次分裂时根据信 息增益/信息增益比/基尼指数选择最好的特征进行分裂
每棵树都一直这样分裂下去，直到该节点的所有训练样例都属于同一类。在 决策树的分裂过程中不需要剪枝。
将生成的每棵决策树组成随机森林。对于分类问题，按多棵树分类器投票决 定最终分类结果；对于回归问题，由多棵树预测值的均值决定最终预测结果。
9.特征选择的优点：
高效：更简单的分割平面、更短的训练预测时间
泛化能力增强：无用特征被移除
可解释性增强
缺点：
计算代价大
如果没有选好特征的话，会影响模型精度
10.置换体验：
如果特征k是重要的，那么用随机的值将该特征破坏，重新训练和评估，计 算模型泛化能力的退化程度，即，
importance(k) = performance(G) - performance(G‘) ，
这个退化程度就可以度量特征k的重要性, 如果特征k对于模型是有利的,那 么第k维特征置换成随机值,将会降低模型的性能,也就是会使oob-error(袋外 误差)变大
11.参数：
1.n_estimators : integer, 可选(default=10)，森林中树的数目
2.criterion : string, 可选(default=“gini”), 节点分裂标准，基尼不纯度用’gini’， 信息熵’entropy’；对于回归问题， (default=“mse”)
3.max_features : int, float, string or None, 可选(default=“auto”)，分裂时选取考 虑的特征数; 如果是int，就是特征数, 如果是float, 代表百分比i nt(max_features * n_features). 如果是 “auto”, max_features=sqrt(n_features), 如果‘sqrt’, max_features=sqrt(n_features),(同“auto”). 如果是 “log2”, 4.max_features=log2(n_features), 如果是None, max_features=n_features.
5.max_depth : integer or None, 可选(default=None) 树的最大深度; 如果None, 所有的节点展开直到所有叶子节点包含不大于min_samples_splity样本.
6.min_samples_split : int, float, 可选(default=2), 分裂内部节点所需的最少样 本，如果是int, min_samples_split就是最小数. 如果是float, 则 7.min_samples_split是百分比:ceil(min_samples_split * n_samples)
8.min_samples_leaf : int, float, 可选(default=1)，成为叶子节点所需的最少样本 数，如果是int, min_samples_leaf 就是最小数，如果是float, 则 min_samples_leaf是百分比: ceil(min_samples_leaf * n_samples)
9.min_weight_fraction_leaf : float, 可选(default=0.) 成为叶子节点所需的最小 的占全部样本权重和的比例
10.max_leaf_nodes : int or None, 可选(default=None)最大叶子节点数，在 best-first fashion中使用
11.random_state：整数型，可选参数，默认为None。如果RandomState的实 例，random_state是随机数生成器; 如果None，则随机数生成器是由 np.random使用的RandomState实例。
12.方法和属性：
fit(x,y,sample_weights=None)训练模型
score(X,y)计算得分
predict(self, X) 预测
predict_log_proba(self, X) 预测log概率
predict_proba(self, X) 预测概率
classes_ : [n_classes] (single output), 或者是类别标签列表 (multi-output problem).
n_classes_ : int or list, 类别数 (single output problem), 或者是每个输出包含 的类别数列表 (multi-output problem).
n_features_ : int，fit中的特征数
n_outputs_ : int, fit执行时，输出的数量
feature_importances_ : [n_features]，特征重要性
oob_score_ : float，使用oob评估的训练集得分
oob_decision_function_ : [n_samples, n_classes] ，适用oob评估训练集的决策 函数，如果n_estimators比较小，在 bootstrap过程中没有样本剩下来，此时， oob_decision_function_ 可能包含NaN.
13.随机森林的优缺点：

优点：
1.具有较高的准确率
2.随机性的引入，使得随机森林不容易过拟合，而且使得随机森林有很好的抗 噪声能力
3.能处理很高维度的数据，并且不用做特征选择
4.既能处理离散型数据，也能处理连续性数据，数据集无需规范化
5.训练速度快，可以得到变量的重要性排序
6.容易实现并行化
缺点：
当随机森林中的决策树个数很多时，训练时需要的空间和时间会较大
随机森林还有许多不好解释的地方，类似黑盒模型

十一．GBDT stacking
1.导包：from sklearn.ensemble import GradientBoostingClassifier
from sklearn.ensemble import GradientBoostingRegressor
2.Boosting：Boosting通过串行地构造多个个体分类器(基分类器)，然后以一定的方 式将他们组合成一个强学习器
3.提升树：
采用前向分布算法，把一次计算多个参数的问题转换为逐步计算的问题
对于分类问题选用二叉分类树（指数损失）
对于回归问题选用二叉回归树（平方损失）
5.提升树的回归分类问题：
回归：
拟合当前残差
残差：

代价：
平方损失分类：
对于分类问题的提升树算法来说，只需要新增树拟合y值即可达到损失最小。

代价：
指数代价
6.正则化：
v的取值范围为0< v ≤1，目的是不让模型一次学的太“到位”，给“后人”留点机 会，这种结合策略就是之前提过但一直没说的正则后叠加。
7.拟合负梯度：
提升树的学习过程中，当损失函数是平方损失和指数损失时比较好优化，对 于其他损失函数不太好优化，即提升树缺少一种通用的优化方案。针对这一 问题，freidman提出了梯度提升（Gradient Boosting）
GBDT的基础学习器为CART树。无论选择什么样的损失函数（使用不同损失 函数可以做不同任务），都有一个通用的（general）最优化方案——拟合负梯 度！
无论做分类还是回归，GBDT拟合的目标都是一个负梯度值（连续值），因此， GBDT的基础学习器只有CART回归树。
8.GBDT的优缺点：
优点：
GBDT能处理类别特征，能扩展到多类分类，不需要特征缩放，并且能够捕获 特征间的非线性关系和特征的相互影响
在相对少的调参时间情况下，预测的准确率也可以比较高。
GBDT的核心就在于，每一棵树学的是之前所有树结论和的残差(负梯度)，这 个残差就是一个加预测值后能得真实值的累加量。
AdaBoost 学习的是错误数据，GBDT学习的是上一个结果的残差值

缺点：
由于弱学习器之间存在依赖关系，难以并行训练数据。
有过拟合的风险
9.参数:
GBDT类库boosting框架参数:

n_estimators: 也就是弱学习器的最大迭代次数，或者说最大的弱学习器的个 数。一般来说n_estimators太小，容易欠拟合，n_estimators太大，又容易过 拟合，一般选择一个适中的数值。默认是100。在实际调参的过程中，我们常 常将n_estimators和下面介绍的参数learning_rate一起考虑。

alpha：这个参数只有GradientBoostingRegressor有，当我们使用Huber损失 "huber"和分位数损失“quantile”时，需要指定分位数的值。默认是0.9，如果 噪音点较多，可以适当降低这个分位数的值。

GBDT类库弱学习器参数:
max_features：划分时考虑的最大特征数，可以使用很多种类型的值，默认是 “None”,意味着划分时考虑所有的特征数；如果是"log2"意味着划分时最多考 虑log2Nlog2N个特征；如果是"sqrt"或者"auto"意味着划分时最多考虑N−−√N 个特征。如果是整数，代表考虑的特征绝对数。如果是浮点数，代表考虑特 征百分比，即考虑（百分比xN）取整后的特征数。其中N为样本总特征数。 一般来说，如果样本特征数不多，比如小于50，我们用默认的"None"就可以 了，如果特征数非常多，我们可以灵活使用刚才描述的其他取值来控制划分 时考虑的最大特征数，以控制决策树的生成时间。

max_depth：决策树最大深度，默认可以不输入，如果不输入的话，默认值是 3。一般来说，数据少或者特征少的时候可以不管这个值。如果模型样本量多， 特征也多的情况下，推荐限制这个最大深度，具体的取值取决于数据的分布。 常用的可以取值10-100之间.

对于Bagging算法来说，由于我们会并行地训练很多不同的分类器的目的就是降低这个方差(variance) ,因为采用了相互独立的基分类器多了以后，h的值自然就会靠近.所以对于每个基分类器来说，目标就是如何降低这个偏差（bias),所以我们会采用深度很深甚至不剪枝的决策树。
  对于Boosting来说，每一步我们都会在上一轮的基础上更加拟合原数据，所以可以保证偏差（bias）,所以对于每个基分类器来说，问题就在于如何选择variance更小的分类器，即更简单的分类器，所以我们选择了深度很浅的决策树

十二．聚类算法深化：
1.分类： 基于划分的聚类
基于密度的聚类
基于分层的聚类
2.K-means流程请看 ----->七．K-Means
3.K-means缺点：
缺点一：聚类中心的个数K需要事先给定，但在实际中K值的选定是非常困难的，很多时候我们并不知道给定的数据集应该聚成多少个类别才最合适
针对这个缺点：很难在k-means算法以及其改进算法中解决，一般来说，我们会根据对数据的先验经验选择一个合适的k值，如果没有什么先验知识，则可以通过“肘部方法”选择一个合适的k值
缺点二：k-means算法需要随机地确定初始聚类中心，不同的初始聚类中心可能导致完全不同的聚类结果，有可能导致算法收敛很慢甚至出现聚类出错的情况
针对这个缺点：可以通过k-means++算法来解决

5.K-means++:
K-Means++算法选择初始seeds的基本思想就是：初始的聚类中心之间的相互距离要尽可能的远。
K-Means++的对于初始化质心的优化策略：
a) 从输入的数据点集合中随机选择一个点作为第一个聚类中心 μ1
b) 对于数据集中的每一个点xi，计算它与已选择的聚类中心中最近聚类中心的距离D
c) 选择一个新的数据点作为新的聚类中心，选择的原则是：D较大的点，被选取作为聚类中心的概率较大。
d) 重复b和c直到选择出k个聚类质心
e) 利用这k个质心来作为初始化质心去运行标准的K-Means算法
6.K-means++的缺点：
虽然k-means++算法可以初始化聚类中心，但是从可扩展性来看，它存在一个缺点：它内在的有序性特性：下一个中心点的选择依赖于已经选择的中心点
6.K-means,K-means++,K-means|| 对比图：

7.Mini Batch K-Means：
为了增加算法的准确性，一般会多跑几次Mini Batch K-Means算法，用得到不同的随机采样集来得到聚类簇，选择其中最优的聚类簇。
8.k-modes：
k-modes作为k-means的一种扩展，适用于离散属性的数据集。
9.密度聚类：
密度聚类方法的指导思想是，只要样本点的密度大于某阈值，则将该样本添加到最近的簇中
优点：
这类算法能克服基于距离的算法只能发现“类圆形”(凸)的聚类的缺点，可发现任意形状的聚类，且对噪声数据不敏感。
缺点：
计算密度单元的计算复杂度大，因此需要建立空间索引来降低计算量。

9.DBSCAN：
DBSCAN算法概念
对象的ε-邻域：给定对象在半径ε内的区域。
核心对象：对于给定的数目MinPts ，如果一个对象的ε-邻域至少包含MinPts个对象，则称该对象为核心对象。
直接密度可达：给定一个对象集合D，如果p是在q的ε-邻域内，而q是一个核心对象，说对象p从对象q出发是直接密度可达的。
密度可达：如果存在一个对象链p 1p 2 …p n ，p 1 =q，p n =p，对p i ∈D，(1≤i ≤n)，p i+1 是从p i 关于ε和MinPts直接密度可达的，则对象p是从对象q关于ε和MinPts密度可达的。
密度相连：如果对象集合D中存在一个对象o，使得对象p和q是从o关于ε和MinPts密度可达的，那么对象p和q是关于ε和MinPts密度相连的。
簇：一个基于密度的簇是最大的密度相连对象的集合。
噪声：不包含在任何簇中的对象称为噪声。
10. 直接密度可达，

图1.ε=1cm， MinPts =5，q是一个核心对象，从对象q出发到对象p是直接 密度可达的。但注意：从p到q不是直接密度可达，因为p都不是个核心对 象。
图2.q直接密度可达p1，p1直接密度可达p，则q到p是密度可达。
图3.O密度可达p，O密度可达q，则p和q密度相连。

由密度可达关系导出的最大密度相连的样本集合，即为最终聚类的一个类别， 或者说一个簇。这些核心对象的ϵ-邻域里所有的样本的集合组成的一个 DBSCAN聚类簇。
11.密度最大值算法：
ρi = 任何一个点以dc为半径的圆内的样本点的数量
定义：高局部密度点距离δi(简称“高密距离”)
δi = 比我高的局部密度点到我的最小距离
簇中心： 那些有着比较大的局部密度ρi和很大的高密距离δi 的点被认为是簇 的中心。
异常点： 高密距离δi较大但局部密度ρi较小的点是异常点。
12.密度聚类：
导包：sklearn.cluster.DBSCAN
13.参数：
eps : float, optional, 两个样本能够在同一邻域的最大距离，邻域半径.
min_samples : int, optional，一个样本成为核心对象所需的邻域内的最小样本 数(或者是权重和)
14.方法：
fit(X, y=None, sample_weight=None)：训练模型，
fit_predict(self, X, y=None, sample_weight=None)：训练并预测，返回 y : shape (n_samples,), 聚类下标
core_sample_indices_ : array, shape = [n_core_samples]，核心对象的索引下标|
labels_ : array, shape = [n_samples]，每个点的聚类索引下标，噪音样本为-1
15.DBSCAN的主要优点：
聚类结果没有偏倚，在邻域参数(ε,MinPts)给定的情况下，结果是确定的，只要数据进入算法的顺序不变，与初始值无关相对的，K-Means之类的聚类算法初始值对聚类结果有很大影响。
和传统的K-Means算法相比，DBSCAN最大的不同就是不需要指定簇的个数，当然它最大的优势是可以发现任意形状稠密数据的聚类簇，既可以适用于凸样本集（简单点说集合里任意两点连接成的线段中的点也在集合中，那么就是凸集），也可以适用于非凸样本集，而不是像K-Means，一般仅仅使用于凸的样本集聚类。同时它在聚类的同时还可以找出异常点,对数据集中的异常点不敏感。
那么我们什么时候需要用DBSCAN来聚类呢？一般来说，如果数据集是稠密的，并且数据集不是凸的，那么用DBSCAN会比K-Means聚类效果好很多。如果数据集不是稠密的，则不推荐用DBSCAN来聚类。

16.DBSCAN的主要缺点：
如果样本集的密度不均匀、聚类间距差相差很大时，聚类质量较差，这时用DBSCAN聚类一般不适合。
如果样本集较大时，聚类收敛时间较长，此时可以对搜索最近邻时建立的KD树或者球树进行规模限制来改进。
调参相对于传统的K-Means之类的聚类算法稍复杂，主要需要对距离阈值ϵ，邻域样本数阈值MinPts联合调参，不同的参数组合对最后的聚类效果有较大影响。
不适合高维数据，对于高维数据，点之间极为稀疏，密度就很难定义了, 可以先进行降维操作，造成”维数灾难”
簇之间密度差距过多大时效果不好，因为对整个数据集我们使用的是一组邻域参数。
数据集较大的时候很消耗内存，目前在sklearn-trees已经可以使用ball-trees和kd-trees来确定邻域点,但是在默认情况下是不使用它们的。而是使用很消耗内存的距离矩阵。Sklearn中效率很慢，可以先执行数据削减策略
16.DBSCAN的改进算法OPTICS
1.问题：
由于DBSCAN使用的是全局的密度阈值MinPts, 因此只能发现密度不少于MinPts的点组成的簇，即很难发现不同密度的簇。
2.改进方法：
为了解决其发现不同密度的簇，目前已经有很多新的方法被发明出来，比如OPTICS（Ordering points to identify the clustering structure）将邻域点按照密度大小进行排序，再用可视化的方法来发现不同密度的簇。
17.DBSCAN 的改进算法 SNN：
SNN采用一种基于KNN（最近邻）来算相似度的方法来改进DBSCAN。对于每个点，在空间内找出离其最近的k个点（称为k近邻点）。两个点之间相似度就是数这两个点共享了多少个k近邻点。如果这两个点没有共享k近邻点或者这两个点都不是对方的k近邻点，那么这两个点相似度就是0。然后我们把DBSCAN里面的距离公式替换成SNN相似度，重新算每个点的邻域和密度，就可以发现不同密度的簇了。SNN的核心就是，把原始的密度计算替换成基于每对点之间共享的邻域的范围，而忽略其真实的密度分布。SNN的缺点就是必须定义最近邻个数k, 而且其性能对k的大小很敏感。
18.网格聚类：
该方法是一种使用多分辨率的网络数据结构。将数据空间划分成为有限个单元（cell）的网格结构,所有的聚类操作都在该结构上进行。这种方法的主要优点处理速度快，其处理的时间独立于数据对象数，而仅依赖于量化空间中每一维的单元数。代表算法有：STING算法、CLIQUE算法、WAVE-CLUSTER算法；
1.CLIQUE算法
CLIQUE算法即自动子空间聚类算法。该算法利用自底向上方法求出各个子空间的聚类单元。CLUQUE算法主要用于找出在高维数据空间中存在的低维聚类。为了求出d维空间聚类，必须组合给出所有d-1维子空间的聚类，导致其算法的空间和时间效率都较低，而且要求用户输入两个参数：数据取值空间等间隔 距离和密度阈值。这两个参数与样本数据紧密相关，用户一般难以确定。CLIQUE算法对数据输入顺序不敏感。

2.CLIQUE算法特点：
发现的聚类类型是凸形或是球形，对脏数据或异常数据的敏感性一般，对数据输入顺序不敏感。

19.层次聚类：
导包：sklearn.cluster.AgglomerativeClustering
层次聚类的合并算法通过计算两类数据点间的相似性，对所有数据点中最为相似的两个数据点进行组合，并反复迭代这一过程。简单的说层次聚类的合并算法是通过计算每一个类别的数据点与所有数据点之间的距离来确定它们之间的相似性，距离越小，相似度越高。并将距离最近的两个数据点或类别进行组合，生成聚类树。
计算两个组合数据点间距离的方法有三种，分别为Single Linkage，Complete Linkage和Average Linkage。
Single Linkage的计算方法是将两个组合数据点中距离最近的两个数据点间的距离作为这两个组合数据点的距离。这种方法容易受到极端值的影响。两个很相似的组合数据点可能由于其中的某个极端的数据点距离较近而组合在一起。
Complete Linkage的计算方法与Single Linkage相反，将两个组合数据点中距离最远的两个数据点间的距离作为这两个组合数据点的距离。Complete Linkage的问题也与Single Linkage相反，两个不相似的组合数据点可能由于其中的极端值距离较远而无法组合在一起。
Average Linkage的计算方法是计算两个组合数据点中的每个数据点与其他所有数据点的距离。将所有距离的均值作为两个组合数据点间的距离。这种方法计算量比较大，但结果比前两种方法更合理。
参数：
n_clusters : int, default=2, 寻找的聚类中心数目
affinity : string or callable, default: “euclidean”，计算linkage的度量方法.可以是“euclidean”, “l1”, “l2”,“manhattan”, “cosine”, ‘precomputed’.如果是linkage是“ward”, 只能是"euclidean“

20.基于模型的聚类
基于模型的方法(model-based methods) 给每一个聚类假定一个模型，然后去寻找能够很好的满足这个模型的数据集。这样一个模型可能是数据点在空间中的密度分布函数或者其它。它的一个潜在的假定就是：目标数据集是由一系列的概率分布所决定的。
高斯混合模型(Gaussian Mixed Model, GMM)：
对于两个二维高斯分布做线性组合，用线性组合后的分布来描述整个集合中的数据。这就是高斯混合模型（GMM）。

21.聚类算法的分类：

聚类算法： 划分聚类K-means，
层次聚类 AgglomerativeClustering，
密度聚类DBSCAN，
基于网格和模型的聚类技术：EM