python构建简单的神经网络

╰半橙微兮° 2021-11-22 03:10 368阅读 0赞

转载自https://www.cnblogs.com/yanxiatingyu/articles/9279874.html

## 样本数据的产生 ##

N = 100 # 每个类中的样本点
    D = 2 # 维度
    K = 3 # 类别个数
    X = np.zeros((N*K,D)) # 样本input
    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
    # 可视化一下我们的样本点
    plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.Spectral)
    plt.show()

得到如下的样本分布：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70]  
紫色，红色和黄色分布代表不同的3种类别。

一般来说，拿到数据都要做预处理，包括之前提到的去均值和方差归一化。不过我们构造的数据幅度已经在-1到1之间了，所以这里不用做这个操作。

## 使用Softmax线性分类器 ##

**一、初始化参数**  
我们先在训练集上用softmax线性分类器试试。如我们在之前的章节提到的，我们这里用的softmax分类器，使用的是一个线性的得分函数/score function，使用的损失函数是交叉熵损失/cross-entropy loss。包含的参数包括得分函数里面用到的权重矩阵W和偏移量b，我们先随机初始化这些参数。

#随机初始化参数
    import numpy as np
    #D=2表示维度，K=3表示类别数
    W = 0.01 * np.random.randn(D,K)
    b = np.zeros((1,K))

**二、计算得分**  
线性的得分函数，将原始的数据映射到得分域非常简单，只是一个直接的矩阵乘法。

#使用得分函数计算得分
    scores = np.dot(X, W) + b

在我们给的这个例子中，我们有2个2维点集，所以做完乘法过后，矩阵得分scores其实是一个\[300\*3\]的矩阵，每一行都给出对应3各类别(紫，红，黄)的得分。

**三、计算损失**  
然后我们就要开始使用我们的损失函数计算损失了，我们之前也提到过，损失函数计算出来的结果代表着预测结果和真实结果之间的吻合度，我们的目标是最小化这个结果。直观一点理解，我们希望对每个样本而言，对应正确类别的得分高于其他类别的得分，如果满足这个条件，那么损失函数计算的结果是一个比较低的值，如果判定的类别不是正确类别，则结果值会很高。我们之前提到了，softmax分类器里面，使用的损失函数是交叉熵损失。一起回忆一下，假设f是得分向量，那么我们的交叉熵损失是用如下的形式定义的：  
![在这里插入图片描述][20190726142011707.png]  
直观地理解一下上述形式，就是Softmax分类器把类别得分向量f中每个值都看成对应三个类别的log似然概率。因此我们在求每个类别对应概率的时候，使用指数函数还原它，然后归一化。从上面形式里面大家也可以看得出来，得到的值总是在0到1之间的，因此从某种程度上说我们可以把它理解成概率。如果判定类别是错误类别，那么上述公式的结果就会趋于无穷，也就是说损失相当相当大，相反，如果判定类别正确，那么损失就接近log(1)=0。这和我们直观理解上要最小化损失是完全吻合的。

当然，当然，别忘了，完整的损失函数定义，一定会加上正则化项，也就是说，完整的损失L应该有如下的形式：  
![在这里插入图片描述][20190726142037128.png]  
好，我们实现以下，根据上面计算得到的得分scores，我们计算以下各个类别上的概率：

# 用指数函数还原
    exp_scores = np.exp(scores)
    # 归一化
    probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)

在我们的例子中，我们最后得到了一个\[300\*3\]的概率矩阵prob，其中每一行都包含属于3个类别的概率。然后我们就可以计算完整的互熵损失了

#计算log概率和互熵损失
    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)
    loss = data_loss + reg_loss

正则化强度λ在上述代码中是reg，最开始的时候我们可能会得到loss=1.1，是通过np.log(1.0/3)得到的(假定初始的时候属于3个类别的概率一样)，我们现在想最小化损失loss

**四、计算梯度与梯度回传**  
我们能够用损失函数评估预测值与真实值之间的差距，下一步要做的事情自然是最小化这个值。我们用传统的梯度下降来解决这个问题。多解释一句，梯度下降的过程是：我们先选取一组随机参数作为初始值，然后计算损失函数在这组参数上的梯度(负梯度的方向表明了损失函数减小的方向)，接着我们朝着负梯度的方向迭代和更新参数，不断重复这个过程直至损失函数最小化。为了清楚一点说明这个问题，我们引入一个中间变量p，它是归一化后的概率向量，如下：  
![在这里插入图片描述][2019072614311771.png]

我们现在希望知道朝着哪个方向调整权重能够减小损失，也就是说，我们需要计算梯度∂Li/∂fk。损失Li从p计算而来，再退一步，依赖于f。于是我们又要做高数题，使用链式求导法则了，不过梯度的结果倒是非常简单：  
![在这里插入图片描述][20190726143125134.png]

