动手实现深度神经网络2 增加批处理

动手实现深度神经网络2 增加批处理

在上一部分中，我们构造了一个简单的两层神将网络，上文中那个网络使用数值微分计算梯度，没有实现批处理，所以可以认为时不可用的。在着一部分中，批处理将会被实现。

得益于numpy的广播属性，我们要实现批处理不难。简单来说，我们原来的网络中，每次输入都是一个有784个元素的二维矩阵，而加入我们每次输入一批数据（例如200条），那输入就是一个200*784的二维矩阵。

那么我们来看看代码中有哪些地方需要为批处理的实现做修改

1.对神经网络类的修改

下面是原来实现的神经网络的主要代码

# 经过两层运算
def predict(self,x):
    # 取出参数
    w1,b1=self.params['w1'],self.params['b1']
    w2,b2=self.params['w2'],self.params['b2']


    
    a1=np.dot(x,w1)+b1
    #一 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    z1=sigmoid(a1)

    a2=np.dot(z1,w2)+b2
    #一 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    y=softmax(a2)

    return y

# 求损失函数值
def loss(self,x,t):
    y=self.predict(x)
    #二 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    return cross_entropy_error(y,t)

# 求个损失函数值关于各个参数的梯度
def gradient_numerical(self,x,t):
    loss_W=lambda w:self.loss(x,t)
    grads={}
    #三 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    grads['w1'] = numerical_gradient_2d(loss_W, self.params['w1'])
    grads['b1'] = numerical_gradient_onenumber(loss_W, self.params['b1'])
    grads['w2'] = numerical_gradient_2d(loss_W, self.params['w2'])
    grads['b2'] = numerical_gradient_onenumber(loss_W, self.params['b2'])

    return grads

# 计算准确率
def accuracy(self, x, t):
    y = self.predict(x)
    #四 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    y=np.argmax(y)
    t=np.argmax(t)

    return y==t

得益于numpy的广播机制，例如np.dot等操作就不需要修改了，可能需要修改的部分我都已经用感叹号做了标注，接下来我们一个一个来看看。

1.1 sigmoid和softmax

我们先来看一下之前实现的sigmoid和softmax源代码

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

sigmoid只是简单的做矩阵运算，不管一维矩阵还是二维矩阵都不影响，所以sigmoid不需要修改。

def softmax(x):
    # 这里就需要修改了
    max = np.max(x)
    x = x - max
    return np.exp(x) / np.sum(np.exp(x))

**softmax中涉及到np.max操作这就需要修改了。**因为对二维矩阵做np.max操作只会返回最大的一个值，而我们需要的是每一条数据中的最大值。

幸好，np.max提供了 axis 参数，具体来说就是对于二维矩阵np.max(x,axis=0)返回每列的最大值，np.max(x,axis=1)返回每行的最大值。

a_2d=np.array([[0.1,0.05,0.6,0.05,0.05,0.05,0.01,0.01,0.02,0.06],
         [0.8,0.05,0.6,0.05,0.05,0.05,0.01,0.01,0.02,0.06],
         [0.1,1.5,0.6,0.05,0.05,0.05,0.01,0.01,0.02,0.06]])
print(np.max(a_2d))
print(np.max(a_2d,axis=0)) #每列的做大值
print(np.max(a_2d,axis=1)) #每行的最大值

那我们接下来来实现二维矩阵的softmax

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

然后我们来测试一下，

#测试一下
x=np.array([[0.1,0.05,0.6,0.05,0.05,0.05,0.01,0.01,0.02,0.06],
         [0.8,0.05,0.6,0.05,0.05,0.05,0.01,0.01,0.02,0.06],
         [0.1,1.5,0.6,0.05,0.05,0.05,0.01,0.01,0.02,0.06]])
softmax(x)

额。。。。。报错了

原因是max=np.max(x,axis=1)取到的max是一个3元素的一维矩阵，而x是3*10的二维矩阵，他们二者之间无法相减。一个简单的解决办法就是把max转换成3*1的二维矩阵，代码如下：

max = np.max(x,axis=1)
print(max)   # [0.6 0.8 1.5]
max=max.reshape(max.size,1)
print(max)   #[[0.6]
             # [0.8]
             # [1.5]]

我们再试一次：

def softmax(x):
    if x.ndim==2:
        max = np.max(x,axis=1)
        max=max.reshape(max.size,1)
        x = x - max
        return np.exp(x) / np.sum(np.exp(x),axis=1)

