逻辑斯蒂回归分类算法[sklearn.linear_model/LogisticRegression/最大似然/梯度下降]

【关键词】Logistics函数，最大似然估计，梯度下降法

1、Logistics回归的原理

利用Logistics回归进行分类的主要思想是：根据现有数据对分类边界线建立回归公式，以此进行分类。这里的“回归” 一词源于最佳拟合，表示要找到最佳拟合参数集。

训练分类器时的做法就是寻找最佳拟合参数，使用的是最优化算法。接下来介绍这个二值型输出分类器的数学原理

Logistic Regression和Linear Regression的原理是相似的，可以简单的描述为这样的过程：

（1）找一个合适的预测函数，一般表示为h函数，该函数就是我们需要找的分类函数，它用来预测输入数据的判断结果。这个过程是非常关键的，需要对数据有一定的了解或分析，知道或者猜测预测函数的“大概”形式，比如是线性函数还是非线性函数。

（2）构造一个Cost函数（损失函数），该函数表示预测的输出（h）与训练数据类别（y）之间的偏差，可以是二者之间的差（h-y）或者是其他的形式。综合考虑所有训练数据的“损失”，将Cost求和或者求平均，记为J(θ)函数，表示所有训练数据预测值与实际类别的偏差。

（3）显然，J(θ)函数的值越小表示预测函数越准确（即h函数越准确），所以这一步需要做的是找到J(θ)函数的最小值。找函数的最小值有不同的方法，Logistic Regression实现时有梯度下降法（Gradient Descent）。

1) 构造预测函数

Logistic Regression虽然名字里带“回归”，但是它实际上是一种分类方法，用于两分类问题（即输出只有两种）。首先需要先找到一个预测函数（h），显然，该函数的输出必须是两类值（分别代表两个类别），所以利用了Logistic函数（或称为Sigmoid函数），函数形式为：

该函数形状为：

预测函数可以写为：

2）构造损失函数

Cost函数和J(θ)函数是基于最大似然估计推导得到的。

每个样本属于其真实标记的概率，即似然函数，可以写成：

所有样本都属于其真实标记的概率为

对数似然函数为

最大似然估计就是要求得使l(θ)取最大值时的θ，其实这里可以使用梯度上升法求解，求得的θ就是要求的最佳参数

3) 梯度下降法求J(θ)的最小值

求J(θ)的最小值可以使用梯度下降法，根据梯度下降法可得θ的更新过程:

式中为α学习步长，下面来求偏导：

上式求解过程中用到如下的公式：

因此，θ的更新过程可以写成:

因为式中α本来为一常量，所以1/m一般将省略，所以最终的θ更新过程为：

Type Markdown and LaTeX: α2α2

2、实战

参数：

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

solver参数的选择：

“liblinear”：小数量级的数据集
“lbfgs”, “sag” or “newton-cg”：大数量级的数据集以及多分类问题
“sag”：极大的数据集

LogisticRegression，一共有14个参数，参数说明：参考详细说明 ↓↓↓↓

