你在画分割线区分红绿两类点的时候，可以问自己一个问题，你认不认为所有的点对于分割线的位置都是起决定性作用的？

其实在特别远的区域，哪怕你增加10000个样本点，对于分割线的位置，也是没有作用的，因为分割线是由几个关键点决定的（图上三个），这几个关键点支撑起了一个分割超平面，所以这些关键点，就是支持向量。

所谓向量，其实就是样本点，因为每个样本都是一行数据，也就是向量。

SVM可以用下面这个图表示。

红线和蓝线分别是决策平面。决策平面上的样本点就是支持向量。

来个自己朴素的见解：

对于普通的求解一个二次凸规划的Vapnik型SVM（简称其为V-SVM）而言，所谓支持向量就是落在支撑平面上的数据点，“支撑平面”是两个和最终求解规划问题得到的划分平面在高维特征空间中平行的平面(高维指维度等于或高于训练点所在的维度，和核函数的选取相关)，直观上来讲，这两个平面在高维空间中分别紧紧地贴合着训练点中的两个类别（一般是+、-表示），之所以说“紧紧贴着”，是因为两类点中有点落在了这两个平面上，这样来看，是不是就像是两个平面在高维空间里牢牢得把点“撑开”，以形成中间尽可能宽阔的无点地带，所以说“撑（support）”这个自己在我就是如上形象直观来理解的，那么落在这个支撑平面上的训练点就叫做“支撑向量”，那可能会奇怪，为什么要叫“向量”而不叫“支撑点”呢？因为我们在计算时都是使用点的全部坐标，而一个坐标的组合可以在空间内表示一个点，也可以说是一个由原点O作为起点的向量，那么命名者采用了向量去命名，其实就是点的意思（至于什么是促成选择“向量”命名而不是“点”来命名的具体逻辑其实我也不知道，有没有人来解惑一下）。经过对凸二次规划的求解可以发现，对于那些不在支撑平面上的点而言，其对于最终求得的划分平面的贡献为0（即其对应的拉格朗日乘数为0），那么就是说，在V-SVM中，只有支撑向量会决定划分平面的表达式；

那么还有一种情况，就是最小二乘支持向量机（LS-SVM），这个时候所谓“支持向量”就泛化了意思了，因为它的经验最小化项是准确的点与划分平面之间的误差，这使得所有的训练点都要参与计算，所有的训练带你都对最终的划分平面的表达式有影响，这样按照前面对于V-SVM的认知，就说，在LS-SVM中，所有的点都是支撑向量。

soft margin的SVM的loss function

$$l(w)=\frac{1}{n}\sum_{i=1}^{n}max(0,1-y_i(w^Tx_i-b))+\lambda||w||^2$$

support vectors是$1-y_i(w^Tx_i-b)\geq 0$的点，或者说在loss function中有贡献的点。具体找support vectors，要用dual problem方法。假设已经找出所有support vectors，有

$$l(w)=\frac{1}{n}\sum_{i\in S}(1-y_i(w^Tx_i-b))+\lambda||w||^2$$

其中$S$是SV点集合。对$w$求导

$$\dfrac{dl(w)}{dw}=\frac{1}{n}\sum_{i\in S}(-y_ix_i)+\frac{\lambda}{2}w=0$$

$$w=\frac{2}{n\lambda}\sum_{i\in S}(y_ix_i)$$

设新输入点$x_i'=y_ix_i$，当$y_i=1$时，$x_i'=x_i$，当$y_i=-1$时， 把$x_i$沿原点翻转，得到新的标签为1的点$x_i'=-x_i$。最后$x'$就是所有标签都为1的点。求$x'$的平均正比于法线$w$（normal vector），也就决定了分割平面的方向。

$$w=\frac{2}{n\lambda}\sum_{i\in S}(x_i')$$

支持向量就是离决策超平面最近的那些数据点吧。

图中橘黄色的就是支持向量。

相对于单个的Decision Tree，Random Forest不太容易over-fitting。Over-fitting的主要原因是因为模型学习了太多样本中的随机误差。因为Random Forest随机选择了样本和特征，并且将很多这样的随机树进行了平均，这些随机误差也随之被平均，乃至相互抵消了。但是这不代表它不会

很多人说Random Forest不会over-fitting。相信很多人也亲身经历过，我自己也见识过过RandomForest over-fitting了。

防止RandomFroest过拟合，一个方法是控制每个树的深度，深的树有可能会过拟合；另外一个是对模型进行交叉验证。

任何机器学习算法都无法彻底避免过拟合的。

这是由机器学习的本质决定的，不是在技术层面可以修复的。 机器学习的核心在于泛化，但是数据又不可避免的包含noise，所以泛化就无法避免多多少少地也把noise包含进去。对于一个算法，它是没有办法区分noise和好数据的。因为这些通常是人也无法知道的，我们说一个toy dataset中某些数据是noise，这是我们的prior，机器是没有办法知道的。

所以随机森林当然也会过拟合，即使Breiman确实说过它不会overfitting。他口中的不会过拟合不过是指当树的数量够大多时，随着training error的持续下降，test error会稳定，而不是像很多算法一样，开始快速上升。有过手头经验的都知道，training error和test error之间始终是有差距的，他们的差值也通常可以看作是过拟合导致的。这个差值越大可以看作过拟合越厉害。

（1）增加了正则项，树越复杂，惩罚越大，这防止了over-fitting，而GradientBoosting并没有惩罚项。

（2）在迭代更新的时候，Xgboost采用了二阶导数（海瑟矩阵），而GradientBoosting只是用了一阶导数（梯度）。

此外，xgboost跑起来也更快，因为采用了并行计算、块处理、稀疏矩阵处理技术等等。

xgboost是从决策树一步步发展而来的。

决策树 $\longrightarrow$ 对样本重抽样，然后多个树平均 $\longrightarrow$ Tree bagging

Tree bagging $\longrightarrow$ 再同时对特征进行随机挑选 $\longrightarrow$ 随机森林

随机森林 $\longrightarrow$ 对随机森林中的树进行加权平均，而非简单平均$\longrightarrow$ Boosing (Adaboost, GradientBoost)

boosting $\longrightarrow$ 对boosting中的树进行正则化 $\longrightarrow$ xgboosting

从这条线一路发展，就能看出为什么xgboost的优势了。

• 传统GBDT以CART作为基分类器，xgboost还支持线性分类器，这个时候xgboost相当于带L1和L2正则化项的逻辑斯蒂回归（分类问题）或者线性回归（回归问题）。传统GBDT在优化时只用到一阶导数信息，xgboost则对代价函数进行了二阶泰勒展开，同时用到了一阶和二阶导数。顺便提一下，xgboost工具支持自定义代价函数，只要函数可一阶和二阶求导。
  
• xgboost在代价函数里加入了正则项，用于控制模型的复杂度。正则项里包含了树的叶子节点个数、每个叶子节点上输出的score的L2模的平方和。从Bias-variance tradeoff角度来讲，正则项降低了模型的variance，使学习出来的模型更加简单，防止过拟合，这也是xgboost优于传统GBDT的一个特性。
• Shrinkage（缩减），相当于学习速率（xgboost中的eta）。xgboost在进行完一次迭代后，会将叶子节点的权重乘上该系数，主要是为了削弱每棵树的影响，让后面有更大的学习空间。实际应用中，一般把eta设置得小一点，然后迭代次数设置得大一点。（补充：传统GBDT的实现也有学习速率）
• 列抽样（column subsampling）。xgboost借鉴了随机森林的做法，支持列抽样，不仅能降低过拟合，还能减少计算，这也是xgboost异于传统gbdt的一个特性。对缺失值的处理。对于特征的值有缺失的样本，xgboost可以自动学习出它的分裂方向。
• xgboost工具支持并行。boosting不是一种串行的结构吗?怎么并行的？注意xgboost的并行不是tree粒度的并行，xgboost也是一次迭代完才能进行下一次迭代的（第t次迭代的代价函数里包含了前面t-1次迭代的预测值）。xgboost的并行是在特征粒度上的。我们知道，决策树的学习最耗时的一个步骤就是对特征的值进行排序（因为要确定最佳分割点），xgboost在训练之前，预先对数据进行了排序，然后保存为block结构，后面的迭代中重复地使用这个结构，大大减小计算量。这个block结构也使得并行成为了可能，在进行节点的分裂时，需要计算每个特征的增益，最终选增益最大的那个特征去做分裂，那么各个特征的增益计算就可以开多线程进行。
• 可并行的近似直方图算法。树节点在进行分裂时，我们需要计算每个特征的每个分割点对应的增益，即用贪心法枚举所有可能的分割点。当数据无法一次载入内存或者在分布式情况下，贪心算法效率就会变得很低，所以xgboost还提出了一种可并行的近似直方图算法，用于高效地生成候选的分割点。

因为xgboost针对regression tree采用了dropout regularization。（详情见该论文）

1.损失函数是用泰勒展式二项逼近，也就是海森矩阵，而不是像gbdt里的就是一阶导数

2.对树的结构进行了正则化约束(regularization)，防止模型过度复杂，降低了过拟合的可能性

3.节点分裂的方式不同，gbdt是用的gini系数，xgboost是经过优化推导后的

4.优化了计算过程，缩短了运行时间

推荐这篇文章：从决策树到XGBoost

剪枝(prune)是一种防止决策树模型过拟合(over-fitting)的一种手段。顾名思义，剪枝就是删去决策树中的一些树枝、树杈。

剪枝又分为两类，一个是预剪枝(pre-pruning)另一个是后剪枝(post-pruning)。

预剪枝就是在构建决策树的时候进行剪枝。通常决策树会不断生长，直到该树枝无法变得更纯（对于ID3决策树来说，就是无法使得熵更小）。我们可以通过设定一个阈值使得决策树提前终止生长。比如设定最小分叉样本数(sklearn RandomForest中的min_samples_split)，当该树杈上的样本小于所设定的min_sample_splt，树就不再继续生长。

后剪枝就是在决策树在完全生长完之后，再剪去一些树枝、枝叶。方法也是类似的，我们先设定一个阈值。将某节点与其父节点合并，熵必然会增加，如果这个增加值小于这个阈值，我们最终就保留这个合并。这个过程由树叶逐渐向根部进行。

简单来说，k应该选择一个不大不小的奇数。

k太大了，会出现under-fitting。比如训练集有75个“1”，25个“0”。如果k=51，那无论测试点在哪里都会被预测为“1”。

k太小了，会出现over-fitting。如果k=1，那么测试点的标签就是离它最近的训练点的标签，如果这个训练点本身是个outlier，那这个测试点的预测结果当然就靠谱了。

k是偶数的话，会有打平的现象。比如k=10，如果一个预测点的10个近邻中5个是“1”，5个是“0”，那么它到底是什么呢？选偶数就是给自己添麻烦。

可以对k进行cross validation，候选的k可以是1,3,5,7,9,15,25,45。

熵是信息不确定度的度量，做分类，最后的目标是都分对类别，所以理想中，树的最下层叶节点如果够纯，其实没有不确定性，因此熵是0，而决策树就是要找到一条熵下降最快的路径。

所以选择这一层用哪个特征来分裂最好，其实就是看哪个特征能让熵下降的最多，让信息的不确定度因为有了这个特征而减少的最多。

Logistic regression的loss function不是凭空出现的，是根据逻辑回归本身式子中系数的最大似然估计推导而来的。

逻辑回归的式子是这样的

$$Pr(y_i = 1) = \frac{1}{1+e^{-(\beta_0+\beta_1x_i)}}.$$

下面我们可以写出逻辑回归中的$\beta_0$和$\beta_1$的似然函数

\begin{eqnarray*} L(\beta_0,\beta_1)&=&\prod_{i=1}^n p(Y=y_i|X=x_i)\\ &=& \prod_{i=1}^n p(x_i)^{y_i}(1-p(x_i))^{1-y_i}. \end{eqnarray*}

其中$(x_i,y_i)$表示训练集中的每一个样本点。我们对似然函数取对数，可得

$$ \log L(\beta_0,\beta_1) = \sum_{i=1}^n\left(y_i\log(p(x_i))+(1-y_i)\log(1-p(x_i))\right).$$

我们希望上式越大越好，换句话说，对于给定样本数量$n$，我们希望$-\frac{1}{n}\log L(\beta_0,\beta_1)$越小越好，这个也就是LogLoss。

$$ \text{log-loss} = - \frac{1}{n}\sum_{i=1}^n\left(y_i\log(p(x_i))+(1-y_i)\log(1-p(x_i))\right). $$

所以说逻辑回归的损失函数不是定义出来的，而是根据最大似然估计推导而来的。

逻辑回归是最大熵模型对应类别为两类时的特殊情况

朴素贝叶斯是基于所有变量都是独立的假设。而贝叶斯网络却没有这样的假设，贝叶斯网络中允许变量之间存在关联性。

贝叶斯网络是一种经典的概率图模型，我们通常用有向无环图来表示贝叶斯网络的结构。我们用节点表示每个自变量（特征），最下面的根节点，就是我们的因变量（标签）。如果两个点之间没有边直接相连，说明这两个点所代表的变量之间是条件独立的。

因为朴素贝叶斯的前提假设是所有特征都是相互独立的，所以我们也可以把它看成一种特殊的贝叶斯网络，它的结构如下

朴素贝叶斯的图结构非常简单，不具有有向无环图的一般特性，所以通常不会去特地强调它是概率图模型。

这两个都是正则化的手段。LASSO是基于回归系数的一范数，Ridge是基于回归系数的二范数的平方。

根据Hastie, Tibshirani, Friedman的经典教材，如果你的模型中有很多变量对模型都有些许影响，那么用Ridge；如果你的模型中只有少量变量对模型很大影响，那么用LASSO。LASSO可以使得很多变量的系数为0（相当于降维），但是Ridge却不能。

因为Ridge计算起来更快，所以当数据量特别大的时候，更倾向于用Ridge。

最万能的方法是用LASSO和Ridge都试一试，比较两者Cross Validation的结果。

最后补充一下，你也可以尝试一下两者的混合，Elastic Net。

你可以用elastic net, 多了一个超参，但是结合了both ridge and LASSO

Logistic Regression的前提要求相对比较少。

相对于线性回归的线性、独立性、正态性、等方差性（具体看这里），这里我们只需要线性和独立性。

独立性：error必须是独立的

线性：自变量和logit函数是线性关系。

还有一个比较显然的前提假设，target variable应该服从伯努利分布。

$logloss$可以大于1，但是对于二元分类来说，大于1说明这个模型是比较糟糕。

回顾一下$logloss$的公式

$$logloss=−\sum_{i=1}^n\left(\frac{y_i}{n}\text{log}(p_i)+\frac{1−y_i}{n}\text{log}(1−p_i)\right)$$

其中$n$是测试样本的个数，$p_i$为预测第$i$个样本为阳性的概率，$y_i$表示第$i$个预测样本的真实标签（1代表阳性，-1代表阴性）。

我一开始就说了大于1的logloss是很差的。我在Gakki下面留言说0.8依然很差。我凭什么这么说？

假如我们现在有个训练集，100万个数据点，其中10万个为阳性，那么总体上每个样本为1的概率可近似认为是0.1。通常来说，测试集的分布是非常接近于训练集的，那么测试集中大概有10%的样本为阳性。如果我们预测测试集中每个样本为1的概率都为0.1，那么logloss会是多少呢？

$$logloss=−\left(0.1\text{log}(0.1)+0.9\text{log}(1−0.1)\right)\approx 0.325$$

假如总体分布是每个样本以$p$的概率为阳性，我们预测每个样本为阳性的概率都为$p$，也就是$p_i=p$，那么$logloss$是多少呢？

很显然

$$logloss=-p\log (p) - (1-p) \log(1-p)$$

若$p=0.1$，$logloss = 0.325$

若$p=0.2$，$logloss = 0.500$

若$p=0.3$，$logloss = 0.611$

若$p=0.4$，$logloss = 0.673$

若$p=0.5$，$logloss = 0.693$

若$p=0.6$，$logloss = 0.673$

若$p=0.7$，$logloss = 0.611$

若$p=0.8$，$logloss = 0.500$

若$p=0.9$，$logloss = 0.325$

所以最差的情况就是，样本正好是一半阳性一半阴性，此时你按照上面方面预测（乱猜）出的logloss是0.693。

换句话说，只要loglss是在0.693以上，就基本说明了模型是失败的。

先搞清楚logloss的定义

$$\text{logloss}=-\frac{1}{n}\sum_{i=1}^n y_i\log(p_i)+(1-y_i)\log(1-p_i),$$

其中$n$是测试数据的个数，$y_i$是第$i$条记录的真实值（0或者1），$p_i$是你预测的第$i$条记录是1的概率。

很明显$\text{logloss}$的取值范围是$[0,+\infty)$。试想一下，有个记录的真实是1，但是你预测它是1的概率为0，$-\log 0$就是正无穷，你的$\text{logloss}$就是正无穷大。

所以你得到1.1是可能发生的。

LogLoss是越小越好，至于多小是好，并没有统一标准。这个要根据实际问题来看。我参加过两个用LogLoss做标准的比赛，一个比赛的第一名是0.01左右，另外一个是0.4左右。用其他数据的LogLoss作为自己模型的标准，参考意义不大。

可以参考这个（机器读中文2：“辨古识今”-排行榜）咯

感觉0.2到1之间吧

cross entropy 的定义

$$H(p,q)=-\sum_{y=(0,1)}p(y)\log q(\hat{y}=y)$$

$$=H(p)+D_{KL}(p||q)$$

$$=-\sum_{y=(0,1)}p(y)\log p(y)+D_{KL}(p||q)$$

其中$y$是真实输出标签，$\hat{y}$是预测输出标签，$p(y)$是$y$的概率密度函数（pdf）,$q(\hat{y})$是预测的$\hat{y}$的pdf。cross entropy分两部分：

1. $H(p)$是真实标签$y$的熵，表示其$y$的分散程度，对于训练数据是一个常数，只和数据有关，和预测模型无关。

2.$D_{KL}(p||q)$是 Kullback–Leibler divergence 表示真实和预测的pdf之间的匹配程度。这才能衡量预测模型是否好。$D_{KL}(p||q)=0$表示$p$和$q$完全匹配。

需要注意$H(p_i,q_i)$只是第i个数据点的cross entropy。我们求的是所有训练数据点cross entropy的和。

$$J(w)=\frac{1}{N}\sum_{i=1}^{N}H(p_i,q_i)$$

$$=-\frac{1}{N}\sum_{i=1}^{N}(y_i\log (\hat{y_i})+(1-y_i)\log (1-\hat{y_i})))$$

如果是logistic regression, $\hat{y_i}=g(w^Tx_i)=1/(1+e^{-w^Tx_i})$。

相似我们可以得到所有训练数据的entropy和

$$H(y)=-\frac{1}{N}\sum_{i=1}^{N}(y_i\log (y_i)+(1-y_i)\log (1-y_i)))$$

而$D_{KL}(w)=J(w)-H(y)$才是表示预测模型好坏的指标。比如平衡过的数据，$y_i=0.5$，则$H(y)=-\frac{1}{N}*N*2*0.5\log 0.5=-log 0.5=0.693$，我们得到的logloss需要$-0.693$。

结论：

1.如果数据相同，可以直接比logloss。

2.如果数据不同，需要减去$H(y)$才能比较$D_{KL}(w)$。

3.或者比较normalized cross entropy$\dfrac{J(w)}{H(y)}$

我之前有过0.8的loglss，仅供参考

xgboost的目标函数是损失函数+惩罚项。从下面的式子可以看出，树越复杂，惩罚越重。

树的复杂度定义如下。

叶节点的数量和叶节点的得分越高，树就越复杂。

红魔鲁尼 大神，你好。看到你在比赛《公共自行车使用量预测》拿到了第三，很是厉害！想看一下你的模型，来学习一下。我现在没有很好的办法来联系你。所以只能这样了。我的邮箱是xuan619@sina.com 麻烦了红神来联系我了！万分感谢！ 

有的。Multi-classification的问题可以用Multi-LogLoss

$$\text{Multi-LogLoss}=-\frac{1}{n}\sum_{i=1}^n\sum_{j=1}^m y_{i,j}\log (p_{i,j}).$$

其中$n$是预测样本的个数

$m$是class的数量

$y_{i,j}$是真实的分类，如果第$i$个样本属于第$j$个class，那么$y_{i,j}=1$

$\log$是自然对数

$p_{i,j}$是模型预测出来第$i$个样本属于第$j$个class的概率

Hamming Loss是用来计算多标签分类(Multi-label classification)模型精度的。

$$\text{HammingLoss}=\frac{1}{N}\sum_{i=1}^N\frac{\text{XOR}(Y_{i,j}, P_{i,j})}{L}$$

$N$是样本的数量，$L$是标签的个数，$Y_{i,j}$是第$i$个预测结果中第$j$个分量的真实值，$P_{i,j}$是第$i$个预测结果中第$j$个分量的预测值，$\text{XOR}$是抑或，$\text{XOR}(0,1)=\text{XOR}(1,0)=1$，$\text{XOR}(0,0)=\text{XOR}(1,1)=0$。

例子：三个样本

$$Y_{1}=(0,1,1,1,0), P_{1}=(1,1,1,0,0)$$

