kera子类api的使用

kera子类api的使用

1.kernel_initializer 和 bias_initializer：创建层权重（核和偏差）的初始化方案。此参数是一个名称或可调用对象，默认为 “Glorot uniform” 初始化器。

2.kernel_regularizer 和 bias_regularizer：应用层权重（核和偏差）的正则化方案，例如 L1 或 L2 正则化。默认情况下，系统不会应用正则化函数。

3.模型子类的使用：
build：创建层的权重。使用add_weight方法添加权重
call:定义前向传播
compute_output_shape：指定在给定输入形状的情况下如何计算层的输出形状

残差网络构建

'''
自定义模型
如果想要保存模型，需要两个类实现get_config
'''
class ResidualBlock(tf.keras.layers.Layer):
    def __init__(self,n_layers,n_eurons,**Kwargs):
        super().__init__(**Kwargs)
        self.hidden=[tf.keras.layers.Dense(n_eurons,activation='elu',kernel_initializer='he_normal') for _ in range(n_layers)]  #创建几个dense层 其实就是sequence

    def call(self, inputs, **kwargs):
        Z=inputs
        for layer in self.hidden:  #连接上几层
            Z=layer(Z)
        return inputs+Z



class ResidualRegressor(tf.keras.Model):
    def __init__(self,output_dim,**Kwargs):
        super().__init__(**Kwargs)
        self.hidden1=tf.keras.layers.Dense(30,activation='elu',kernel_initializer='he_normal')

        self.block1=ResidualBlock(2,30)
        self.block2 = ResidualBlock(2, 30)
        self.out=tf.keras.layers.Dense(output_dim)

    def call(self, inputs, training=None, mask=None):
        z=self.hidden1(inputs)
        for _ in range(1+3):
            z=self.block1(z)
        z=self.block2(z)
        return self.out(z)



class ReconstructingRegressor(tf.keras.Model):
    def __init__(self,output_dim, **kwargs):
        super().__init__(**kwargs)
        self.hidden = [keras.layers.Dense(30, activation="selu",
                                          kernel_initializer="lecun_normal")
                       for _ in range(5)]
        self.out = keras.layers.Dense(output_dim)  #最后要几分类

    def build(self, input_shape):
        n_inputs=input_shape[-1]    #因为它的单元数必须等于输入数，并且在调用build之前这个数量是未知的 input_shape的最后一个数
        self.reconstruct=tf.keras.layers.Dense(n_inputs)
        super().build(input_shape)

    def call(self, inputs):
        Z = inputs
        for layer in self.hidden:
            Z = layer(Z)
        reconstruction = self.reconstruct(Z)
        recon_loss = tf.reduce_mean(tf.square(reconstruction - inputs))
        self.add_loss(0.05 * recon_loss)
        return self.out(Z)

自定义层

模型子类的使用：
build：创建层的权重。使用add_weight方法添加权重
call:定义前向传播
compute_output_shape：指定在给定输入形状的情况下如何计算层的输出形状
'''
class MyLayer(tf.keras.layers.Layer):
    def __init__(self,output_dim, **kwargs):
        super().__init__(**kwargs)
        self.output_dim=output_dim

    def build(self,input_shape):
        shape=tf.TensorShape((input_shape[1],self.output_dim))
        self.kernel=self.add_weight(name='kernel1',shape=shape,initializer='uniform',trainable=True)
        super().build(input_shape)  #传给父类

    def call(self, inputs, **kwargs):
        return tf.matmul(inputs,self.kernel)


    # 指定在给定输入形状的情况下如何计算层的输出形状,调整形状
    # 如果你的层更改了输入张量的形状，你应该在这里定义形状变化的逻辑，这让Keras能够自动推断各层的形状
    def compute_output_shape(self, input_shape):
        shape=tf.TensorShape(input_shape).as_list()  #将形状转化为一个列表  只有输入的
        shape[-1]=self.output_dim  #列表最后一个是output_dim 包含了输出的形状

        return tf.TensorShape(shape)


    def get_config(self):
        base_config = super(MyLayer, self).get_config()
        base_config['output_dim'] = self.output_dim
        return base_config

    @classmethod
    def from_config(cls, config):
        return cls(**config)