logistic回归

1.介绍

logistic回归常用于二元分类，原因是logistic回归的$\sigma$函数的特征非常适合做二元分类，本文下面会介绍。这里首先看一下logistic回归的公式。logistic回归的公式为：
$z=wx+b$
$\sigma=\frac{1}{1+e^{-z}}$
$\hat{y}=\sigma(z)$
其中x为样本数据，w、b为变量

2.$\sigma$函数

这里用我自己的理解介绍下$\sigma$函数，首先用我给大家画出的一幅图展现下$\sigma$函数

有图片可以看出，函数$\sigma$连续且可导，定义域为$-\infty,+\infty$，相对应的值域在（0，1）之间，所有$sigma$函数可以对数据进行二元分类。

3.代价函数

由logistic回归公式，可以看出如果我们给logistic函数设定一个初始的w和b值，很容易求出$\hat{y}$,这里用pathon模拟单个样本为例子

import numpy as np
w = np.array([0.035,0.076])
x = np.array([[1],[2]])
y = np.array([1])
b =np.array([0.02])
z=np.dot(w,x)+b
yhat = 1/(1+np.exp(-z))
print(yhat)

结果为[ 0.551566]
误差是预测值与真实值的差值,那么误差应为$\hat{y}-y=[-0.448434]$,
由于误差往往有正有负不利于统计总体误差，因此就有了损失函数，即：$L(\hat{y}，y)$。
一般来说损失函数公式为：

$$L(\hat{y}，y)=\frac{1}{2}(\hat{y}-y)^2$$
对于logistic回归来讲，不适用这个损失函数，经过画出图像可以看到它并不是个凸函数，我们想要误差尽可能变小，可以使用梯度下降法迭代w，b，得到一个可观的误差值。使用梯度下降法最好选选用凸函数，防止陷入局部最优。梯度下降法我会在下面介绍。logistic回归则采用了一个不同的损失函数，起到与误差平方相同的作用。损失函数为： $$L(\hat{y}，y)=-(ylog\hat{y}+(1-y)log(1-\hat{y}))$$

损失函数是衡量单个训练样本的表现，而成本函数是整个训练样本的表现。 成本函数公式为：
$\begin{align*} J(w,b)&=\frac{1}{m}\sum\limits_{i=1}nL(\hat{y}{(i)}，y^{(i)})\ &=-\frac{1}{m}\sum\limits_{i=1}m[y{(i)}log(\hat{y}{(i)})+(1-y{(i)})log(1-\hat{y}^{(i)})] \end{align*}$
而我们的目的是选择出一个$w$和$b$来使成本函数$J(w，b)$最小。

4.误差反向传播：梯度下降法

首先来看一下，下面这张图。
这张图向我们完美的展示了logistic回归的流程。
当我们自己初始w，b并把样本数据带入后可以求出$\hat{y}$
进而会求出成本函数的值，而我们的目的是则是要$L$成本函数降到最低，利用误差反向传播，进而迭代出合理的w和b的值。

这里用代价函数为例子：
我们先看一下$L$对$z$的偏导
$\frac{\partial{L}}{\partial{z}}=A-Y$
其中A为logistic回归的输出，Y为样本真实数据结果值，这里直接拿矩阵表示。
接着求一下
$\frac{\partial{L}}{\partial{w1}}=\frac{\partial{L}}{\partial{z}}*\frac{\partial{z}}{\partial{w1}}=(A−Y)*x1^{T}$

$\frac{\partial{L}}{\partial{w2}}=\frac{\partial{L}}{\partial{z}}*\frac{\partial{z}}{\partial{w2}}=(A−Y)*x2^{T}$

$\frac{\partial{L}}{\partial{b}}=\frac{\partial{L}}{\partial{z}}*\frac{\partial{z}}{\partial{b}}=(A−Y)$
这时我们可以分别得到了w、b变量对于代价函数L的影响，然后我们设置学习率，沿着它的负梯度方向来减小我们的误差值
$w=w-n*dw$
$b=b-n*db$

5. 小结

最后赋上一个简单的2层的神经网络的python小程序，其中隐藏层的激活函数为$\sigma$函数，输出层的激活函数同样为$\sigma$函数，其中又熟悉了一下梯度下降法

from sklearn import datasets
import numpy as np
iris = datasets.load_iris()
x1 = iris.get('data')[0:100]
Y = iris.get('target')[0:100]
m = x1.shape[0]
nameType = iris.get('target_names')
x1=x1.T
#深度学习作业

#神经元输入：
w1 = np.random.random(3*4)*0.01
w1 = np.reshape(w1,(3,4))
b1 = np.random.random(3*1)*0.01
b1 = np.reshape(b1,(3,1))
w2 = np.random.random(1*3)*0.01
w2 = np.reshape(w2,(1,3))
b2 = np.random.random(1)*0.01
b2 = np.reshape(b2,(1,1))

for i in range(20000):
    #隐藏层的激活函数：
    z1 = np.dot(w1,x1)+b1
    A1= 1/(1+np.exp(-z1))
    #计算输出层的w2A1+b2
    z2 = np.dot(w2,A1)+b2
    A2 = 1/(1+np.exp(-z2))
    err = (A2-Y)**2/2

    errsum = np.sum(err)
    if(i%1000==0):
        print(str(i)+':'+str(errsum))

    #反向传播更改w
    dz2 = A2-Y  #(1*150)
    dw2 = np.dot(dz2,A1.T)/m #(1*150  * 150*3  ===1*3)
    db2 = np.sum(dz2,axis = 1,keepdims=True)/m  # 1*1
    dA1 = np.dot(w2.T,dz2)  #(3*150)
    dz1 = dA1*(A1*(1-A1)) #(3*150)
    dw1 = np.dot(dz1,x1.T)/m  #(3*4)
    db1 = np.sum(dz1,axis = 1,keepdims = True)/m

    n=0.05
    w1= w1-n*dw1
    b1 = b1-n*db1
    w2 = w2 - n*dw2
    b2 = b2-n*db2

结果：