$$Y_{2}=(1,0,0,1,1), P_{2}=(1,0,0,0,1)$$

$$Y_{3}=(1,1,0,0,0), P_{3}=(1,0,1,0,1)$$

$$\text{HammingLoss}=\frac{1}{3}\times\frac{2+1+3}{5}=0.4$$

你说反了，LASSO是$L_1$范数，Ridge才是$L_2$范数，ElasticNet是同时用了$L_1,L_2$范数。

对于linear regression: $Y= X\beta$，（默认$Y$和$X$都是中心化的）。

LASSO的目标函数

$$\min_{\beta}\frac{1}{N}\sum_{i=1}^n\left(y_i-x_i\beta \right)^2+\lambda\|\beta\|_1 $$

其中$x_i\beta$是预测值，$y_i$是真值，$\lambda\|\beta\|_1$是LASSO的惩罚项。

Ridge的目标函数

$$\min_{\beta}\frac{1}{N}\sum_{i=1}^n\left(y_i-x_i\beta x\right)^2+\lambda\|\beta\|^2_2 $$

其中$\lambda\|\beta\|_2^2$是Ridge的惩罚项。

Elastic Net的目标函数

$$\min_{\beta}\frac{1}{N}\sum_{i=1}^n\left(y_i-\beta x_i\right)^2+\lambda_1\|\beta\|_1+\lambda_2\|\beta\|^2_2 $$

其中$\lambda_1\|\beta\|_1+\lambda_2\|\beta\|_2^2$是ElasticNet的惩罚项。

对于logistic regression: $\text{logit}(p)= X\beta$，（截距被包含在$\beta$中）。

LASSO的目标函数

$$\min_{\beta}\text{LogLoss}(y, p)+\lambda\|\beta\|_1 $$

其中$y$是真实值，$p$是预测的概率，$\lambda\|\beta\|_1$是LASSO的惩罚项。

Ridge的目标函数

$$\min_{\beta}\text{LogLoss}(y, p)+\lambda\|\beta\|^2_2 $$

其中$y$是真实值，$p$是预测的概率$\lambda\|\beta\|_2^2$是Ridge的惩罚项。

Elastic Net的目标函数

$$\min_{\beta}\text{LogLoss}(y, p)+\lambda_1\|\beta\|_1+\lambda_2\|\beta\|^2_2 $$

其中$y$是真实值，$p$是预测的概率，$\lambda_1\|\beta\|_1+\lambda_2\|\beta\|_2^2$是ElasticNet的惩罚项。

为了方便叙述，假设有N个样本，P个特征。

Tree Bagging是Decision Tree的改良。

对这N个样本有放回的抽样，抽出N个样本作为新的训练集，训练出一个决策树。如此重复m次，得到m个不同的训练集，从而有m个不同的决策树，最后对这m个决策树预测模型取均值。这就是Tree Bagging。

Random Forest是Tree Bagging的改良。

对这N个样本有放回的抽样，抽出N个样本作为新的训练集，从P个特征中（无放回）地取出p个特征，训练出一个决策树。如此重复m次，得到m个不同的训练集（特征也不同），从而有m个不同的决策树，最后对这m个决策树预测模型取均值。这就是Random Forest。

所以我们可以看出唯一的区别就是Random Forest不仅随机选择了样本，也随机地选择了一些特征。至于p的值是多少，这个可以通过Cross Validation来选择。

简单地说,Tree bagging用了全部特征，RandomForest随机选择了部分特征

混淆矩阵是用来总结一个分类器结果的矩阵。对于k元分类，其实它就是一个k x k的表格，用来记录分类器的预测结果。

对于最常见的二元分类来说，它的混淆矩阵是2乘2的，如下

TP = True Postive = 真阳性； FP = False Positive = 假阳性

FN = False Negative = 假阴性； TN = True Negative = 真阴性

你要的例子来了。。。比如我们一个模型对15个样本进行预测，然后结果如下。

预测值：1    1    1    1    1    0    0    0    0    0    1    1    1    0    1

真实值：0    1    1    0    1    1    0    0    1    0    1    0    1    0    0

这个就是混淆矩阵。

混淆矩阵中的这四个数值，经常被用来定义其他一些度量。

准确度(Accuracy) = (TP+TN) / (TP+TN+FN+TN)

在上面的例子中，准确度 = (5+4) / 15 = 0.6

精度(precision, 或者PPV, positive predictive value) = TP / (TP + FP)

在上面的例子中，精度 = 5 / (5+4) = 0.556

召回(recall, 或者敏感度，sensitivity，真阳性率，TPR，True Positive Rate) = TP / (TP + FN)

在上面的例子中，召回 = 5 / (5+2) = 0.714

特异度(specificity，或者真阴性率，TNR，True Negative Rate) = TN / (TN + FP)

在上面的例子中，特异度 = 4 / (4+2) = 0.667

F1-值(F1-score) = 2*TP / (2*TP+FP+FN) 

在上面的例子中，F1-值 = 2*5 / (2*5+4+2) = 0.625

至于多元分类的混淆矩阵，可以查看我回答的这个问题多元分类的混淆矩阵是什么

Surrogate loss function，中文可以译为代理损失函数。当原本的loss function不便计算的时候，我们就会考虑使用surrogate loss function。

在二元分类问题中，假如我们有$n$个训练样本$\{(X_1,y_1),(X_2,y_2),\cdots,(X_n,y_n)\}$，其中$y_i\in\{0,1\}$。为了量化一个模型的好坏，我们通常使用一些损失函数，损失函数越小，模型越好。最常用的损失函数就是零一损失函数$l(\hat y,y)$。

$$l(y, \hat y)=\sum_{i=1}^m\chi(y_i\neq\hat y_i).$$

比如说，测试集里有$5$个数据点，真实分类为$y=(1,1,1,-1,-1)$，预测分类为$\hat y =(1,-1,1,1,-1)$。那么

$$l(y, \hat y)=0+1+0+1+0=2.$$

对于一个loss function$l$，我们的目标是要找到一个最优的分类器$h$，使得这个分类器在测试样本上的期望损失最小。数学式子表达是

$$\min_{h}\mathbb{E}_{X\times y}[l(y, h(X))].$$

理论上，我们是可以直接对上式进行优化，得到最优的分类器$h$。然而这个过程是非常困难的（甚至不可行）。其一是因为$X\times y$的概率分布是未知的，所以计算loss的期望是不可行的。另外一个难处是这个期望值很难进行优化，因为这个loss function是非连续的，这个优化问题本质是NP-Hard的。举个例子来说，假定$X\in\mathbb{R}^2$，我们希望找一个线性分类器

$$h(X)=\begin{cases}1, ~Xw\geq 0\\ -1, ~Xw<0 \end{cases}$$

使得loss的期望最小化。所以我们也就是求解$w=(w_1, w_2)^T$。关于$w_1,w_2$以及loss的图像大致如下，

这个函数显然是非连续的。我们常用的优化方法，比如梯度下降，对此都失效了。正因此，我们可以考虑一个与零一损失相接近的函数，作为零一损失的替身。这个替身我们就称作surrogate loss function代理损失函数。为了计算的便利，这个函数通常是凸函数。例如逻辑回归的loss function，$\log(1+e^{-yXw})$，就是光滑可导的，更容易被求解。

最后补充几句。当我们把原来的零一损失函数替代为其他损失函数的时候，我们自然会问，当我们对代理损失函数进行优化的时候，原来的零一损失是否也被最小化了？它们的差距是多少呢？如果最优化代理损失函数的同时我们也最优化了原本的损失函数，我们就称校对性(calibration)或者一致性(consistency)。这个性质与我们所选择的代理损失函数相关。一个重要的定理是，如果代理损失函数是凸函数，并且在0点可导，其导数小于0，那么它一定是具有一致性的。这也是为什么我们通常选择凸函数作为我们的loss function的原因之一。

下图是零一损失函数与logloss，hinge loss，squared hinge loss以及modified Huber loss的联系。

我的回答主要是参考（翻译）了这篇文章。

高代兄已经说得很多了。我补充一下。Surrogate loss function远比我们想象得重要。

当我们进行分类任务的时候，我们的目标常常是分错样本越少越好，也就是零一损失。

但是零一损失很难计算。我们就寻找一些可以进行计算的损失函数来替代零一损失。也就是说我们把原来的优化问题转化为一个近似的优化问题。不同的surrogate loss function对应着不同的优化问题，就有着不同的优化目标和优化方法，也就从本质上定义了不同类型的分类器。

当我们用hinge loss做surrogate loss function去找一个线性分类器的时候，实际上我们就是用的SVM。当我们用logloss作为surrogate loss function去求解一个线性分类器的时候，实际上我们的模型就是LogisticsRegression。

树的数量m：m越大越好，但是太大会影响训练速度。

树的最大深度d：d越大，越容易过拟合；越小，越容易欠拟合。如果d没有上限，那么每棵树都会是一棵完整的决策树，设置了d，相当于给树进行了剪枝。

特征数量f：假设数据集一共有p个特征，树的每次分叉会随机使用f个特征，f一般设定为sqrt(p)，但是也可以设定为任意数值。f越大，每棵树越像，为了增加多样性，f一般不会接近p。除了设置为固定值外，也通常可以设定为0.3*p，0.5*p等。

叶节点最小样本数量s：当某个节点上的样本数量小于s时，树就停止生长，s越小，单个决策树越容易过拟合。设置一个较大的s，也有剪枝的作用，s=5，10，50，都很常见。

不同的数据集可能有不同的最佳参数，有的最佳参数也许也很反常。但是归根结底，利用交叉验证来调整参数，选择最佳的参数组合才是最可靠的随机森林调参方法。

----更新----

上文根据Zealing的指正，已经修改。

对@数据痴汉 提到的这几个参数进行grid search，然后对比cross validation之后的结果。

也可以参考xgb调参的方法

我知道的有三个思路。

一、通过随机森林，获取每个特征的importance，这个一般在python或者r里都是可以直接得到的数值。相似的gradient boosted trees或者xgboost也都有这样的importance。

二、单个特征。用单个特征建立分类器（比如，决策树，或者逻辑回归），哪个特征的模型越好，说明这个特征越重要。

三、向后选择。先用全部特征建立个分类器，然后把某个特征去掉，再做一个分类器，两个分类器表现的差值，就可以看作是这个特征的重要性。差值越大，说明越重要。

对于逻辑回归分类器的话，就是看每个变量的系数，绝对值越大，说明越重要。

（变量需要标准化）

当然可以的。python的sklearn.tree.DecisionTreeClassifier就可以直接用来做多元分类。因为它是基于C4.5算法的。C4.5又是基于Gini不纯度的。Gini不纯度也是可以用来描述多元分类的。所以没毛病！

你可以对线性回归模型进行Bagging，但是毫无意义。

决策树需要做bagging，是因为它的预测bias小，variance大，所以可以通过bagging降低variance。

线性回归则是完全相反，bias大，variance非常小。从这个角度看，bagging并不能够改善什么。最重要的是，bagging对线性回归并不起作用。因为bagging会对多个单个模型的预测结果加和求平均，多个线性方程的平均，依然是个线性方程。所以当对很多线性回归模型求平均之后，最终得到模型的变量系数的还是你最初的线性方程的系数。

线性回归的bagging是没有意义的。

但是广义线性模型，比如逻辑回归，bagging却是有意义的。我们不是bagging logit(p)，而是bagging最终的p。

这个问题一直没有人回答，我来说说吧。

假设负样本非常多，正样本非常少。于是我们训练时保留了全部的正样本，但是对负样本进行了欠采样，比如说我们只用了$\beta$比例的负样本，$0\lt \beta\lt 1$。假设$X$样本在欠采样之后，被预测为正样本的概率为$p_s$，那么修正后的概率为

$$p=\frac{p_s\beta}{p_s\beta-p_s+1}$$

比如说，原来正负比例为1：10，欠采样的$\beta$为0.2，也就是说20%的负样本被选中。欠采样之后，正负比例为1：2，样本$X$被预测为正的概率为$p_s=0.5$，那么

$$p=\frac{p_s\beta}{p_s\beta-p_s+1}=\frac{0.5\cdot 0.2}{0.5\cdot 0.2-0.5+1}\approx 0.183$$

参考文献：

Calibrating Probability with Undersampling for Unbalanced Classification. A.D. Pozzolo, et al.

令$X$为输入数据，$Y$为原始标签，$Y'$为数据平衡（subsample/oversample）后的标签，$P(X|Y)$为模型得到的释然函数，$P(Y)$为0/1类概率的先验知识。默认释然函数在数据平衡前后是一致的，$P(X|Y)=P(X|Y')$

根据贝叶斯， $P(Y|X)=\dfrac{P(X|Y)P(Y)}{P(X)} =P(X|Y)P(Y)\frac{1}{Z}$，这里$P(X)=Z$是一常数，一般忽略。

做完数据平衡后, $P(Y'=1)=P(Y'=0)=0.5$，模型输出（比如logistic regression）为标签1的概率$p_s$

