keras layers笔记

base

Layer.get_weights():Returns the current weights of the layer

Layer.set_weights(weights): Sets the weights of the layer, from Numpy arrays.

Model.get_config(): config of the layer

Layer.add_loss(losses, **kwargs): Add loss tensor(s), potentially dependent on layer inputs.模型中增加损失函数

Layer.add_metric(value, name=None, **kwargs):Adds metric tensor to the layer

Layer.losses: 列出add_loss的结果

Layer.metrics: 列出add_metric的结果

• 单节点
  • layer.input
  • layer.output
  • layer.input_shape
  • layer.output_shape
• 多节点
  • layer.get_input_at(node_index)
  • layer.get_output_at(node_index)
  • layer.get_input_shape_at(node_index)
  • layer.get_output_shape_at(node_index)

activations

layer actions

• 以下两个用法一致
  • 独立一层

    from keras.layers import Activation, Dense
    
    model.add(Dense(64))
    model.add(Activation('tanh'))
    model.add(layers.Activation(activations.tanh))
    

  • 构建层时通过传递activation参数实现

    model.add(Dense(64, activation='tanh'))
    model.add(layers.Dense(64, activation=activations.tanh))
    

  • 高级激活层

activation layers

• 用法同上

weight initializers

• 初始化定义了设置 Keras 各层权重随机初始值的方法
• 用法 & 参数

  #  方法一
    model.add(Dense(units=64, 
                    kernel_initializer='random_uniform',
                    bias_initializer='zeros'))
  # 方法二
  layers.Dense(units=64,
               kernel_initializer=keras.initializers.RandomNormal(stddev=0.01),
               bias_initializer=keras.initializers.Zeros())
  

• 可用的初始化器
  • keras.initializers.RandomNormal(mean=0.0, stddev=0.05, seed=None)
  • keras.initializers.RandomUniform(minval=-0.05, maxval=0.05, seed=None)
  • keras.initializers.TruncatedNormal(mean=0.0, stddev=0.05, seed=None)：按照截尾正态分布生成随机张量的初始化器：在距离平均值两个标准差之外的随机值将被丢弃并重新生成。这是用来生成神经网络权重和滤波器的推荐初始化器
  • keras.initializers.Zeros()
  • keras.initializers.Ones()
  • keras.initializers.GlorotNormal(seed=None)/keras.initializers.glorot_normal(seed=None)
    • Glorot 正态分布初始化器，也称为 Xavier 正态分布初始化器：以 0 为中心，标准差为 $\sigma =\sqrt{\frac{2}{a+b}}$的截断正态分布中抽取样本， 其中 $a$ 是权值张量中的输入单位的数量， $b$ 是权值张量中的输出单位的数量
  • keras.initializers.GlorotUniform(seed=None)/keras.initializers.glorot_uniform(seed=None)
    • Glorot 均匀分布初始化器，也称为 Xavier 均匀分布初始化器：它从 $[-\sqrt{\frac{6}{a+b}}，\sqrt{\frac{6}{a+b}}]$ 中的均匀分布中抽取样本
  • keras.initializers.Identity(gain=1.0): 生成单位矩阵的初始化器：仅用于 2D 方阵
  • keras.initializers.Orthogonal(gain=1.0, seed=None)：生成一个随机正交矩阵的初始化器。
  • keras.initializers.Constant(value=0)
  • keras.initializers.VarianceScaling(scale=1.0, mode="fan_in", distribution="truncated_normal", seed=None)：初始化器能够根据权值的尺寸调整其规模。
  • keras.initializers.lecun_uniform(seed=None): LeCun 均匀初始化器
  • keras.initializers.lecun_normal(seed=None)：LeCun 正态分布初始化器：以 0 为中心，标准差为 $\sigma =\sqrt{\frac{1}{a}}$ 的截断正态分布中抽取样本， 其中 $a$ 是权值张量中的输入单位的数量
  • keras.initializers.he_normal(seed=None)：He 正态分布初始化器：它从以 0 为中心，标准差为 $\sigma =\sqrt{\frac{2}{a}}$ 的截断正态分布中抽取样本， 其中 $a$ 是权值张量中的输入单位的数量
  • keras.initializers.he_uniform(seed=None)：He 均匀方差缩放初始化器：从 $[-\frac{6}{a}，\frac{6}{a}]$ 中的均匀分布中抽取样本
• weight regularizers
  • 惩罚是以层为对象进行的。具体的 API 因层而异，但 Dense，Conv1D，Conv2D 和 Conv3D 这些层具有统一的 API
  • 可用正则化器
    • keras.regularizers.l1(l1=0.01, **kwargs): loss = l1 * reduce_sum(abs(x))
    • keras.regularizers.l2(l2=0.01, **kwargs)：loss = l2 * reduce_sum(square(x))
    • keras.regularizers.l1_l2(l1=0.01, l2=0.01)
  • 用法

   layers.Dense(units=64,
                kernel_regularizer=regularizers.l1_l2(l1=1e-5, l2=1e-4), #  layer's kernel 应用正则
                bias_regularizer=regularizers.l2(1e-4),  # layer's bias应用正则
                activity_regularizer=regularizers.l2(1e-5))  # layer's output应用正则
  

