Keras:如何在编译期间输入形状未知时创建带权重的自定义图层?

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Keras:如何在编译期间输入形状未知时创建带权重的自定义图层?相关的知识,希望对你有一定的参考价值。

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

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

使用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)]]

根据我的理解,由于我的权重(均值和变量)需要与输入x具有相同的形状,因此当batch_size不是训练大小的除数时,第一轴会产生问题,因为它在训练期间将具有不同的值。这会导致崩溃,因为必须在编译时确定形状,我不能将其留空。

有没有办法让第一个形状值具有动态值?如果没有,解决这个问题?

答案

我不认为你需要添加meanvar作为权重。您可以在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除。

我不保证这会起作用,但也许试一试。

另一答案

对于任何具有相同问题的人 - 这是与纪元结束时的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

以上是关于Keras:如何在编译期间输入形状未知时创建带权重的自定义图层?的主要内容,如果未能解决你的问题,请参考以下文章

输入形状 Keras RNN

如何确定keras中的输入形状?

Keras:如何保存模型或权重?

如何在形状未知的张量上应用 numpy 函数

如何在 Keras 的顺序模型中更改输入形状

Keras weighted_metrics 在计算中不包括样本权重[关闭]