逻辑回归（Logistic Regression）

喜欢ヅ旅行 2022-01-31 03:47 308阅读 0赞

## 一. 逻辑回归 ##

在前面讲述的回归模型中，处理的因变量都是数值型区间变量，建立的模型描述是因变量的期望与自变量之间的线性关系。比如常见的线性回归模型：

![20170910104143876][]

而在采用回归模型分析实际问题中，所研究的变量往往不全是区间变量而是顺序变量或属性变量，比如二项分布问题。通过分析年龄、性别、体质指数、平均血压、疾病指数等指标，判断一个人是否换糖尿病，Y=0表示未患病，Y=1表示患病，这里的响应变量是一个两点（0-1）分布变量，它就不能用h函数连续的值来预测因变量Y（只能取0或1）。  
总之，线性回归模型通常是处理因变量是连续变量的问题，如果因变量是定性变量，线性回归模型就不再适用了，需采用逻辑回归模型解决。

逻辑回归（Logistic Regression**）**是用于处理因变量为分类变量的回归问题，常见的是二分类或二项分布问题，也可以处理多分类问题，它实际上是属于一种分类方法。  
二分类问题的概率与自变量之间的关系图形往往是一个S型曲线，如图所示，采用的Sigmoid函数实现。

![20170910104311138][]

PS:如果你觉得这篇文章看起来稍微还有些吃力，或者想要系统地学习人工智能，那么推荐你去看床长人工智能教程。非常棒的大神之作。教程不仅通俗易懂，而且很风趣幽默。点击[这里][Link 1]可以查看教程。

这里我们将该函数定义如下：

![20170910104422843][]

函数的定义域为全体实数，值域在\[0,1\]之间，x轴在0点对应的结果为0.5。当x取值足够大的时候，可以看成0或1两类问题，大于0.5可以认为是1类问题，反之是0类问题，而刚好是0.5，则可以划分至0类或1类。对于0-1型变量，y=1的概率分布公式定义如下：

![20170910104659287][]

y=0的概率分布公式定义如下：

![20170910104722704][]

其离散型随机变量期望值公式如下：

![20170910104818902][]

采用线性模型进行分析，其公式变换如下：

![20170910104904006][]

而实际应用中，概率p与因变量往往是非线性的，为了解决该类问题，我们引入了logit变换，使得logit(p)与自变量之  
间存在线性相关的关系，逻辑回归模型定义如下：

![20170910104945540][]

通过推导，概率p变换如下，这与Sigmoid函数相符，也体现了概率p与因变量之间的非线性关系。以0.5为界限，预

测p大于0.5时，我们判断此时y更可能为1，否则y为0。

![20170910105019958][]

得到所需的Sigmoid函数后，接下来只需要和前面的线性回归一样，拟合出该式中n个参数θ即可。test17\_05.py为绘

制Sigmoid曲线，输出上图所示。

import matplotlib.pyplot 
          
           as plt
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
          
           import numpy 
          
           as np
         
          
        
         
        
        
         
         
          
        
         
        
         
         
           
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
          
           def Sigmoid(x):
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
              
          
           return 
          
           1.0 / (
          
           1.0 + np.exp(-x))
         
          
        
         
        
        
         
         
          
        
         
        
         
         
           
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
          x= np.arange(
          
           -10, 
          
           10, 
          
           0.1)
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
          h = Sigmoid(x)            
          
           #Sigmoid函数
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
          plt.plot(x, h)
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
          plt.axvline(
          
           0.0, color=
          
           'k')   
          
           #坐标轴上加一条竖直的线（0位置）
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
          plt.axhspan(
          
           0.0, 
          
           1.0, facecolor=
          
           '1.0', alpha=
          
           1.0, ls=
          
           'dotted')  
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
          plt.axhline(y=
          
           0.5, ls=
          
           'dotted', color=
          
           'k') 
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
          plt.yticks([
          
           0.0, 
          
           0.5, 
          
           1.0])  
          
           #y轴标度
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
          plt.ylim(
          
           -0.1, 
          
           1.1)       
          
           #y轴范围
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
          plt.show()  
         
          
        
         
       
      
       
      
       
        1

