ValueError：没有为任何变量提供梯度 - Tensorflow 2.0/Keras

Question

我正在尝试使用 Keras 实现一个简单的序列到序列模型。但是，我一直看到以下内容ValueError：

ValueError: No gradients provided for any variable: ['simple_model/time_distributed/kernel:0', 'simple_model/time_distributed/bias:0', 'simple_model/embedding/embeddings:0', 'simple_model/conv2d/kernel:0', 'simple_model/conv2d/bias:0', 'simple_model/dense_1/kernel:0', 'simple_model/dense_1/bias:0'].

像这样的其他问题或在 Github 上查看此问题表明这可能与交叉熵损失函数有关；但我看不到我在这里做错了什么。

我不认为这是问题所在，但我想说的tf-nightly==2.2.0.dev20200410是，准确地说，我正在夜间构建 TensorFlow 。

下面的代码是一个独立的示例，应该重现上面的异常：

import random
from functools import partial

import tensorflow as tf
from tensorflow import keras
from tensorflow_datasets.core.features.text import SubwordTextEncoder

EOS = '<eos>'
PAD = '<pad>'

RESERVED_TOKENS = [EOS, PAD]
EOS_ID = RESERVED_TOKENS.index(EOS)
PAD_ID = RESERVED_TOKENS.index(PAD)

dictionary = [
    'verstehen',
    'verstanden',
    'vergessen',
    'verlegen',
    'verlernen',
    'vertun',
    'vertan',
    'verloren',
    'verlieren',
    'verlassen',
    'verhandeln',
]

dictionary = [word.lower() for word in dictionary]


class SimpleModel(keras.models.Model):

    def __init__(self, params, *args, **kwargs):
        super().__init__(*args, **kwargs)

        self.params = params
        self.out_layer = keras.layers.Dense(1, activation='softmax')

        self.model_layers = [
            keras.layers.Embedding(params['vocab_size'], params['vocab_size']),
            keras.layers.Lambda(lambda l: tf.expand_dims(l, -1)),
            keras.layers.Conv2D(1, 4),
            keras.layers.MaxPooling2D(1),
            keras.layers.Dense(1, activation='relu'),
            keras.layers.TimeDistributed(self.out_layer)
        ]

    def call(self, example, training=None, mask=None):
        x = example['inputs']
        for layer in self.model_layers:
            x = layer(x)
        return x


def sample_generator(text_encoder: SubwordTextEncoder, max_sample: int = None):
    count = 0

    while True:
        random.shuffle(dictionary)

        for word in dictionary:

            for i in range(1, len(word)):

                inputs = word[:i]
                targets = word

                example = dict(
                    inputs=text_encoder.encode(inputs) + [EOS_ID],
                    targets=text_encoder.encode(targets) + [EOS_ID],
                )
                count += 1

                yield example

                if max_sample is not None and count >= max_sample:
                    print('Reached max_samples (%d)' % max_sample)
                    return


def make_dataset(generator_fn, params, training):

    dataset = tf.data.Dataset.from_generator(
        generator_fn,
        output_types={
            'inputs': tf.int64,
            'targets': tf.int64,
        }
    ).padded_batch(
        params['batch_size'],
        padded_shapes={
            'inputs': (None,),
            'targets': (None,)
        },
    )

    if training:
        dataset = dataset.map(partial(prepare_example, params=params)).repeat()

    return dataset


def prepare_example(example: dict, params: dict):
    # Make sure targets are one-hot encoded
    example['targets'] = tf.one_hot(example['targets'], depth=params['vocab_size'])
    return example


def main():

    text_encoder = SubwordTextEncoder.build_from_corpus(
        iter(dictionary),
        target_vocab_size=1000,
        max_subword_length=6,
        reserved_tokens=RESERVED_TOKENS
    )

    generator_fn = partial(sample_generator, text_encoder=text_encoder, max_sample=10)

    params = dict(
        batch_size=20,
        vocab_size=text_encoder.vocab_size,
        hidden_size=32,
        max_input_length=30,
        max_target_length=30
    )

    model = SimpleModel(params)

    model.compile(
        optimizer='adam',
        loss='categorical_crossentropy',
    )

    train_dataset = make_dataset(generator_fn, params, training=True)
    dev_dataset = make_dataset(generator_fn, params, training=False)

    # Peek data
    for train_batch, dev_batch in zip(train_dataset, dev_dataset):
        print(train_batch)
        print(dev_batch)
        break

    model.fit(
        train_dataset,
        epochs=1000,
        steps_per_epoch=100,
        validation_data=dev_dataset,
        validation_steps=100,
    )


if __name__ == '__main__':
    main()

更新

• 要点链接
• Github 问题链接

Answer 1

您的代码中有两组不同的问题，它们可以归类为语法和架构问题。引发的错误（即No gradients provided for any variable）与我将在下面主要解决的语法问题有关，但我也会尝试为您提供一些有关此后架构问题的指示。

语法问题的主要原因是为模型使用命名的输入和输出。当模型具有多个输入和/或输出层时，Keras 中的命名输入和输出最有用。但是，您的模型只有一个输入层和一个输出层。因此，在这里使用命名输入和输出可能不是很有用，但如果这是您的决定，我会解释如何正确完成。