$$p_s=P(Y'=1|X)=P(X|Y'=1)P(Y'=1)$$。

做完数据平衡前$P(Y=1)/P(Y=0)=\beta$，假设标签1的样本更少，$\beta \in [0,1)$。我们想要知道的原始数据得到的为标签0/1的概率$p_0,p_1$

$$p_1=P(Y=1|X)=P(X|Y=1)P(Y=1)=\dfrac{P(Y'=1|X)}{P(Y'=1)}P(Y=1)=2p_sP(Y=1)$$

$$p_0=P(Y=0|X)=P(X|Y=0)P(Y=0)=\dfrac{1-P(Y'=1|X)}{P(Y'=0)}P(Y=0)=2(1-p_s)P(Y=0)$$

对上面两式做归一化，得原始标签为1的概率

$$p=\dfrac{p_1}{p_1+p_0}$$

$$=\dfrac{2p_sP(Y=1)}{2p_sP(Y=1)+2(1-p_s)P(Y=0)}$$

$$=\dfrac{p_s\beta}{p_s\beta+1-p_s}$$

结论：关键的思想是释然函数只和模型相关，和数据无关。对数据subsample或oversample，只会影响先验概率$P(Y)$。以释然函数为桥，通过平衡后的后验概率$p_s$得到释然函数$P(Y=1|X)$，然后由释然函数再得平衡前的后验概率$p$。

这里对这种先数据平衡再对后验概率做修正的方法提出疑问。结论是用SVM更好。

这个总结提到，如果用logistic regression。有两种方法。

1.Bias Correction method

2.Penalized Maximum Likelihood Estimation， Firth method

ExtRa Trees是Extremely Randomized Trees的缩写，意思就是极度随机树。这是一种组合方法，与其说像决策树，实际上它更像随机森林。

与随机森林的相同点：1. bootstrap了样本。2. 随机选取了部分特征，来构造一个棵树。

我们知道随机森林是由很多个随机的决策树组成的，extra trees比随机森林更随机。

与随机森林的不同点：每棵决策树选择划分点的方式不同。对于普通决策树，每个特征都是根据某个标准(信息增益或者gini不纯)去进行划分，比如说一个数值特征的取值范围是0到100，当我们把这个特征划分为0-45，45-100的时候，效果最佳（从信息增益或者gini不纯的角度），决策树就会将45作为划分点；然后再按照某个标准来选择特征。而对于extra trees中的决策树，划分点的选择更为随机，比如一个数值特征的取值范围是0到100，我们随机选择一个0到100的数值作为划分点；然后再按照评判标准选择一个特征。

背景知识是你要知道精度和召回的定义。

比如有100个测试样本，根据你的模型，你得到了这100个点是被分为标签1的概率$y_1,y_2,\cdots,y_{100}$。

下面我们需要阈值$t$，把概率转化为标签。

显然，一个$t$的取值，对应着一组(精度，召回)。我们遍历$t$所有的取值，$0,y_1,y_2,\cdots,y_{99},y_{100},1$，我们就得到了102组(精度，召回)。

以召回为X轴，精度为Y轴，我们就可以在XOY坐标系中标出102个坐标点，把这102个点连成线，这个折线就称为精度召回曲线。曲线与坐标轴围城的面积就是精度-召回AUC。AUC越接近1，说明模型越好。

不同于余弦相似，Jaccard相似是用来度量两个集合的相似的程度的。对于集合$A$和$B$，它们的Jaccard相似是

$$J_{A,B}=\frac{|A\cap B|}{|A\cup B|}.$$

$|S|$表示集合$S$中元素的个数。Jaccard距离就是$1-J_{A,B}$。

比如集合$A=\{a,b,c,d,e\}$，$B=\{b,c,f\}$，

$$J_{A,B}=\frac{|A\cap B|}{|A\cup B|}=\frac{2}{6}=0.3333$$

当然也可以用在无限的集合上面，用长度或者面积表示集合大小。比如有两个0.95置信区间$A=(0.8,2.5)$和$B=(1.5,4)$，

$$J_{A,B}=\frac{|A\cap B|}{|A\cup B|}=\frac{1}{3.2}=0.3125$$

也可以用在两个二进制向量上，第$k$个分量是$1$就表示这个集合中含有元素$k$。比如$A=(1,0,0,1,1,1,1)$和$B=(1,1,0,0,0,1,1)$，

$$J_{A,B}=\frac{|A\cap B|}{|A\cup B|}=\frac{3}{6}=0.5$$

关于特征筛选

首先建议做成对的相关系数计算，如果这一对特征的相关系数大于某个阈值，就删除其中一个。正如另外一个答案讲的，朴素贝叶斯需要特征独立性假设。

其次还可以考虑backward stepwise特征选择，一开始用全部特征，然后去遍历每个特征，选一个最差的特征删掉，然后反复进行，直到保留适当数量的特征。这个要根据你的评价metric来决定的。

关于特征工程

数值变量应该进行离散化处理。

此外还要考虑到零概率的特征，这个要做laplace平滑。

你有200个特征，其实根本就不适合用naive bayes。因为naive bayes要求特征是独立的，你有这么多特征，怎么可能都是独立的。

建议你换个方法。

如果非要用naive bayes，那你先用pca降维吧

根据自己定义的loss function来选特征，可以是RMSE，也可以MAE。

哪个特征能最大程度的降低这棵树的loss，就选哪个特征。这个是和普通的分类决策树一个道理。

ROC AUC是可以拓展到多元分类问题上。常见有两种拓展思路。

一个是Peter Flach的体积法。因为二元分类是AUC面积，三元很自然就是某个曲面下的体积，也就是Volumn under Surface。更多元就到了更高维空间。具体可以参考这个。

第二种思路是更实际的方法，one-vs-rest。比如说是四元分类（A,B,C,D）问题，把A看作一类，BCD合起来看成一类，然后对预测结果做正常的二元ROC AUC；下面把B看作一类，ACD合起来看成一类，再得到一个ROC AUC。以此类推，所以k元分类问题就可以得到k个ROC AUC。把这k个数值取均值就可以得到这个多元分类的ROC AUC。

我以python里XGBClassifier为例

首先，要确定哪些参数要调，以下是比较重要和常用的参数。

max_depth: 每棵树的最大深度。太小会欠拟合，太大过拟合。正常值是3到10。

learning_rate: 学习率，也就是梯度下降法中的步长。太小的话，训练速度太慢，而且容易陷入局部最优点。通常是0.0001到0.1之间。

n_estimators: 树的个数。并非越多越好，通常是50到1000之间。

colsample_bytree: 训练每个树时用的特征的数量。1表示使用全部特征，0.5表示使用一半的特征。

subsample: 训练每个树时用的样本的数量。与上述类似，1表示使用全部样本，0.5表示使用一半的样本。

reg_alpha: L1正则化的权重。用来防止过拟合。一般是0到1之间。

reg_lambda: L2正则化的权重。用来防止过拟合。一般是0到1之间。

min_child_weight: 每个子节点所需要的样本的数量（加权的数量）。若把它设置为大于1的数值，可以起到剪枝的效果，防止过拟合。

以上只是作为参考，通常我们只对其中的少数几个进行调参，模型就可以达到很好的效果。

下一步就是对这些参数进行优化，最常用的是Grid Search。

比如说我们要优化max_depth和learning_rate。max_depth的候选取值为[3, 4, 5, 6, 7]，learning_rate候选取值为[0.0001, 0.001, 0.01, 0.1]。那么我们就需要尝试这两个参数所有的可能的组合（共5*4=20个不同的组合）。通过交叉验证，我们可以得到每个组合的预测评价结果，最后从这20个组合中选择最优的组合。

Grid Search的想法简单易行，但是缺陷就是当我们需要对很多参量进行优化时，我们需要遍历太多的组合，非常耗时。比如说我们有5个参量需要优化，每个参量又有5个候选值，那么就一共有5*5*5*5*5=3125种不同的组合需要尝试，非常耗时。

另外一个常用的方法Random Search就可以解决这个问题。Random Search是从所有的组合中随机选出k种组合，进行交叉验证，比较它们的表现，从中选出最佳的。虽然Random Search的结果不如Grid Search，但是Random Search通常以很小的代价获得了与Grid Search相媲美的优化结果。所以实际调参中，特别是高维调参中，Random Search更为实用。

除了别人上面已经提到的GridSearch和RandomSearch，我再说个稍微邪门一点的方法。

用RandomForest，对，就是它！

第一步：

和GridSearch或者RandomSearch一样，用很多点，得到模型结果。

那些点就是特征，模型结果就是label。

第二步：

随机产生很多点，但这些点你并不知道模型结果。这就是关键了，你可以用第一步得到的结果作为训练集，然后来预测这些随机点的预测结果。

第三步：

挑个最好的点。

--------------蜜汁分界线----------

更新：

这个方法有点诡异，如果你未曾听过，就当看个新鲜。若是你觉得无靠谱，就当一笑话。

下面的表格可以作为参考

截自这里的第14页

xgb调参的黄金搭档

learning_rate = 0.05

max_depth = 6

n_estimators = 500

其他保留默认值就行

我一般初始设置是这样

learning_rate: 0.01



n_estimators: 200



max_depth: 3



subsample: 0.8



colsample_bytree: 1



gamma: 1

我觉得比较重要的是learning_rate和max_depth。

learning_rate一般在0.01到0.2之间，max_depth一般是3起步，一个一个往上加

当然还有贝叶斯优化调参法。其实本质上和随机森林调参法是类似的。都是属于自动调参法。

贝叶斯优化调参法可以参考这个讲稿。

XGBoost参数调优完全指南（附Python代码）

Scikit 中的模型特征选择，XGBoost 数据比赛实战之调参篇

用cross validation

同意@waccam  说的。随机森林的预测能力不受多重共线性影响。

但是数据的解释性会被多重共线性影响。随机森林可以返回特征的重要性（importantce），当有多重共线性时，importance会被影响。一些具体多重共线性的特征的重要性会被相互抵消，从而影响我们解释和理解特征。

比如说，特征A和B完全一样，我们在用随机森林时，它们的重要性应该非常接近（考虑到随机性）。如果我们在训练前删除特征B，那么特征A的重要性就会翻番。这一下子就影响了我们对特征、数据的理解。

多重共线性的特征不会对决策树、随机森林的预测能力有影响。

多重共线性最极端的情况是有两个完全一样的特征，特征A和特征B。当特征A被使用之后，决策树不会再选择使用特征B，因为特征B并没有增加新的有效信息。同理，如何决策树先选择了使用特征B，那么特征A也不会再被使用。

所以基于树的模型不会收到多重共线性的影响。

参考这个实验英文原文

如果没时间看的话，我可以直接告诉你结论，多重共线性不影响random forest的预测能力。

一般来说非平衡的情况下用AUC更适合。

如果是平衡的分类问题，那么AUC和LogLoss都可以。

决策树模型有以下几个特点。

1. 训练过程比较简单，也就是在实际使用中比较好实现。
2. 在对一个新的样本进行预测时，时间复杂度是 O(k)，这个k是树的深度，也就是树有多少层。因此决策树的预测过程的非常快速而简单。
3. 决策树在训练过程中也能算出每个特征（feature）的重要程度。
4. 想比于其它分类算法，比如SVM和逻辑回归，决策树更能简单地应用到多元分类的问题上。
5. 如不加限制，决策树模型很容易出现过拟合(overfitting)。

针对决策树模型容易过拟合的特点，目前常见的有以下几个性质来进行控制。

1. 树的深度，也就是树有多少层。
2. 一个节点能被继续拆分出子节点所需要的包含最少的样本个数。
3. 最底层节点所需要包含的最少样本个数。

以上三个决策树都相当于它的超参数(hyper-parameter), 也就是我们在训练过程中需要去调整的。但是如果采用随机森林模型，它能够已集成(ensemble) 的方法解决过拟合的问题，因此可以作为实际应用的决策树的很好的替代算法。

决策树可以通过剪枝来避免过拟合。

或者也可以随机生成很多决策树（也就是TreeBagging或者随机森林），这样也能防止过拟合。（随机森林会发生过拟合吗？）

随机森林属于平行集成(parallel ensemble), 也就是同时训练若干个决策树模型，希望它们尽量地相互独立，然后对所有的决策树的预测结果进行平均作为最终的预测结果。

Gradient Tree Boosting属于连续集成(consecutive ensemble)，也就是有顺序地训练若干的决策树模型。其大致过程如下。首先训练出一个决策树模型，接着再训练一个决策树，而这个新的决策树的目标变量（也就是想要预测的值）是前面所有决策树的预测结果和真实值之间的误差（residual）。也就是Gradient Tree Boosting是一个连续累加的过程。

本质上说它们是一个东西，所以没有所谓的谁好谁坏。

Softmax是广义的Sigmoid，因为Sigmoid只能做二元分类。Softmax是可以做多元分类。二元的Softmax其实就退化成了Sigmoid。

对于二元分类Softmax和Sigmoid在数学上相似，但是在数值计算（numerical）上有点差别。

 对于Softmax，

$P(y=1|X)=\frac {e^{X^Tw_1}} {e^{X^Tw_0}+e^{X^Tw_1}}$，

$X$是全连接层输入，$w$是全连接层参数，$X^Tw_k$是logits，全连接层输出。当$X^Tw_1=$inf，输出$P$=inf/inf=Nan；当$X^Tw_1=$-inf，$X^Tw_0=$-inf，输出$P$=0/0，会报错float division by zero。

对于Sigmoid，

$P(y=1|X)=\frac {e^{X^Tw_1}} {e^{X^Tw_0}+e^{X^Tw_1}}$

$=\frac {e^{X^Tw_1}/e^{X^Tw_1}} {(e^{X^Tw_0}+e^{X^Tw_1})/e^{X^Tw_1}}$

$=\frac {1} {e^{X^T(w_0-w_1)}+1}$

$=\frac {1} {e^{X^T\Delta w}+1}$

当$X^T\Delta w$为inf/-inf时，输出$P$为0/1。

Softma需要学习两组$w_0,w_1$，而Sigmoid只需要学一组$\Delta w$。所以最好用一位输出的Sigmoid。

虽说它们似乎是等价的，不过感觉sigmoid更常用，更保险一点吧

在实际运用中，我个人认为随机森林比支持向量机更加实用。主要有以下几个原因：

1. 随机森林更适用于多元分类。如果用支持向量机处理多元分类的问题，则需要one vs rest的框架。而这种框架通常要消耗更多的内存。
2. 随机森林算法可以输入每个特征的重要程度。
3. 支持向量机的训练过程通常比较费时，尤其是在实用了非线性的核(kernel)的情况下

第一个字母T和F代表true和false，是形容词。

第二个字母代表P和N阴性阳性，positive和negative，是预测结果。

所以现在翻译一下：

TP: true positive, 正确的阳性，说明预测是阳性，而且预测对了，那么实际也是正例。

TN： true negative, 正确的阴性，说明预测是阴性，而且预测对了，那么实际也是负例。

FP: false positive, 假阳性，说明预测是阳性，预测错了，所以实际是负例。

FN: false negative, 假阴性，说明预测是阴性，预测错了，所以实际是正例。

你只要记住第一个字母是形容词，就不容易搞混淆。

在二元分类中

TP：真阳性，真实值是1，预测值也是1

TN：真阴性，真实值是0，预测值也是0

FP：假阳性，真实值是0，预测值是1

FN：假阴性，真实值是1，预测值是0

其实很好记，第一个字母表示你的预测值是否正确，第二个字母表示你的预测值是什么。

TP，FP，TN，FN其实就是你的预测结果的列联表（混淆矩阵）

可以参考什么是混淆矩阵(confusion matrix)-SofaSofa

除了各位说的，我再补充一些我所认为的坑

• PCA依赖于线性假设。

            我们知道PCA本质上就是SVD，所以PCA不过是利用线性投影进行降维。但是数据的内在结构未必是简单的线性关系。

• PCA是正交的。

            正如第一点所说，PCA是正交的投影，可是未必正交的就是最好的。想象一下，姚明和郭敬明（两个三维物体），我们用灯去照他们的影子，当灯光从两人正上方10米向下照的时候，两个人影子都是一坨圆；如果我们从侧面照他们，投影出来的两个影子，可能宽度差不多，长度却差不少，这样的影子（三维降到二维）就含有更多信息。

• PCA让方差尽量大。

            PCA本质上就是抓住主体，放过细枝末节。但有时候细枝末节往往是很重要的。五个韩国姑娘，其中一个姑娘鼻子上有痣，于是你一眼就认出了。你对她们的照片做PCA，之后发现，大家的脸型五官都没变，但是那个痣却找不到了，那你还能认出那个姑娘吗？你的算法还能认出那个姑娘吗？

• PCA的可解释性

             如果PCA之后需要使用线性模型，那么这个线性模型大概率也是不可解释的。因为PCA本身是特征重组压缩，原本的变量的意义会消失。

一定要记得先做标准化。参考这个。

我也说个我的。我之前是把training set的特征和test set的特征和一起做了PCA降维。

其实这是大错特错的，因为在PCA中用test set的特征，这属于信息泄露。

正确的方法是在training set上fit_transform，在test set上transform。

降维不能降太多，不然丢失了太多信息，反而不利于预测

PCA降为前需要把相关性高的那些列去掉，不然会影响到PCA的效果。

说明你的样本量不够大。

为什么你要PCA降维？ 因为你的数据样本大到上千万行几十列，必须用hadoop进行算法计算，而你只有一台1万的台式机，你需要做一定的数据信息舍弃，放弃精准度，得到一个95%或者90%近似正确的结果。

PCA降维的核心理念是，抓住核心部分，放弃一些有影响力但是却不那么重要的列，以此减少算法的计算复杂度。

如果你PCA降维后反而效果更差了，说明你的样本量（行数）不够大，放弃的那些列对结果有“较大”的影响。

所以，别人扛着三百斤的大石头（大数据），为了方便，造了一辆马车（PCA降维）。不代表，你扛着三斤的石头（你的数据集），也需要一辆马车（PCA降维）。在现实的情况中，如果BAT是三百斤的大石头，可能你扛的只是0.00003斤的石头，放口袋里就可以了，不需要马车。

每个数据集都是不一样的烟火，抛开了数据集属性谈算法，都是耍流氓。

如果每个xgboost都是用一样的数据、一样的特征训练出来的，那么它们会具有更高的相关性。用多个相关性高的模型进行组装，通常效果不会很好，一般来说是不会超过这几个模型最好的那个的。

stack的时候一定要让各个模型多样化，百家争鸣那种，而不是千篇一律。你都是用xgb的话，模型应该很相似。

此外，stack本身也并不能确保总是有效的，有兴趣的话可以看看这篇论文Is Combining Classifiers with Stacking Better than Selecting the Best One?

stack多个模型就好比街头采访，采访的人越多越好，但同时被采访对象越多样性，越容易得到接近真实的反馈信息。

1、相关性高的模型stack在一起通常效果不好的。因为它们没有足够的多样性，彼此之间并不能提供很多不同的信息。

2、你也可以试试加权取平均，而不是等权重的平均。

我感觉这个也是要看运气的（我算是新鲜人，不太懂）。

有时候stack一样效果就很好，有时候stack一下效果反而很烂，感觉和数据本身关系挺大的。效果可能也挺随机的，cross validation的效果好就用，不好就不用。

楼主可以尝试在每组xgb的特征上引入差异性

题主的方法准确地说应该是bagging，而不是stack吧

• 首先对这个连续变量排序。比如说年龄，把所有样本中年龄的数值从小到大排序。
• 在数据没有重复的假设下，如果有n个样本，那么排序后的数据之间应该有n-1个间隔。
• 决策树会对这n-1个间隔进行逐一尝试（分叉），每个不同的分叉，会带来不同的gini指数，我们最终选gini指数最小的那个分叉作为最优分叉，也就是阈值。

理论上是这样进行的，但是实际情况是为了一些计算优化，可能会进行一些随机搜索，而不一定是遍历。

上面这个过程就把那个连续变量进行了一分为二（第一次离散化），比如说年龄被分成了0到20岁，20到100岁。

接下来，当决策树继续生长时，之前一分为二的连续特征可能会再次被选中。比如说20到100岁这个分叉被选中，我们再次重复上面那三个步骤，再去寻找下一个次分叉的阈值。这次得到的结果可能是20到35，35到100岁。

以此反复，这样一个连续变量就不停地被离散化，直到模型达到停止的条件。

假如训练集上有Age这么个特征，数值分别为

10，11， 16， 18， 20， 35

那么在这个节点上，算法会自动考虑下面几种划分的可能

Age <=10 和 Age>10



Age <=11 和 Age>11



Age <=16 和 Age>16



Age <=18 和 Age>18



Age <=20 和 Age>20

六个数值点，所以就有5个对应划分的可能。对这5个可能一一尝试，选出损失函数最小的那个。

对于数值特征，决策树会对所有取值一一尝试，直到选择到最好的。

对于分类，就是对应gini最小

对于回归，就是对应rmse最小

ROC AUC有个非常直白的概率意义。

随机挑选一个标签为0的样本A，再随机挑选一个标签为1的样本B。你预测样本B为1的概率大于样本A为1的概率的概率就是你的ROC AUC。比较拗口，多念几遍，就通顺了，嘿嘿嘿。

我再多说几句，ROC AUC的数值与每个预测概率的数值大小无关，在乎的是每个预测概率的排序。假设我们按照概率从大到小排。如果根据你的预测结果，所有标签为1的样本都排在了标签为0的样本前面，那么你的ROC AUC就是1。

ROC AUC = 0.8的意思是说，随机挑选个标签为1的样本，它被排在随机的0样本的前面的概率是0.8。显然ROC AUC是0.5的话，就说明这个模型和随便猜没什么两样。

首先要清楚二元分类的过程。一般是先对每个数据点计算一个score $x$，可以是这个点属于positive的概率，也可以是其他。一般来说是$x$越大，越可能是positive。把所有positive/negative的score的直方图画出来，如下图的两个概率分布函数$f_1(x)$, $f_0(x)$。然后人为设定一个threshold $T$，当$x>T$判断为positive，否者为negative，这样可以把$f_1(x)$, $f_0(x)$分割成TP,FN,TN,FP四部分。

ROC就是把$T$从$\infty$到$-\infty$，所有$P(FP),P(TP)$的点连成的曲线。

$P(FP)=FPR(T)=\int_{T}^{\infty} f_0(x) dx$

$P(TP)=TPR(T)=\int_{T}^{\infty} f_1(x) dx$

现实中只有有限个数据点，所以用$P(FP)=\frac{FP}{FP+TN}$,$P(TP)=\frac{TP}{FN+TP}$估计。

$AUC=\int_{\infty}^{-\infty}P(TP)P'(FP)dT$

注意$P'(FP)=d(\int_{T}^{\infty} f_0(x) dx)/dT=-f_0(T)$是横轴上的$\delta$，$P(TP)$是纵轴上的长度，它俩的积分为曲线下面积

$AUC=\int_{\infty}^{-\infty}\int_{T}^{\infty} f_1(x) dx (-f_0(T)) dT$

$=\int_{-\infty}^{\infty}\int_{T}^{\infty} f_1(x) dx f_0(T) dT$

令$x=x_1$，$T=x_0$

$=\int_{-\infty}^{\infty}\int_{x_0}^{\infty} f_1(x_1) f_0(x_0) dx_1dx_0$

$=P(x_1>x_0|x_1 \sim f_1,x_0 \sim f_0)$

假设随机得到一个positive和一个negative数据点，它们在某分类器中的score分别是$x_1$，$x_0$，AUC就是$x_1>x_0$的概率。

这里其实还有一个隐藏条件是$T \sim U(-\infty,\infty)$，也就是对$T$的选择没有喜好。但实际应用中对$T$有限制，比如希望$FPR(T)<0.05$，这时AUC只能做参考，要看ROC中的局部线段是否靠近左上角。

首先要理解怎么作图的。ROC曲线是true positive rate(TPR) vs False positive rate(FPR) 。注意这两个rate的分母是不一样的。对于一个模型，按照预测score从小到大排序，然后把分界线从第一个sample往后逐渐移动到最后一个，看左边的sample TPR和 FPR值是多少。比如分界线在最左边，TPR==FPR==0，最右边TPR==TPR==1

更深层、直观的概率统计的意义最好从limit考虑

• AUC==1: 模型可以100%准确分类
• AUC==0.5: 效果等于随机
• AUC==0: 模型分类100%错误

参考： https://docs.eyesopen.com/toolkits/cookbook/python/plotting/roc.html

xgboost其实就是带惩罚项的gbdt，正如题主所言，复杂度就是惩罚项。

题主可以参考xgboost是怎么做到regularization的？。

如果感兴趣的话，也可以参考英文的xgboost文档。

推荐这篇文章：从决策树到XGBoost

根据随机森林的原创者的论文，如果是回归问题选$p/3$个特征，如果是分类问题选$\log_2(p+1)$个特征，$p$为特征总数。

不过这个只是一个“场外指导”，最好还是通过cross validation来选。

所谓规则或者规律，其实都是经验之谈。

特征选太多或者太少都是不合适的。

理论上来说，

太少：预测能力不强

太多：树的相关性太高

小橘书《elements of statistical learning》上推荐的是取根号。也就是说，如果原来有100个特征，那么每个split用10个；原来50个，那么差不多用7个。

归根结底，还是要做cross validation的。

上传一下，我最爱的图

上面是二维的示意图。左边是LASSO，右边是Ridge。

LASSO的目标函数是非光滑的。我们知道对于非光滑的优化问题，它的最优解要么是在导数为0处，要么就是在不可导的地方，也就是各个角上。对于多维的LASSO，所谓的“角”，就是那些很多特征的系数为0的地方。

所以LASSO会给出一个稀疏解，能有特征选择的作用。

LASSO是L1正则，Ridge是L2正则。而L1正则与L2正则的不同就在于L1在和每个坐标轴相交的地方都有“角”出现，而目标函数的测地线除非位置摆得非常好，大部分时候都会在角的地方相交。注意到在角的位置就会产生稀疏性，例如图中的相交点就有w1=0，而更高维的时候除了角点以外，还有很多边的轮廓也是既有很大的概率成为第一次相交的地方，又会产生稀疏性。

相比之下，L2正则就没有这样的性质，因为没有角，所以第一次相交的地方出现在具有稀疏性的位置的概率就变得非常小了。这就从直观上来解释了为什么L1正则，而L2正则不行的原因了。

因此，一句话总结就是：L1会趋向于产生少量的特征，而其他的特征都是0，而L2会选择更多的特征，这些特征都会接近于0。Lasso在特征选择时候非常有用，而Ridge就只是一种规则化而已。

Ridge（右）和Lasso（左图）分别可以视作在限制参数的$l_2$和$l_1$范数不超过$t$的前提下，最小化残差平方和，其中$t$是自己设置的一个约束变量。残差平方和的等高线是空间中的椭球，$l_2$和$l_1$范数不超过$t$的限制分别是一个球体内部和多面体内部。

几何上，球体更容易与椭球相切在各坐标均非0的位置。而多面体更容易和椭球在角点处相交。

所以Ridge的解倾向于各坐标都0，而Lasso的解更倾向于有一些坐标为0即稀疏。

直觉上，在稀疏解中寻找损失最小的这一问题等价于在均方误差的基础上增加非零元素个数这一惩罚项。非零元素个数等于每个元素是否非0的示性函数的总和。

代数上，考虑单个数据点$x_1=2,y=1$，截距为$a$，斜率为$b$。

均方误差的损失函数为$(1−a−2b)^2$，有无数个最小值点$(1−2b,b)$。若使用$l_1$正则化，也就是Lasso，相当于寻找使得$|1−2b|+|b|$最小的$b$，即$(0,12)$。若使用$l_2$正则化也就是Ridge，相当于寻找使得$(1−2b)^2+b^2$最小的$b$，即$(15,25)$。

由此简单的例子，可以说明Ridge更倾向于稠密解，Lasso更倾向于稀疏解。

特征工程是个很广的概念，包括特征筛选、特征变换、特征合成、特征提取等等。

对于xgboost，它能够很好地做到特征选择，所以这一点不用我们去操心太多。

至于特征变换（离散化、归一化、标准化、取log等等），我们也不需要做太多，因为xgboost是基于决策树，决策树自然能够解决这些。相比较来说，线性模型则需要做离散化或者取log处理。因为xgboost（树类模型）不依赖于线性假设。但是对于分类特征，xgboost需要对其进行独热编码，否则无法训练模型。

xgboost也可以免于一部分特征合成的工作，比如线性回归中的交互项a:b，在树类模型中都可以自动完成。但是对于加法a+b，减法a-b，除法a-b这类合成的特征，则需要手动完成。

绝大部分模型都无法自动完成的一步就是特征提取。很多nlp的问题或者图象的问题，没有现成的特征，你需要自己去提取这些特征，这些是我们需要人工完成的。

综上来说，xgboost的确比线性模型要省去很多特征工程的步骤。但是特征工程依然是非常必要的。

相对于线性模型来说，特征工程不是那么重要吧

线性模型有时候还需要做interaction term

决策树或者boosting都是模型自己在做interaction的。

从特征多重共线性的角度来说，xgboost可以省去很多特征工程的工程。

至于原因可以参考决策树、随机森林中的多重共线性问题

线性可分性是描述两分类的数据集的。

对于二维（两个特征）的数据集来说，如果存一条直线，能够把这两个分类完美区分，那么这个数据集就是线性可分的。

这三种情况都是线性可分的情况。

这个情况就不是线性可分，因为你需要一条以上的直线。

如果是多维数据，比如有k个特征，如果存在一个维度为k-1的超平面能够完美分开两类的数据点的化，也同样称为线性可分。

截图来自维基

举个两元分类的例子。上图是k=1，下图是k=100。

当k=1的时候，决策边界变得非常不光滑，换句话说，模型的决策规则变得非常复杂，而这个就会很容易造成过拟合。

至于k怎么选，可以参考k近邻算法怎么选k

k=1会严重的过拟合。

严重到训练误差为0，但是测试误差会很大。

+ $k$ 的值越小，模型就越复杂，所以就越容易过拟合，过拟合表现出来的特点就是“训练误差远小于测试误差”。

+ $k$ 的值越大，模型就越简单（可以从极端情况来理解，$k$ 设置成一个很大很大的数值，那么我们的模型就不用计算 $k$ 近邻了，把所有的训练样本都拿进来做一次投票就行了），所以就越容易欠拟合。

先了解knn的原理：给定一个实例点，然后在所有的数据中找到与该实例点距离最近的 k 个样本，最后选择 k 个样本中出现最多的分类标记作为实例点的分类预测结果。

k 值如何选择？

- k 值的选择不能过小，否则实例点会对自己周边的点异常敏感，容易过拟合

- k 值的选取也不能过大，容易产生较大的误差

- 一般选择一个合适的 k 值，用交叉验证法择优选取

如果你将 k 设置为 1，那么knn会找所有数据中与该点距离最近的 1 个点，此时模型会变得很敏感。想想小蝌蚪找妈妈，它总不能看到一个人就叫妈妈吧？:)