## 二. LogisticRegression回归算法 ##

LogisticRegression回归模型在Sklearn.linear\_model子类下，调用sklearn逻辑回归算法步骤比较简单，即：

(1) 导入模型。调用逻辑回归LogisticRegression()函数。

(2) fit()训练。调用fit(x,y)的方法来训练模型，其中x为数据的属性，y为所属类型。

(3) predict()预测。利用训练得到的模型对数据集进行预测，返回预测结果。

代码如下：

from sklearn.linear_model 
           
            import LogisticRegression  
           
            #导入逻辑回归模型 
          
           
         
          
         
         
          
          
           
         
          
         
          
          
           
            
           clf = LogisticRegression()
          
           
         
          
         
         
          
          
           
         
          
         
          
          
           
           
            print clf
          
           
         
          
         
         
          
          
           
         
          
         
          
          
           
            
           clf.fit(train_feature,label)
          
           
         
          
         
         
          
          
           
         
          
         
          
          
           
            
           predict[
           
            'label'] = clf.predict(predict_feature)
          
           
         
          
        
       
        
       
        
         1

输出结果如下：

LogisticRegression(C=
           
            1.0, class_weight=
           
            None, dual=
           
            False, fit_intercept=
           
            True,
          
           
         
          
         
         
          
          
           
         
          
         
          
          
           
            
                     intercept_scaling=
           
            1, max_iter=
           
            100, multi_class=
           
            'ovr', n_jobs=
           
            1,
          
           
         
          
         
         
          
          
           
         
          
         
          
          
           
            
                     penalty=
           
            'l2', random_state=
           
            None, solver=
           
            'liblinear', tol=
           
            0.0001,
          
           
         
          
         
         
          
          
           
         
          
         
          
          
           
            
                     verbose=
           
            0, warm_start=
           
            False)
          
           
         
          
        
       
        
       
        
         1

其中，参数 penalty 表示惩罚项（ L1 、 L2 值可选。 L1 向量中各元素绝对值的和，作用是产生少量的特征，而其他特征

都是0，常用于特征选择；L2向量中各个元素平方之和再开根号，作用是选择较多的特征，使他们都趋近于0。）； C

值的目标函数约束条件：s.t.||w||1<C，默认值是0，C值越小，则正则化强度越大。

# 2. 正则化选择参数：penalty #

LogisticRegression和LogisticRegressionCV默认就带了正则化项。penalty参数可选择的值为"l1"和"l2".分别对应L1的正则化和L2的正则化，默认是L2的正则化。

在调参时如果我们主要的目的只是为了解决过拟合，一般penalty选择L2正则化就够了。但是如果选择L2正则化发现还是过拟合，即预测效果差的时候，就可以考虑L1正则化。另外，如果模型的特征非常多，我们希望一些不重要的特征系数归零，从而让模型系数稀疏化的话，也可以使用L1正则化。

penalty参数的选择会影响我们损失函数优化算法的选择。即参数solver的选择，如果是L2正则化，那么4种可选的算法\{‘newton-cg’, ‘lbfgs’, ‘liblinear’, ‘sag’\}都可以选择。但是如果penalty是L1正则化的话，就只能选择‘liblinear’了。这是因为L1正则化的损失函数不是连续可导的，而\{‘newton-cg’, ‘lbfgs’,‘sag’\}这三种优化算法时都需要损失函数的一阶或者二阶连续导数。而‘liblinear’并没有这个依赖。

3. 优化算法选择参数：solver

solver参数决定了我们对逻辑回归损失函数的优化方法，有4种算法可以选择，分别是：

a) liblinear：使用了开源的liblinear库实现，内部使用了坐标轴下降法来迭代优化损失函数。

b) lbfgs：拟牛顿法的一种，利用损失函数二阶导数矩阵即海森矩阵来迭代优化损失函数。

