使用输入管道时如何将数据注入图形？

Question

我在我的代码中使用了一个可初始化的迭代器。迭代器从具有 20.000 个条目的 csv 数据集中返回大小为 100 的批次。然而，在训练过程中，我遇到了一个问题。考虑这段代码：

def get_dataset_iterator(batch_size): 

    # parametrized with batch_size
    dataset = ... 
    return dataset.make_initializable_iterator()


## build a model and train it (x is the input of my model)
iterator = get_dataset_iterator(100)
x = iterator.get_next()
y = model(x)

## L1 norm as loss, this works because the model is an autoencoder
loss = tf.abs(x - y)

## training operator
train_op = tf.train.AdamOptimizer(0.01).minimize(loss)

with tf.Session() as sess:

    for epoch in range(100):

        sess.run(iterator.initializer)

        # iterate through the whole dataset once during the epoch and 
        # do 200 mini batch updates

        for _ in range(number_of_samples // batch_size):
            sess.run(train_op)

        print(f'Epoch {epoch} training done!')

        # TODO: print loss after epoch here

我对完成 epoch 后的训练损失感兴趣。对我来说最有意义的是我计算整个训练集的平均损失（例如，通过网络输入所有 20.000 个样本并平均它们的损失）。我可以在这里重用数据集迭代器，批量大小为 20.000，但我已将 x 声明为输入。

所以问题是：

1.) 对所有 20.000 个示例进行损失计算是否有意义？我见过有些人只用一个小批量（时代的最后一批）进行计算。

2.) 如何使用输入管道计算整个训练集的损失？我必须以某种方式注入所有的训练数据，这样我就可以运行sess.run(loss)，而不需要仅计算 100 个样本（因为 x 被声明为输入）。

编辑澄清：

如果我按以下方式编写训练循环，会有一些事情困扰我：

with tf.Session() as sess:

    for epoch in range(100):

        sess.run(iterator.initializer)

        # iterate through the whole dataset once during the epoch and 
        # do 200 mini batch updates

        for _ in range(number_of_samples // batch_size):
            _, current_loss = sess.run([train_op, loss])

        print(f'Epoch {epoch} training done!')
        print(current_loss)

首先，在进行最后一次权重更新之前，仍会评估损失。这意味着出现的任何东西都不是最新的值。其次，退出 for 循环后我将无法访问current_loss，因此无法打印。

Answer 1

1) 整个训练集的损失计算（在更新权重之前）确实有意义，称为批量梯度下降（尽管使用整个训练集而不是小批量）。

但是，在更新权重之前计算整个数据集的损失会很慢（尤其是对于大型数据集），而且训练需要很长时间才能收敛。因此，通常使用小批量数据来计算损失和更新权重。尽管使用小批量会产生一个嘈杂的损失估计，但它实际上是足够好的估计来训练具有足够训练迭代的网络。

编辑：

我同意您打印的损失值不会是具有最新更新权重的最新损失。可能在大多数情况下，它确实不会产生太大的不同或改变结果，所以人们只是按照您编写上面代码的方式进行。但是，如果您真的想在完成训练（打印出来）后获得真正的最新损失值，那么您只需要在完成训练操作后再次运行损失操作，例如：

for _ in range(number_of_samples // batch_size):
            sess.run([train_op])
            current_loss = sess.run([loss])

这将获得您真正的最新价值。当然，这不会出现在整个数据集上，仅适用于 100 个小批量。同样，该值可能是一个足够好的估计值，但如果您希望计算整个数据集的准确损失，则必须遍历整个数据集，例如另一个循环，然后平均损失：

    ...
    # Train loop
    for _ in range(number_of_samples // batch_size):
        _, current_loss = sess.run([train_op, loss])

    print(f'Epoch {epoch} training done!')

    # Calculate loss of whole train set after training an epoch.
    sess.run(iterator.initializer)
    current_loss_list = []
    for _ in range(number_of_samples // batch_size):
            _, current_loss = sess.run([loss])
            current_loss_list.append(current_loss)
    train_loss_whole_dataset = np.mean(current_loss_list)
    print(train_loss_whole_dataset)

编辑 2： 正如所指出的那样，对 train_op 进行串行调用，然后 loss 将调用迭代器两次，因此事情可能不会很好地进行（例如，数据用完）。因此我的第二段代码会更好用。

Answer 2

我认为以下代码将回答您的问题： （A）如何在执行训练步骤后打印批量损失？ (B) 即使数据集迭代器每次只给出一个批次，你如何计算整个训练集的损失？

import tensorflow as tf
import numpy as np

dataset_size = 200
batch_size= 5
dimension = 4

# create some training dataset
dataset = tf.data.Dataset.\
    from_tensor_slices(np.random.normal(2.0,size=(dataset_size,dimension)).
    astype(np.float32))

dataset = dataset.batch(batch_size) # take batches

iterator = dataset.make_initializable_iterator()
x = tf.cast(iterator.get_next(),tf.float32)
w = tf.Variable(np.random.normal(size=(1,dimension)).astype(np.float32))

loss_func = lambda x,w: tf.reduce_mean(tf.square(x-w)) # notice that the loss function is a mean!
loss = loss_func(x,w) # this is the loss that will be minimized
train_op = tf.train.GradientDescentOptimizer(0.1).minimize(loss)

# we are going to use control_dependencies so that we know that we have a loss calculation AFTER the train step
with tf.control_dependencies([train_op]):
    loss_after_train_op = loss_func(x,w) # this is an identical loss, but will only be calculated AFTER train_op has
                                         # been performed

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())

    # train one epoch
    sess.run(iterator.initializer)
    for i in range(dataset_size//batch_size):
        # the training step will update the weights based on ONE batch of examples each step
       loss1,_,loss2 = sess.run([loss,train_op,loss_after_train_op])
       print('train step {:d}.  batch loss before step: {:f}.  batch loss after step: {:f}'.format(i,loss1,loss2))

    # evaluate loss on entire training set. Notice that this calculation assumes the the loss is of the form 
    # tf.reduce_mean(...)
    sess.run(iterator.initializer)
    epoch_loss = 0
    for i in range(dataset_size // batch_size):
        batch_loss = sess.run(loss)
        epoch_loss += batch_loss*batch_size
    epoch_loss = epoch_loss/dataset_size
    print('loss over entire training dataset: {:f}'.format(epoch_loss))

至于您的问题，计算整个训练集的损失是否有意义 - 是的，出于评估目的，这是有意义的。执行基于所有训练集的训练步骤通常没有意义，因为该集通常非常大，并且您希望更频繁地更新权重，而无需每次都检查整个训练集。