我还想补充个验证误差。

训练过程中的误差，就是训练误差。

在验证集上进行交叉验证选择参数（调参），最终模型在验证集上的误差就是验证误差。

训练完毕、调参完毕的模型，在新的测试集上的误差，就是测试误差。

假如所有的数据来自一个整体，模型在这个整体上的误差，就是泛化误差。通常说来，测试误差的平均值或者说期望就是泛化误差。

综合来说，它们的大小关系为

训练误差 < 验证误差 < 测试误差 ～= 泛化误差

训练误差是模型在训练集上的误差

测试误差是模型在测试集上的误差

泛化误差是用来衡量模型的泛化性  

ID3 ：信息增益Information Gain作为特征选取指标，多叉树，特征必须离散变量。 

C4.5 ：也以信息增益率作为特征选取指标，多叉树，特征也可以是连续变量。

CART： 以基尼系数gini index作为特征选取指标，二叉树，可用于分类，此外也可以用于回归。

ID3奠定了决策树的理论基础，采用信息增益作为标准，但性能不好、计算消耗大，而且仅适用于分类标签，过拟合情况也严重 。

信息增益的计算中，熵仅作为减数进行加减计算，计算结果的偏差比较大 。

C4.5改进为采用增益率，性能消耗有所减小，可以适用于连续标签，但是过拟合情况还是有 。信息增益率的计算中，熵不仅作为减数进行加减计算，还作为分母，因此计算结果实质上更多考虑熵的作用，偏差相对较小。

CART进一步改进使用基尼（不纯性），应用更广，不仅可用于决策树，还可以用于回归，实践中在此基础上的优化更多。CART在python的机器学习标准包sklearn里已经被实现。

CART可以用来做回归、也可以用来做分类。但是ID3，C4.5不行。

CART必须是二叉树。ID3和C4.5可以是多叉树。

多元分类的意思就是说标签是多元的，比如1，2，3...，k就是k元的，每个整数代表一个分类。

k元分类的混淆矩阵就是k乘k的矩阵。矩阵(i, j)上的数字就是模型预测为分类i、但实际为分类j的样本的个数。

比如下图。第二行、第三列的6的意思就是说这个模型把6个实际上为分类3的样本预测为分类2。

entropy是用于表示二元分类器的误差，而cross entropy则用于表示多元分类器的误差。

对于一个用$n$的测试样本的$k$元分类器，那么cross entropy的计算公式如下：

$$CrossEntropy=-\frac{1}{n}\sum_{i=1}^n \sum_{j=1}^ky_{i,j}\log p_{i,j}$$

比如一个三元分类问题，有两个测试样本，第一个样本：

预测出来的概率为$(0.5, 0.3, 0.2)$，实际标签为$2$，写成one-hot的形式是$(0,1,0)$；

第二个样本：

预测出来概率为$(0.6, 0.1, 0.3)$，实际标签为$1$，one-hot的形式为$(1, 0, 0)$

那么cross-entropy为

$$-\frac{1}{2}(1\times \log(0.3)+ 1\times\log(0.6))$$

决策树剪枝不同的算法有不同的解决方法。大体上分为两种，预剪枝和后剪枝。预剪枝是在决策树的生成过程中进行的，后剪枝是在决策树生成之后进行的（需要用到验证集）。预剪枝相对来说简单一些，容易造成欠拟合。后剪枝有多种策略，简单来说就是树生成好了以后，通过验证集验证“精度”来达到剪枝的目的，不容易前拟合。效果比预剪枝要好，但是时间的消耗比预剪枝要多的多！

对于决策树的推荐使用RandomForest模型，这个模型不容易过拟合，不过，一般的比赛都是直接用xgb或者lgb模型。

强化学习既不是有监督学习也不是无监督学习。

强化学习是自我强化的，在最开始强化学习没有任何有标签的数据。

但是模型在给出判断或者决策之后，会接受到外界反馈的数据，根据反馈，模型进行学习，然后做出下一次决策／判断，再得到新的反馈，然后这么一直进行下去。

所以强化学习和传统观念里的有监督学习和无监督学习都不一样。

举个例子好了，你要判断今天有没有下过雨。你观测了过去32天的两项特征：一、能不能看到太阳，二、地上有没有水。于是你就把这32天的数据做成了如下的决策树。

假如今天能看得到太阳，那么根据上面的决策树，今天下雨的概率为1/（1+9）=0.1

假如今天不能看到太阳，但是地上有水，那么预测今天下过雨的概率为18/（18+2）=0.9

假如今天不能看到太阳，地上也没有水，那么预测今天下过雨的概率为0/（0+2）=0.0

所以决策树预测出来的概率就是对应子节点里下雨天的比率。

其实预测出的分类也是根据数值概率来的。

比如一个叶节点里有3个阳性样本，2个阴性样本，那么这个叶节点预测出来的概率就是0.6。因为0.6 > 0.5，所以预测出来的标签是阳性。

你理解错了，树的深度和特征的个数没有什么必然联系。

对于二元特征来说，只能被使用一次。可是对于一个数值特征，它可以被反复使用，而不只是使用一次。

下面就是一个小例子，年龄这个特征被用了两次。此时树的深度是2。

LightGBM采用了基于梯度的单边采样（GOSS）的方法。

在过滤数据样例寻找分割值时，LightGBM 使用的是全新的技术：基于梯度的单边采样（GOSS）；而 XGBoost 则通过预分类算法和直方图算法来确定最优分割。

在 Adaboost 中，样本权重是展示样本重要性的很好的指标。但在梯度提升决策树（GBDT）中，并没有天然的样本权重，因此 Adaboost 所使用的采样方法在这里就不能直接使用了，这时我们就需要基于梯度的采样方法。

梯度表征损失函数切线的倾斜程度，所以自然推理到，如果在某些意义上数据点的梯度非常大，那么这些样本对于求解最优分割点而言就非常重要，因为算其损失更高。

GOSS 保留所有的大梯度样例，并在小梯度样例上采取随机抽样。比如，假如有 50 万行数据，其中 1 万行数据的梯度较大，那么我的算法就会选择（这 1 万行梯度很大的数据+x% 从剩余 49 万行中随机抽取的结果）。如果 x 取 10%，那么最后选取的结果就是通过确定分割值得到的，从 50 万行中抽取的 5.9 万行。

在这里有一个基本假设：如果训练集中的训练样例梯度很小，那么算法在这个训练集上的训练误差就会很小，因为训练已经完成了。

为了使用相同的数据分布，在计算信息增益时，GOSS 在小梯度数据样例上引入一个常数因子。因此，GOSS 在减少数据样例数量与保持已学习决策树的准确度之间取得了很好的平衡。

上文部分转载机器之心

原论文链接如下

LightGBM: A Highly Efficient Gradient Boosting Decision Tree

从纯工程的角度来说，lightgbm更好地处理了多进程（毕竟是微软）。

从优化角度来说，对数值特征找划分点时，lightgbm没有去穷举每个可能的数值，而是利用直方图只去尝试很少数的划分点。

抛砖引玉。

注意看第二段的最后一句话，根据这句话中$c^*$的意义，我们就知道，对于任意的$c$

$$P(c^*|x)\geq P(c|x)$$

对于k分类问题，$\mathcal Y$就有k个元素，那么蓝色框框里的式子就可以写成

$$1-\sum_{c\in\mathcal{Y}}P^2(c|x)\leq 1-kP^2(c^*|x)\leq 1-P^2(c^*|x)$$

这样看就很显然了

0101RG 的推导有错误。

根据$\sum_{c\in Y} P(c|x)=1 \geq P(c^*|x)=max(P(c|x))$

有$\sum_{c\in Y} P^2(c|x)) \geq P^2(c^*|x)$

所以$1-\sum_{c\in Y} P^2(c|x) \leq 1-P^2(c^*|x)$

话说$P^2(c^*|x)$不是属于$\sum_{c \in y}{P^2(c|x)}$中的一项嘛？也就是说$\sum_{c \in y}{P^2(c|x)} \ge P^2(c^*|x)$。所以$1-\sum_{c \in y}{P^2(c|x)} \le 1-P^2(c^*|x)$

adaboost没有用到梯度下降，adaboost中的learning rate也不是步长，这里的学习率只是指的每个树的权重的衰减速度。adaboost会逐一产生很多随机的决策树，每棵树的权重不同，learning rate就是权重衰减的速率。

sklearn文档的官方说法是

learning_rate : float, optional (default=1.)

Learning rate shrinks the contribution of each classifier by learning_rate. 

我回答下你最后一个问题。

而且如果一直迭代出新樹，分數不就爆表了嗎？

------

一直迭代出新树，训练误差当然会降低，但是测试误差（泛化误差）未必会降低，因为模型就overfit了。

所以我们需要控制树的最大深度(max_depth)。

gbdt类模型 都是回归树，对于二分类默认使用binary_logloss.怎么理解呢？对于正样本，损失函数就是ln（1+e（-x））  ，对于负样本，损失函数就是ln（1+e（x））。总之，对于负样本，预测值越负越好，正样本越大越好。

这样总损失就是ln（1.。*1.。*1.。……），一堆1+无穷小  相乘，还是1+无穷小 ，在ln一下，无穷小，美滋滋。

这样输出就是负无穷到正无穷。

那概率值则么来的呢？节点分数x， 模型会输出    1/(1+e（-x）)     ，公式不太会，见谅。这个值是0到1的假概率值。

从损失函数就可以看出，模型只是一个负样本给负值，正样本给正值的游戏规则下，一种平衡状态的解，本来就不是预测概率值的，只是假概率值，忽悠一下外行的。所以本质上二分类binary_logloss是个排序模型，给出模型认为谁更有资格当正样本的回答，只不过恰好有资格当正样本，意味着正样本概率也高。

决策树算法CART中用的是哪一个？

用的是Gini impurity，也就是基尼不纯。

Gini impuirty是什么？

假设这个数据集里有$k$种不同标签，第$i$个标签所占的比重为$p_i$，那么Gini impurity为

$$1-\sum_{i=1}^k p^2_i,$$

它描述了一个数据集中标签分布的纯度，类似于entropy。

Gini coefficient是什么？

Gini coefficnet针对于二元分类问题。对于二元分类问题，我们的预测结果会有对应的ROC AUC，那么

$$\text{GiniCoefficient}=2AUC-1$$ 

经济学中的基尼系数是什么？和上面的GiniCoefficient是一回事吗？

是的，本质是一回事。经济学中GiniCoefficient用累计分布来衡量一个地区财富的分配的合理程度。当$G=0$，说明财富均匀分配。

分类问题中，GiniCoefficient用累积分布衡量正负两种标签的分配合理程度。当$G=0$，说明正负标签的预测概率均匀分配，模型相当于是随机排序，所以$AUC=0.5$。

Gini index是什么？

这是一个尴尬的问题，因为很多时候有人把gini index等价于gini impurity，但有人有时候把它用作gini coefficient。你自己看懂别人的上下文就好了，自己可以避免使用，防止让别人误会。

CART是用的gini impurity

对线性回归boost并没有意义，因为叠加多个线性回归最后还是线性回归

比如第一个线性回归$a_1x+b_1$

第二个线性回归$a_2x+b_2$

将这两个相加，得到的是

$(a_1+a_2)x+(b_1+b_2)$，依然是个线性回归

线性回归是有解析解的，一旦求出一个线性回归，那一定是最优的，叠加也没有意义

这个和xgb中的弱分类器LR是一个意思，其实本质上没有被boost，只是被迭代求解而已。

可以参考我之前问过的问题：xgboost的gblinear是什么意思？

可以，但是没有意义，也没有必要，boost完之后也没有区别。

KNN属于懒惰算法，对测试样本分类时的计算量大，内存开销大，评分慢

可解释性较差，无法给出决策树那样的规则。

kNN算法必须保存全部的数据集，如果训练数据集很大，那么就需要耗费大量的存储空间。此外，由于必须对待分类数据计算与每一个训练数据的距离，非常耗时。

1. 计算代价很大

2. 无法处理categorical变量

3. 对变量的缩放非常敏感

4. 难以处理不同单位和不同数值范围的变量

5. 对高维数据表现不佳

kNN还有个问题就是k的选择。k总是在过拟合与欠拟合之间游走。

你可以说通过cross validation来选k，可是呢，你选出的k是全局适用的，而每个局部都是这个k最佳。

所以kNN总是无法避免地在一些区域过拟合，同时在另一些区域欠拟合。

不能调参算缺点么？

比较牛的模型，一般都有很多参数可以调，比如神经网络或者xgboost。

但是对于K近邻模型来说，本来水平就一般，连参数也只有一个k可以调，就显得有点弱上加弱了。

k-NN怕高维啊怕高维啊怕高维，说三遍

特别是遇到没什么用的特征，k-NN会不知所措，而且被那些没有什么prediction power的特征牵着鼻子走。

所以k-NN必须要先做特征选择，不然这些不相关的特征会影响到分类效果，因为k-NN自己无法学习到哪些特征重要、哪些不重要

如果用K近邻模型做回归的话，一个比较明显的缺陷，就是K-NN无法做out of sample的回归预测。

因为用K-NN做回归的时候，预测值是它附近几个值的平均值。所以预测值不可能超过预测样本的最大值，也不可能小于样本的最小值。这个缺点其实是和回归树一样的。

本质上是一样的

逻辑回归其实就是使用sigmod函数将$wx+b$映射到0到1之间

一个激活函数为sigmoid的单层感知机就是完全等价于一个逻辑回归的。

虽然说是one class，但我感觉应该还是监督式学习，因为在训练时，你是知道所有的样本都是同一类的。

而非监督式学习时，你并不知道样本是否是一类或者几类。

网上有说无监督，有说有监督的，也有人说是半监督的。

我觉得更像是有监督的。因为在one class svm里，你不会对训练集进行聚类，而是把训练集的样本全部标签当作已知的。

不过这个不重要吧，会用就行了。

我觉得用了kernel (RBF)的one class svm可用于无监督的clustering，把数据分为几个clusters，而linear one class svm可看作把空间分为两份，所有数据点在其中一半，相当于imbalanced two classes svm。但第二种情况估计没人用，所以可笼统的看作无监督。

再看一下two classes SVM的dual problem公式（来至wiki），

其中$y$是$+1/-1$的标签，$x$是数据，$c$是数据点的重要性系数，$c>0$的点是support vector。可以看到当$y_i=-1$时，$y_i*x_i=1*-x_i$，也就是把标签为$-1$的点$x_i$沿坐标原点对称得到$-x_i$，并当做标签为$1$的点。此时就是one class SVM，所有数据点在分割平面的一侧。

------------------------------------------------------------

当 one class SVM做异常点检查时应该是无监督的，因为不知道是否为异常点的标签。当求出分割边沿后，可以定义离边沿一定距离的点为异常点。

One-class SVM is used for novelty detection, that is, given a set of samples, it will detect the soft boundary of that set so as to classify new points as belonging to that set or not. The class that implements this is called OneClassSVM.

In this case, as it is a type of unsupervised learning, the fit method will only take as input an array X, as there are no class labels.

原文出处

"求问下模型融合，怎么知道两个单一模型融合后一定能够得到更优解呢"

未必吧，没有科学道理啊

“比如说SOFA 中自行车单一XGBOOST调参后能够达到15，而与逻辑斯特回归融合后却是下降”

为什么是逻辑回归呢？应该是线性回归吧

模型融合能够提高精度的前提是你的base level模型是真的很base....不能上来就加boosting或者bagging啥的

hyperparameter的临界点？

用cross validation吧

sklearn里的importance就是所谓的Gini importance。

一个feature的importance等于这个feature在所有的树里的Gini importance的和。

Gini importance就是树在这个feature进行分叉时，Gini impurity下降的数值。

random forest和xgboost计算feature importance是一样的

可以参考这个问题：在random forest和xgboost这类集成树模型中是如何计算_feature_importance的里的回答

随机梯度下降之所以要标准化或者归一化，是为了加速收敛、提高它的计算效率。而解矩阵这种解法是不需要这种迭代计算的，所以不要进行归一化。

是否归一化只是优化上的考虑，和模型的表现没有什么关系。

从结果上来说，我们期望它们是一样的，但是实际上会不大一样，因为SGD是具有随机性的，所以回归模型的参数自然具有随机性。

应该不行吧，naive bayes需要条件概率吧，回归是数值，不是概率

吴恩达课程里的这一张图其实就是最好的答案了

最简单的情况，假设只有两个变量，然后它们的大小范围相差很多，那么损失函数可能就是如左图那样，是长椭圆形的等高线。

椭圆型的等高线下，sgd收敛路径很曲折，就是说收敛速度慢。

如果把变量进行标准化或者缩放处理，那么损失函数的等高线就会接近于一个正圆。

此时sgd的收敛路径就“坦荡荡”了，少走了弯路，自然收敛得顺畅。

归一化后有什么好处呢？原因在于神经网络学习过程本质就是为了学习数据分布，一旦训练数据与测试数据的分布不同，那么网络的泛化能力也大大降低；另外一方面，一旦每批训练数据的分布各不相同(batch梯度下降)，那么网络就要在每次迭代都去学习适应不同的分布，这样将会大大降低网络的训练速度，这也正是为什么我们需要对数据都要做一个归一化预处理。

如果题主是问，如何证明归一化加速了训练，这个可以看看相关的论文。

理论上说是可能是负数的，但是实际上应该都是正数的，而且没上限。每棵树的权重是$$\alpha=\frac{1}{2}\log\frac{1-\epsilon}{\epsilon}$$

其中$\epsilon$是这个棵树的misclassification rate。

如果$\epsilon=0.5$，那么它的权重$\alpha=0$。

一颗树表现越好（$\epsilon$越小），权重越大。

如果$\epsilon=0$，那么权重就是无穷大。

因为boosting是把weak learner强化的过程，我们一般认为weak learner准确率应该大于$0.5$，也就是$\epsilon<0.5$，所以这种情况下$\alpha$始终是大于零的。

knn是惰性算法，不代表没有训练误差。模型在训练集上的误差就是训练误差。所以knn也是一样的。

当k=1时，对于训练集来说，每个点都会被自己本身标上标签，所以训练误差为0。即使是一些孤立点，训练偏差也会是0。

当k>1时，训练集那些孤立点就被被错误分类，因为它们周围都是其他类别的点。

当k=样本数量时，训练集中的每个点都被标上多数的那个标签。

其实k从1到无穷大的过程就是bias从0变大的过程，也是variance逐渐变小的过程。

公式截自维基百科

---------欢迎理性讨论---------

k-NN不需要训练,需要做的事情是将所有所有训练集遍历一遍,如果所验证的数据是来自训练集,那么选择k=1时,误差唯一.

个人感觉题目没有说清楚.(此回答仅供参考)

因为kNN中k=1时，一个训练数据找到的邻居就是他自己。和自己的误差当然为0。

其实kNN没有训练一个模型去学习输入到输出的映射，只是会把训练数据存储在kdtree的数据结构中，唯一训练的是kdtree中每个节点的split规则。而kdtree只是加速找NN的过程。

同样对此题不理解，knn应该不涉及训练的过程，训练误差体现在哪？

单决策树最大的缺陷在于，无约束，容易over-fitting，往往通过剪枝（内部）或集成方法（外部）来解决此问题

可能会对纯度高的特征非常依赖。导致人的行为变化，模型就会不稳定。因此，随机森林的出现解决这一问题。

同时也可以看出决策树的发展,在不断完善,从ID3到C4.5,CART

推荐阅读:https://zhuanlan.zhihu.com/p/32877396

如果要具体地说的话，那是因为用MSE作为二元分类的损失函数会有梯度消失的问题。

给你推导一番：