c) newton-cg：也是牛顿法家族的一种，利用损失函数二阶导数矩阵即海森矩阵来迭代优化损失函数。

d) sag：即随机平均梯度下降，是梯度下降法的变种，和普通梯度下降法的区别是每次迭代仅仅用一部分的样本来计算梯度，适合于样本数据多的时候，SAG是一种线性收敛算法，这个速度远比SGD快。关于SAG的理解，参考博文[线性收敛的随机优化算法之 SAG、SVRG（随机梯度下降）][SAG_SVRG]

从上面的描述可以看出，newton-cg, lbfgs和sag这三种优化算法时都需要损失函数的一阶或者二阶连续导数，因此不能用于没有连续导数的L1正则化，只能用于L2正则化。而liblinear通吃L1正则化和L2正则化。

同时，sag每次仅仅使用了部分样本进行梯度迭代，所以当样本量少的时候不要选择它，而如果样本量非常大，比如大于10万，sag是第一选择。但是sag不能用于L1正则化，所以当你有大量的样本，又需要L1正则化的话就要自己做取舍了。要么通过对样本采样来降低样本量，要么回到L2正则化。

在sklearn的官方文档中，对于solver的使用说明如下：

In a nutshell, one may choose the solver with the following rules:

<table>     
 <thead> 
  <tr> 
   <th>Case</th> 
   <th>Solver</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Small dataset or L1 penalty</td> 
   <td>“liblinear”</td> 
  </tr> 
  <tr> 
   <td>Multinomial loss or large dataset</td> 
   <td>“lbfgs”, “sag” or “newton-cg”</td> 
  </tr> 
  <tr> 
   <td>Very Large dataset</td> 
   <td>“sag”<br><br></td> 
  </tr> 
 </tbody> 
</table>

从上面的描述，大家可能觉得，既然newton-cg, lbfgs和sag这么多限制，如果不是大样本，我们选择liblinear不就行了嘛！错，因为liblinear也有自己的弱点！我们知道，逻辑回归有二元逻辑回归和多元逻辑回归。对于多元逻辑回归常见的有one-vs-rest(OvR)和many-vs-many(MvM)两种。而MvM一般比OvR分类相对准确一些。郁闷的是liblinear只支持OvR，不支持MvM，这样如果我们需要相对精确的多元逻辑回归时，就不能选择liblinear了。也意味着如果我们需要相对精确的多元逻辑回归不能使用L1正则化了。

总结而言，liblinear支持L1和L2，只支持OvR做多分类，“lbfgs”, “sag” “newton-cg”只支持L2，支持OvR和MvM做多分类。

具体OvR和MvM有什么不同我们下一节讲。

# 4. 分类方式选择参数：multi\_class #

multi\_class参数决定了我们分类方式的选择，有 ovr和multinomial两个值可以选择，默认是 ovr。

ovr即前面提到的one-vs-rest(OvR)，而multinomial即前面提到的many-vs-many(MvM)。如果是二元逻辑回归，ovr和multinomial并没有任何区别，区别主要在多元逻辑回归上。

OvR的思想很简单，无论你是多少元逻辑回归，我们都可以看做二元逻辑回归。具体做法是，对于第K类的分类决策，我们把所有第K类的样本作为正例，除了第K类样本以外的所有样本都作为负例，然后在上面做二元逻辑回归，得到第K类的分类模型。其他类的分类模型获得以此类推。

而MvM则相对复杂，这里举MvM的特例one-vs-one(OvO)作讲解。如果模型有T类，我们每次在所有的T类样本里面选择两类样本出来，不妨记为T1类和T2类，把所有的输出为T1和T2的样本放在一起，把T1作为正例，T2作为负例，进行二元逻辑回归，得到模型参数。我们一共需要T(T-1)/2次分类。

从上面的描述可以看出OvR相对简单，但分类效果相对略差（这里指大多数样本分布情况，某些样本分布下OvR可能更好）。而MvM分类相对精确，但是分类速度没有OvR快。

