神经网络通俗讲，麻瓜变大神(一)-初识神经网络

向右看齐 2022-05-28 14:09 327阅读 0赞

系列目录:  
[神经网络通俗讲，麻瓜变大神(一)-初识神经网络][-]  
[神经网络通俗讲，麻瓜变大神(二)-解释非线性][- 1]  
[神经网络通俗讲，麻瓜变大神(三)-卷积神经网络][- 2]

理解神经网络，我们就从一个例子开始吧，该例子输入5个特征，然后输出这个人是美还是丑:  
![这里写图片描述][70]  
该神经网络结构包含三层，分别为:  
1.输入层(input):5个特征，分别表示皮肤颜色，身高，体重，脸型，臀。  
2.隐藏层(hidden):100个神经元,w1(5,100),可以理解为有100个国家同时对这个5个特征进行一个打分。有些国家就觉得臀部屁股大觉得好看，那这样权重w就会大一点,开玩笑。  
3.输出层(output):2个神经元,分别表示美，丑，w2(100,2),可以理解为有个权威机构，对100个国家审美等级有个置信度，例如美国w=0.9,而韩国=0.3，就说美国对美和丑更有话语权。

这样一个网络，该怎么训练:

1.计算出美和丑的概率:
    mul1 = w1 * x
    add1 = mu1 + b1
    score1 = max(0,add1) #使用Relu
    mul2 = score1 * w2
    score2 = mul2 +b2
    prob = exp(score2[美])/sum(exp(score2[美])+exp(score[丑])) #soft分类器
    2.计算损失值loss(计算得出的结果prob和原本标签label之间有多大区别):
    loss = data_loss + reg_loss
    data_loss = -np.log(prob[正确])
    reg_loss = 0.5*reg*np.sum(W*W) + 0.5*reg*np.sum(W2*W2) #正则化惩罚项
    其实以上整个就是一个前向传播，从x 到计算出loss的过程。
    3.反向传播，目的是让loss不断减小，记住loss是一个方程，loss=data_loss + reg_loss,先求
    在点w2,和点b2的梯度
    dprob = prob
    dprob = dprob[正确] - 1 #对dataloss进行softmax求导,也就是prob的求导
    dw2 = np.dot(score1.T, dprob) #求得loss方程在点w2上的梯度
    db2 = dscore #在点b2上的梯度
    4.再求点w1,和点b1的梯度
    dscore1 = np.dot(dprob, W2.T) #进行score1求导
    if dscore1<0 : dscore1=0 #Relu
    dw1 = np.dot(x.T, dscore1) #进行求得loss方程在点w1上的梯度
    db1 = dscore1 #在点b1上的梯度
    5.根据w1,b1,w2,b2的梯度进行修改
    w1 = w1-学习率*dw1
    b1 = b1-学习率*db1
    w2 = w2-学习率*dw2
    b2 = b2-学习率*db2