$loss=\sum^{N}_{i}(y_{i}-\sigma(w^{T}x_{i}))^{2}$    ,其中$\sigma(w^{T}x_{i})=\frac{1}{1+exp(-w^{T}x_{i})}$

$\frac{\partial loss}{\partial w}=\sum^{N}_{i}(-2(y_{i}-\sigma(w^{T}x_{i}))\sigma(w^{T}x_{i})(1-\sigma(w^{T}x_{i}))x_{i})$

因为$\sigma(w^{T}x_{i})$的优化目标是接近$y_{i}$

所以$\sigma(w^{T}x_{i})$和$(1-\sigma(w^{T}x_{i}))$中的一个也会越来越接近0，也就是梯度消失。

而CrossEntropy的梯度是$\sum^{N}_{i}(\sigma(w^{T}x_{i})-y_{i})x_{i}$就没有这个问题。

关于CrossEntropy的梯度用SGD计算逻辑回归时的迭代公式是什么？

不用MSE也是有理论依据的。理论依据来源于surrogate loss function。

准确率(accuray)是不连续的，所以需要用连续的函数来代理。

红色是Hing Loss，绿色是Log Loss，而浅蓝色是MSE。明显可以看出浅蓝色不是好的代理，所以优化MSE并不能优化模型的准确度。

CrossEntropy比MSE的优点是：

1.在nobodyoo1中说的，MSE有梯度消失的问题。

2.在Andrew Ng的ppt中（参考），$MSE(y,\sigma(X^Tw))$是non-convex。有很多local minimum。

这个所谓的“Non-convex”应该指因为梯度消失问题，数据点是loss上的saddle point,如果learning rate不是足够大，有些saddle point会变成很难跳出的“local minimum”。

我的理解是MSE可以作为二元分类的损失函数，但是效果不好。

其实某种意义上也可以将二元分类看做回归问题，即将$y=1$，$y=0$看做实数域上的两个值就可以了，不要想着类别，最终应该也可以得到一个模型，但是效果很差（网络上有人试过，你也可以自己试一试）。

其实机器学习很多问题是很灵活的，对于很多问题，可以考虑不同的模型、损失函数等等，但是当然要具体问题具体分析选择适合他的喽

如果把平方损失函数用在逻辑回归上，那么就是下图这样的过程

最后两行的意思说，如果真是标签是1，你的预测值越接近接近0，梯度越小。这样的目标函数显然是无法进行二元分类的。

之所以用logloss来作为逻辑回归的损失函数，是因为它是通过最大似然估计得到的。

类似地，mse是线性回归的损失函数，也是通过最大似然估计得到的。

感觉这就是个常识。均方根误差(MSE)只能用回归，二元分类一般用log loss。

我也不知道有没有什么科学道理。

从梯度来讲，mse容易梯度消失

小于0.5说明还不如随便猜呢，把结果反过来会更好

小于0.5，往往是模型很差，或者就是code里有bug。后者的可能性更大。

比如你要预测为1的概率，结果你检验的时候，是拿为0的概率了。所以就会得到相反的结果。

如果auc < 0.5，不妨把预测值代替为 1 - 预测值。这样的话，auc就会变成 1 - 原来的auc。

此外，建议阅读下怎么直观理解ROC AUC的概率统计意义

用1减一减就好了

题主说的两个，是因为两点确定一条直线吗？

我说说我的理解，如果不对请轻拍。

就拿binary feature举例吧。

比如你回归预测码农们的工资，一个变量是性别$X_1$，0代表男，1代表女，一个变量是学历$X_2$，0代表本科，1代表研究生。

如果没有interaction term（交互项、交叉项等等翻译），线性模型就是$$y=\beta_0+\beta_1X_1+\beta_2X_2$$

如果是决策树，会生成两个子树，一个子树对于男生做预测、一个子树对于女生做预测。$S_1$就代表是男生并且本科学历，而$S_2$就代表是男生并且研究生学历。这就相当于起到了interaction的作用。

个人理解树模型虽然自带特征工程效果，其本质在于寻找一条最佳的分类(回归)路径，在以数据为基础的训练过程中，以熵或不纯度的减少为目的，其从输入到模型输出的路径组成一组分类规则，而这组分类规则对应一系列特征的组合，如上述“岛歌”所述。

总结就是决策树的interaction在做特征的联立组合，其确实可以起到减少手工特征工程的工作量，但是类似却不能覆盖如统计特征、时间效应等其他特征因素，这也是为什么决策树的自动特征不能代替特征工程的原因。

对于sklearn里的naive bayes，需要谨慎使用predict_proba

官网上是这么说的

although naive Bayes is known as a decent classifier, it is known to be a bad estimator, so the probability outputs from predict_proba() are not to be taken too seriously

sklearn里每个classifer都有predict_proba的方法的

你调用一下就可以了

roc convex hull可以用来比较分类器。通常如果分类器输出的是概率，我们直接比较roc auc了。但是如果分类器返回的是标签，而不是概率，那么roc convex hull可以用来作为初步的判断。

首先要知道roc曲线的横坐标和纵坐标分别是FPR(False Positive Rate)和TPR(True Positive Rate)。

对于一个二元分类器A，如果它的FPR是0.2，它的TPR是0.7。在下图中用红点已经标出。

把A点和(0,0)，(1,1)连起来，就会得到一个凸多边形(convex hull)。

现在又有另一个二元分类器B，它的FPR是0.5，它的TPR是0.9。也可以在图中标出。

A和B以及(0,0)，(1,1)的连线依然是凸的。

现在又来了第三个分类器C，它的FPR是0.8，它的TPR是0.92。第三个分类器D，它的FPR是0.6，它的TPR是0.7。

发现C和D都在原来的convex hull内，如果非要把A，B，C，D连接起来我们发现，它也不会是凸的。

所以相对A和B，C和D是较差的分类器。至于A和B谁好，无法区分。

如果只有A，C，D三个分类器，D是较差的，而A和C则无法比较。

roc convex hull可以看作是一种“没有比较，就没有伤害”，“别人家孩子系列”。

------

roc convex hull的另一个作用是用来筛选operation point（也就是是0-1分类的阈值）。比如分类器返回的是概率，这个时候，这个分类器自己就对应了一个roc curve。注意，这个curve未必是convex的。选择operation point的时候，最好要选择在convex hull上的点。

搬运一下StackOverflow上的答案。

这个答案的意思说roc convex hull可以帮你构造一个最优的分类器。

为什么是“最优”的呢？

因为你的分类器在roc坐标系中会有很多点，而这些点的连线未必是convex的。你画出这些点的convex hull，这时convex hull下的面积就最大化了，换句话说roc auc就被最大化了。答案里引用的那片论文说，你总是可以人为的进行一些组合，使得你的分类器达到最个最优。

你的疑问应该在于：“如何理解？在这第k轮迭代时，这时的目标函数应该就是损失函数，这时候的变量是什么？”。

首先，GBDT 的基分类器可以是回归树或者是分类树，在回归任务下，GBDT 在每一轮的迭代时对每个样本都会有一个预测值，此时的损失函数为均方差损失函数，

$$\large L(y_i,F(x_i))=\left(\frac{1}{2}\right)*(y_i-F(x_i))^2$$

那此时的负梯度是这样计算的

$$\large -\left[\frac{\partial L(y_i,F(\mathbf{x}_i))}{\partial F(\mathbf{x}_i)}\right]=(y_i-F(x_i))$$

所以，当损失函数选用均方损失函数是时，每一次拟合的值就是（真实值-当前模型的值），即残差。

此时的变量是$F(\mathbf{x}_i)$，即“当前模型的值”，也是对它求负梯度。

如果没特殊要求，那就保持原始数据。数据重复的次数本身也含有信息。在梯度下降优化里，出现两次的数据点，它贡献的梯度也是两倍。

比如bootstrap技术里，resample with replacement,会出现重复数据。

看你重复样本多不多，少的话就直接删了，多的话那就多加几列特征“是否重复”，“重复次数”，“在重复中的原始排名”等等

--根据我在腾讯社交广告赛中的经验来看，这个可能是leak 好好利用

如果信息一样，应该是需要保留的，因为重复未必代表冗余，可能说明了发生的频率。

但是如果明显是错误地重复（比如id一样，key一样），那么则应该删掉。

https://www.rdocumentation.org/packages/mlr/versions/2.10/topics/calculateConfusionMatrix

和题主式子里的分母就是倒数关系

$$\text{gamma}=\frac{1}{2\sigma^2}$$

正常的log loss

$$\text{logloss}=-\frac{1}{n}\sum_{i=1}^n\left(y_i\log(p_i)+(1-y_1)\log(1-p_i)\right)$$

$y_i$是真实值，0或者1；$p_i$是预测出的为1的概率。

加权重$r$，就是考虑到0和1的真实比例。weighted log loss可以写成

$$\text{logloss}_w=-\frac{1}{n}\sum_{i=1}^n\left(ry_i\log(p_i)+(1-r)(1-y_i)\log(1-p_i)\right)$$

如果0标签样本较少，你想给它们加权重，那就可以让$r$取一个小于0.5的数值。

还有一个比较直接的设置方法是让$r$是全部样本中是0的比例，比如100个样本，0有10个，那么$r=0.1$。

如果数据量足够大，这类似的数据占比可以忽略的话，可以不考虑影响，这对训练结果带来的影响很小。

但是如果占比较大，就需要修正保留正确的样本。如果不能修正，建议去除。

我倒是和极客兔兔的观点有些不同。

我觉得数据相同、目标值不同的样本，自身也是含有信息的。比如10条重复样本，70%是阳性，30%是阴性的情况与20条重复样本，50%是阳性，50%是阴性的情况是不同的。

直接删去会影响到模型的精度。

把年级转为0，1，2，3，在决策树中，这个变量是会被当作连续变量处理。这样的处理并没有很精细化，如果和直接把它们进行one-hot相比。假如大学二年级（“1”）明显的与其他三个不同，决策树只能切出{0，1}和{2，3}，而不能做到{0，2，3}和{1}。

网上找到一个答案，对于xgb什么时候适合用onehot提到了：

1.对于类别有序的类别型变量，比如 age 等，当成数值型变量处理可以的。对于非类别有序的类别型变量，推荐 one-hot。但是 one-hot 会增加内存开销以及训练时间开销。

2.类别型变量在范围较小时（tqchen 给出的是[10,100]范围内）推荐使用

仅供参考

当然还是有必要的做特征筛选的，毕竟对模型是有影响的。

另外推荐你看看决策树、随机森林中的多重共线性问题，里面提到了特征筛选对模型解释性的影响。

需要进行特征选择的，不然的话整个模型就是garbage-in-garbage-out（垃圾数据进，垃圾数据出）。

具体效果，还是应数据而定，看交叉验证的结果。

sklearn里的决策树是不支持增量学习的。

关于增量学习的决策树，比较早期有一个ID5R算法，可以看看这篇论文的第8页，有具体的例子。每有一个新的training point，树的整个结构都可能变化，所以ID5R的劣势也比较明显。

GBDT的全称是梯度提升决策树，核心思想就在于将损失函数的负梯度在当前模型的值作为回归问题提升树算法中的残差的近似值，而xgboost的思想可以说来源于gbdt等，不光用了一阶导数信息，还有二阶导数，以及在树的复杂度衡量、并行化等各方面做了改进和优化，而且基模型也不再局限于树模型，可以使用线性模型。

所以我个人觉得“相比xgboost，GBDT有什么优势？”并不是一个合理的问题，如果勉强给个答案，相比xgboost，gbdt可能没有什么优势，一己之见。

你这个问题要找的就是比较特殊的情况了。首先要理解这两种算法的区别，就可以自然的找到你想要的答案。

xgboost比gbdt要多考虑hessian 矩阵的迭代信息，并且结构上可以实现更多的并行，gbdt的优化。所以如果一定要找个情况gbdt比较好，应该是在一介导对收敛的效果远远大于二介导，可以使得计算二介导带来的增益远远不够支付额外计算hessian的费用的情况吧。

还有一个比较general的优势，可能就是对硬件的要求gbdt应该会低一点。

没有免费的午餐嘛，所以没有一个模型能够完全压倒另一个模型的

pca后testing精度变好和变坏都见过。和很多因素有关，比如pca前要normalization，能量阈值（99%）的选择，数据本身的复杂度（是否能用线性模型表示），模型的拟合复杂函数的能力（线性或深度神经网络），还有模型的训练程度（overfitting或者underfitting）。pca原本是针对简单数据和线性模型，如果数据和模型都很复杂，pca效果很难保证。

我理解是两种情况下pca有好处：1.损失的信息里噪音占多数，有人说相当于加了正则项；2.模型太弱（比如线性），本来就提取不出被扔掉的信息，反而会学到一部分噪音。

非线性降维可以了解下kernel pca，t-SNE，autoencoder。

------------------------------------------------

举例说明下PCA在线性回归里的作用。

$y=Xw$里$w=X^{-1}y=(X^TX)^{-1}Xy$。 当$X$的condition number很大时（ill-conditioned），$(X)^{-1}$会有很大误差，比如放大$X$里的round-off error。而condition number是$X$的最大singular value/最小singular value。

PCA的作用是：

$PCA(X)=SVD(X)=USV^T$,而X的singular value$S$等于$X^TX$的eigen value的平方根。

$X^{-1}=VS^{-1}U^T$。$s_i$指第i个singular value。假如$s_i=10^{-30}$ 则 $1/s_i=10^{30}$ 。也就说$s_i$很小的维度，误差会放大很多。

PCA降维就是扔掉$S$中很小的一些维度，变向减小了剩余的$X_1$的condition number, 让$X_1^{-1}$ 的误差更小。

正则项作用：

如果不用PCA扔掉这些$s_i$小的维度，还可以用正则项（比如 Tikhonov regularization），相当于在$s_i=s_i+c$, $c$是一常数，这样也能降低$X$的condition number。比如加正则项前condition number=100/0.001=100000，加正则项后condition number=(100+1)/(0.001+1)=100.899，变小了1000倍。

很多时候，我们在分类或者回归任务前先PCA降维，不一定是为了精度。可能是为了

1. 为了可视化（降到2或者3维）
2. 为了减小数据量、增加训练速度
3. 为了去掉冗余的特征

在PCA之后，数据的维度降低，必然会造成信息丢失，减少的维度越多，丢失信息越多；同时，数据中的噪声也可能被降低。所以精度可能提高、也可能降低。

最直接的方法是做cross validation，选出最佳的PCA后数据的维度。

我理解的PCA就是在总体上降低数据的信息量，在删减数据的时候难免会同时删减有效信息和噪音信息。

当删减噪音信息比较多的时候，PCA就是对精度有帮助的。

当删减有效信息比较多的时候，PCA就是对精度有反作用的。

我觉得会的，因为降维毕竟会损失很多信息。

可以试试先对消费者做聚类？把消费者分成k簇。

然后每个月的数据就是

销售额，1簇人数，2簇人数，...，k簇人数

对于销售额，你可以按照AR模型的方式来处理

销售额，上月销售额，上上月销售额，1簇人数，2簇人数，...，k簇人数

仅供参考！

交叉验证了解一下

你的test set是哪里来的？如果test set和training set不是来自于同一个总体，或者分布差距很大，的确会出现题主的情况。

1.有可能问题本身就很难。你可以把骑行距离的直方图或PCA后的散点图（scatter）画出来，看3km是否是一个好的分类的划分值。比如3km是一个峰值，左右两边都集中有很多数据，这样的分类问题就很困难。如果没有特殊要求，可以考虑变为其他值，或者变成回归问题。

2.每次只Random Search一项参数，这样search的精度更高，容易找到重要的参数。

3. 试试其他方法，比如Neural Network。一般Neural Network 分类优于Ramdom Forest。

我觉得是需要的。

比如5-fold cv，你会得到5个模型，那你用哪个呢？

cv只是用来调参和得到方法的准确度的估计，不能代替训练模型。

应该是不需要了，交叉本就是为了防止过拟合，采用的28分，5层28也是全量，反正我没用全量重新训练。

我想应该是分类问题吧。之前学计量经济学的时候，老师给过我这样一个观点：在连续变量中比如1和2，2和3这种值之间的差异是相同的，相差1就是1。但是一些有序的分类变量，比如楼主提到的“A+”“A”“A-”“B+”“B”等等，他们之间的差异意义是相同的吗？很多时候应该是不同的。

分类问题。如果是回归，那你怎么定义任务，怎么保证结果在你定义的这些数值里面

我也觉得算是分类问题。

比如“A”“B”“C”“D”“F”，如果用回归，那么预测结果肯定也是连续的，比如说预测结果中最有可能的是的“A”的话，其次就是“B”，然后是“C”，等等。

但实际情况未必如此，应该让模型和数据自己去说话。

用多分类模型可能预测为最有可能为“A”其次为“C”，然后是“B”。这样的非连续结果可以是根据模型学习得到的，而非强迫它设置为连续的。

其次还有s3040608090提到的，虽然是有序分类变量，但是它们的间距未必是等距的。

简单地说，就是把gbdt的输出，作为logistic regression的输入，最后得到一个logistic regression模型。

例如，gbdt里有$3$棵树$T_1,T_2,T_3$，每棵树的叶节点个数为$4$，第$i$个树的第$j$个叶节点是$L_{i,j}$。

当gdbt训练完成之后，样本$X_1$在第一棵树中被分到了第$3$个叶节点上，也就是$L_{1,3}$，那么这个样本在$T_1$上的向量表达为$(0,0,1,0)$。

样本$X_1$在$T_2$被分到了$L_{2,1}$，那么$X_1$在$T_2$上的向量表达为$(1,0,0,0)$

样本$X_1$在$T_3$被分到了$L_{3,4}$，那么$X_1$在$T_3$上的向量表达为$(0,0,0,1)$

那么$X_1$在整个gbdt上的向量表达为

$$(0,0,1,0,1,0,0,0,0,0,0,1)$$

所以每个样本都会被表示为一个长度为12的0-1向量，其中有3个数值是1。

然后这类向量就是LR模型的输入数据。

简单来说是将GBDT中每棵树的叶节点作为一个新的特征（01变量，如果某样本落在该叶节点上就是1，否则为0）。可以在r中用xgboost的create.features函数手动玩一下。

这个是现在广告业界的套路，好像叫什么ctr。

因为xgb等的梯度提升树训练过于复杂，而lr众所周知过于简单，只能发现线性过于简单，对于交互项和非线性关系没有辨识度，于是大佬们就开发一个新套路，用gbdt的训练数据，gbdt=梯度+树，基于树模型，就有了交叉和非线性，然后把叶子节点放到lr里，这不解决了lr的缺点。

当然，我并没有做过，所以就这样简单粗略说一下，等待大佬给出学术性专业回答。

ps：至于厉害不厉害，就不知道了，工业界比较厉害吧，毕竟谷歌阿里都在用，至于比赛的话，我就不晓得了，我还指望哪个大佬能指点一下我，最近瓶颈啊，完全不知道怎么清洗数据，每次搞完特征，发现还不如原特征往里面塞

一棵树的叶节点把数据空间非线性的划分为 $2^d$个互不相交的子空间，$d$为树的深度。多棵树就有多种划分。这里把多棵树子空间的序号的one-hot编码组合作为输入数据$x$。$x_i=1$，表示数据点在第i个子空间。每一个子空间都是一个cluste。这个技术的关键思想是用是否在子空间的指示标签（binary indicator）代表子空间中的所有点，类似于kmeans中mean代表所有点的值。最后通过所有子空间的影响力的和算出$P(\hat{y}=1)$。

再看LR，$P(y=1)=\sigma(w^Tx)=\dfrac{1}{1+e^{-w^Tx}}$，如果logit $w^Tx$值越大，预测标签$y=1$的概率越大；如果$w^Tx$越小（$w^Tx<0$），$y=0$的概率越大。在训练时，如果第i个子空间中$y=1$的数据点很多，相应的$w_i$会被训练成一个较大的正数。在预测时，如果$x_i=1$,则$w_ix_i=w_i$会贡献一个较大的logit，驱使$\hat{y}=1$的概率变大。如果$x_i=0$,$w_ix_i=0$对预测没影响。$w_i$可以看做第i个子空间对$P(y=1)$的影响力。

打个比方，小明上的小学，初中，高中，大学都是好学校，最后小明学习成绩好的概率就会高。其中小学的划分就是一棵树，初中是另外一棵树。新造的$x$就是所读学校的编号的组合。$w_i$就是第i个学校对学习成绩好的影响。

计算的链条是原始数据$x_0$-(GBDT)-> 新one-hot编码组合$x$->$w^Tx$->$P(y=1)=\sigma(w^Tx)$。

根据这个blog，原始数据加新造的one-hot编码组合（新特征），效果最好。

bias大是指预测值与真实值之间的误差很大，通常是因为模型欠拟合

variance大是指当数据有小的扰动时，预测结果相差却不小，通常是因为模型过拟合

模型要不是欠拟合，要么过拟合，要么两者之间，所以bias和variance就会有trade off，因为不可能同时发生欠拟合和过拟合。当模型不过拟合也不欠拟合的时候，bias适中，variance也适中。

我是这么认为的：

bias 是指模型拟合训练数据的偏差。bias越小，模型拟合的程度就越好

variance 是模型在不同训练集的预测结果的方差。

