Question

在TF 1.x中，可以使用自定义变量构建图层。这是一个示例：

import numpy as np
import tensorflow as tf

def make_custom_getter(custom_variables):
    def custom_getter(getter, name, **kwargs):
        if name in custom_variables:
            variable = custom_variables[name]
        else:
            variable = getter(name, **kwargs)
        return variable
    return custom_getter

# Make a custom getter for the dense layer variables.
# Note: custom variables can result from arbitrary computation;
#       for the sake of this example, we make them just constant tensors.
custom_variables = {
    "model/dense/kernel": tf.constant(
        np.random.rand(784, 64), name="custom_kernel", dtype=tf.float32),
    "model/dense/bias": tf.constant(
        np.random.rand(64), name="custom_bias", dtype=tf.float32),
}
custom_getter = make_custom_getter(custom_variables)

# Compute hiddens using a dense layer with custom variables.
x = tf.random.normal(shape=(1, 784), name="inputs")
with tf.variable_scope("model", custom_getter=custom_getter):
    Layer = tf.layers.Dense(64)
    hiddens = Layer(x)

print(Layer.variables)

构造的密集层的打印变量将是我们在custom_variables字典中指定的自定义张量：

[<tf.Tensor 'custom_kernel:0' shape=(784, 64) dtype=float32>, <tf.Tensor 'custom_bias:0' shape=(64,) dtype=float32>]

这允许我们创建直接使用custom_variables中提供的张量作为其权重的层/模型，以便我们可以进一步针对custom_variables的任何张量来区分层/模型的输出可能取决于（对于在modulating sub-nets，parameter generation，meta-learning等中实现功能特别有用。）

可变范围用于轻松地将带有自定义getter的所有图构建嵌套在范围内，并在提供的张量之上将模型构建为其参数。由于在TF 2.0中不再建议使用会话和可变作用域（并且所有这些低级内容已移至tf.compat.v1），因此，使用Keras实施上述操作最佳做法和TF 2.0？

（相关issue on GitHub。）

Answer 1

根据下面的评论进行回答

鉴于您有：

kernel = createTheKernelVarBasedOnWhatYouWant() #shape (784, 64)
bias = createTheBiasVarBasedOnWhatYouWant() #shape (64,)

做一个简单的函数，从Dense复制代码：

def custom_dense(x):
    inputs, kernel, bias = x

    outputs = K.dot(inputs, kernel)
    outputs = K.bias_add(outputs, bias, data_format='channels_last')
    return outputs

在Lambda层中使用该功能：

layer = Lambda(custom_dense)
hiddens = layer([x, kernel, bias])

警告：kernel和bias必须由Keras层产生，或者必须来自kernel = Input(tensor=the_kernel_var)和bias = Input(tensor=bias_var)

如果上面的警告对您不利，您可以随时使用kernel和bias来自外部，例如：

def custom_dense(inputs):
    outputs = K.dot(inputs, kernel) #where kernel is not part of the arguments anymore
    outputs = K.bias_add(outputs, bias, data_format='channels_last')
    return outputs

layer = Lambda(custom_dense)
hiddens = layer(x)

最后一个选项使保存/加载模型更加复杂。

旧答案

您可能应该使用Keras Dense图层并以标准方式设置其权重：

layer = tf.keras.layers.Dense(64, name='the_layer')
layer.set_weights([np.random.rand(784, 64), np.random.rand(64)])

如果您需要这些权重不可训练，请在编译设置的keras模型之前：

model.get_layer('the_layer').trainable=False

如果您想直接访问张量变量，它们是：

kernel = layer.kernel    
bias = layer.bias

还有很多其他选择，但这取决于您的确切意图，这在您的问题中尚不清楚。

Answer 2

以下是适用于TF2中任意Keras模型的通用解决方案。

首先，我们需要定义一个具有以下签名的辅助函数canonical_variable_name和上下文管理器custom_make_variable（请参见meta-blocks library中的实现）。

def canonical_variable_name(variable_name: str, outer_scope: str):
    """Returns the canonical variable name: `outer_scope/.../name`."""
    # ...

@contextlib.contextmanager
def custom_make_variable(
    canonical_custom_variables: Dict[str, tf.Tensor], outer_scope: str
):
    """A context manager that overrides `make_variable` with a custom function.

    When building layers, Keras uses `make_variable` function to create weights
    (kernels and biases for each layer). This function wraps `make_variable` with
    a closure that infers the canonical name of the variable being created (of the
    form `outer_scope/.../var_name`) and looks it up in the `custom_variables` dict
    that maps canonical names to tensors. The function adheres the following logic:

    * If there is a match, it does a few checks (shape, dtype, etc.) and returns
      the found tensor instead of creating a new variable.
    * If there is a match but checks fail, it throws an exception.
    * If there are no matching `custom_variables`, it calls the original
      `make_variable` utility function and returns a newly created variable.
    """
    # ...

使用这些功能，我们可以使用自定义张量作为变量来创建任意Keras模型：

import numpy as np
import tensorflow as tf

canonical_custom_variables = {
    "model/dense/kernel": tf.constant(
        np.random.rand(784, 64), name="custom_kernel", dtype=tf.float32),
    "model/dense/bias": tf.constant(
        np.random.rand(64), name="custom_bias", dtype=tf.float32),
}

# Compute hiddens using a dense layer with custom variables.
x = tf.random.normal(shape=(1, 784), name="inputs")
with custom_make_variable(canonical_custom_variables, outer_scope="model"):
    Layer = tf.layers.Dense(64)
    hiddens = Layer(x)

print(Layer.variables)

Answer 3

不能完全确定我是否正确理解了您的问题，但在我看来，可以结合使用custom layers和keras functional api来完成您想要的事情。

自定义图层允许您以与Keras兼容的方式构建所需的任何图层，例如：

class MyDenseLayer(tf.keras.layers.Layer):
    def __init__(self, num_outputs):
        super(MyDenseLayer, self).__init__()
        self.num_outputs = num_outputs

    def build(self, input_shape):
        self.kernel = self.add_weight("kernel", 
                                      shape=[int(input_shape[-1]), 
                                             self.num_outputs],
                                      initializer='normal')

        self.bias = self.add_weight("bias", 
                                    shape=[self.num_outputs,],
                                    initializer='normal')

    def call(self, inputs):
        return tf.matmul(inputs, self.kernel) + self.bias

和功能性api允许您访问所述图层的输出并重新使用它们：

inputs = keras.Input(shape=(784,), name='img')
x1 = MyDenseLayer(64, activation='relu')(inputs)
x2 = MyDenseLayer(64, activation='relu')(x1)
outputs = MyDenseLayer(10, activation='softmax')(x2)

model = keras.Model(inputs=inputs, outputs=outputs, name='mnist_model')

这里x1和x2可以连接到其他子网。

使用自定义张量作为变量的TensorFlow 2.0 Keras层

3 个答案:

根据下面的评论进行回答

旧答案