Question

我正在寻找一种使用可选输入创建Keras模型的方法。在原始TensorFlow中，您可以使用以下可选输入创建占位符：

import numpy as np
import tensorflow as tf


def main():
    required_input = tf.placeholder(
        tf.float32,
        shape=(None, 2),
        name='required_input')

    default_optional_input = tf.random_uniform(
        shape=(tf.shape(required_input)[0], 3))
    optional_input = tf.placeholder_with_default(
        default_optional_input,
        shape=(None, 3),
        name='optional_input')

    output = tf.concat((required_input, optional_input), axis=-1)

    with tf.Session() as session:
        with_optional_input_output_np = session.run(output, feed_dict={
            required_input: np.random.uniform(size=(4, 2)),
            optional_input: np.random.uniform(size=(4, 3)),
        })

        print(f"with optional input: {with_optional_input_output_np}")

        without_optional_input_output_np = session.run(output, feed_dict={
            required_input: np.random.uniform(size=(4, 2)),
        })

        print(f"without optional input: {without_optional_input_output_np}")


if __name__ == '__main__':
    main()

以类似的方式，我希望能够为我的Keras模型提供可选输入。似乎keras.layers.Input.__init__中的tensor参数可能正是我想要的，但至少它没有按我的期望工作（即与显示的tf.placeholder_with_default相同）以上）。这是一个中断的示例：

import numpy as np
import tensorflow as tf
import tensorflow_probability as tfp


def create_model(output_size):
    required_input = tf.keras.layers.Input(
        shape=(13, ), dtype='float32', name='required_input')

    batch_size = tf.shape(required_input)[0]

    def sample_optional_input(inputs, batch_size=None):
        base_distribution = tfp.distributions.MultivariateNormalDiag(
            loc=tf.zeros(output_size),
            scale_diag=tf.ones(output_size),
            name='sample_optional_input')

        return base_distribution.sample(batch_size)

    default_optional_input = tf.keras.layers.Lambda(
        sample_optional_input,
        arguments={'batch_size': batch_size}
    )(None)

    optional_input = tf.keras.layers.Input(
        shape=(output_size, ),
        dtype='float32',
        name='optional_input',
        tensor=default_optional_input)

    concat = tf.keras.layers.Concatenate(axis=-1)(
        [required_input, optional_input])
    dense = tf.keras.layers.Dense(
        output_size, activation='relu')(concat)

    model = tf.keras.Model(
        inputs=[required_input, optional_input],
        outputs=[dense])

    return model


def main():
    model = create_model(output_size=3)

    required_input_np = np.random.normal(size=(4, 13))
    outputs_np = model.predict({'required_input': required_input_np})
    print(f"outputs_np: {outputs_np}")

    required_input = tf.random_normal(shape=(4, 13))
    outputs = model({'required_input': required_input})
    print(f"outputs: {outputs}")


if __name__ == '__main__':
    main()

对model.predict的第一次调用似乎给出了正确的输出，但是由于某些原因，直接调用模型失败，并出现以下错误：

ValueError：图层模型需要2个输入，但收到1个输入张量。收到的输入：[]

是否可以像上面的示例中那样，使用tensor中的Input.__init__参数来实现Keras模型的可选输入？如果是，我应该在示例中进行哪些更改以使其正确运行？如果没有，在Keras中创建可选输入的预期方式是什么？

Answer 1

我真的认为，没有解决方法是不可能的。 Keras并不是为了这个目的。

但是，注意到您在每种情况下都使用了两个不同的session.run命令，因此似乎很容易使用两个模型来完成。一种模型使用可选输入，另一种则不使用。您可以选择使用哪个呼叫方式来选择呼叫session.run()的方式。

也就是说，您可以使用Input(tensor=...)或仅在Lambda层内创建可选输入。这两件事都很好。但是不要使用Input(shape=..., tensor=...)，它们是多余的参数，有时Keras不能很好地处理这种冗余。

理想情况下，将所有操作都保留在Lambda层内，甚至包括tf.shape操作。

说：

required_input = tf.keras.layers.Input(
    shape=(13, ), dtype='float32', name='required_input')

#needs the input for the case you want to pass it:
optional_input_when_used = tf.keras.layers.Input(shape=(output_size,))


#operations should be inside Lambda layers
batch_size = Lambda(lambda x: tf.shape(x)[0])(required_input)

#updated for using the batch size coming from lambda
#you didn't use "inputs" anywhere in this function
def sample_optional_input(batch_size):
    base_distribution = tfp.distributions.MultivariateNormalDiag(
        loc=tf.zeros(output_size),
        scale_diag=tf.ones(output_size),
        name='sample_optional_input')

    return base_distribution.sample(batch_size)

#updated for using the batch size as input
default_optional_input = tf.keras.layers.Lambda(sample_optional_input)(batch_size)

#let's skip the concat for now - notice I'm not "using" this layer yet
dense_layer = tf.keras.layers.Dense(output_size, activation='relu')

#you could create the rest of the model here if it's big, so you don't create it twice 
#(check the final section of this answer)

使用传递的输入进行建模：

concat_when_used = tf.keras.layers.Concatenate(axis=-1)(
    [required_input, optional_input_when_used]
)

dense_when_used = dense_layer(concat_when_used)  
#or final_part_of_the_model(concat_when_used)     

model_when_used = Model([required_input, optional_input_when_used], dense_when_used)

模型未使用可选输入：

concat_not_used = tf.keras.layers.Concatenate(axis=-1)(
    [required_input, default_optional_input]
)

dense_not_used = dense_layer(concat_not_used) 
#or final_part_of_the_model(concat_not_used)

model_not_used = Model(required_input, dense_not_used)

可以创建两个这样的模型并选择一个使用（两个模型共享最后一层，因此它们将始终一起训练）是可以的

现在，在选择session.run的那一点上，现在您将选择要使用的模型：

model_when_used.predict([x1, x2])
model_when_used.fit([x1,x2], y)

model_not_used.predict(x)
model_not_used.fit(x, y)

如何创建共享的最终零件？

如果最后的部分很大，则您将不希望两次调用所有内容来创建两个模型。在这种情况下，请首先创建一个最终模型：

input_for_final = Input(shape_after_concat)
out = Dense(....)(input_for_final)
out = Dense(....)(out)
out = Dense(....)(out)
.......
final_part_of_the_model = Model(input_for_final, out)

然后在上一个答案中使用此最后一部分。

dense_when_used = final_part_of_the_model(concat_when_used)
dense_not_used = final_part_of_the_model(concat_not_used)

如何使用可选输入创建Keras模型

1 个答案:

如何创建共享的最终零件？