虽然计算过程已经给出，但是其实里面还有很多值得去讨论和解释的问题:  
1.神经元怎么理解？  
以上面的例子，我们可以理解为w1.shape = (5,100),可以理解为，100个不同的国家对这5个不同的特征进行评估,然后得出每个国家对这5个特征的得分值，这完全就是对这5个特征往上抽象了，神经元越多，隐藏层越多，就越抽象，到最后抽象成什么样子我自己都不知道，但方向就是这样。  
2.神经元，和隐藏层是不是越多越好？  
的确也可以这么说，以现在的例子，明明可以只对5个特征和权重相乘然后得出结果值，但这样肯定不会比我们综合100个国家，再加个权威机构认定来得准确吧。当然网上也会说神经元多，隐藏层多会出现过拟合，其实也可以理解，你综合的东西太多，看的角度太多，确实会发生这样的情况。  
3.为什么再add1以后使用Relu非线性函数？  
因为如果没有Relu，可以将整个score2看作 score2 = w2(w1\*x+b1),这就是一种线性函数，类似y=4x。当加上Relu以后，score2 = w2 \* max(0,w1\*x+b1)，这就成了非线性。  
4.为什么在计算概率中要使用exp指数函数？  
只是为了让更大的值显得更大，这样显示更明显，这也是softmax分类器特点。  
5.为啥使用-np.log(prob\[正确\])来计算损失值？  
log函数图像大家也都知道，当prob\[正确\]=1的时候，log(1)=0，当下于1的时候-log  
为正数，且prob\[正确\]值越小，-log得到的值也越大，也表示loss值也越大，这个使用log来作为计算loss值还有一个特点，就是这个函数是属于永不满足函数(不可能出现log(1))，所以会一直调整权值w。  
6.为什么在loss方程中还有+个reg\_loss正则化惩罚项R(w)?  
这个正则化惩罚项R(w)，主要用于对当前权重w对模型好坏的一个评估。比方有:  
![这里写图片描述][70 1]  
通过计算可以知道score = w1 *x = w2*  x=1,得分值一摸一样，那么一般我们认为w2要比w1要好，因为w2 4个特征都有去考虑了，而w1只对一个特征考虑，所以这里就用到一个权重正则化惩罚项R(w)来评估一个权重的好坏。目前R(w)的计算公式有两种:L1和L2(例子中采用L2)，具体可参考[Keras Dense层整理][Keras Dense]，其实这里也解释了网上说可以使用R(w)来防止模型过拟合，w1就是过拟合的表现，一刀切。还可以用通俗的方式来讲:就是说一个公司有4个领导，w1就是说决策只用1个领导说了算，而w2是综合了4个领导的意见才决定的，显然w2更好。  
7.反向传播是如何体现的？  
其实可以先不管反向传播这个名词。我们知道在计算得到loss值以后，loss是一个方程，然后我们想降低loss值，以让模型更好，那么我们就让w1,b1,w2,b2分别作为loss方程的变量，然后分别对它们进行求导，也就得到loss方程在点w1,b1,w2,b2的梯度，我们又知道梯度是方程变化最快的方向(注意，这里是变化最快的方向，而不是网上说的什么下降最快的方向)。计算dw1,db1,dw2,db2，根据链式法则如下:  
![这里写图片描述][70 2]  
往箭头方向看，这就是反向传播，至于对softmax求导得到prob\[正确\]-1,推到过程可以查看[softmax求导推算][softmax]。  
8.往下坡路走方向最快是什么意思？  
比方有y=x2  y = x 2  ,y’= dx = 2x,在点x = 1 的梯度为dx = 2,则说明x->2的方向变化最快，但x往2方向是y增大最快的方向，所以我们要往返方向走，而反方向走也是y下降最快的方向，所以在更新权重的时候才有w2 = w2 - 学习率 \* dw2。这才是最快走下坡路。  
9.学习率有什么作用？  
学习率就是让下坡的步伐慢一点，假设以问题8的中的例子y=x2  y = x 2 ,大家都知道x=0的时候到达低谷，则现有 dx = 2x=2,,假设x往梯度的反方向走,f(1-dx) =f(-1)= 1,发现越过了低谷，而假设学习率=0.1，则有f(1-学习率\*dx) = f(0.8)=0.64,这样看的话就发现往梯度dx反方向迈的步伐越小，就不会轻易错过低谷，所以学习率的作用就在此，慢慢的沿着函数曲线下坡。

下面我们再来看一个网上经常能够看到的例子,我只对变量名进行修改，以方便对比:

