【实验操作】关于深度学习中的批处理数据的问题——epochs，batch_size，iterations

概念

batch

深度学习的优化算法，说白了就是梯度下降。按照损失函数的计算规模和每次的参数更新分类有三种方式。

1、批梯度下降(BGD——Batch gradient descent)

损失函数计算：遍历全部数据集算一次损失函数，然后算函数对各个参数的梯度，更新梯度。

特点：每更新一次参数都要把数据集里的所有样本都看一遍，计算量开销大，计算速度慢，不支持在线学习

2、随机梯度下降（SGD——stochastic gradient descent）

损失函数计算：每看一个数据就算一下损失函数，然后求梯度更新参数。

特点：速度比较快，但是收敛性能不太好，可能在最优点附近晃来晃去，hit不到最优点。两次参数的更新也有可能互相抵消掉，造成目标函数震荡的比较剧烈。

3、小批梯度下降（mini-batch gradient decent）

为了克服两种方法的缺点，现在一般采用的是一种折中手段

损失函数计算：把数据分为若干个批，按批来更新参数，这样，一个批中的一组数据共同决定了本次梯度的方向，下降起来就不容易跑偏，减少了随机性。另一方面因为批的样本数与整个数据集相比小了很多，计算量也不是很大。

iterations

iterations（迭代）：每一次迭代都是一次权重更新，每一次权重更新需要batch_size个数据进行Forward运算得到损失函数，再BP算法更新参数。1个iteration等于使用batchsize个样本训练一次。

epochs

epochs被定义为向前和向后传播中所有批次的单次训练迭代。这意味着1个周期是整个输入数据的单次向前和向后传递。简单说，epochs指的就是训练过程中数据将被“轮”多少次。

三者之间的关系

训练集有1000个样本，batch_size=10，那么训练完整个样本集需要： 
100次iteration，1次epoch。

具体的计算公式为： 
one epoch = numbers of iterations = N = 训练样本的数量 / batch_size

注：在LSTM中我们还会遇到一个seq_length表示序列的长度(步长)，关系是：
batch_size = num_steps * seq_length

参考来源：https://blog.csdn.net/maweifei/article/details/80722097

---

对训练的影响

https://www.zhihu.com/question/32673260

---

数据准备——batch_size中涉及到的参数

对于时间序列的数据集，模型的输入格式为[batch_size, seq_length, input_dim], 其中，batch_size表示一个batch中的样本的个数，seq_length表示序列的长度，input_dim表示输入样本的维度。
那实际工程下如何取准备这些数据呢，我们假设样本训练集[x1,x2,x3,...,xdatalength][x1,x2,x3,...,xdatalength]的长度为data_length，事实上有两种截取方式。

法一

第一种就是先按照seq_length这个窗口进行截取，然后按照bacth_size个数据向后依次截取，则总的迭代次数iterations = (data_length - seq_length) // batch_size, 则一个batch中的第一行数据可以表示为[x1,x2,...,xseqlength][x1,x2,...,xseqlength],第二行的数据可以表示为[xseqlength+1,xseqlength+2,...,xseqlength+xseqlength+1][xseqlength+1,xseqlength+2,...,xseqlength+xseqlength+1], 最后一行数据可以表示为[xbatchsize][xbatchsize]

程序模拟

假设序列为:[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]

import numpy as np

batch_size = 4
seq_length = 3
raw_data = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]

def get_batch(raw_data, batch_size, seq_length):
    data = np.array(raw_data)
    data_length = data.shape[0]
    num_steps = data_length - seq_length + 1
    iterations = num_steps // batch_size
    xdata=[]
    ydata=[]
    for i in range(num_steps-1):
        xdata.append(data[i:i+seq_length])
        ydata.append(data[i+1:i+1+seq_length])

    for batch in range(iterations):
        x = np.array(xdata)[batch * batch_size: batch * batch_size + batch_size, :]
        y = np.array(xdata)[batch * batch_size + 1: batch * batch_size + 1 + batch_size, :]
        yield x, y