解释一下，公式的最后一个部分表示yi=k的时候，取值为1。整个公式其实非常的优雅和简单。假设我们计算的概率p=\[0.2, 0.3, 0.5\]，而中间的类别才是真实的结果类别。根据梯度求解公式，我们得到梯度df=\[0.2,−0.7,0.5\]。我们想想梯度的含义，其实这个结果是可解释性非常高的：大家都知道，梯度是最快上升方向，我们减掉它乘以步长才会让损失函数值减小。第1项和第3项(其实就是不正确的类别项)梯度为正，表明增加它们只会让最后的损失/loss增大，而我们的目标是减小loss；中间的梯度项-0.7其实再告诉我们，增加这一项，能减小损失Li，达到我们最终的目的。

我们依旧记probs为所有样本属于各个类别的概率，记dscores为得分上的梯度，我们可以有以下的代码：

dscores = probs
    dscores[range(num_examples),y] -= 1
    dscores /= num_examples

我们计算的得分scores = np.dot(X, W)+b，因为上面已经算好了scores的梯度dscores，我们现在可以回传梯度计算W和b了

dW = np.dot(X.T, dscores)
    db = np.sum(dscores, axis=0, keepdims=True)
    #得记着正则化梯度哈
    dW += reg*W

我们通过矩阵的乘法得到梯度部分，权重W的部分加上了正则化项的梯度。因为我们在设定正则化项的时候用了系数0.5（因为d/dw(1/2λw2)=λw），因此直接用reg\*W就可以表示出正则化的梯度部分。  
**参数迭代与更新**  
在得到所需的所有部分之后，我们就可以进行参数更新了

#参数迭代更新
    W += -step_size * dW
    b += -step_size * db

**训练SoftMax分类器**

#代码部分组一起，训练线性分类器
     import numpy as np
    from matplotlib import pyplot as plt
    
    N = 100 # 每个类中的样本点
    D = 2 # 维度
    K = 3 # 类别个数
    X = np.zeros((N*K, D)) # 样本input
    y = np.zeros(N*K, dtype='uint8') # 类别标签
    
    # 随机初始化参数
    h = 100  # 隐层大小
    W = 0.01 * np.random.randn(D, h)
    b = np.zeros((1, h))
    W2 = 0.01 * np.random.randn(h, K)
    b2 = np.zeros((1, K))
    
    #随机初始化参数
    W = 0.01 * np.random.randn(D,K)
    b = np.zeros((1,K))
     
    #需要自己敲定的步长和正则化系数
    step_size = 1e-0
    reg = 1e-3 #正则化系数
     
    #梯度下降迭代循环
    num_examples = X.shape[0]
    for i in xrange(200):
     
      # 计算类别得分, 结果矩阵为[N x K]
      scores = np.dot(X, W) + b
     
      # 计算类别概率
      exp_scores = np.exp(scores)
      probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True) # [N x K]
     
      # 计算损失loss(包括互熵损失和正则化部分)
      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)
      loss = data_loss + reg_loss
      if i % 10 == 0:
        print "iteration %d: loss %f" % (i, loss)
     
      # 计算得分上的梯度
      dscores = probs
      dscores[range(num_examples),y] -= 1
      dscores /= num_examples
     
      # 计算和回传梯度
      dW = np.dot(X.T, dscores)
      db = np.sum(dscores, axis=0, keepdims=True)
     
      dW += reg*W # 正则化梯度
     
      #参数更新
      W += -step_size * dW
      b += -step_size * db

循环之后，结果大致收敛了。我们评估一下准确度：

#评估准确度
    scores = np.dot(X, W) + b
    predicted_class = np.argmax(scores, axis=1)
    print 'training accuracy: %.2f' % (np.mean(predicted_class == y))

输出结果为49%。不太好，对吧？实际上也是可理解的，你想想，一份螺旋形的数据，你偏执地要用一个线性分类器去分割，不管怎么调整这个线性分类器，都非常非常困难。我们可视化一下数据看看决策边界(decision boundaries)：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 1]

## 使用神经网络分类 ##

从刚才的例子里可以看出，一个线性分类器，在现在的数据集上效果并不好。我们知道神经网络可以做非线性的分割，那我们就试试神经网络，看看会不会有更好的效果。对于这样一个简单问题，我们用单隐藏层的神经网络就可以了，这样一个神经网络我们需要2层的权重和偏移量：

