《深度学习入门》读书笔记4：误差反向传播法

数值微分计算了神经网络的损失函数关于权重参数的梯度，数值微分虽然简单，也容易实现，但缺点是计算上比较费时间
下面是一种高效计算权重参数的方法——误差反向传播法，原理是根据链式法则，倒着来，主要内容是推各种激活函数，层的backward

ReLU

如果正向传播时的输入值小于等于0，则反向传播的值为0。因此，反向传播中会使用正向传播时保存的mask，将从上游传来的dout的mask中的元素为True的地方设为0。

ReLU层的作用就像电路中的开关一样。正向传播时，有电流通过的话，就将开关设为 ON；没有电流通过的话，就将开关设为 OFF。反向传播时，开关为ON的话，电流会直接通过；开关为OFF的话，则不会有电流通过。

class Relu:
    def __init__(self):
        self.mask = None

    def forward(self, x):
        self.mask = (x <= 0)
        out = x.copy()
        out[self.mask] = 0

        return out

    def backward(self, dout):
        dout[self.mask] = 0
        dx = dout

        return dx

Relu类有实例变量mask。这个变量mask是由True/False构成的NumPy数组，self.mask = (x <= 0) 它会把正向传播时的输入x的元素中小于等于0的地方保存为True，其他地方（大于0的元素）保存为False

dout=np.array([1,2,3,4])
mask=np.array([True,False,True,False])
dout[mask]=0
print(dout)

>>>[0 2 0 4]

Sigmod

乘法的反向传播会将上游的值乘以正向传播时的输入信号的“翻转值”后传递给下游
加法节点的反向传播输入的值会原封不动地流向下一个节点

$y= \frac{1}{1+e^{-x}}$

$\begin{aligned} \frac {\partial L} {\partial y}y^2e^{-x} &= \frac{\partial L}{\partial y}\frac{1}{(1+e^{-x})^2}e^{-x}\\ &= \frac{\partial L}{\partial y}\frac{1}{(1+e^{-x})}\frac{1+e^{-x}-1}{(1+e^{-x})}\\ &= \frac{\partial L}{\partial y}y(1-y) \end{aligned}$

class Sigmoid:
 def __init__(self):
   self.out = None
 def forward(self, x):
   out = 1 / (1 + np.exp(-x))
   self.out = out
   return out
 def backward(self, dout):
   dx = dout * (1.0 - self.out) * self.out
   return dx

Affine

class Affine:
    def __init__(self, W, b):
        self.W =W
        self.b = b
        
        self.x = None
        self.original_x_shape = None

        self.dW = None
        self.db = None

    def forward(self, x):
        # 用于backward 将形状变回去
        self.original_x_shape = x.shape
        x = x.reshape(x.shape[0], -1)
        self.x = x

        out = np.dot(self.x, self.W) + self.b

        return out

    def backward(self, dout):
        dx = np.dot(dout, self.W.T)
        self.dW = np.dot(self.x.T, dout)
        self.db = np.sum(dout, axis=0)
        
        dx = dx.reshape(*self.original_x_shape) # 返回输入数据的形状
        return dx

class test:
    def __init__(self):
        self.x=np.empty([3,2,2,2])
    def test(self):
        print(self.x.shape) # (3, 2, 2, 2)
        print(*self.x.shape)  # 3 2 2 2


x= np.empty((3,2,2,2))
y=x.reshape((x.shape[0],-1))
a= np.empty((3,8))
b= a.reshape((3,2,2,2))
print(y.shape) # (3, 8)

print(b.shape)  # (3, 2, 2, 2)

Softmax-with-Loss

softmax函数会将输入值正规化之后再输出

神经网络中进行的处理有推理（inference）和学习两个阶段。神经网络的推理通常不使用 Softmax层。比如，用图 5-28的网络进行推理时，会将最后一个 Affine层的输出作为识别结果。神经网络中未被正规化的输出结果（图 5-28中 Softmax层前面的 Affine层的输出）有时被称为“得分”。也就是说，当神经网络的推理只需要给出一个答案的情况下，因为此时只对得分最大值感兴趣，所以不需要 Softmax层。不过，神经网络的学习阶段则需要 Softmax层。

def softmax(x):
    if x.ndim == 2:
        x = x.T
        x = x - np.max(x, axis=0)
        y = np.exp(x) / np.sum(np.exp(x), axis=0)
        return y.T 

    x = x - np.max(x) 
    return np.exp(x) / np.sum(np.exp(x))
    
def cross_entropy_error(y, t):
   if y.ndim == 1:
       t = t.reshape(1, t.size) # 正确标签数据
       y = y.reshape(1, y.size) # softmax输出后的数据
       
   # 输入数据为为one-hot-vector时，转换为正确标签的索引
   if t.size == y.size:
       t = t.argmax(axis=1)
            
   batch_size = y.shape[0]
   return -np.sum(np.log(y[np.arange(batch_size), t] + 1e-7)) / batch_size
   
class SoftmaxWithLoss:
   def __init__(self):
       self.loss = None
       self.y = None # softmax输出
       self.t = None # 输入

   def forward(self, x, t):
       self.t = t
       self.y = softmax(x)
       self.loss = cross_entropy_error(self.y, self.t)
       
       return self.loss
 
   def backward(self, dout=1):
       batch_size = self.t.shape[0]
       if self.t.size == self.y.size: # 输入数据为one_hot类型
           dx = (self.y - self.t) / batch_size
       else:
           dx = self.y.copy()
           dx[np.arange(batch_size), self.t] -= 1
           dx = dx / batch_size
       
       return dx