输出的训练集数据的格式为：

x1: [[1 2 3]
     [2 3 4]
     [3 4 5]
     [4 5 6]]
y1: [[2 3 4]
     [3 4 5]
     [4 5 6]
     [5 6 7]]
x2: [[ 5  6  7]
     [ 6  7  8]
     [ 7  8  9]
     [ 8  9 10]]
y2: [[ 6  7  8]
     [ 7  8  9]
     [ 8  9 10]
     [ 9 10 11]]
x3: [[ 9 10 11]
     [10 11 12]
     [11 12 13]
     [12 13 14]]
y3: [[10 11 12]
     [11 12 13]
     [12 13 14]
     [13 14 15]]
x4: [[13 14 15]
     [14 15 16]
     [15 16 17]
     [16 17 18]]
y4: [[14 15 16]
     [15 16 17]
     [16 17 18]
     [17 18 19]]

法二

第二种方法以bacth_size和seq_length为基础一个batch中应该包含的数据个数为batch_size * seq_length个数据，那么iterations= data_length//(batch_size * seq_length).
- step1、利用numpy中的矩阵技巧，先将序列reshpe成[batch_size, seq_length* iterations]的形状，
- step2、然后利用for循环将reshape后的数据截取成若干个batch。

程序模拟

import numpy as np

batch_size = 4
seq_length = 3
raw_data = [1,2,3,4,5,6,7,8,9,10,11,12,13,
            14,15,16,17,18,19,20, 21, 22, 
            23, 24, 25, 26, 27, 28, 29, 30, 
            31, 32, 33, 34, 35, 36, 37, 38, 39, 40]

def get_batch(raw_data, batch_size, seq_length):
    data = np.array(raw_data)
    data_length = data.shape[0]
    iterations = (data_length - 1) // (batch_size * seq_length)
    round_data_len = iterations * batch_size * seq_length
    xdata = data[:round_data_len].reshape(batch_size, iterations*seq_length)
    ydata = data[1:round_data_len+1].reshape(batch_size, iterations*seq_length)

    for i in range(iterations):
        x = xdata[:, i*seq_length:(i+1)*seq_length]
        y = ydata[:, i*seq_length:(i+1)*seq_length]
        yield x, y

step1 产生的结果为：

x：
[[ 1  2  3  4  5  6  7  8  9]
 [10 11 12 13 14 15 16 17 18]
 [19 20 21 22 23 24 25 26 27]
 [28 29 30 31 32 33 34 35 36]]
对应的标签y为：
[[ 2  3  4  5  6  7  8  9 10]
 [11 12 13 14 15 16 17 18 19]
 [20 21 22 23 24 25 26 27 28]
 [29 30 31 32 33 34 35 36 37]]

step2 生成的结果为：

x1: [[ 1  2  3]
     [10 11 12]
     [19 20 21]
     [28 29 30]]
y1: [[ 2  3  4]
     [11 12 13]
     [20 21 22]
     [29 30 31]]
x2: [[ 4  5  6]
     [13 14 15]
     [22 23 24]
     [31 32 33]]
y2: [[ 5  6  7]
     [14 15 16]
     [23 24 25]
     [32 33 34]]
x3: [[ 7  8  9]
     [16 17 18]
     [25 26 27]
     [34 35 36]]
y3: [[ 8  9 10]
     [17 18 19]
     [26 27 28]
     [35 36 37]]

总结

目前我还不能确定第一种方法的正确性，但是从生产的结果上来看我没有找到明显的错误，第二种方法是我看到的大部分人在准备训练集的时候所用的方法，可能代码的思想不一样，但是思路应该差不多。
对比两种方法产生的结果，在训练样本数目相同的情况下，法一生产的一个epoch中的iterations多于法二产生的iterations。每个batch间，法一的数据比较密集，法二的数据样本比较稀疏。

参考来源：https://blog.csdn.net/javastart/article/details/84065011