机器学习---逻辑回归总结(概念总结，手推公式，python代码实现)

1. 概念及公式推导

1.1 逻辑回归总述

逻辑回归学习算法，适用于二分类——y的输出值为0或1的问题。比如输入一张图片，输出这张图片上的动物是或不是猫。算法能够输出预测值$\hat{y}$ ，可以称之为对实际值y的估计。或者说在输入了$n_x$维度的X后，输出的$\hat{y}$是表示y=1的可能性大小，即$\hat{y}=P\left(y=1|x\right)$。在线性回归中，$\hat{y}={\omega }^{T}x+b$（w是特征权重，b是偏差）是训练出一个较好的w和b值，用于拟合真实的输出值y，但在逻辑回归中，y的预测值$\hat{y}$由于表示的是概率P，值分布在0和1之间，而$\hat{y}={\omega }^{T}x+b$得出的$\hat{y}$值属于实数集R，对于想要的在0和1之间的概率来说它是没有意义的。所以需要找到一个函数，能将$\hat{y}$映射到0和1之间。

1.2 为何选用sigmoid函数

需要找到一个函数，将线性回归模型的实数值转换为[0,1]之间的输出结果，即输入$z=f\left(x\right)=w^{T}x+b\in R$，经过这个函数输出$\hat{y}\in \left(0,1\right)$。由广义的线性模型可知，可以找到一个输出$\hat{y}\in \left(0,1\right)$的函数，若预测值z大于0判为正例，小于0 判为反例，若处于临界值则可任意判别。可知阶跃函数符合这个性质：
$$y=\{\begin{array}{l}0,z<0;\\ 0.5,z=0;\\ 1,z>0,\end{array}$$
但是可以看出，阶跃函数是不连续的，不利于后续w,b值的训练，所以找到了sigmoid函数，又称对数几率函数，输入$z=w^{T}x+b$，输出$g\left(z\right)=\frac{1}{1+e^{-z}}$，将z值映射到[0,1]之间，用python画出sigmoid函数图像如下：

import numpy as np
import matplotlib.pyplot as plt
def sigmoid(z):
    return 1/(1+np.exp(-z))

x=np.linspace(-10,10,1000)
y=sigmoid(x)
plt.plot(x,y)
plt.show()

由函数图像可知，输出值在0到1之间，符合条件。可以看出

$z=0$ 时 $g(z)=0.5$

$z>0$ 时 $g(z)>0.5$

$z<0$ 时 $g(z)<0.5$
我们认为当$g\left(z\right)>0.5$时，输出值为1，判断为正例；当$g\left(z\right)<0.5$时，输出值为0，判断为反例；当$g\left(z\right)=0.5$时任意判别。
由函数的表达式容易分析出：

1. z趋近正无穷时，$e^{-z}$趋近于0，g(z)趋近于1，判断正例；
2. z=0时，$e^{-z}$=1，g(z)=0.5，任意判别;
3. z趋近于负无穷时，$e^{-z}$趋近于正无穷，g(z)趋近于0，判断反例；

1.3 损失函数

1.3.1 为何不使用均方误差作为损失函数

前面已经了解了逻辑回归的样子，下一步需要做的是训练出w和b值，需要一个损失函数（代价函数）。损失函数顾名思义，代表预测值离真实值差异大小，差异越大，损失也越多，所以为了降低差异，需要最小化损失函数。在线性回归中，损失函数为预测值和真实值的均方误差，利用最小化均方误差进行训练，即求解$w,b:{\min }_{w,b}{E}_{\left(w,b\right)}={\Sigma }_{i=1}^m{\left(y_i-w{x}_i-b\right)}^2$。但是当在学习逻辑回归参数的时候，会发现我们的优化目标不是凸优化，梯度下降方法只能找到多个局部最优值，而找不到全局最优值，所以虽然均方误差确实是一种不错的损失函数，但不适合逻辑回归。
凸函数，可以找到全局最优值：

非凸函数，只能找到局部最优值：

1.3.2 单个训练样本的损失函数推导

回想一下，在逻辑回归中，我们约定$\hat{y}=p\left(y=1|x\right)$。即如果y=1，在给定训练样本x的条件下$y=\hat{y}$；反过来说，如果y = 0，在给定训练样本x条件下y等于1减去$\hat{y}$，$y=1-\hat{y}$，因此，如果$\hat{y}$代表y=1的概率，那么$1-\hat{y}$就是y=0的概率。接下来，分析这两个概率公式：
$IFy=1:p\left(y|x\right)=\hat{y}$
$IFy=0:p\left(y|x\right)=1-\hat{y}$
这两个公式代表了y=0和y=1时的情况，需要注意我们仅讨论二分类问题的损失函数，因此y的取值只是0或者1，所以可以将上述两个概率公式合并成如下公式：
$$p\left(y|x\right)={\hat{y}}^y{\left(1-\hat{y}\right)}^{1-y}$$
看合并成这种表达形式是否可以呢，分别判断y=0和y=1时是否符合上面两个概率公式，将y=0和y=1带入，容易得出是符合的。所以这样就得出了$p\left(y|x\right)$的完整定义。由于$p\left(y|x\right)$表示的是概率，在训练学习算法时需要输出值的概率当然是越大越好，即最大化$p\left(y|x\right)$。因为log函数是严格单调递增的函数，最大化$p\left(y|x\right)$就是最大化$\log \left(p\left(y|x\right)\right)$，即计算$\log \left({\hat{y}}^y{\left(1-\hat{y}\right)}^{1-y}\right)$，通过对数函数化简为：$$y\log \hat{y}+\left(1-y\right)\log \left(1-\hat{y}\right)$$
其中y为真实值，$\hat{y}$为预测值。将上述函数取负号，得到逻辑回归的损失函数：$$L\left(\hat{y},y\right)=-\left(y\log \hat{y}+\left(1-y\right)\log \left(1-\hat{y}\right)\right)$$
由于取了负号，所以需要最小化损失函数，即最小化$L\left(\hat{y},y\right)$。我们通过这个称为 L 的损失函数，来衡量预测输出值和实际值有多接近。

1.4 m个样本的损失函数

上面我们已经求到了单个训练样本的损失函数表达式，但逻辑回归是很多样本放在一起训练，如何求m个样本的损失函数(代价函数)呢?对比于线性回归，在线性回归中，当有m个样本存在时，我们用的损失函数为：$$J_{\left(\theta \right)}=\frac{1}{m}\underset{i=1}{\stackrel{m}{\Sigma }}\frac{1}{2}{\left(h_{\theta }\left(x^{\left(i\right)}\right)-y^{\left(i\right)}\right)}^2$$
其中h(x)为预测值，也就是$\hat{y}$，可以看出是每个样本预测值和真实值之差的平方的平均值。为了对比方便，我们直接给出逻辑回归中的损失函数为：$$J_{\left(\theta \right)}=-\frac{1}{m}\underset{i=1}{\stackrel{m}{\Sigma }}\left[y^{\left(i\right)}\log h_{\theta }\left(x^{\left(i\right)}\right)+\left(1-y^{\left(i\right)}\right)\log \left(1-h_{\theta }\left(x^{\left(i\right)}\right)\right)\right]$$
不难发现，其实就是上述单个样本的损失函数的累加之后除以m，即为m个损失函数的平均值。
那么为什么可以用到均值来表示总体的损失函数呢？推导过程中用到了似然函数的概念，参考《概率论与数理统计》（第四版）.高等教育出版社

1.4.1 似然函数

理解，对于0-1分布的似然函数
0-1分布的分布律为$$P\left\{X=k\right\}=p^k{\left(1-p\right)}^{1-k},k=0,1\left(0<p<1\right)$$
当$x_1,x_2,\dots ,x_n$是来自与样本$X_1,X_2,\dots ,X_n$的一个样本值，$X$的分布律为$$P\left\{X=x\right\}=p^x{\left(1-p\right)}^{1-x},x=0,1\left(0<p<1\right)$$
它的似然函数为$$L\left(p\right)=\underset{i=1}{\stackrel{n}{\Pi }}{p}^{x_i}{\left(1-p\right)}^{1-x_i}$$
似然函数的对数形式为（取对数后累乘变为对数的累加）$$\log L\left(p\right)=\left(\underset{i=1}{\stackrel{m}{\Sigma }}{x}^{\left(i\right)}\right)\log p+\left(\underset{i=1}{\stackrel{m}{\Sigma }}\left(1-x^{\left(i\right)}\right)\log \left(1-p\right)\right)$$

1.4.2 逻辑回归中的似然函数

逻辑回归中sigmoid函数其实就是表示0-1中取1的概率，对应于0-1分布中的概率p；而我们输入的$y_i$为真实值，在机器学习中称为标签，对应于0-1分布中的$x_i$。这样就将逻辑回归和0-1分布对应起来了。我们用逻辑回归来作为分类模型，需要用最大似然估计的方法来评判模型的好坏。让总体分布尽量与样本的分布趋同，就是总体的分布与样本分布具有最大的相似性。所以将对应的表达式代入0-1分布，得到逻辑回归似然函数的对数形式为：$$\log L\left(p\right)=\underset{i=1}{\stackrel{m}{\Sigma }}{y}^{\left(i\right)}\log h_{\theta }\left(x^{\left(i\right)}\right)+\underset{i=1}{\stackrel{m}{\Sigma }}\left(1-y^{\left(i\right)}\right)\log \left(1-h_{\theta }\left(x^{\left(i\right)}\right)\right)$$
逻辑回归的损失函数为：$$J\left(\theta \right)=-\frac{1}{m}\underset{i=1}{\stackrel{m}{\Sigma }}\left[y^{\left(i\right)}\log h_{\theta }\left(x^{\left(i\right)}\right)+\left(1-y^{\left(i\right)}\right)\log \left(1-h_{\theta }\left(x^{\left(i\right)}\right)\right)\right]$$
可以发现，损失函数和似然函数的对数形式很像，只是在前面乘上了$-\frac{1}{m}$，最大似然估计的方法要求对数似然函数的最大值，损失函数在其前面加上负号，即求损失函数的最小值，最小化损失，符合定义。$-\frac{1}{m}$是用来对m个样本值的损失函数值取平均，不会影响最小化函数和训练。所以可以看出，逻辑回归中损失函数的求解用到了0-1分布以及似然函数的知识。

1.5 梯度下降

1.5.1 梯度下降作用及解释

梯度下降在训练过程中扮演着怎样的角色呢
在测试集上，通过最小化代价函数（成本函数）$J\left(w,b\right)$来训练参数$w$和$b$，如图：

其实梯度下降就是当前函数值朝着最陡峭的坡度下降到最低点。我们将上面下降的曲面想象成一个山谷，如果想要最快又最精准的下降到山谷位置，肯定首先要朝着最低点的方向下降，并且越陡的地方下降的越快，越缓的地方下降的越慢（假如在很缓的地方也下降的很快，很容易越过最低点，不容易收敛）。
那么在函数中某一点的导数就是一个很好的指标用于指明参数下降的方向和大小，导数就是曲线的斜率，斜率越大，导数绝对值越大，下降的也就越快。但是不能仅仅用导数来更新参数，需要乘以一个$\alpha$学习率（learning rate），来控制步长（step）。$:=$表示更新参数。公式如下：
$w:=w-\alpha \frac{\partial J\left(w,b\right)}{\partial w}$
$b:=b-\alpha \frac{\partial J\left(w,b\right)}{\partial b}$
$\partial$表示求偏导符号，可以读作round，$\frac{\partial J\left(w,b\right)}{\partial w}$就是损失函数$J\left(w,b\right)$对$b$求偏导，表示随着$w$的改变$J\left(w,b\right)$改变的快慢。小写字母用在求导数（derivative），即函数只有一个参数， 偏导数符号$\partial$用在求偏导（partial derivative），即函数含有两个以上的参数。

我们来看一个图：

有关于w的迭代更新：

1. 假如起始点在山谷的左侧，w也位于达到最低点w的左侧，此时导数为负，学习率为正，分析公式可得$-\alpha w$为正，符合设想。
2. 假如起始点在山谷的右侧，w也位于达到最低点w的右侧，此时导数为正，学习率为正，分析公式可得$-\alpha w$为负，符合设想。

1.5.2 逻辑回归梯度下降公式推导

损失函数$J\left(w,b\right)$对$w$求偏导，即求$\frac{\partial J\left(w,b\right)}{\partial w}$是一个难点，当然如果你有较好的微积分数理基础可以来看看如何求的：

所有，如果有n个特征，也就是说：
$$\theta =\left[\begin{array}{c}{\theta }_0\\ {\theta }_1\\ \dots \\ {\theta }_n\end{array}\right]$$，参数向量$\theta$包括${\theta }_0$ ${\theta }_1$ ${\theta }_2$一直到${\theta }_n$，那么将会用到这个式子：${\theta }_j:={\theta }_j-\alpha \frac{1}{m}{\Sigma }_{i=1}^m\left(h_{\theta }\left(x^{\left(i\right)}\right)-y^{\left(i\right)}\right)x_j^{\left(i\right)}$来同时更新所有的$\theta$的值。

1.5.3 有关学习率的设定

学习率能控制一次迭代下降的大小，需要根据不同问题设定不同的学习率。学习率设定过大，虽然下降的很快，但是很容易跳过最低点，无法收敛；学习率设定过小，迭代一个很小的模型也需要迭代很多次，计算量过大，增加训练难度，所以要找到一个始终的学习率，使得模型在达到最大训练次数之前可以下降到最低点。

1.5.4 向量化

向量化其实就是深度学习中代替for循环的一种技巧，在训练逻辑回归过程中，你要输入并计算很多项格式相同的样本训练数据，一般来说会用到for循环进行迭代，但是由于数据量过大，训练速度很慢，所以导入numpy包，它将所有样本同类型的数据组合在一起组成一个向量，运用矩阵运算，计算效率很高，大大加快了训练速度。

1.6 逻辑回归正则化解决过拟合问题

不论是在线性回归还是逻辑回归中，都会存在过拟合或者欠拟合的问题。
线性回归欠拟合、正好拟合、过拟合对比图：

逻辑回归欠拟合、正好拟合、过拟合对比图：

当欠拟合发生时，继续训练或者加大训练数据等可以解决。但是当发生过拟合时，有两种解决方式：

1. 丢弃一些不能帮助我们正确预测的特征。可以是手工选择保留哪些特征，或者使用一些模型选择的算法来帮忙（例如 PCA）
2. 正则化。 保留所有的特征，但是减少参数的大小（magnitude）。

逻辑回归通常使用正则化来预防过拟合。
下面介绍正则化的相关概念：
以线性回归为例讲解正则化（参考吴恩达老师机器学习课的笔记（黄海广博士）



逻辑回归中的正则化

import numpy as np
def sigmoid(z):
    return 1/(1+np.exp(-z))
def costReg(theta, X, y, learningRate):
    theta = np.matrix(theta)
    X = np.matrix(X)
    y = np.matrix(y)
    first = np.multiply(-y, np.log(sigmoid(X*theta.T)))
    second = np.multiply((1 - y), np.log(1 - sigmoid(X*theta.T)))
    reg = (learningRate / (2 * len(X))* np.sum(np.power(theta[:,1:theta.shape[1]],2)))
    return np.sum(first - second) / (len(X)) + reg

2. logistic代码实现

2.1 手撕代码

import numpy as np

#sigmoid函数
def sigmoid(x):
    return 1/(1+np.exp(-x))

#预测函数，调用sigmoid函数，0到0.5返回0，0.5到1返回1，可以看出是分类问题
def predict(x_test, weight):
    if sigmoid(weight.T @ x_test) > 0.5:     #@表示矩阵的乘法
        return 1
    return 0

#实现逻辑回归的训练
def fit(x, y):
    m, n = x.shape   #m为行，n为列
    w = np.zeros(n)  #一行，n列的0,设置为w的初始值
    r = 0.001        #learning rate学习率
    cnt = 0
    max_cnt = 10000  #设置最大迭代次数
    t = 0.01         #设置收敛条件

    #利用梯度下降方法求最优解
    while cnt<max_cnt:         #在到达最大迭代次数之前
        cnt+=1
        for i in range(m):     #m为行，对于每一条元素
            diff=(y[i]-sigmoid(w.T @ x[i]))*x[i]     #diff=[(y-sigmoid(w.T*x)]*x
            w=w+r*diff                               #更新w值,w=w+(学习率)*diff
            if (abs(diff)<t).all():                  #表示如果diff中所有的值都小于t,.all()的意思就是所有的都满足
                break
    return w

if __name__ == '__main__':
    #输入训练数据
    x_train = np.array([
        [1, 2.697, 6.254],
        [1, 1.872, 2.014],
        [1, 2.312, 0.812],
        [1, 1.983, 4.990],
        [1, 0.932, 3.920],
        [1, 1.321, 5.583],
        [1, 2.215, 1.560],
        [1, 1.659, 2.932],
        [1, 0.865, 7.362],
        [1, 1.685, 4.763],
        [1, 1.786, 2.523]
    ])
    x_train = np.array([
        [25,20,22,23],
        [1.862,1.872, 2.014,1.222],
        [1.669,2.312, 0.812,1.222],
        [24,23,21,23],
        [1.649,0.932, 3.920,1.222],
        [23,24,21,23],
        [1.589,2.215, 1.560,1.222],
        [1.666,1.659, 2.932,1.222],
        [22,25,23,23],
        [1.090,1.685, 4.763,1.222],
        [23,24,24,23]
    ])
    y_train = np.array([1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1])

    #进行训练，得到权重w
    weight = fit(x_train, y_train)

    # 调用预测函数，输出x_train的预测结果ans
    ans = []
    for i in x_train:
        tmp = predict(i, weight)
        ans.append(tmp)

    #计算预测准确率
    res = list(ans - y_train)
    rate = res.count(0) / len(res)
    print("逻辑回归预测结果为：", ans)
    print("预测结果准确率为：", "%.2f" % (rate * 100), "%")

2.2 利用sklearn库实现

import pandas as pd
import numpy as np
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression  #逻辑回归，也就是对数几率回归，用于分类

#1.加载数据，良/恶性乳腺癌肿瘤预测》
column_names = ['Sample code number', 'Clump Thickness', 'Uniformity of Cell Size', 'Uniformity of Cell Shape',
                'Marginal Adhesion', 'Single Epithelial Cell Size', 'Bare Nuclei', 'Bland Chromatin', 'Normal Nucleoli',
                'Mitoses', 'Class']
data = pd.read_csv(
    'https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin//breast-cancer-wisconsin.data',
    names=column_names)
data = data.replace(to_replace='?', value=np.nan)  # 非法字符的替代
data = data.dropna(how='any')  # 去掉空值，any：出现空值行则删除
print(data.shape)
print(data.head())

#2.数据分割
X_train,X_test,y_train,y_test = train_test_split(data[column_names[1:10]],data[column_names[10]],test_size=0.25,random_state=5)

#3.数据标准化，保证每个维度的特征数据方差为1，均值为0.使得预测结果不会被某些维度过大的特征值主导
ss = StandardScaler()
X_train = ss.fit_transform(X_train)
X_test = ss.transform(X_test)

#4.调用逻辑回归模型，这里采用l2惩罚项
lr = LogisticRegression(C=1.0, penalty='l2', tol=0.1)
lr.fit(X_train, y_train)

#5.预测
lr_predict = lr.predict(X_test)
print("预测结果为：{}".format(lr.score(X_test,y_test)))
print("预测结果为：{}".format(accuracy_score(y_test,lr_predict)))

参考资料：

1. 《概率论与数理统计》（第四版）.高等教育出版社.
2. 吴恩达深度学习deeplearning.ai
3. 吴恩达老师机器学习课的笔记（黄海广博士）