首先，您应该记住，在使用 Keras 模型时，从任何输入管道（无论是 Python 生成器还是tf.data.Dataset）生成的数据都应该作为元组 ie(input_batch, output_batch)或(input_batch, output_batch, sample_weights). 而且，正如我所说，这是 Keras 中处理输入管道时所期望的格式，即使我们使用命名输入和输出作为字典也是如此。

例如，如果我想使用输入/输出命名并且我的模型有两个名为“words”和“importance”的输入层，还有两个名为“output1”和“output2”的输出层，它们的格式应该是这样的：

({'words': words_data, 'importance': importance_data},
 {'output1': output1_data, 'output2': output2_data})

正如你在上面看到的，它是一个元组，元组的每个元素都是一个字典；第一个元素对应于模型的输入，第二个元素对应于模型的输出。现在，根据这一点，让我们看看应该对您的代码进行哪些修改：

• 在sample_generator我们应该回到类型的字典元组，而不是一个字典。所以：

  example = tuple([
       {'inputs': text_encoder.encode(inputs) + [EOS_ID]},
       {'targets': text_encoder.encode(targets) + [EOS_ID]},
  ])
  

• 在make_dataset函数中， 的输入参数tf.data.Dataset应该尊重这一点：

  output_types=(
      {'inputs': tf.int64},
      {'targets': tf.int64}
  )
  
  padded_shapes=(
      {'inputs': (None,)},
      {'targets': (None,)}
  )
  

• 的签名prepare_example和它的正文也应该修改：

  def prepare_example(ex_inputs: dict, ex_outputs: dict, params: dict):
      # Make sure targets are one-hot encoded
      ex_outputs['targets'] = tf.one_hot(ex_outputs['targets'], depth=params['vocab_size'])
      return ex_inputs, ex_outputs
  

• 最后，call子类模型的方法：

  return {'targets': x}
  

• 还有一件事：我们还应该name在构造层时使用参数将这些名称放在相应的输入和输出层上（例如Dense(..., name='output')；但是，由于我们在Model这里使用子类来定义我们的模型，因此没有必要这样做。

好的，这些将解决输入/输出问题，与梯度相关的错误将消失；但是，如果您在应用上述修改后运行代码，您仍然会收到有关不兼容形状的错误。正如我之前所说，您的模型中存在架构问题，我将在下面简要说明。

正如您所提到的，这应该是一个 seq-to-seq 模型。因此，输出是一个单热编码向量序列，其中每个向量的长度等于（目标序列）词汇量大小。因此，softmax 分类器应该具有与词汇量大小一样多的单元，如下所示（注意：永远不要在任何模型或问题中使用只有一个单元的 softmax 层；那都是错的！想想为什么会错！）：

self.out_layer = keras.layers.Dense(params['vocab_size'], activation='softmax')

接下来要考虑的事实是我们正在处理一维序列（即标记/单词序列）。因此，在这里使用 2D 卷积和 2D 池化层没有意义。您可以使用它们的 1D 对应物，也可以用其他类似 RNN 层的东西替换它们。因此，该Lambda层也应该被移除。另外，如果你想使用卷积和池化，你应该适当调整每一层的过滤器数量以及池大小（即一个卷积过滤器，Conv1D(1,...)可能不是最优的，池大小为 1 没有意义）。

此外，Dense只有一个单元的最后一层之前的那一层可能会严重限制模型的表示能力（即它本质上是模型的瓶颈）。要么增加它的单位数，要么删除它。

另一件事是，没有理由不对开发集的标签进行单热编码。相反，它们应该像训练集的标签一样进行单热编码。因此，要么完全删除trainingof的参数，要么make_generator，如果您有其他用例，则应使用training=True传递给make_dataset函数的参数创建开发数据集。

最后，在所有这些更改之后，您的模型可能会工作并开始拟合数据；但是经过几批后，您可能会再次收到不兼容的形状错误。那是因为您正在生成具有未知维度的输入数据，并且还使用宽松的填充方法来根据需要（即通过使用(None,）来填充每个批次的相应参数。即使您希望您的模型支持可变长度的输入/输出序列，那么您也应该在模型的架构和超参数以及 padded_shapes）。为了解决这个问题，你应该决定一个固定的输入/输出维度（例如通过考虑输入/输出序列的固定长度），然后调整模型的架构或超参数（例如卷积核大小、卷积填充、池化大小） ，添加更多层等）以及padded_shapespadded_shapes争论。由于此解决方案取决于您心中的任务和所需的设计，并且没有万能的解决方案，因此我不会对此进一步发表评论，而是让您自行解决。但这里有一个可行的解决方案（它可能不是，也可能根本不是最佳的）只是为了给你一个想法：

self.out_layer = keras.layers.Dense(params['vocab_size'], activation='softmax')

self.model_layers = [
    keras.layers.Embedding(params['vocab_size'], params['vocab_size']),
    keras.layers.Conv1D(32, 4, padding='same'),
    keras.layers.TimeDistributed(self.out_layer)
]


# ...
padded_shapes=(
    {'inputs': (10,)},
    {'targets': (10,)}
)