weight constraints

• 该模块的函数允许在优化期间对网络参数设置约束
• 约束是以层为对象进行的。具体的 API 因层而异，但 Dense，Conv1D，Conv2D 和 Conv3D 这些层具有统一的 API
• 可用约束
  • keras.constraints.MaxNorm(max_value=2, axis=0): 最大范数权值约束：映射到每个隐藏单元的权值的约束，使其具有小于或等于期望值的范数
  • keras.constraints.MinMaxNorm(min_value=0.0, max_value=1.0, rate=1.0, axis=0)：最小/最大范数权值约束。映射到每个隐藏单元的权值的约束，使其范数在上下界之间
  • keras.constraints.NonNeg()：权重非负的约束
  • keras.constraints.UnitNorm(axis=0)：映射到每个隐藏单元的权值的约束，使其具有单位范数。
  • keras.constraints.RadialConstraint()/keras.constraints.radial_constraint: 约束 Conv2D 的kernel weights to be the same for each radius.
• 用法
  • kernel_constraint: 用于kernel
  • bias_constraint: 用于bias

core

Input：实例化 Keras 张量

Dense：全连接层

kernel：由网络层创建的权值矩阵

• 若该层的输入的秩大于2，那么它首先被展平然后 再计算与 kernel 的点乘

keras.layers.Dense(units,  #  输出空间维度
                   activation=None, # 激活函数
                   use_bias=True,  # 是否使用偏置向量
                   kernel_initializer="glorot_uniform",
                   bias_initializer="zeros",
                   kernel_regularizer=None,  # 正则
                   bias_regularizer=None,
                   activity_regularizer=None,
                   kernel_constraint=None,  # 约束
                   bias_constraint=None,
                   **kwargs)

Activation：将激活函数应用于输出。见上述

keras.layers.Activation(activation, **kwargs)

Embedding

• 要点
  • 场景：适用于文本数据的神经网络
  • 目的：将正整数（索引值）转换为固定尺寸的稠密向量
  • 使用：该层只能用作模型中的第一层
• 介绍：某些情况下，将特征转换为one-hot编码后维度会十分高。所以我们会将one-hot这种稀疏特征转化为稠密特征，通常做法也就是转化为我们常用的embedding。
  在NLP领域中，我们需要将文本转化为电脑所能读懂的语言，也就是把文本语句转化为向量，也就是embedding。
• Word Embedding：单词嵌入是使用密集的矢量表示来表示单词和文档的一类方法。
  • 词嵌入是对传统的词袋模型编码方案的改进，传统方法使用大而稀疏的矢量来表示每个单词或者在矢量内对每个单词进行评分以表示整个词汇表：稀疏，量大
  • 学习到的向量空间（向量空间中的单词的位置是从文本中学习的，并且基于在使用单词时围绕单词的单词）中的单词的位置被称为它的嵌入：Embedding
  • 从文本学习单词嵌入的两个方法：Word2Vec， GloVe
• 用法

keras.layers.Embedding(input_dim, # 词汇表大小， 即，最大整数 index + 1
                       output_dim,  # 词向量的维度
                       embeddings_initializer='uniform',  # 矩阵的初始化方法
                       embeddings_regularizer=None, 
                       activity_regularizer=None, 
                       embeddings_constraint=None, 
                       mask_zero=False, # 是否把 0 看作为一个应该被遮蔽的特殊的 "padding" 值。 这对于可变长的 RNN 十分有用。 如果设定为 True，那么接下来的所有层都必须支持 masking，否则就会抛出异常。 如果 mask_zero 为 True，作为结果，索引 0 就不能被用于词汇表中 （input_dim 应该与 vocabulary + 1 大小相同）
                       input_length=None, # 输入序列的长度，当它是固定的时。 如果你需要连接 Flatten 和 Dense 层，则这个参数是必须的
                        **kwargs)

Masking：使用覆盖值覆盖序列，以跳过时间步

• keras.layers.Masking(mask_value=0.0, **kwargs)

Lambda: 将任意表达式封装为 Layer 对象：lambda表达式

 keras.layers.Lambda(function, # 函数
                   output_shape=None, # 预期的函数输出尺寸。 只在使用 Theano 时有意义
                   mask=None, 
                   arguments=None)

Flatten：将输入展平。不影响批量大小

Reshape：将输入重新调整为特定的尺寸

Permute：根据给定的模式置换输入的维度

• 某些场景下很有用。如：将RNN和CNN连接在一起

keras.layers.Permute(dims)

RepeatVector：将输入重复 n 次

• 输入：二维tensor：(num_samples, features)
• 输出：三维tensor：(num_samples, n, features)

keras.layers.RepeatVector(n)

Masking：使用覆盖值覆盖序列，以跳过时间步

Cropping1D：一维裁剪层（如：时序）