# 初始化参数
    h = 100 # 隐层大小(神经元个数)
    W = 0.01 * np.random.randn(D,h)
    b = np.zeros((1,h))
    W2 = 0.01 * np.random.randn(h,K)
    b2 = np.zeros((1,K))

然后前向计算的过程也稍有一些变化

#2层神经网络的前向计算
    hidden_layer = np.maximum(0, np.dot(X, W) + b) # 用的 ReLU单元
    scores = np.dot(hidden_layer, W2) + b2

注意到这里，和之前线性分类器中的得分计算相比，多了一行代码计算，我们首先计算第一层神经网络结果，然后作为第二层的输入，计算最后的结果。哦，对了，代码里大家也看的出来，我们这里使用的是ReLU神经单元。

其他的东西都没太大变化。我们依旧按照之前的方式去计算loss，然后计算梯度dscores。不过反向回传梯度的过程形式上也有一些小小的变化。我们看下面的代码，可能觉得和Softmax分类器里面看到的基本一样，但注意到我们用hidden\_layer替换掉了之前的X:

# 梯度回传与反向传播
    # 对W2和b2的第一次计算
    dW2 = np.dot(hidden_layer.T, dscores)
    db2 = np.sum(dscores, axis=0, keepdims=True)

恩，并没有完事啊，因为hidden\_layer本身是一个包含其他参数和数据的函数，我们得计算一下它的梯度：

dhidden = np.dot(dscores, W2.T)

现在我们有隐层输出的梯度了，下一步我们要反向传播到ReLU神经元了。不过这个计算非常简单，因为r=max(0,x)，同时我们又有dr/dx=1(x>0)。用链式法则串起来后，我们可以看到，回传的梯度大于0的时候，经过ReLU之后，保持原样；如果小于0，那本次回传就到此结束了。因此，我们这一部分非常简单：

#梯度回传经过ReLU
    dhidden[hidden_layer <= 0] = 0

终于，翻山越岭，回到第一层，拿到总的权重和偏移量的梯度

dW = np.dot(X.T, dhidden)
    db = np.sum(dhidden, axis=0, keepdims=True)

**神经网络的过程串起来：**

import numpy as np
    from matplotlib import pyplot as plt
    
    N = 100 # 每个类中的样本点
    D = 2 # 维度
    K = 3 # 类别个数
    X = np.zeros((N*K, D)) # 样本input
    y = np.zeros(N*K, dtype='uint8') # 类别标签
    
    # 随机初始化参数
    h = 100  # 隐层大小
    W = 0.01 * np.random.randn(D, h)
    b = np.zeros((1, h))
    W2 = 0.01 * np.random.randn(h, K)
    b2 = np.zeros((1, K))
    
    # 手动敲定的几个参数
    step_size = 1e-0
    reg = 1e-3  # 正则化参数
    
    # 梯度迭代与循环
    num_examples = X.shape[0]
    
    
    for i in range(1000):
    
        hidden_layer = np.maximum(0, np.dot(X, W) + b)  # 使用的ReLU神经元
        scores = np.dot(hidden_layer, W2) + b2
    
        # 计算类别概率
        exp_scores = np.exp(scores)
        probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)  # [N x K]
    
        # 计算互熵损失与正则化项
        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))
    
        # 计算梯度
        dscores = probs
        dscores[range(num_examples), y] -= 1
        dscores /= num_examples
    
        # 梯度回传
        dW2 = np.dot(hidden_layer.T, dscores)
        db2 = np.sum(dscores, axis=0, keepdims=True)
    
        dhidden = np.dot(dscores, W2.T)
    
        dhidden[hidden_layer <= 0] = 0
        # 拿到最后W,b上的梯度
        dW = np.dot(X.T, dhidden)
        db = np.sum(dhidden, axis=0, keepdims=True)
    
        # 加上正则化梯度部分
        dW2 += reg * W2
        dW += reg * W
    
        # 参数迭代与更新
        W += -step_size * dW
        b += -step_size * db
        W2 += -step_size * dW2
        b2 += -step_size * db2
    
    scores = np.dot(X, W) + b
    predicted_class = np.argmax(scores, axis=1)
    print('training accuracy: %.2f' % (np.mean(predicted_class == y)))

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 2]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70]: /images/20211122/fc48d00df35849b48aeda2d6303f9631.png
[20190726142011707.png]: /images/20211122/93bcd63dad584eeaa195f188f26d3d3d.png
[20190726142037128.png]: /images/20211122/723f2a84b6404edcb38cde19323e2c09.png
[2019072614311771.png]: https://img-blog.csdnimg.cn/2019072614311771.png
[20190726143125134.png]: https://img-blog.csdnimg.cn/20190726143125134.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20190726143713882.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20190726144709392.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2,size_16,color_FFFFFF,t_70