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

我正在尝试使用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,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,Training=TruE)
    dev_dataset = make_dataset(generator_fn,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问题链接