#测试一下
x=np.array([[0.1,0.05,0.6,0.05,0.05,0.05,0.01,0.01,0.02,0.06],
         [0.8,0.05,0.6,0.05,0.05,0.05,0.01,0.01,0.02,0.06],
         [0.1,1.5,0.6,0.05,0.05,0.05,0.01,0.01,0.02,0.06]])
softmax(x)

h

还是出问题了，这次是“np.exp(x) / np.sum(np.exp(x),axis=1)”，其实你很快就会发现，这次的错误更上次本质上是一样的：

np.sum(np.exp(x),axis=1) 的结果是一个3元素的一维矩阵 而让3*10二维矩阵np.exp(x)去除以一个一维矩阵显然做不到。怎么办呢？更上面解决办法一样，再讲=将一维矩阵装换为二维矩阵就可以了。

不过这样总感觉非常的麻烦，有没有一种便捷的方法呢？看下面的代码：

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=np.array([[0.1,0.05,0.6,0.05,0.05,0.05,0.01,0.01,0.02,0.06],
         [0.8,0.05,0.6,0.05,0.05,0.05,0.01,0.01,0.02,0.06],
         [0.1,1.5,0.6,0.05,0.05,0.05,0.01,0.01,0.02,0.06]])
softmax(x)

执行成功了！！

其实，上面的两个矩阵“不能相减”和“无法相除”都是因为它们的位置对应不上。而将x装置之后变为10*3的矩阵就可以轻松运算了