随着模型复杂性的增加，bias就会越小，而variance就会越大。因为模型越复杂，模型对于训练数据集的学习就会越细致，模型拟合程度就会越好。但是对于不同数据集之间的共性的学习就会不太好，会导致不同数据集之间的预测的差异性很大。

L0是非零个数，最稀疏，但是NP hard问题，不容易求解。L1对应Laplace分布，L2对应高斯分布，比较容易理解。至于Lp，p<1，可能求解很难，所以不常用。

L0一般用L1替代。

其实除了单纯的L1，L2，常用的还有L1和L2的混合，称作ElasticNet(参考ElasticNet的目标函数是什么)

当然有影响的。

看下图，横坐标是数据中阳性样本的比重，纵坐标是一个随机预测结果对应的F1值，可以看作是baseline。阳性样本的比重不同，baseline变化很大，所以数据的平衡性对F1值影响还是很大的。

代码如下

from sklearn.metrics import f1_score

import numpy as np

import matplotlib.pyplot as plt



fracs, f1s = [], []

for frac in np.linspace(0.01, 0.99, 20):

    n = 1000000

    n1 = int(n * frac)

    n0 = n - n1

    true = [1] * n1 + [0] * n0

    pred = np.random.randint(0, 2, n)

    fracs.append(frac)

    f1s.append(f1_score(true, pred))

    

plt.plot(fracs, f1s)

plt.xlabel('% of positive labels')

plt.ylabel('F1 score of random guess')

plt.show()

关于非平衡数据以及各种metric对应的表现可以看看这篇Facing Imbalanced Data

你这是手动选择batch size吗？如果数据量很大的话，你这样做应该没问题的

数据归一化（normalization）相当于做数据矩阵的较弱的right preconditioning，目的是减小矩阵的condition number，从而让梯度递减一类的优化算法收敛更快，而且求矩阵逆的误差减小。

举个简单的例子，一层的线性回归，$Xw=y$，其中$X$是mxn输入数据矩阵，每一行是一个n维数据点，$w$是要求的网络参数，y是m个1维输出。当做数据归一化时，相当于乘上了right preconditioner$P$。

$XP^{-1}Pw=y$

其中$P$是个简单的可逆的对角线矩阵。$P_{ii}=\sigma_i$, $P_{ij}=0,i \neq j$, $\sigma_i$是输入数据X第i维的标准差。新求的网络参数是$Pw=w'$。新矩阵$XP^{-1}=X'$的condition number会小于$X$。还可以看出对$y$没有变化。

当用最小二乘法时，$loss=argmin_w(|XP^{-1}w'-y|^2)$，近似锥形。当condition number约等于1时，loss function在$w'$空间上的等高线（contour）更接近于圆/球；否则，当condition number是一个很大的正数时，等高线更接近于椭圆/椭球。对于梯度下降算法，圆形等高线下降更快。

结论是应该对输入数据做归一化，保持原始输出。

归一化是把数据都变为（0,1）的范围内，这样的话处理起来方便，计算量也大大减少了，损失函数更容易收敛。

你这里指的gini指数一般叫做gini不纯。

gini impurity越小，说明这个分叉的结果越纯净，所以就是选小的。

参考问题Gini指数、Gini系数、Gini不纯是一回事吗？

如果是线性的kernel，有良好的解释性，类似于线性回归。

如果是非线性的kernel，比如rbf，那么解释性则很差。

逻辑回归求的$d$维参数$w$，表示每个输入特征对结果$y$的重要性，所以从特征的角度很好解释。然而SVM以测试点$z$和所有支持向量$x_i$的相识度向量$k(x_i,z)$作为特征，所以从输入向量$z$来说就不好解释。应该做预处理，计算出点的相识度向量$k(x_i,z)$，然后就容易解释了。比如$k(x_i,z)$很大（$z$和某个支持向量$x_i$相似），而且$c_i$较大（$x_i$靠近分割超平面），此时$y_i$对输出标签的影响就很大。

解释性不是很强。但是特征对应的系数越大，也能够说明这个特征的重要性越大。

（不是个人观点，参考这个论文）。

我觉得不会。因为随机森林中每棵树见到的数据子集（sample with replacement）和特征都不一样，很难衡量一棵树比另一棵好。一个极端的例子，有棵树训练用到所有数据和特征，达到过拟合，训练错误为0，如果它权重很大，那结果接近于一棵树的结果，测试错误会较大。按训练误差给树加权重，本质上是减弱随机性，更倾向于达到过拟合。

但实际效果要试试才知道，可能针对不同数据和参数，效果会不同。而且树权重分布的设计也很重要。

这篇论文用准确率做权重，号称有改进。

ppv的全称是Positive Predicted Value，是和Precision（精度）完全一回事。

$$ppv = \frac{预测为真中正确的个数}{预测为真的个数}$$

一。决策树/随机森林（RF）直接处理missing data的方法：

1.CART中可用surrogate splits，但是根据Random Survival Forests，RF不推荐surrogate splits。

"Although surrogate splitting works well for trees, the method may not be well suited for forests. Speed is one issue. Finding a surrogate split is computationally intensive and may become infeasible when growing a large number of trees, especially for fully saturated trees used by forests. Further, surrogate splits may not even be meaningful in a forest paradigm. RF randomly selects variables when splitting a node and, as such, variables within a node may be uncorrelated, and a reasonable surrogate split may not exist. Another concern is that surrogate splitting alters the interpretation of a variable, which affects measures such as VIMP."

2.用C4.5代替CART，C4.5计算information gain时没直接用到missing data。

二。或者用填值（imputation）的方法预处理：

1.用average/median/mode填；或根据原始的RF，用加权后的average/median/mode填，权重是missing data point和其他data point的相识度。

2.用复杂算法去估计missing data，比如R中SVDmiss，交替地算SVD和填值。还有missRanger和missForest，交替的填值和进行随机森林。

3.这里提到"on the fly imputation" (OTFI)，随机地填其他数据点中出现过的值，但是填充的值不用于split的计算。

4.Handling missing data in trees: surrogate splits or statistical imputation ?其中说填值方法计算量小，效果好。

我的理解是最好用填值，因为填值和训练是独立的两个步骤，填值后数据比较稳定，利于分析，且训练计算量小。对于决策树可以不用填值，但是随机森林需要填值。

python里sklearn不能，pycaret能。

原理上说随机森林是支持有缺失值的。

泊松回归主要是用在y服从泊松分布的问题上。

泊松分布是用来计数的，比如公交车的停靠次数、服务器宕机的次数、每个链接1天内被点击的次数等等。

这些变量的回归残差不是正态分布，所以用最小二乘就不合适了。

消灭零回复。。

泊松分布主要应用于离散型随机变量。

应用场景举例：酒店收益管理，应用泊松分布估算售卖进度的快慢从而调整价格来实现收益最大化。

详细了解可私聊我知乎号：zhihu.com/people/wangweitong

我觉得会有很大差异的，但是应该不会影响到模型训练。

因为baseline是相对的吧。

$\triangledown _{\theta }J( \theta;x_{i},y_{i})$

=$-\frac{\partial }{\partial \theta}(y_{i}log(h_{ \theta}(x_{i}))+(1-y_{i})log(1-h_{ \theta}(x_{i})))$ （交叉熵损失）

=$-\frac{y_i}{h_{ \theta}(x_i)}\frac{\partial h_{ \theta}(x_i)}{\partial \theta}+\frac{1-y_i}{1-h_{ \theta}(x_i)}\frac{\partial h_{\theta}(x_i))}{\partial \theta}$ 

=$-\frac{y_i}{h_{\theta}(x_i)}h_{\theta}(x_i)(1-h_{\theta}(x_i)))x_i+\frac{1-y_i}{1-h_{\theta}(x_i)}h_{\theta}(x_i)(1-h_{\theta}(x_i))x_i$（sigmoid的导数公式）

=$-y_i(1-h_{\theta}(x_i))x_i)+(1-y_i)h_{\theta}(x_i)x_i$

=$-y_ix_i+y_ih_{\theta}(x_i)x_i+h_{\theta}(x_i)x_i1y_ih_{\theta}(x_i)x_i$

=$(h_{\theta}(x_i)-y)x_i$

第$j$个coefficient update的公式

$$\theta_j:=\theta_j - \alpha (h_\theta(x^r) - y^r)x^r_j$$

$h_\theta(x^r)$是当前模型对某个随机样本$x^r$的预测值，$x^r_j$是第$r$个样本中第$j$个变量

写成向量的形式就是

$$\theta:=\theta - \alpha (h_\theta(x^r) - y^r)x^r$$

lasso path描绘了自变量的回归系数和lasso惩罚系数$\lambda$的关系。

惩罚系数越大，自变量的回归系数越小，非零的系数也越少。下图就是lasso path的一个例子，每条线代表着一个自变量的回归系数。

lasso path可以看出各个回归系数随惩罚系数的变化、看出自变量退出模型的先后顺序。

随机森林和xgboost中的importance是一样的计算方法。

概括地说，一棵树中，某个特征的importance就是损失函数在这个特征切分点上的提升。在整个模型中，importance就是它在所有树上importance的均值。

例如，对于一个二元分类问题，我们用了gini impurity作为分叉标准的随机森林。假设，森林中一共三棵树。

特征A在树1中作为划分点，并且在这个点上，gini从0.6降到0.3。

特征A在树2中作为划分点，并且在这个点上，gini从0.5降到0.4。

特征A并没有出现在树3中。

特征A的importance为：((0.6-0.3)+(0.5-0.4))/3=0.13

特征B在树1中作为划分点，并且在这个点上，gini从0.3降到0.1。

特征B在树2中作为划分点，并且在这个点上，gini从0.7降到0.5。

特征B在树3中作为划分点，并且在这个点上，gini从0.4降到0.1。

特征B的importance为：((0.3-0.1)+(0.7-0.5)+(0.4-0.1))/3=0.23

上面的例子是gini，当然也可以entropy。对于回归任务来说，损失函数可以是MSE，或者MAE之类。

S是Seasonal，就是季节性、周期性的意思

X是eXogenous，外部信息的意思

所以SARIMAX和ARIMA比就是增加了周期性，并且使用了外部信息来增强模型的预测能力

真正画全了的图应该是两组等高线，一个像你图中的椭圆等高线（contour），在贝叶斯框架中表示的是似然函数（likelihood），描述如何由未知变量生成观测值的数学模型；对于Lasso，另一组是正方形等高线，代表的是先验知识（prior）。最优解就是这两组等高线的交点。因为相交点有无数个，具体相交点的选择由拉格朗日乘数来控制，确定似然函数和先验知识在loss中的比重。

一般为了说明prior项的作用，只画一条线示意，代替等高线曲面。比如$|w_1|+|w_2|=1$，画出来就是你左图的正方形。$|w_1|+|w_2|=2$会是更大的正方形。

如果是ridge，应该是一组圆形等高线，或者说是一个倒的圆锥。

严格来说，OOB error不能完全取代交叉验证（看完下文就知道了）。

OOB(Out-of-bag) error也叫做包外误差，是随机森林中的一种度量预测误差的方式。

我们知道随机森林是由很多数组成的，而每棵树当中只用了部分样本来训练。

假设训练集中一共有$N$个样本$x_1,x_2,\cdots,x_N$，随机森林中有$M$棵树，$T_1,T_2,\cdots,T_M$。

对于一个样本$x_i$，我们用那些没有使用$x_i$训练的树组成的小随机森林来预测$x_i$，其预测误差就是$x_i$在这个随机森林上的OOB error，$\text{Err}_i$。

整个随机森林的OOB误差就是所有训练样本的平均OOB误差，

$$\text{OOB Error}=\sum^{N}_{i=1}\frac{\text{Err}_i}{N}$$

通常来说，OOB误差会比交叉验证的误差更大，因为估计OOB时，我们只用了随机森林中的部分树，没有使用完整的模型，限制了模型的发挥。但OOB省去了交叉验证中多次训练的步骤，所以比较方便，节约了时间。

是的，不需要交叉验证了。

正则项的目的是约束变量的回归系数而不是intercept，所以是不应该包含intercept的。

另外一方面，题主的链接里的目标函数，应该都是针对数据已经中心化的情况。在这种情况下，截距已经是零了。

正则项是不包括截距的。

当然可能发生啊，题主看看这个，形状识别：是方还是圆 标杆模型

一个是CNN，一个是逻辑回归

也基本上没有差别

1.你的图有错误，横轴和纵轴应该是$w_1$，$w_2$，不是 $x$。

2.loss function是参数 $w$的函数，不是输入数据$x$的函数。

$L(w)=\underset{w}{\mathrm{argmin}}(f_x(w)+\lambda|w|_n)$，$n=1,2$

$f_x(w)$是似然函数项，比如是$|X^Tw-y|^2$

3.左图中LASSO $w_1=0$,$w_2\neq0$，而右图中Ridge $w_1\neq0$,$w_2\neq0$，明显LASSO中非0的参数$w$更少，更稀疏。

参考：

为什么LASSO具有稀疏性，

L1和L2的区别是什么？为什么L1是稀疏的？

Ridge和LASSO的区别

参数更新的时候，L1求导值为+1或-1，假如说经常出现+1的话，k=k-α*1那么参数就会很快下降到0；L2求导的话值为w（权重，一般为小数），k=k-α*w，这样的话下降时不断减去一个越来越小的小数，只能慢慢趋近于0而无法到达0。

个人理解，求大佬指正。

有人知道吗？

http://sofasofa.io/forum_main_post.php?postid=1002420

SVMR一般有两种，一种是vapink SVMR，设定$\epsilon$，error大于这个值的是support vector。还有一种是least-square SVMR，所有点都是support vector。

图像分割不能从几何空间的维度（长宽高）增加训练数据，比如cnn这类patch based算法，已经用了所有的已定义大小的数据块（patch）。我的理解，图像分割可增加特征信息：

1.一维像素点属于某类/某区域的标签（class/region label）

2.是否是边沿（edge）

3.整个class/region的统计量，比如mean，variance。

我觉得主要看应用，然后设计要添加的信息。

通常图片数量不够的时候，我们需要增加训练样本的数量，也就是数据增量(data augmentation)。

如果只是随机剪裁的话，可能会造成图片中的信息（轮廓、边缘）不完整。

数据增量的常用方法是旋转图片、翻转图片、增加噪点、调整图片亮度、灰度等等。

只需要建立一个kd tree。kd tree不会直接给出相邻点，只能减小相邻点的查找范围，减小两点间距离的计算量。如果是kNN，需要记录k个当前最相邻点，在遍历kd tree时把每个可能的点和这k个当前最相邻点比较并更新，直到达到root。

二阶导数收敛得快！

Random Forsest是由很多个数组成的，最终的结果可以看作是

$$M=\frac{M_1+M_2+\cdots+M_n}{n}$$

假设$M_i$是同分布的，那么$\mathbb{E}(M)$和$\mathbb{E}(M_i)$是相等的；而对于方差$\text{Var}(M)$应该就是只有$\text{Var}(M_i)$的$1/n$。$n$越大，方差越小，但是减小的幅度也随之变小。所以通常1000以内也就够了。

偏差不变，方差变小

像kidd23说的precision-recall曲线下面积(AUCPR)是精度precision的期望（加权平均）。首先，二元分类问题对每个数据点生成一个score ，然后设置一个threshold $c$，当score $>c$时输出标签1。

令随机变量X，Y分别表示真实标签为0，1的score，那么二元分类问题的score是两个概率密度函数（$p_X(x), p_Y(y)$）组成的混合模型（mixture model）,如下图。

$Precision(c)=\dfrac{TP}{TP+FP}$

$Recall(c)=\dfrac{TP}{TP+FN}=P(Y>c)$

再看AUCPR的计算，纵轴长度是$Precision(c)$,横轴的微分长度是$|dRecall(c)|$

$$AUCPR=\int_{-\infty}^{\infty} Precision(c) |dRecall(c)| $$

$$=\int_{-\infty}^{\infty} Precision(c) \dfrac{|dP(Y>c)|}{dc}dc$$

大家很熟悉roc auc，它小于0.5就说明不好。

为什么呢？因为随便猜的结果就是0.5。

对于精度-召回曲线下的面积，多少就是不好呢？

当然也是和随便猜相比较。

如果正样本的比例为$\alpha$，那么随便猜的情况下，精度-召回曲线下的面积就是$\alpha$。

如果数据是平衡的，正负各一半，那么精度-召回曲线下的面积等于0.5就不好。

如果数据是非平衡的，正样本占10%，那么精度-召回曲线下的面积等于0.5就说明模型还不错。

------

下面我做了一个simulation，100万个样本，20万个是正标签，80万个是负标签，如果我们随便猜，那么对应的精度-召回面积就是约等于0.2，也就是正样本的比例。

这条线也可以当作是baseline了

precision-recall曲线下面积实际上就是等于平均精度(average precision)。与roc auc不同，即使它小于0.5，也不能说明它差。

kNN不会去根据训练集主动学习或者拟合一个判别函数，而是去记住所有的训练样本。所以它并没有所谓的“训练”过程。当要进行预测时，它才会根据训练集去寻找最近邻，获得预测结果。

logistic regression中用的是logistic sigmoid函数

$$\text{sigmoid}(x)=\frac{e^x}{e^x+1}\in [0,1]$$

而$$\text{tanh}(x)=2\text{sigmoid}(2x)-1=\frac{e^x-e^{-x}}{e^x+e^{-x}}\in [-1,1]$$

下面蓝色是sigmoid，红色是tanh。

如果是用neural network，标签是一位的-1/+1，最后一层用tanh activation function。如果标签是一位的0/1，可用sigmoid。如果标签是多位的one hot编码，最后一层用softmax。

---------------------------------------------------------------------------------

令$x$是输入数据，$w$是logistic regression参数，$y=-1/1$是标签，$\sigma(z)=\sigma(w^Tx)$是sigmoid函数。

似然函数(likelihood)模型是

$P(y_i|x_i)_w=\sigma(y_iz_i)$，$y_i=-1/1$, $z_i=w^Tx_i$

minimum negtive log likelihood可得损失函数：

$argmin_w{l(w)_{y,x}}$

$=argmin_w{-\sum_{i=1}^N ln\sigma(y_iz_i)}$

$=argmin_w{\sum_{i=1}^N ln\dfrac{1}{\sigma(y_iz_i)}}$

$=argmin_w{\sum_{i=1}^N ln(1+e^{-y_iz_i})}$

注意，因为用的模型是sigmoid函数，这里的最小负log释然函数等价于最小cross entropy。

如果用cross entropy写

令$t=0.5y+0.5$，表示是否$y==1$的标签，$t=0/1$。

$argmin_w{CE(w)_{y,x}}$

$=argmin_w{-[t_i ln\sigma(z_i)+(1-t_i)ln(1-\sigma(z_i))]}$

$=argmin_w{-[(0.5y+0.5)ln\dfrac{1}{1+e^{-z_i}}+(0.5-0.5y)ln\dfrac{1}{1+e^{z_i}}]}$

$=argmin_w{ln(1+e^{z_i})-\dfrac{y+1}{2}z_i}$

当$y=-1/1$

$CE(w)_{y,x}=l(w)_{y,x}$

为什么非要是-1和+1呢？把0，1映射成-1，+1不就可以了？

逻辑回归里通常把负样本标记为0其实是有意义的，因为逻辑回归可以得到预测概率，预测结果为0，不仅表示了是负样本，同时也是表示$P(Y=1)=0$的意思。-1，+1表达不了这个。

建议你看林轩田老师的 机器学习基石 的第十课的ppt，里面就有推导

LASSO的loss有两项分别是likelihood和prior。Loss对于$\beta$的gradient也分成两项。来至于likelihood的gradient和问题本身相关，很难比较$grad_{\beta_1}$和$grad_{\beta_2}$的大小。我们只能比较来至于prior的gradient。

$d(|\beta|)/d\beta=sign(\beta)$

也就是说来至于prior的改变量的绝对值是一个常数$C$（$C=\alpha*\lambda$,$\alpha$是learning rate，$\lambda$是拉格朗日乘数，用于平衡likelihood和prior）。假如$C=0.1，\beta_1=10,\beta_2=1$，那么$\beta_1$和$\beta_2$只通过prior能变成0的最少步数分别是100步和10步。

如果是RIDGE，来至于prior的gradient

$d(|\beta|^2)/d\beta=2\beta$

随着$\beta$的减小，改变的速度也会下降。

Ridge回归是等比例衰减

lasso的话要分情况，有一种情况是还直接变为0.

模型参数优化遇到了瓶颈就多做点特征工程呗。

举个简单的例子，如果数据集中正例远多于负例（比如说99:1），那么我们的模型即使什么都不学习，只要预测数据为正例，就可以得到很高的准确率（比如说99%），但是这并不是一个好模型，因为它无法识别出负例，这种极端的情况下，我们通常直观上的一些评价标准并不适用这种模型。需要引用F1-Score这样的评价方法。而且在模型的训练过程中，比如说卷积神经网络，过多正例使其Loss在整个Loss中占主导地位，从而容易忽略了负例的Loss，很难收敛到一个很好的结果，通常要在Loss中加入权重，比如说Focal Loss的方法。

机器学算法在不平衡数据上表现往往会下降

原因有：

1. 目标变量的分布不均匀使得算法精度下降，对于小类的预测精度会很低，因为学习样本不够多