• 输入：三维tensor：(batch, axis_to_crop, features)
• 输出：三维tensor：(batch, cropped_axis, features)

keras.layers.Cropping1D(cropping=(1, 1)) # 在裁剪维度（第 1 个轴）的开始和结束位置 应该裁剪多少个单位

Cropping2D：二维裁剪层（如：图像）

• 输入：4维tensor：data_format=‘channels_last’: (batch, cropped_rows, cropped_cols, channels); data_format=‘channels_first’:(batch, channels, cropped_rows, cropped_cols)
• 输出：同输入

keras.layers.Cropping2D(cropping=((0, 0), (0, 0)), data_format=None)

Cropping3D：三维裁剪层（如：空间或时空）

• 输入：5维tensor：data_format=‘channels_last’: (batch, first_cropped_axis, second_cropped_axis, third_cropped_axis, depth); data_format=‘channels_first’:(batch, depth, first_cropped_axis, second_cropped_axis, third_cropped_axis)
• 输出：同输入

keras.layers.Cropping3D(cropping=((1, 1), (1, 1), (1, 1)), data_format=None)

UpSampling1D：一维输入的上采样层

• 输入：三维tensor：(batch, steps, features)
• 输出：三维tensor：(batch, upsampled_steps, features)

keras.layers.UpSampling1D(size=2) # 上采样因子

UpSampling2D：2维输入的上采样层

  *  输入：4维tensor：data_format='channels_last': (batch, rows, cols, channels); data_format='channels_first':(batch, channels, rows, cols)
  *  输出：4维tensor：data_format='channels_last': (batch, upsampled_rows, upsampled_cols, channels); data_format='channels_first':(batch, channels, upsampled_rows, upsampled_cols)
  ```python
   keras.layers.UpSampling2D(size=(2, 2),  # 行和列的上采样因子
                             data_format=None, 
                             interpolation='nearest') # nearest, bilinear
  ```

UpSampling3D：3维输入的上采样层

• 沿着数据的第 1、2、3 维度分别重复 size[0]、size[1] 和 size[2] 次
• 输入：5维tensor：data_format=‘channels_last’: (batch, dim1, dim2, dim3, channels); data_format=‘channels_first’:(batch, channels, dim1, dim2, dim3)
• 输出：5维tensor：data_format=‘channels_last’: (batch, upsampled_dim1, upsampled_dim2, upsampled_dim3, channels); data_format=‘channels_first’:(batch, channels, upsampled_dim1, upsampled_dim2, upsampled_dim3)

 keras.layers.UpSampling3D(size=(2, 2, 2),  # 行和列的上采样因子
                           data_format=None) # nearest, bilinear

ZeroPadding1D：一维输入的零填充层（例如，时序）

• 输入：三维tensor：(batch, axis_to_pad, features)
• 输出：三维tensor：(batch, padded_axis, features)

keras.layers.ZeroPadding1D(padding=1) # 在填充维度的开始和结尾处添加多少个零

ZeroPadding2D：2维输入的零填充层（例如图像）

• 该图层可以在图像张量的顶部、底部、左侧和右侧添加零表示的行和列
• 输入：4维tensor：data_format=‘channels_last’: (batch, rows, cols, channels); data_format=‘channels_first’:(batch, channels, rows, cols)
• 输出：4维tensor：data_format=‘channels_last’: (batch, padded_rows, padded_cols, channels); data_format=‘channels_first’:(batch, channels, padded_rows, padded_cols)

 keras.layers.ZeroPadding2D(padding=(1, 1), 
                           data_format=None) 

ZeroPadding3D：3维输入的零填充层（空间或时空）

• 输入：5维tensor：data_format=‘channels_last’: (batch, first_axis_to_pad, second_axis_to_pad, third_axis_to_pad, channels); data_format=‘channels_first’:(batch, channels, first_axis_to_pad, second_axis_to_pad, third_axis_to_pad)
• 输出：5维tensor：data_format=‘channels_last’: (batch, first_padded_axis, second_padded_axis, third_axis_to_pad, channels); data_format=‘channels_first’:(batch, channels, first_padded_axis, second_padded_axis, third_axis_to_pad)

 keras.layers.ZeroPadding3D(padding=(1, 1, 1), 
                           data_format=None) 

convolution

Conv1D：

• 1维度卷积层 (如时序卷积)
• 输入输出均为3维向量，具体形式由参数data_format确定

keras.layers.Conv1D(filters,  # 输出空间的维度 （即卷积中滤波器的输出数量）
                    kernel_size,  # 一个整数，或者单个整数表示的元组或列表， 指明 一维 卷积窗口的长度
                    strides=1,  # 卷积的步长
                    padding="valid", # 填充方式：'valid'为不填充，'same'为填充输入以使输出具有与原始输入相同的长度，'causal'为因果（膨胀）卷积
                    data_format="channels_last", # 输入的各个维度顺序：默认的'channels_last'对应输入尺寸：(batch, steps, channels)；'channels_first'对应