penalty：惩罚项，str类型，可选参数为l1和l2，默认为l2。用于指定惩罚项中使用的规范。newton-cg、sag和lbfgs求解算法只支持L2规范。L1G规范假设的是模型的参数满足拉普拉斯分布，L2假设的模型参数满足高斯分布，所谓的范式就是加上对参数的约束，使得模型更不会过拟合(overfit)，但是如果要说是不是加了约束就会好，这个没有人能回答，只能说，加约束的情况下，理论上应该可以获得泛化能力更强的结果。
dual：对偶或原始方法，bool类型，默认为False。对偶方法只用在求解线性多核(liblinear)的L2惩罚项上。当样本数量>样本特征的时候，dual通常设置为False。
tol：停止求解的标准，float类型，默认为1e-4。就是求解到多少的时候，停止，认为已经求出最优解。
c：正则化系数λ的倒数，float类型，默认为1.0。必须是正浮点型数。像SVM一样，越小的数值表示越强的正则化。
fit_intercept：是否存在截距或偏差，bool类型，默认为True。
intercept_scaling：仅在正则化项为”liblinear”，且fit_intercept设置为True时有用。float类型，默认为1。
class_weight：用于标示分类模型中各种类型的权重，可以是一个字典或者’balanced’字符串，默认为不输入，也就是不考虑权重，即为None。如果选择输入的话，可以选择balanced让类库自己计算类型权重，或者自己输入各个类型的权重。举个例子，比如对于0,1的二元模型，我们可以定义class_weight={0:0.9,1:0.1}，这样类型0的权重为90%，而类型1的权重为10%。如果class_weight选择balanced，那么类库会根据训练样本量来计算权重。某种类型样本量越多，则权重越低，样本量越少，则权重越高。当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，让类库自动提高非法用户样本的权重。提高了某种分类的权重，相比不考虑权重，会有更多的样本分类划分到高权重的类别，从而可以解决上面两类问题。
random_state：随机数种子，int类型，可选参数，默认为无，仅在正则化优化算法为sag,liblinear时有用。
solver：优化算法选择参数，只有五个可选参数，即newton-cg,lbfgs,liblinear,sag,saga。默认为liblinear。solver参数决定了我们对逻辑回归损失函数的优化方法，有四种算法可以选择，分别是：
- liblinear：使用了开源的liblinear库实现，内部使用了坐标轴下降法来迭代优化损失函数。
- lbfgs：拟牛顿法的一种，利用损失函数二阶导数矩阵即海森矩阵来迭代优化损失函数。
- newton-cg：也是牛顿法家族的一种，利用损失函数二阶导数矩阵即海森矩阵来迭代优化损失函数。
- sag：即随机平均梯度下降，是梯度下降法的变种，和普通梯度下降法的区别是每次迭代仅仅用一部分的样本来计算梯度，适合于样本数据多的时候。
- saga：线性收敛的随机优化算法的的变重。
- 总结：
  - liblinear适用于小数据集，而sag和saga适用于大数据集因为速度更快。
  - 对于多分类问题，只有newton-cg,sag,saga和lbfgs能够处理多项损失，而liblinear受限于一对剩余(OvR)。啥意思，就是用liblinear的时候，如果是多分类问题，得先把一种类别作为一个类别，剩余的所有类别作为另外一个类别。一次类推，遍历所有类别，进行分类。
  - newton-cg,sag和lbfgs这三种优化算法时都需要损失函数的一阶或者二阶连续导数，因此不能用于没有连续导数的L1正则化，只能用于L2正则化。而liblinear和saga通吃L1正则化和L2正则化。
  - 同时，sag每次仅仅使用了部分样本进行梯度迭代，所以当样本量少的时候不要选择它，而如果样本量非常大，比如大于10万，sag是第一选择。但是sag不能用于L1正则化，所以当你有大量的样本，又需要L1正则化的话就要自己做取舍了。要么通过对样本采样来降低样本量，要么回到L2正则化。
  - 从上面的描述，大家可能觉得，既然newton-cg, lbfgs和sag这么多限制，如果不是大样本，我们选择liblinear不就行了嘛！错，因为liblinear也有自己的弱点！我们知道，逻辑回归有二元逻辑回归和多元逻辑回归。对于多元逻辑回归常见的有one-vs-rest(OvR)和many-vs-many(MvM)两种。而MvM一般比OvR分类相对准确一些。郁闷的是liblinear只支持OvR，不支持MvM，这样如果我们需要相对精确的多元逻辑回归时，就不能选择liblinear了。也意味着如果我们需要相对精确的多元逻辑回归不能使用L1正则化了。
max_iter：算法收敛最大迭代次数，int类型，默认为10。仅在正则化优化算法为newton-cg, sag和lbfgs才有用，算法收敛的最大迭代次数。
multi_class：分类方式选择参数，str类型，可选参数为ovr和multinomial，默认为ovr。ovr即前面提到的one-vs-rest(OvR)，而multinomial即前面提到的many-vs-many(MvM)。如果是二元逻辑回归，ovr和multinomial并没有任何区别，区别主要在多元逻辑回归上。
- OvR和MvM有什么不同*？*
  - 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了。
verbose：日志冗长度，int类型。默认为0。就是不输出训练过程，1的时候偶尔输出结果，大于1，对于每个子模型都输出。
warm_start：热启动参数，bool类型。默认为False。如果为True，则下一次训练是以追加树的形式进行（重新使用上一次的调用作为初始化）。
n_jobs：并行数。int类型，默认为1。1的时候，用CPU的一个内核运行程序，2的时候，用CPU的2个内核运行程序。为-1的时候，用所有CPU的内核运行程序。

总结：

优点：实现简单，易于理解和实现；计算代价不高，速度很快，存储资源低。
缺点：容易欠拟合，分类精度可能不高。
其他：
- Logistic回归的目的是寻找一个非线性函数Sigmoid的最佳拟合参数，求解过程可以由最优化算法完成。
- 改进的一些最优化算法，比如sag。它可以在新数据到来时就完成参数更新，而不需要重新读取整个数据集来进行批量处理。
- 机器学习的一个重要问题就是如何处理缺失数据。这个问题没有标准答案，取决于实际应用中的需求。现有一些解决方案，每种方案都各有优缺点。
- 我们需要根据数据的情况，这是Sklearn的参数，以期达到更好的分类效果。

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