2. 如果算法本身是精度驱动的，即该模型的目标是最小化总体误差，而小类对于总体误差的贡献很低

3. 有些算法本身的前提假设就是数据集的类分布均衡，同时它们也可能假定不同类别的误差带来相同的损失

当然是需要的。

逆向思维一下，如果你加一堆不相关的变量到你的数据集里，然后再训练一次模型，你觉得模型的精度是下降的可能性大还是提高的可能性大？

一般来说，xgboost（包括random forests）对冗余的变量是不敏感的。

但是正如MangoCoke说的，“垃圾”变量肯定是对模型有负面影响的。

另外一方面，xgboost或者说每棵树在选择分叉点的时候，都是以贪婪的方式选择局部最优，所以有些特征可能在局部不错，但是从整体上看降低了模型整体的精度。

再有就是不相关或者重复的变量会影响最终的feature importance。

多余的变量对xgboost或者gbdt都是有影响的，所以做特征选择肯定是有帮助的。

另外可以参考一下：对于xgboost，还有必要做很多特征工程吗？

如果你的搜索算法用是暴力搜索的话，如果样本是D维的，复杂度是O(D*n)

数据量小的时候要尽量避免复杂的模型，比如boosting，神经网络。

要用简单一点的模型，比如线性模型（线性回归，逻辑回归），kNN，朴素贝叶斯，还有SVM。

贝叶斯模型一般都可以处理小数据，分类回归都可以

SVM

它们都是属于广义线性模型(GLM)，但是用了不同的link function，因为它们假设了不同的分布，Probit model假设了残差是正态分布，Logistic regression假设了残差服从Logistic分布

估计是标签是0的数据太多，数据不平衡引起的。以sklearn.linear_model.LogisticRegression为例，你可以尝试：

1.设置参数class_weight=‘balanced’，或者手动设置0/1类的数据权重。

2.逻辑回归真正的输出是一个数据点属于各个类的概率。用predict_proba()可得到。但是为了简化应用，sklearn中predict()方法自己设置了一个阈值0.5，如果P(Y=1)>0.5,那么输出标签就是1。你可以用predict_proba()得到测试数据属于0/1的概率，然后自己设置阈值。

你说的“最终结果”是指什么？是概率呢还是分类呢？

如果数据非常倾斜，有可能得到的分类标签都是0（因为概率都小于0.5），但是概率不可能都是0。

题主不熟悉输出的格式的话，可以看看网上的例子，比如SofaSofa上的教程标杆模型：交通事故理赔审核

里面用的就是

clf.predict_proba(test)[:, 1]

当数据很少的时候，就必须得充分利用数据了，所以更推荐用交叉验证。但是交叉验证只能用来估计误差，而不能用来调参，因为一旦用来调参就很容易过拟合。

另外k-fold交叉验证时，k不能选太大，对于小数据集而言，k取3或者4就足够了。

我们用xgboost或者random forest的时候，一般都说这些是黑箱模型，我们可以得到特征的重要性(feature importance之类的)，但是很难理解每个特征和目标值的关系；而线性模型就很好的解释性。

Partial Dependence就是用来解释某个特征和目标值y的关系的，一般是通过画出Partial Dependence Plot(PDP)来体现。

PDP是依赖于模型本身的，所以我们需要先训练模型（比如训练一个random forest模型）。假设我们想研究$y$和特征$X_1$的关系，那么PDP就是一个关于$X_1$和模型预测值的函数。我们先拟合了一个随机森林模型$\text{RF}(X)$，然后用$X_{i}^k$表示训练集中第$k$个样本的第$i$个特征，那么PDP的函数就是

$$f(X_1)=\frac{1}{n}\sum_{k=1}^n\text{RF}(X_1, X_{2}^k,X_{3}^k,\cdots,X_{n}^k)$$

也就是说PDP在$X_1$的值，就是把训练集中第一个变量换成$X_1$之后，原模型预测出来的平均值。

根据$X_1$的不同取值，$f(X_1)$就可以练成折线，这个折线就是Partial Dependence Plot，横轴是$X_1$，纵轴就是Partial Dependence。

下图就是一个例子

extrapolation（外推、外插）一般对应的是interpolation（内插、插值）。

在机器学习里来说，一个测试点如果是个孤立点，或者说一个测试点不在原训练集的定义域范围内，那么模型在这种测试点上的估计就是外推。

正如Zealing所说，线性回归在extrapolation上有良好性质，而诸如kNN和决策树，extrapolation的结果就不好，因为它的预测值不会超过原训练集的取值范围。

下图是几个例子

外插extrapolation是相对于内插interpolation而言的。内插字面意思指测试输入在训练输入的取值范围内。假设训练输入在0到2之间，若测试输入为1则是内插，为100则是外插。

外插只能用线性回归等基于模型拟合数据的方法，不能用knn等基于相邻数据的方法，因为外插没有或很少相邻数据。内插是两种都能用。

可以看下这篇文章 文章 图片是从里面拷出来的。

最好是多分类问题，因为你最后想知道的也是分类信息。而且每个年龄段数据的特性可能不一样，多个分类器才可学习出这些特性。用一个回归模型去拟合这些不同的特性，得到也是比较中庸的结果。比如说三条线段$x\in [0,1],y=1$,$x\in [1,2],y=2$,,$x\in [2,3],y=3$,如果分三段处理要简单点；如果用一条曲线去拟合（regression），曲线是非线性的，而且误差会很大。

唯一想到的问题是数据量是否足够去学习这些参数。数据量越多，分类器或回归模型参数估计的可信度越高。可以用置信区间区间来衡量。具体的置信区间公式我不清楚，印象中它宽度和$\frac{1}{\sqrt(n)}$成正比，大概需要50个点。

如果每年龄段的数据个数不多，学到的分类器参数误差很大，还不如合并数据变为一个回归问题。回归问题中要求输出值是线性的。你可以用年龄段的均值或中位数代表年龄段。比如0-9,10-19,20-29,...，你可以用[5,15,25,..]代表年龄段，除以5变为[1,3,5,...]；如果是0-9,10-24,25-29,...,可映射为[5,17.5,27.5,...],除以5最后可变为[1,3.5,5.5,...]。

如果你知道原始的年龄的数值，当然是用回归问题的处理方式更好。

如果你只知道年龄区间的话，那就当作多分类问题处理。

可以参考下这个问题：有序的分类变量的预测是回归问题还是多分类问题？

总体上说朴素贝叶斯是很快的。

1.  训练的过程很快。因为训练朴素贝叶斯就是计算一些概率，并不需要矩阵计算或者迭代优化。朴素贝叶斯甚至比线性回归还快。

2.  预测的过程很快。预测的过程就是做一系列的乘法，这个速度应该是和线性模型等价的。

----

补充一下，朴素贝叶斯占用的空间也不大，因为模型参数不多，这点是明显优于Random Forests和xgboost的

Adaboost做回归时误差率、权重系数如何选择：

先看看回归问题的误差率的问题，对于第$m$个弱学习器，计算他在训练集上的最大误差:

$$E_m=max\left | y_i-G_m(x_i) \right |\quad i=1,2,...,N$$

然后计算每个样本的相对误差:

$$e_{mi}=\frac{\left | y_i-G_m(x_i) \right |}{E_m}$$

这里是误差损失为线性时的情况，如果我们用平方误差，则

$$e_{mi}=\frac{\left ( y_i-G_m(x_i) \right )^2}{E_m^2}$$

最终得到第$m$个弱学习器的误差率:

$$e_m=\sum_{i=1}^Nw_{mi}e_{mi}$$

我们再来看看如何得到弱学习器权重系数 \alpha 。这里有：

$$\alpha_m=\frac{e_m}{1-e_m}$$

对于更新更新样本权重$D$，第$m+1$个弱学习器的样本集权重系数为:

$$w_{m+1,i}=\frac{w_{mi}}{Z_m}\alpha_m^{1-e_{mi}}$$

这里$Z_m$是规范化因子:

$$Z_m=\sum_{i=1}^{N}w_{mi}\alpha_m^{1-e_{mi}}$$

最后是结合策略，和分类问题稍有不同，采用的是对加权的弱学习器取中位数的方法，最终的强回归器为:

$$f(x)=\sum_{i=1}^{N}(ln\frac{1}{\alpha_m})g(x)$$

其中，$g(x)$是所有$\alpha_m G_m(x),m=1,2,....M$的中位数。

-------------------------------------------------

AdaBoost回归算法总结起来就是：

输入：训练数据集$T = \left\{ \left( x_{1}, y_{1} \right), \left( x_{2}, y_{2} \right), \cdots, \left( x_{N}, y_{N} \right) \right\}$，其中$x_{i} \in \mathcal{X} \subseteq R^{n}, y_{i} \in \mathcal{Y} = \left\{ +1, -1 \right\}, i = 1, 2, \cdots, N$

输出：回归器$G\left(x\right)$

1. 初始化训练数据的权值分布

$$D_{1}=\left(w_{11},w_{12},\cdots,w_{1N}\right), \quad w_{1i} = \dfrac{1}{N}, \quad i=1,2,\cdots,N$$

2. 对$m=1,2,\cdots,M$

    2.1 使用具有权值分布$D_{m}$的训练数据集学习，得到基本分类器$G_{m}\left(x\right)$

    2.2 计算训练集上的最大误差

$$E_m=max\left | y_i-G_m(x_i) \right |\quad i=1,2,...,N$$

    2.3 计算每个样本的相对误差（如果采用平方误差）:

$$e_{mi}=\frac{\left ( y_i-G_m(x_i) \right )^2}{E_m^2}$$

    2.4 计算回归误差率:

$$e_m=\sum_{i=1}^Nw_{mi}e_{mi}$$

    2.5 计算弱学习器的系数

$$\alpha_m=\frac{e_m}{1-e_m}$$

    2.6 更新样本集的权重分布为

$$w_{m+1,i}=\frac{w_{mi}}{Z_m}\alpha_m^{1-e_{mi}}$$

    其中， $Z_{m}$是规范化因子

$$Z_k=\sum_{i=1}^{N}w_{ki}\alpha_k^{1-e_{ki}}$$

3. 构建基本分类器的线性组合

$$f(x)=\sum_{m=1}^{M}(ln\frac{1}{\alpha_m})g(x)$$

其中，$g(x)$是所有$\alpha_mG_m(x),m=1,2,....M$的中位数。

参考来源：http://www.cnblogs.com/pinard/p/6133937.html

你截图里的$y_D$应该是观测值，$y$是真实值，具体的前后文不知道，我觉得应该是有观测误差，所以$y$和$y_D$不一定相等。

一般偏差是指总体的均值和预测的均值的差，假设$y_i$是真值，$\hat y_i$是预测值，偏差的式子为

$$\sum_{i=1}^n\frac{y_i-\hat y_i}{n}$$

你说的方差是

$$\sum_{i=1}^n\frac{(\hat y_i-\text{mean}(\hat y))^2}{n-1}$$

你用的是rpart么？

反欺诈是分类问题，所以你需要把y进行factor一下，然后再设置

method="class"

对，把某特征$X_1$扩大，并且惩罚系数$\lambda$不变，$X_1$的回归系数$w_1$更容易为0。

把一个特征扩大变相把回归系数缩小，$X_1'=100X_1$可得$w_1'=w_1/100$。而且正则项提供的让回归系数变为0的gradient是相等的，$\lambda sign(w_1)=\lambda sign(w_1')$。所以新回归系数$w_1'$更容易为0。

如果你觉得变量在Lasso之后仍然太多，你应该增大你的正则系数，让惩罚更大，而不是再重复一次Lasso。

其次你说“直到剩下的变量比较少为止”，这不是一个很科学的说法，变量的多少不是人为决定的，应该是通过对惩罚系数进行交叉验证调参得到的。

你可以看下Lasso path，它能够反映出惩罚系数和剩下的变量的个数。

它们两者区别不大，lightgbm不是太吃内存的，速度更快，你也提到了，更适合大数据吧

为什么lightgbm比xgb快？

跟楼主的经验一样，数据小的时候xgb好一点。

可以看这两篇论文

Confidence Intervals for the Area under the ROC Curve(Cortes and Mohri)

Confidence Intervals for the Area Under an ROC Curve(PASS)

roc的auc也是可以阐释为概率的（见这里）。所以就是相当于去估计一个硬币正面朝上的概率的置信区间。

用bootstrap的方法，选出$n$组正负样本，正样本的概率比负样本大的组数为$k$，那么roc auc的估计值为$k/n$，这个估计值的方差为

$$\frac{\text{auc}(1-\text{auc})}{n}=\frac{k/n(1-k/n)}{n}=\frac{kn-k^2}{n^3}$$

只要$n$够大，这个估计值应该是服从正态分布的，均值和方差都已知，也就能得到置信区间。

可以多跑几次validation，比如30次，然后求这30次auc的均值和方差，根据正态分布，得到置信区间。

周志华的机器学习前面部分就有。打开qq群流行的pdf看看，和朴素贝叶斯统计相关，和医院判断hiv阳性阴性概率的方法差不多，就是条件概率，打表就能算了~

相关系数是用来表示线性关系的，如果是线性模型，相关系数很小的变量的确不会显著；对于广义线性模型的话就不一定了；对于非线性模型，比如决策树，即使相关系数为0的变量，也可能很有用。

不可以简单是删除相关性小的变量哦。有两个原因

第一：看你选择的是什么相关性分析，皮尔森系数是线性的，斯皮尔曼等级是更通用的。如果你用皮尔森算出来很小，只能说明没有线性关系，有可能也很相关哦。

第二：例如房价和经纬度的关系，即使是用斯皮尔曼等级相关也会很小，但是经纬度却是很重要的信息

我觉得这样做不是太好

“多小算是小”这个问题很难决定

其次就是相关系数只是线性相关而已，非线性的怎么办？

有时候很多变量都相关性不高，但是它们一起作用可能效果明显，全都删掉明显就不好了

你说的是对的

$h_\theta$是模型，$\theta$是模型的参数

$h_\theta(x)$是模型在样本$x$上的预测值

$h_\theta(x)-y$是预测值和真实值的差

$J_\theta$可以表示模型参数为$\theta$时的损失函数，你的目标是找到最优的$\theta$让$J(\theta)$越小越好

在回归时$J_\theta$也可以表示为

$$J_\theta=\sum_{(x, y)\in S}(h_\theta (x) - y)^2=\sum_{(x,y)\in S}\text{Cost}(h_\theta (x), y)$$

platt's scaling本质上就是利用一个逻辑回归将SVM的输出值映射为概率。

因为SVM的输出值是样本和决策边界的距离而非概率，输出值大于0是正样本，输出值小于0是负样本。

platt's scaling就利用这个输出值作为样本的特征，再利用样本的标签，训练一个一维数据的逻辑回归。这个逻辑回归的最后输出的概率值就是platt's scaling后的预测概率。

假设第$i$个样本的特征为$X_i$，SVM的决策函数的输出结果为$f(X_i)$，那么platt's scaling之后预测这个样本为正的概率为

$$P(1|X_i)=\frac{1}{1+e^{af(X_i) + b}}$$

其中$a$和$b$是通过训练集训练得到的。

从神经网络的角度来说，platt scaling相当于在最外面加一个sigmoid输出层

先用lasso进行特征选择，再用lasso中系数不为零的特征再进行一次线性回归或者逻辑回归，这个就是post lasso。

post-lasso来源于这一篇论文Least squares after model selection in high-dimensional sparse models

文章里提到先训练一个LASSO回归，其目的是进行特征选择，保留系数不为零的特征。用这些特征再重新训练一个最小二乘回归。整个过程叫做post-lasso模型。

论文里也证明了post-lasso是优于lasso的，因为有较小的bias。

先用所有变量fit一个lasso模型，然后用lasso选出的变量再fit一个模型

是的，你说的没错，KS是用来判断两个连续分布的。

所以我们用KS来比较二元分类模型的时候，我们用的是模型的概率输出。类似于auc一下，我们不能直接用预测标签，而是用预测的概率。这样我们就有了两组连续数值：一组是真实值为+的预测概率值，一组是真实值为-的预测概率值，然后对两组预测值分别画出cdf，两个cdf的最大距离就是KS-score。

如果模型预测出来的结果完全线性可分，那么KS-score就是1。

上图的例子里，蓝色曲线是真实标签$y=0$的预测样本的输出概率的CDF，绿色曲线是真实标签$y=1$的预测样本的输出概率的CDF，红色是它们距离最远的点，这个距离就是这个分类模型的KS score。

感知机和SVM不等价。

参考https://www.zhihu.com/question/51500780中DeAlVe的回答。

带margin感知机目标函数是

Soft margin SVM目标函数是

可以看到SVM是带参数$w$的L2正则项的感知机，目的是让支持向量到分割超平面的几何距离最大，也就是maximum margin。

我自己理解是：当$||w||_2^2$减小或者margin$\frac{2}{||w||_2}$增大时，让有更多的$x_i$在第一项中得到非零值，从而得到更多的支持向量（support vector）。$w$是支持向量的加权和（见下面公式）。越多的支持向量让$w$更robust，减少过拟合。margin越小越可能过拟合。

其中$c_i$是SVM dual problem中的拉格朗日乘数，$c_i$大于0时，$x_i$为支持向量。

感知机的目标就是找到一个分割平面，使得尽量得区分正确

SVM的目标是找到一个分割平面，不仅区分正确，而且要让正负样本尽量远离这个分割平面

下图里面，$H_2$就是感知机的（不一定唯一），$H_3$就是SVM的。

先说结论：我觉得楼主问题中有个误解。用precision-recall的主要理由不是因为正负样本个数悬殊，而是因为应用更关心正样本的分类结果。

非平衡的数据一般来至于正样本明显小于负样本，且更关心正样本分类结果的应用。比如信用卡诈骗中，诈骗的交易数远小于正常交易数，并且主要关心是否能找出欺诈交易及其效率。

ROC里看TPR和FPR，精度-召回曲线看Precision 和recall，其中TPR=recall。那我们主要是比较FPR 和Precision。

TPR (True Positive Rate) =Recall = TP / (TP+FN)  

FPR (False Positive Rate) = FP / (FP+TN) 

Precision = TP/(TP+FP) 

以上三个指标（metric）都是$x/(x+y)$的形式，对分子$x$更敏感。也就是说TPR（Recall）只和正样本相关，FPR是只和负样本相关，Precision是偏向正样本的指标。所以precision-recall更适合于关心正样本的应用。ROC适合对正负分类结果都关心的应用。

假如有个应用是正样本个数远远小于负样本个数，且对正负样本的结果都关心。TP<<FP，所以precision接近于0，很难用precision去评价分类器好坏；而FP和TN可比，0<FPR<1。反而此时应该用ROC而不用precision-recall。

参考这里。

题主有兴趣可以看看这篇被引用了两千多次的论文：The Relationship Between Precision-Recall and ROC Curves.

论文里的一个关键句子是“when dealing with highly skewed datasets, Precision-Recall (PR) curves give a more informative picture of an algorithm’s performance.”

xgboost是和gdbt类似的，所有的树都是等权重的，权重就是learning rate

adaboost里的树权重是不一样的

boosting里的树都不是等权重，不然就是random forest了

对，Multinomial logistic regression wiki中：

但是在李航的《统计学习方法》中有点不同。

Multinomial logistic regression是：

maximum entropy是：

它们不同是（6.7）中$w_k$是$n$维向量，参数$w_{k,i}$的总数共有$nK$。而（6.22）中$w_i$总数只有$n$个，对于不同$y=k$,它们共享相同的参数，$w_{k,i}=w_i$。共享参数的原因是maximum entropy 中只有 $n$个限制条件。

如果改为$nK$个限制条件，比如 $E_{P(y=k)}(f_i)=E_{\tilde{P} (y=k)}(f_i)$，二者就一样了。

LASSO的正则项只在“数学”的0点才不可微。但因为有round-off error，“数值计算”中的0并不是数学上的0，而是(0-e,0+e)，e是浮点能表示的精度。在IEEE 754中有$+0,-0$两个浮点数表示0，分别代表（0,0+e）,(0-e,0)。所以当$x=+0/-0$时，$d(|x|_1)/d(x)=+1/-1$，并非不存在。把L1norm当做可微的就可以了。

你在本地可以做模型的交叉验证

或者把数据分割成训练集和验证集

很有意思的问题：

1. 这类最小二乘回归问题$argmin_w(|y-w^Tx|^2)$，所求问题是把$var(y)$所代表的$y$能量如何分布到协方差矩阵$Cov(x)=x^Tx$上。$y^Ty=x^Tww^Tx$，其中 $w_i^2$代表$var(x_i)$单独分到能量的比例，$2w_iw_j$代表因为colinear问题$cov(x_i,x_j)$共享能量的比例。举个极端的例子，$y=w_1x_1+w_2x_2$，如果$x_1=x_2$，$corr(x_1,x_2)=1$。$y$的能量分给$x_1$或$x_2$ 都一样。 那么 $w_1+w_2=1$都是合理的解。只有加上 $|w|_1$正则项，才可以保证得到$w=[1,0]或[0,1]$这样稀疏的解。换句话说，求稀疏解等于能量集中，把colinear引起的共享能量集中到一个变量$x_i$上，此时$|w_i|$增大，而$|w_j|$保持较小值。

2.原始的LARS得到稀疏解有三个原因：a)Forward,起始点是原点$w=[0,0,...]$,b)每次只求一个参数， c)boosting，每一步只分配残差的能量。如果$x_i$被选中，会尽量把能量分配给$x_i$,以后剩余在残差中的能量只有很少能分给$x_j$。因为$x_j$一直不能选中，$w_j=0$ ,从而得到稀疏解。