如果选择了ovr，则4种损失函数的优化方法liblinear，newton-cg, lbfgs和sag都可以选择。但是如果选择了multinomial,则只能选择newton-cg, lbfgs和sag了。

# 5. 类型权重参数： class\_weight #

class\_weight参数用于标示分类模型中各种类型的权重，可以不输入，即不考虑权重，或者说所有类型的权重一样。如果选择输入的话，可以选择balanced让类库自己计算类型权重，或者我们自己输入各个类型的权重，比如对于0,1的二元模型，我们可以定义class\_weight=\{0:0.9, 1:0.1\}，这样类型0的权重为90%，而类型1的权重为10%。

如果class\_weight选择balanced，那么类库会根据训练样本量来计算权重。某种类型样本量越多，则权重越低，样本量越少，则权重越高。

sklearn的官方文档中，当class\_weight为balanced时，类权重计算方法如下：

n\_samples / (n\_classes \* np.bincount(y))，n\_samples为样本数，n\_classes为类别数量，np.bincount(y)会输出每个类的样本数，例如y=\[1,0,0,1,1\],则np.bincount(y)=\[2,3\]

那么class\_weight有什么作用呢？在分类模型中，我们经常会遇到两类问题：

第一种是误分类的代价很高。比如对合法用户和非法用户进行分类，将非法用户分类为合法用户的代价很高，我们宁愿将合法用户分类为非法用户，这时可以人工再甄别，但是却不愿将非法用户分类为合法用户。这时，我们可以适当提高非法用户的权重。

第二种是样本是高度失衡的，比如我们有合法用户和非法用户的二元样本数据10000条，里面合法用户有9995条，非法用户只有5条，如果我们不考虑权重，则我们可以将所有的测试集都预测为合法用户，这样预测准确率理论上有99.95%，但是却没有任何意义。这时，我们可以选择balanced，让类库自动提高非法用户样本的权重。

提高了某种分类的权重，相比不考虑权重，会有更多的样本分类划分到高权重的类别，从而可以解决上面两类问题。

当然，对于第二种样本失衡的情况，我们还可以考虑用下一节讲到的样本权重参数： sample\_weight，而不使用class\_weight。sample\_weight在下一节讲。

# 6. 样本权重参数： sample\_weight #

上一节我们提到了样本不失衡的问题，由于样本不平衡，导致样本不是总体样本的无偏估计，从而可能导致我们的模型预测能力下降。遇到这种情况，我们可以通过调节样本权重来尝试解决这个问题。调节样本权重的方法有两种，第一种是在class\_weight使用balanced。第二种是在调用fit函数时，通过sample\_weight来自己调节每个样本权重。

在scikit-learn做逻辑回归时，如果上面两种方法都用到了，那么样本的真正权重是class\_weight\*sample\_weight.

以上就是scikit-learn中逻辑回归类库调参的一个小结，还有些参数比如正则化参数C（交叉验证就是 Cs），迭代次数max\_iter等，由于和其它的算法类库并没有特别不同，这里不多累述了。

[20170910104143876]: /images/20220131/b84556fbb9e243108f195af2c7f12d20.png
[20170910104311138]: /images/20220131/6b3e9e9fd6ec4c4f9450160d0522c3f0.png
[Link 1]: http://www.captainbed.net/csdn
[20170910104422843]: /images/20220131/b2facf4870a54ce583a4ebdf1826c8da.png
[20170910104659287]: /images/20220131/80cdf8a75c9f4d8b8cf4e7c1478f1cca.png
[20170910104722704]: /images/20220131/9199d4822f9347adbd0ec1d64e50003f.png
[20170910104818902]: /images/20220131/b64c1ff450344231adc2702b308a364e.png
[20170910104904006]: /images/20220131/4ca45580ecac48a1aa7d6da3cc5e9862.png
[20170910104945540]: /images/20220131/2dc6de828a5d4fedb2451aa9badde669.png
[20170910105019958]: /images/20220131/1e610a1cc6104fbe874377701b4db0fc.png
[SAG_SVRG]: http://blog.csdn.net/sun_shengyun/article/details/53811882