Keras：在编译期间输入形状未知时如何创建具有权重的自定义层？

Question

我想在我的输入层之后定义一个预处理层，即它将使用之前计算的缩放器的均值和方差，并将其应用于我的输入，然后再将它们传递给密集网络。

Lambda 层在我的情况下不起作用，因为我想保存模型，目的是当应用于数据时，不需要处理输入，因为它将在网络的早期阶段完成。

对均值和 var 使用 K.variables 是可行的，但我想改用权重并设置 trainable=False。这样，它们将被保存在网络的权重中，而我不必每次都提供它们。

class PreprocessLayer(Layer):                                                                                                                                                                               
    """                                                                                                                                                                                                     
    Defines a layer that applies the preprocessing from a scaler                                                                                                                                            
    Needed because lambda layers are too fragile to be saved in a model                                                                                                                                     
    """                                                                                                                                                                                                     
    def __init__(self, batch_size, mean, var, **kwargs):                                                                                                                                                    
        self.b = batch_size                                                                                                                                                                                 
        self.m = mean                                                                                                                                                                                       
        self.v = var                                                                                                                                                                                        
        super(PreprocessLayer, self).__init__(**kwargs)                                                                                                                                                     

    def build(self, input_shape):                                                                                                                                                                           
        self.mean = self.add_weight(name='mean',                                                                                                                                                            
                                  shape=(self.b,input_shape[1]),                                                                                                                                            
                                  initializer=tf.constant_initializer(self.m),                                                                                                                              
                                  trainable=False)                                                                                                                                                          
        self.var = self.add_weight(name='var',                                                                                                                                                              
                                  shape=(self.b,input_shape[1]),                                                                                                                                            
                                  initializer=tf.constant_initializer(self.v),                                                                                                                              
                                  trainable=False)                                                                                                                                                          
        super(PreprocessLayer, self).build(input_shape)  # Be sure to call this at the end                                                                                                                  

    def call(self, x):                                                                                                                                                                                      
        return (x-self.mean)/self.var                                                                                                                                                                       

    def compute_output_shape(self, input_shape):                                                                                                                                                            
        return (input_shape[0],input_shape[1])                                                                                                                                                              
    def get_config(self):                                                                                                                                                                                   
        config = super(PreprocessLayer, self).get_config()                                                                                                                                                  
        config['mean'] = self.m                                                                                                                                                                             
        config['var'] = self.v                                                                                                                                                                              
        return config                                                                                                                                                                                       

我用

来称呼这一层

L0 = PreprocessLayer(batch_size=20,mean=scaler.mean_,var=scaler.scale_)(IN)

问题出现在

shape=(self.b,input_shape[1]),

这给了我错误（当 batch_size 为 20 时）

tensorflow.python.framework.errors_impl.InvalidArgumentError: Incompatible shapes: [32,15] vs. [20,15]
     [[Node: preprocess_layer_1/sub = Sub[T=DT_FLOAT, _device="/job:localhost/replica:0/task:0/device:CPU:0"](_arg_IN_0_0, preprocess_layer_1/mean/read)]]

据我了解，由于我的权重（mean 和 var）需要与输入 x 具有相同的形状，因此当 batch_size 不是训练大小的除数时，第一个轴会出现问题，因为它在训练期间会有不同的值培训。这会导致崩溃，因为形状必须在编译时确定，我不能将其留空。

有没有办法为 shape 的第一个值设置动态值？如果没有，是否可以解决此问题？

Answer 1

对于任何有相同问题的人 - 这是一个与 epoch 结束时的 batch_size 不同的余数（由于训练和测试大小不是批量大小的倍数）导致 InvalidArgumentError: Incompatible shapes - 这里是我的解决方法。

由于这个余数的大小总是小于 batch_size，所以我在调用函数中所做的就是像这样对权重进行切片：

def call(self, x):                                                                                                                                            
        mean = self.mean[:K.shape(x)[0],:]                                                                                                                       
        std = self.std[:K.shape(x)[0],:]                                                                                                                        
        return (x-mean)/std

这可行，但这意味着如果使用大于初始化层的批次大小来评估模型，错误将再次弹出。

这就是我在 __init__ 中添加的原因： self.b = max(32,batch_size).

因为 predict() 默认使用 batch_size = 32

Answer 2

我认为您不需要添加 mean 和 var 作为权重。您可以在 call 函数中计算它们。我也不完全明白你为什么要使用它而不是 BatchNormalization 但无论如何，也许你可以试试这个代码

class PreprocessLayer(Layer):
    def __init__(self, eps=1e-6, **kwargs):
        self.eps = eps
        super(PreprocessLayer, self).__init__(**kwargs)
    def build(self, input_shape):
        super(PreprocessLayer, self).build(input_shape)
    def call(self, x):
        mean = K.mean(x, axis=-1, keepdims=True)
        std = K.std(x, axis=-1, keepdims=True)
        return (x - mean) / (std + self.eps)
    def compute_output_shape(self, input_shape):
        return input_shape

eps是为了避免被0除。

我不保证这会奏效，但不妨试一试。