3.如果$w$起始点不是原点，就需要有机制让一部分$|w_j|$减小并停在0。所以Lasso_LARS改进，可以有任意的起始点。

原始LARS有点赢者通吃的想法。比如动物=[狼，猪，羊] , 食物=[肉，草]。如果先让狼去吃，第二个让猪吃草，羊就没有食物 ，此时得到解$[1,1,0]$。如果第二步让羊在猪之前去吃，猪就没食物，解为$[1,0,1]$。如果让猪在狼和羊前去吃，那么狼和羊都没有食物， 解为$[0,2,0]$。

查阅了一下，应当是使用修正后的LARS算法对LASSO问题进行求解，但是修正算法没怎么看懂，就是把LASSO问题的损失函数变化为一个类似于X*r=Y的形式的时候，Y其实是系数矩阵的1范数对系数矩阵中分量的求导，这个导数是不存在的，这里怎么进行处理呢?若是以次导数的思想来进行，那么每次推进的时候，Y是选-1，+1还是0呢

又看了一下，修改后的LARS算法就是将变出现系数变号的向量从解集当中剔除，但是有个问题，损失函数里面的正则化系数怎么在LARS中体现呢？

我的理解是，不是对每一个输入向量标准化，而是对每一个特征进行标准化

哦哦，感觉理解了，其实是应该是各个维度分别进行零均值标准化，一开始的理解有误

permutation importance是用来衡量特征的重要性的，不光是xgboost，对于很多模型有可以用，可以是分类也可以是回归。

步骤很简单：

    1. 在数据集A上训练一个xgboost模型

    2. 在数据集B上测试这个模型，得到MSE（回归）或者logloss（分类，或者auc）

    3. 对数据集B中的某一个特征中的值打乱（随机置换，random permute），再用模型进行预测，得到新的指标，这个指标在步骤2和3之间的差值，就是这个特征的重要性

显然差值越大，说明被打乱对模型预测能力影响越大，也是特征越重要。

你提到的permutation importance来自这篇文章Permutation importance: a corrected feature importance measure

Kaggle上有用lightgbm实现的版本：

https://www.kaggle.com/ogrellier/feature-selection-with-null-importances

https://www.kaggle.com/ogrellier/feature-selection-target-permutations

GBDT和XGB一般是使用logloss作为损失函数。

建树的过程就是寻找最佳分叉点和分叉特征的过程。GBDT是用mse作为分叉和建树的标准。

xgboost的损失函数可以参考这里。

用softmax映射成概率，之后一样用(y - y_pred)来算残差。

GBDT使用的是回归树，而XGBoost除了回归树还支持其它线性分类器。如果使用回归树，那么返回的值也是连续的，我知道的是可以设定阈值thres来分类，当然可以根据你所分的区间进行分类。

从工程地角度说，sklearn里的LASSO默认是用坐标下降法。官方文档看这里。我猜测是坐标下降更快。

但是sklearn也提供了基于最小角回归的实现。

你可以自己比较一下：sklearn.linear_model.Lasso和sklearn.linear_model.Lars

1.目标：

$w$对应的condition number可以作为正则化强度的测量，值越大说明正则化越弱。

2.方法：

如何得到$w$对应的condition number。

令数据矩阵$X$有SVD，$X=USV^T$。

带L2norm的OLS解：

$$w_{OLS-reg}=(X^TX+b)^{-1}XTy=V(S^{-2}+b)SU^Ty$$

带L2norm的Gradient Descent解：

$$w_{k}=(1-aX^TX-ab)w_{k-1}+aX^Ty=V(1-ab-aS^2)V^Tw_{k-1}+VaSU^Ty$$

 假设$w_0=0$,可把$w_{k-1}$分解到$X$的range space $w_{k-1}=Vz_{k-1}U^Ty$

有$w_{k}=V((1-ab-aS^2)z_{k-1}+aS)U^Ty$。

$z_{k}=(1-ab-aS^2)z_{k-1}+aS$

其中$a$为学习步长，$b$为L2norm的权重，当$b=0$时无正则项。

$condition number(w_k)=\frac{max(z_k)}{min(z_k)}$

3.实验：

做实验把OLS/GD，带/不带L2norm这四种情况的condition number，以及在range space上投影 $z_k$画出来

4.结论：

GD的condition number增大，并收敛于OLS。绿色收敛于紫色，蓝色收敛于红色。GD迭代过程可理解为有一个逐渐变弱正则化。当迭代无穷步时，正则化消失。越早early stopping，正则化越强。所以early stopping=正则化。

Regularization_wiki上有差不多的结论。

import numpy as np
import matplotlib.pyplot as plt
n=2000 # number of iterations
s=np.array([1.,1.E-3])*1. # singular values of X
a=0.01 # step size
b=.5   # L2 regularizer weight

c_OLS=s[0]/s[1]
c_OLS_reg=(s[1]/(s[1]**2+b))/(s[0]/(s[0]**2+b))

z=np.zeros([n,2])
c=np.zeros([n,1])
z_reg=np.zeros([n,2])
c_reg=np.zeros([n,1])

t1=1.-0*a-a*np.power(s,2)
t1_reg=1.-b*a-a*np.power(s,2)
t2=a*s
np.random.seed(0)
# z starts at the orginal point
z[0]=t2
z_reg[0]=t2
## z starts at a random point
# z[0]=np.random.rand(2)*1
# z_reg[0]=np.random.rand(2)*1

for i in range(1,n):
  z[i]=np.multiply(t1,z[i-1])+t2
  z_reg[i]=np.multiply(t1_reg,z_reg[i-1])+t2
  
for i in range(n):
  c[i]=z[i,1]/z[i,0]
  c_reg[i]=z_reg[i,1]/z_reg[i,0]
  
tt=np.arange(0,n)
tt1=np.ones([n,1])
plt.figure(figsize=[15,5])
plt.subplot(131)
plt.plot(c,'-o',label='GD no reg')    
plt.plot(c_reg,'-^',label='GD with reg')
plt.plot(tt,c_OLS*tt1,'-.',label='OLS no reg')
plt.plot(tt,c_OLS_reg*tt1,'--',label='OLS with reg')
plt.yscale('log')
plt.legend()
plt.title('Condition number')
plt.xlabel('Iteration')

plt.subplot(132)
plt.plot(z[:,0],'-o',label='GD no reg')      
plt.plot(z_reg[:,0],'-^',label='GD with reg')
plt.plot(tt,1/s[0]*tt1,'-.',label='OLS no reg')
plt.plot(tt,s[0]/(s[0]**2+b)*tt1,'--',label='OLS with reg')
plt.yscale('log')
plt.legend()
plt.title('z0')
plt.xlabel('Iteration')

plt.subplot(133)
plt.plot(z[:,1],'-o',label='GD no reg')     
plt.plot(z_reg[:,1],'-^',label='GD with reg')
plt.plot(tt,1/s[1]*tt1,'-.',label='OLS no reg')
plt.plot(tt,s[1]/(s[1]**2+b)*tt1,'--',label='OLS with reg')
plt.yscale('log')
plt.legend()
plt.title('z1')
plt.xlabel('Iteration')
plt.show()

笼统地讲，迭代的过程就是模型学习数据的过程，也是从欠拟合到过拟合的过程。所以及时停止迭代可以看作一种正则效果，防止模型过拟合。

当然会改变斜率的。

你可以就想想一维的情况：

$x\sim \mathcal N(3, 1^2)$，假设它们完美拟合回归公式为$y=2x+2$，那么$y \sim \mathcal N(8, 2^2)$

假如我们同时对$x$和$y$进行标准化，得到

$\hat x\sim \mathcal N(0, 1)$以及$\hat y\sim \mathcal N(0, 1)$，此时回归方程为$\hat y = \hat x$。不仅经过原点，而且斜率也变了。

（题主可以试着用$\LaTeX$，现在题目看起来有点累）

正则项只是防止过拟合，不能杜绝过拟合，因为在训练模型前预判过拟合也不是一件容易的事情。

xgboost中有多个变量可以防止过拟合，除了正则项，还有控制树的深度和叶子数，以及早停。

如果依旧过拟合，你可以考虑调整这些变量。这些变量在一种合适的搭配下合作才能有效阻止过拟合。但是最终判断是否过拟合还是需要用测试集或者交叉验证。

有正则项只是一定程度上减轻了过拟合的情况吧，肯定不可能过拟合完全不出现的

数据集里多多少少会有噪音，有噪音就会有过拟合的现象发生，只是程度大小而已。正则化本身并不能去除数据里的噪音。

正如其他人说的，要防止过拟合，你也需要对xgb模型中的超参进行调参。

防止过拟合并等价于阻止过拟合。相当于高速公路上的减速带，只能减速，并不能保证不撞车。

下面这个例子就是xgboost随着模型中树的个数增加，xgboost开始过拟合。

为什么我已经在运动了还是会肥呢？

我的理解是：

当损失函数为MAE的时候，梯度就只有3种可能，-1，0，+1。

我们用梯度作为训练样本，但是会重新用残差拟合一遍，所以每棵树拟合出来的结果依然是残差。

1.类似Gradient Descent（GD）， GBDT用 -gradient*step_size 逼近残差。负梯度正比于残差。其中step_size 可以是常数（原始GD），或二阶偏导的倒数（牛顿法），或用line search得到的当前最佳步长 。这里用L1norm Loss，二阶偏导为0，所以只能用常数或line search。参考这里。

2.对每个数据($x_i,y_i$)来说，$f_m(x_i)->-ag_i\in[-a,a]$，其中$a$是step size。

3.以固定step size a为例，对某棵树来说，当分类正确时，对最终输出$y_i$只贡献固定份额$a$，当分类错误时，也只惩罚固定份额$a$。比如$y_i=10，a=1$,起始点$y_i^0=0$，那么需要分类结果是$10+k$正确$k$错误才能拟合$y_i$。

另外一个回答里已经说了：1.计算量大；2.严重过拟合。

我们可以看下拉格朗日插值的原理。如果有$n$个样本点，$(x_1,y_1),(x_2,y_2),\cdots,(x_n,y_n)$，拉格朗日多项式的次数就是$n-1$，表达式为

$$y=a_0+a_1x+a_2x^2+a_3x^3+\cdots+a_{n-1}x^{n-1}$$

也就是$n$个样本点，我们需要拟合$n$个模型参数。所以不仅计算量大，同时也严重过拟合。

下面的红色的线就是拉格朗日插值的结果。

因为不好：

一是计算量大

二是严重过拟合

xgboost里实现早停是用了比较贪婪的简单做法。

首先，先划分好训练集和测试集；其次选定好测试的eval metric，比如回归的话就是rmse；如果训练过程中连续k轮boosting之后，测试eval metric没有变好，那么就进行早停。

k这个个数是自己设置的，在调用xgboost的时候，就是设置early_stopping_rounds。

KNN的思想是用目标点邻点的类别投票判断目标点的类别。如果K过大，即和它距离较远的不同类别的点就变成了邻点，偏差变大，准确率就低了。如果K过小，比如就选最近的一个点，容易被噪声和错误的样本干扰，就容易过拟合。

KNN有一个先验假设，物以类聚，人以群分。距离近的点有相似的分布，所以相近点的统计量也相近。

KNN有两步：

1.对一个测试点，找K个最临近的训练点作为一个聚类（cluster）的采样，得到统计量，比如均值、中位数、方差或分类标签等。

2.用得到的统计量表示这个测试点的统计量。

K太小，因为采样数太小，估计统计量的置信区间过大，偏差大，会过拟合。K太大，一个聚类中的训练点没有相同分布，所以聚类的统计量不能代表测试点的统计量，没有找到想要的统计量，会欠拟合。统计量的置信区间和相同分布是两个矛盾的条件。K应该选训练数据中聚类大小的平均值。

对于你的例子，如果K>60，用不是同类的点去计算分类标签，肯定会引入更多错误。

k越小，模型越容易过拟合；k越大，越容易欠拟合。

感谢各位前辈的解答。

小弟还有一个问题，我自己编写的程序和SKLEARN调用的程序，在相同K值、相同数据集的情况下，得到的分类准确率很多不一样，不知道什么原因，这个现象正常吗？

下图是对比曲线，请参考

参考一下这两个问题，应该对题主会很有帮助

k近邻算法(k-NN)怎么选k

k-NN的k取1会怎么样

我给SofaSofa投稿了一个教程，欢迎阅览。

用SHAP来理解Xgboost模型中的特征

我抛砖引玉下。

SHAP的概念是从Shapley value引申来的。Shapley value是博弈论里的一个概念，大概意思是说N个人共同协作，赚了M元，这M元该如何分配。每个人分配到的“钱”就是每个人的shapley value。

对于一个模型来说，我们需要理解和解释每个特征的作用，差不多就是想知道每个特征赚了多少“钱”。这里“钱”是指每个样本的预测值和整体均值之间的差。

在上面的那个图里，relationship这个特征的SHAP值从-2到2，说明这个特征对预测结果的推动大概在-2到2之间。当Relationship本身数值比较高的时候，通常起到正向作用。

Sigmoid是逻辑回归作为glm的link函数。之所以用它是因为：

1. 线性模型的输出都是在$[-\infty, +\infty]$之间的，而Sigmoid能够把它映射到$[0,1]$之间。正好这个是概率的范围。

2. Sigmoid是连续光滑的。

3. 根据Sigmoid函数，最后推导下来逻辑回归其实就是最大熵模型，根据最大似然估计得到的模型的损失函数就是logloss。这让整个逻辑回归都有理可据。

4. Sigmoid也让逻辑回归的损失函数成为凸函数，这也是很好的性质。

5. 逻辑回归的损失函数是二元分类的良好代理函数，这个也是Sigmoid的功劳。

至于为什么LR不用MSE，看这里。

Sigmoid就是有广义线性模型GLM推出来的。对于分类问题，GLM的基本思想是把输入$X$的线性组合($score_k(x)=\beta_kx$)通过逆link function映射到非线性的概率分布$P(Y=k|x)=P_k(x)=\Phi(\beta_kx)$。$\Phi$是link function的逆函数，有两种选择：一种是logistic function/Sigmoid，是取自然指数后再归一化， $P_k(x)=e^{\beta_kx}/Z$，得到logistic regression，残差是logistic分布；还有一种是正态分布的CDF，得到Probit model，残差是正态分布。

对于二元分类，$Z=e^{\beta_0x}+e^{\beta_1x}$,归一化后只有一组参数$\beta$是独立的：

$$P_1(x)=\frac{e^{\beta_1x}}{e^{\beta_1x}+e^{\beta_0x}}$$

$$=\frac{1}{1+e^{-(\beta_1-\beta_0)x}}$$

$$=\frac{1}{1+e^{-\beta x}}$$

Sigmoid就是softmax 在K=2的特例。

然后是假设数据点都服从独立的伯努利分布，建立似然函数，再用最大似然法求$\beta$，这些都和Sigmoid无关。

我自己补充一下吧 不知正确

是广义线性模型理论和伯努利分布推导出的函数形式和sigmoid函数相同。

具体可以看这个链接https://www.cnblogs.com/zhangyuhang3/p/6873339.html

但为啥推导出了h(x)函数形式,就要用这个形式，还没有理解。

因为交叉熵损失函数只和分类正确的预测结果有关。而平方损失函数还和错误的分类有关，该损失函数除了让正确分类尽量变大，还会让错误分类都变得更加平均，但实际中后面的这个调整使没必要的。但是对于回归问题这样的考虑就显得重要了，因而回归问题上使用交叉熵并不适合。

sigmoid函数输出0,1之间，训练好可模拟概率实现分类

>0.5判定为正例，反之为反例（也是新手，说说自己的理解）

导数好求

欢迎关注SofaSofa的面试题库哦，这个问题已经在卷44: 机器学习中收录了哦。

祝您面试顺利！

二项分布对应的就是sigmoid，多项分布对应的是softmax

逻辑回归本身的损失函数是logloss，可以用logloss作为评价标准。此外，凡是二元分类评价指标的在逻辑回归上都适用。

比如roc auc，召回精度曲线。如果把概率输出转换成标签化输出，那么还可以用精度、混淆矩阵、准确率、F1、Kappa等等。

sklearn里基本覆盖了所有常见的分类的评价标准，基本上在逻辑回归上都适用

https://scikit-learn.org/stable/modules/model_evaluation.html#classification-metrics

我的理解是：随机森林在训练每棵子树时，通过随机采样和随机抽特征的方式生成训练数据，避免生成太相似的树。差异性大的多课子树构成的随机森林，相当于增强了模型的多样性，也就导致其有较强的robust。所以关键点就是“随机”。

这个英文博客里解释了这个问题：Linear SVM good for text classification

这个博客里讲了很多都是经验总结，总体上有三个原因：

• 文本分类问题很多是基本上线性可分的
• 文本分类问题中特征很多，再用其他kernel升到更高维的空间也没有必要，也没帮助
• 线性核速度快，也没有太多超惨要调

因为随机森林的一些”随机点“XGBoost也有，比如说随机列采样、随机样本集，可以看这篇文章：从决策树到XGBoost。

xgboost和random forest类似的，都是基于决策树的。决策树在生成树的时候就会用到随机数，参见sklearn的手册https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html#sklearn.tree.DecisionTreeClassifier

“好像一般二元分类不用accuracy”并没有这个说法。二元分类只要是平衡的，或者说不是明显倾斜的情况，都可以用accuracy。

多元分类也是，如果每一类的个数差不多，或者比较均衡，当然也是可以用accuracy的。

accuracy 在分类问题中是必须考虑的，但同时可以考虑 macro-F1

kNN是有监督的，也就是我们需要知道样本的标签。比如下图中红色=正样本，蓝色=负样本。

我们看到红色的正样本中混进去了两个蓝色的负样本，如果用kNN做预测（如5-NN），那么这两个负样本x会被预测为正样本，与实际不符，所以这两个点就被认为是异常点。

--------------

kMeans做anomaly detection，参考这里。

KNN估计的标签和真实标签不同的点当作异常点（outlier)。比如说一堆红球中有个蓝球，对蓝球的KNN估计应该是红球，所以蓝球就是异常点。

因为有输入输出的配对，KNN是有监督的。

KNN是无监督学习，是聚类分析算法的一种。简单来说，就是对一堆数据做归类，彼此接近的归为一类。按照这个道理往下推，就是正常的数据一类，异常点为一类，这样就可以检测出异常点了。

logit和sigmoid是互为反函数的关系。逻辑回归里的sigmoid和深度学习里的sigmoid是一回事。

$$\text{logit}(x)=\log\frac{x}{1-x}$$

对上面的式子求反函数，得到

$$x=\frac{1}{1+e^{-\text{logit}(x)}}$$

这个就等价于sigmoid

$$\text{sigmoid}(x)=\frac{1}{1+e^{-x}}$$

本质上是因为逻辑回归可以写成

$$\text{logit}(p)=ax+b$$

或者

$$p=\text{sigmoid}(ax+b)$$

所以很明显，它们是互为反函数

logit和sigmoid是反函数的关系。画图就可以看出来了，因为它们关于$y=x$对称。

生成上面图像的代码如下：

import numpy as np

import matplotlib.pyplot as plt



def logit(x):

    return np.log(x/(1-x))



def sigmoid(x):

    return 1/(1+np.exp(-x))





x1 = np.linspace(0.001, 0.999, 10000)

y1 = logit(x1)



x2 = np.linspace(-7, 7, 100000)

y2 = sigmoid(x2)



plt.figure(figsize=(6, 6))

plt.axis('equal')

plt.plot(x1, y1, label='logit')

plt.plot(x2, y2, label='sigmoid')

plt.plot([-8, 8], [-8, 8], color='r', ls='--')

plt.legend()

plt.show()

根据平行超平面距离公式，$w*x-b_1=0$和$w*x-b_2=0$的距离是 $d=\frac{|b_1-b_2|}{\Vert w \Vert}$

代入$b_1=-b,b_2=-b+1$,$d=\frac{1}{\Vert w \Vert}$。

几何意义是超平面$w*x=b$在法向量$w$上的投影是常数$b$（因为所有$w *x$都等于$b$）,然后再把$w$单位化，除以$w$长度$\Vert w \Vert$。最终,$w*x=b$在其单位法向量$\frac{w}{\Vert w \Vert}$上的投影是常数$\frac{b}{\Vert w \Vert}$。对两条线有两个常数，所求距离就是两个常数之差。

$wb+1=0$和$wb=0$这两个平面平行，它们的法向量就是$w$，所以距离就是$1/\|w\|$。

决策树每一次分裂，都需要找到某个“最佳”特征，使得模型在该特征的某个值上分裂之后得到的收益最大化。

如果不设置max features的话，那么每次分裂都会遍历每一个可行特征，并从中选择最佳的；如果设置这个参数为n，那么每次分裂前只会选择n个随机特征，并从其中选择最佳的。

这个特征有利于增加random forest中各个树之间的差异性，有助于降低整个random forest的variance。