`

好的，二维矩阵softmax解决了，之后我们整理成一个同时支持一维和二维的方法：

def softmax(x):
    if x.ndim==1:
        x = x - np.max(x) # 溢出对策
        return np.exp(x) / np.sum(np.exp(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

1.2 cross_entropy_error

def cross_entropy_error_batch_1(y, t):
    if y.ndim == 1:
        # 改变t和y的形状，使得它们与批处理情况一致 即每批次1条数据
        # 一维矩阵变为二维矩阵，统一操作
        # t.size-->(1,t.size)
        t = t.reshape(1, t.size)
        y = y.reshape(1, y.size)

    batch_size = y.shape[0]
    return -np.sum(t * np.log(y + 1e-7)) / batch_size

其实还是一维矩阵和二维矩阵的问题，我们这里首先把一维矩阵转换为二维矩阵，方便之后统一处理。

然后计算一个平均损失函数值。

-np.sum(t * np.log(y + 1e-7)) / batch_size实际上相当于先对每一条数据求损失值，再求平均值。

#-np.sum(t * np.log(y + 1e-7)) / batch_size 相当于
a = -np.sum(t * np.log(y + 1e-7),axis=1)
return np.max(a) / batch_size

交叉熵损失函数现在也完成了批处理的支持啦，我在这里再补充一种情况，那就是“监督数据是标签形式”，所谓标签形式就是像“2”“7”这样的标签，看下面的表就能轻易理解啦

监督数据（表明图片是几）	one-hot形式（独热编码）	标签形式
1	[0,1,0,0,0,0,0,0,0,0]	1
5	[0,0,0,0,0,1,0,0,0,0]	5

（批处理 假设一批3条数据）监督数据	one-hot形式（独热编码）	标签形式
[4,2,5]	[ [0,0,0,0,1,0,0,0,0,0] [0,0,1,0,0,0,0,0,0,0] [0,0,0,0,0,1,0,0,0,0] ]	[4,2,5]

对于“监督数据是标签形式”我们这样处理：

# 监督数据是标签形式（非one-hot表示，而是像“2”“7”这样的标签）时
def cross_entropy_error_batch_2(y, t):
    if y.ndim == 1:
        t = t.reshape(1, t.size)
        y = y.reshape(1, y.size)

    batch_size = y.shape[0]
    return -np.sum(np.log(y[np.arange(batch_size), t] + 1e-7)) / batch_size

假设batch_size=3 假设测试数据是[4,2,5]，那么y[np.arange(batch_size), t]实际上就是 [y[0,4], y[1,2], y[2,5]]，也就是y中所有正确解标签的对应的输出的自然对数。根据上一篇文章中的推导就知道：交叉熵误差的值是由正确解标签所对应的输出结果决定的。因此可以用这种方法处理“监督数据是标签形式”的情况。

最后整理成一个包含所有情况的方法：

def cross_entropy_error_batch_all(y, t):
    # 把非批处理数据改为批处理数据格式
    if y.ndim == 1:
        t = t.reshape(1, t.size)
        y = y.reshape(1, y.size)

    # 如果测试数据是one-hot格式，将它转换为标签形式
    if t.size == y.size:
        # argmax返回最大值的索引 例如one-hot下[[0,1,0.....0],[0,0,0.....1]]会转换为[2,9]
        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

1.3 求梯度

因为在所求的梯度是“损失函数值关于参数的梯度”，所以与输入的形式无关，所以不需要修改。

1.4 accuracy

计算准确率的方法做一下简单修改就可以啦

def accuracy(self, x, t):
    y = self.predict(x)
    
    y = np.argmax(y, axis=1)
    t = np.argmax(t, axis=1)
    
    accuracy = np.sum(y == t) / float(x.shape[0]) # shape返回形状 shape[0]行数 shape[1]列数
    return accuracy

np.argmax(y, axis=1)返回每一行中最大值的索引。最后准确率就是 每批次总准确数/每批次总数。2.

2.对网络的使用代码的修改

(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, one_hot_label=True)

network=Myself_Two_Layer_Net(input_size=784, hidden_size=50, output_size=10,weight_init_std=0.01)

train_size = x_train.shape[0]
test_size = x_test.shape[0]
learning_rate = 0.1  # 学习率


iters_num = 100  # 适当设定循环的次数 因为暂时没有实现自动微分，所以循环次数太多会很慢
train_size = x_train.shape[0]
batch_size = 100
learning_rate = 0.1

train_loss_list = []
train_acc_list = []
test_acc_list = []


# 二
# 这里说一下epoch,我们说批处理，在深度学习中往往使用minibatch
# epoch是一个单位。一个 epoch表示学习中所有训练数据均被使用过一次时的更新次数。
# 比如，对于 10000笔训练数据，用大小为 100笔数据的mini-batch进行学习时，重复随机梯度下降法 100次，所
# 有的训练数据就都被“看过”了A。此时，100次就是一个 epoch。
# 因此iter_per_epoch就是训练数据大小/每一批大小
iter_per_epoch = max(train_size / batch_size, 1)


for i in range(iters_num):
    #、一
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    t_batch = t_train[batch_mask]

    # 计算梯度
    grad = network.gradient_numerical(x_batch, t_batch)

    # 更新参数
    for key in ('W1', 'b1', 'W2', 'b2'):
        network.params[key] -= learning_rate * grad[key]
        
        

    if i % iter_per_epoch == 0:
        train_acc = network.accuracy(x_train, t_train)
        test_acc = network.accuracy(x_test, t_test)
        train_acc_list.append(train_acc)
        test_acc_list.append(test_acc)
        print("train acc, test acc | " + str(train_acc) + ", " + str(test_acc))


# 绘制图形
markers = {'train': 'o', 'test': 's'}
x = np.arange(len(train_acc_list))
plt.plot(x, train_acc_list, label='train acc')
plt.plot(x, test_acc_list, label='test acc', linestyle='--')
plt.xlabel("epochs")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
plt.legend(loc='lower right')
plt.show()

源代码中有两个点需要注意的：

一是np.random.choice(train_size, batch_size)从60000条训练数据中挑选100条数据出来，np.random.choice返回的是选中的下标（位置）

batch_mask=np.random.choice(100, 5)
print(batch_mask) # [31 60 43 54 40]

要注意使用随机选择的mini batch数据进行梯度下降的方法就叫做随机梯度下降法（stochastic gradient descent）。 深度学习的很多框架中，随机梯度下降法一般由一个名为SGD的函数来实现。

二是我们说批处理，在深度学习中往往使用的是mini batch方法：神经网络的学习也是从训练数据中选出一批数据（称为mini-batch,小 批量），然后对每个mini-batch进行学习。比如，从60000个训练数据中随机 选择100笔，再用这100笔数据进行学习。这种学习方式称为mini-batch学习。

而epoch是一个单位。一个 epoch表示学习中所有训练数据均被使用过一次时的更新次数。比如，对于 10000笔训练数据，用大小为 100笔数据的mini-batch进行学习时，重复随机梯度下降法 100次，所有的训练数据就都被“看过”了A。此时，100次就是一个 epoch。
因此iter_per_epoch就是训练数据大小/每一批大小，而经过iter_per_epoch训练，可以认为所有训练数据均被使用过，这时一般会计算一下精确率。