1) 手写数字数据集的分类

使用KNN与Logistic回归两种方法

导包：

from sklearn.neighbors import KNeighborsClassifier

from sklearn.linear_model import LogisticRegression

import sklearn.datasets as datasets
from sklearn.model_selection import train_test_split

创建数据集：

iris = datasets.load_iris()

X = iris['data']
y = iris['target']

X.shape
Out: (150,4)


X_train,X_test,y_train,y_test = train_test_split(X,y,test_size = 0.1)
X_test.shape
Out: (15,4)

创建模型，训练和预测

①knn

knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train,y_train)

# 评估
knn.score(X_test,y_test)
Out： 1.0

# 算法，新数据
knn.score(X_train,y_train)
Out：0.9703703703703703

knn.score(X,y)
Out：0.9666666666666667

②logistics

logistic = LogisticRegression()

# 学习
logistic.fit(X_train,y_train)

logistic.score(X_test,y_test)
Out：1.0

# 算法，运算
logistic.score(X_train,y_train)
Out：0.9703703703703703

logistic.score(X,y)
Out：0.96
'''一招逻辑斯蒂打天下'''

y_ = logistic.predict(X_test)
display(y_test,y_)
Out:
array([1, 1, 1, 2, 0, 0, 2, 1, 1, 1, 2, 0, 0, 0, 2])
array([1, 1, 1, 2, 0, 0, 2, 2, 1, 2, 2, 0, 0, 0, 2])

验证出手算样本概率准确率较低

# 鸢尾花3分类
y
Out :
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])

''' 
鸢尾花的属性4个所以：求得的线性回归的数据系数4
3行 鸢尾花分成了3类：0,1,2 
'''
coef_ = logistic.coef_
coef_
Out:
array([[ 0.38587596,  1.43118091, -2.20018994, -0.99472477],
       [ 0.44170356, -1.51578807,  0.5087426 , -1.28678969],
       [-1.65593131, -1.57118279,  2.41128425,  2.4580315 ]])

logistic.intercept_
Out:
array([ 0.25119738,  0.98252054, -1.06417625])

z1 = np.dot(X_test[1],coef_[0]) + logistic.intercept_[0]
z2 = np.dot(X_test[1],coef_[1]) + logistic.intercept_[1]
z3 = np.dot(X_test[1],coef_[2]) + logistic.intercept_[2]

p1 = 1/(1 + np.e**-z1) 
p1
Out: 0.026307743509197783

p2 = 1/(1 + np.e**-z2) 
p2
Out: 0.5276282740359096

p3 = 1/(1 + np.e**-z3) 
p3
Out: 0.1104520286545805

y_proba_ = logistic.predict_proba(X_test)
# 每一类（0,1,2）代表着属于真实值的概率
y_proba_
Out:
array([[6.27212078e-02, 8.03917363e-01, 1.33361429e-01],
       [3.95969549e-02, 7.94156784e-01, 1.66246261e-01],
       [2.13879880e-02, 7.29729879e-01, 2.48882133e-01],
       [8.08742006e-04, 3.33471948e-01, 6.65719310e-01],
       [8.34217842e-01, 1.65683268e-01, 9.88907075e-05],
       [8.18934236e-01, 1.80985882e-01, 7.98825637e-05],
       [2.44679646e-03, 2.65004499e-01, 7.32548704e-01],
       [4.51933705e-02, 4.26488524e-01, 5.28318106e-01],
       [4.28481928e-02, 8.34261996e-01, 1.22889811e-01],
       [1.17617015e-02, 3.32177684e-01, 6.56060614e-01],
       [2.04906038e-04, 4.32615723e-01, 5.67179371e-01],
       [8.70778305e-01, 1.29143433e-01, 7.82620023e-05],
       [9.14259009e-01, 8.57188187e-02, 2.21724636e-05],
       [8.66382774e-01, 1.33609493e-01, 7.73260487e-06],
       [8.32789306e-04, 2.96653463e-01, 7.02513748e-01]])

y_proba_.argmax(axis = 1)
Out:
array([1, 1, 1, 2, 0, 0, 2, 2, 1, 2, 2, 0, 0, 0, 2], dtype=int64)

logistic.predict(X_test)
Out:
array([0, 2, 1, 0, 0, 2, 0, 0, 2, 2, 0, 1, 0, 2, 1])

y_test
Out:
array([0, 2, 1, 0, 0, 2, 0, 0, 2, 2, 0, 1, 0, 2, 1])