import numpy as np
    import matplotlib.pyplot as plt
    
    np.random.seed(0)
    N = 100 # number of points per class
    D = 2 # dimensionality
    K = 3 # number of classes
    X = np.zeros((N*K,D))
    y = np.zeros(N*K, dtype='uint8')
    for j in xrange(K):
      ix = range(N*j,N*(j+1))
      r = np.linspace(0.0,1,N) # radius
      t = np.linspace(j*4,(j+1)*4,N) + np.random.randn(N)*0.2 # theta
      X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]
      y[ix] = j
    
    h = 100 # size of hidden layer
    W1 = 0.01 * np.random.randn(D,h)# x:300*2 2*100
    b1 = np.zeros((1,h))
    W2 = 0.01 * np.random.randn(h,K)
    b2 = np.zeros((1,K))
    
    # some hyperparameters
    step_size = 1e-0
    reg = 1e-3 # regularization strength
    
    # gradient descent loop
    num_examples = X.shape[0]
    #开始训练
    for i in xrange(2000):
    
      # evaluate class scores, [N x K]
      score1 = np.maximum(0, np.dot(X, W1) + b1) # note, ReLU activation hidden_layer:300*100
      #print hidden_layer.shape
      score2 = np.dot(score1, W2) + b2  #scores:300*3
      #print scores.shape
      # compute the class probabilities
      exp_scores = np.exp(score2)
      probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True) # [N x K]
      #print probs.shape
    
      # compute the loss: average cross-entropy loss and regularization
      corect_logprobs = -np.log(probs[range(num_examples),y])
      data_loss = np.sum(corect_logprobs)/num_examples
      reg_loss = 0.5*reg*np.sum(W*W) + 0.5*reg*np.sum(W2*W2)
      loss = data_loss + reg_loss
      if i % 100 == 0:
        print "iteration %d: loss %f" % (i, loss)
    
      # compute the gradient on scores，开始反向传播
      dscore2 = probs
      dscore2[range(num_examples),y] -= 1
      dscore2 /= num_examples
    
      # backpropate the gradient to the parameters
      # first backprop into parameters W2 and b2
      dW2 = np.dot(score1.T, dscore2)
      db2 = np.sum(dscore2, axis=0, keepdims=True)
      # next backprop into hidden layer
      dscore1 = np.dot(dscore2, W2.T)
      # backprop the ReLU non-linearity
      dscore1[score1 <= 0] = 0
      # finally into W,b
      dW = np.dot(X.T, dscore1)
      db = np.sum(dscore1, axis=0, keepdims=True)
    
      # add regularization gradient contribution
      dW2 += reg * W2
      dW1 += reg * W1
    
      # perform a parameter update
      W1 += -step_size * dW1
      b1 += -step_size * db1
      W2 += -step_size * dW2
      b2 += -step_size * db2
    #后面这里只是用于画图了
    hidden_layer = np.maximum(0, np.dot(X, W) + b)
    scores = np.dot(hidden_layer, W2) + b2
    predicted_class = np.argmax(scores, axis=1)
    print 'training accuracy: %.2f' % (np.mean(predicted_class == y))
    
    
    h = 0.02
    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                         np.arange(y_min, y_max, h))
    Z = np.dot(np.maximum(0, np.dot(np.c_[xx.ravel(), yy.ravel()], W) + b), W2) + b2
    Z = np.argmax(Z, axis=1)
    Z = Z.reshape(xx.shape)
    fig = plt.figure()
    plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral, alpha=0.8)
    plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.Spectral)
    plt.xlim(xx.min(), xx.max())
    plt.ylim(yy.min(), yy.max())
    plt.show()

上面的例子和我前面举的例子有啥相同和不同？  
相同:  
1,都是三层全连接网络结构  
2.激活函数都使用的relu函数  
3.分类器和损失都使用的softmax  
不同:  
1.输入训练的数据量不一样，我开始举的例子使用的是batchsize=1,而网上的这个例子使用的整个数据集作为batchsize  
2.因为batchsize不一样，这就在更新w的时候不一样，明显看到网上的例子都有一个/num\_examples的操作，也就是说将整个数据集作为一次训练，然后在更新权重的时候才用平均梯度的方式；其实我使用的优化算法为SGB随机梯度下降算法，而网上使用的例子为BGD批量梯度下降算法，再具体一点可以去看下网上其它的资料。

[-]: https://blog.csdn.net/u011311291/article/details/79841748
[- 1]: https://blog.csdn.net/u011311291/article/details/79996630
[- 2]: https://blog.csdn.net/u011311291/article/details/80273394
[70]: /images/20220528/e4eda0bb62f64f4f8bb0634d976f450b.png
[70 1]: /images/20220528/6c4b79ace8ce421ba61e73055c9b82e1.png
[Keras Dense]: https://blog.csdn.net/u011311291/article/details/79820073
[70 2]: /images/20220528/8982809d026740e1b92556c2d67931e0.png
[softmax]: https://www.jianshu.com/p/ffa51250ba2e