keras layers笔记
发布日期:2022-02-14 23:02:58 浏览次数:33 分类:技术文章

本文共 67922 字,大约阅读时间需要 226 分钟。

文章目录

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)

  • 以下两个用法一致
    • 独立一层
      from keras.layers import Activation, Densemodel.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))

  • 用法同上

  • 初始化定义了设置 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 为中心,标准差为 σ = 2 a + b \sigma = \sqrt{\frac{2}{a + b}} σ=a+b2 的截断正态分布中抽取样本, 其中 a a a 是权值张量中的输入单位的数量, b b b 是权值张量中的输出单位的数量
    • keras.initializers.GlorotUniform(seed=None)/keras.initializers.glorot_uniform(seed=None)
      • Glorot 均匀分布初始化器,也称为 Xavier 均匀分布初始化器:它从 [ − 6 a + b , 6 a + b ] [-\sqrt{\frac{6}{a + b}},\sqrt{\frac{6}{a + b}}] [a+b6 a+b6 ] 中的均匀分布中抽取样本
    • 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 为中心,标准差为 σ = 1 a \sigma = \sqrt{\frac{1}{a}} σ=a1 的截断正态分布中抽取样本, 其中 a a a 是权值张量中的输入单位的数量
    • keras.initializers.he_normal(seed=None):He 正态分布初始化器:它从以 0 为中心,标准差为 σ = 2 a \sigma = \sqrt{\frac{2}{a}} σ=a2 的截断正态分布中抽取样本, 其中 a a a 是权值张量中的输入单位的数量
    • keras.initializers.he_uniform(seed=None):He 均匀方差缩放初始化器:从 [ − 6 a , 6 a ] [-\frac{6}{a},\frac{6}{a}] [a6a6] 中的均匀分布中抽取样本
    • 惩罚是以层为对象进行的。具体的 API 因层而异,但 DenseConv1DConv2DConv3D 这些层具有统一的 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应用正则

  • 该模块的函数允许在优化期间对网络参数设置约束
  • 约束是以层为对象进行的。具体的 API 因层而异,但 DenseConv1DConv2DConv3D 这些层具有统一的 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

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)

  • 要点
    • 场景:适用于文本数据的神经网络
    • 目的:将正整数(索引值)转换为固定尺寸的稠密向量
    • 使用:该层只能用作模型中的第一层
  • 介绍:某些情况下,将特征转换为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)

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'对应尺寸:(batch, channels, steps)                    dilation_rate=1, # 一个整数,或者单个整数表示的元组或列表,指定用于膨胀卷积的膨胀率                    groups=1, # 一个正整数,指定输入沿通道轴划分的组数。 每个组分别与过滤器/组过滤器卷积。 输出是沿通道轴的所有组结果的串联。 输入通道和过滤器都必须被组整除。                    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,                    input_shape, # 仅为第一层提供:(向量数, 向量维度),向量数为None时为变长序列                    **kwargs)

Conv2D

  • 2维度卷积层 (如图像的空间卷积)
  • 输入输出均为4维向量,具体形式由参数data_format确定
keras.layers.Conv2D(filters,  # 输出空间的维度 (即卷积中滤波器的输出数量)                      kernel_size,  # 一个整数,或者2 个整数表示的元组或列表, 指明 2维 卷积窗口的宽度和高度。一个整数,则两个维度值一致                      strides=(1, 1),  # 卷积沿宽度和高度方向的步长                      padding="valid", # 填充方式:'valid'为不填充,'same'为填充输入以使输出具有与原始输入相同的长度                      data_format=None, # 输入的各个维度顺序:默认的'channels_last'对应输入尺寸:(batch, height, width, channels);'channels_first'对应尺寸:(batch, channels, height, width)                      dilation_rate=(1, 1), # 膨胀卷积的膨胀率                      groups=1, # 一个正整数,指定输入沿通道轴划分的组数。 每个组分别与过滤器/组过滤器卷积。 输出是沿通道轴的所有组结果的串联。 输入通道和过滤器都必须被组整除。                      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,                      input_shape, # 仅为第一层提供:不包括样本表示的轴,由参数 data_format 确定                      **kwargs)

Conv3D

  • 3维度卷积层 (如立体空间卷积)
    • 输入输出均为 5维向量,具体形式由参数data_format确定
    keras.layers.Conv3D(filters,  # 输出空间的维度 (即卷积中滤波器的输出数量)                    kernel_size,  # 一个整数,或者3个整数表示的元组或列表, 指明 3维 卷积窗口的深度、宽度和高度。一个整数,则两个维度值一致                    strides=(1, 1, 1),  # 卷积沿各个空间维度的步长                    padding="valid", # 填充方式:'valid'为不填充,'same'为填充输入以使输出具有与原始输入相同的长度                    data_format=None, # 输入的各个维度顺序:默认的'channels_last'对应输入尺寸:(batch, spatial_dim1, spatial_dim2, spatial_dim3, channels);'channels_first'对应尺寸:(batch, channels, spatial_dim1, spatial_dim2, spatial_dim3)                    dilation_rate=(1, 1, 1), # 膨胀卷积的膨胀率                    groups=1, # 一个正整数,指定输入沿通道轴划分的组数。 每个组分别与过滤器/组过滤器卷积。 输出是沿通道轴的所有组结果的串联。 输入通道和过滤器都必须被组整除。                    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,                    input_shape, # 仅为第一层提供:不包括样本表示的轴,由参数 data_format 确定                    **kwargs)

SeparableConv1D

*  深度方向的可分离 1维 卷积:首先执行深度方向的空间卷积 (分别作用于每个输入通道),紧接一个将所得输出通道 混合在一起的逐点卷积  *  输入输出均为 3维向量,具体形式由参数`data_format`确定
keras.layers.SeparableConv1D(filters,  # 输出空间的维度 (即卷积中滤波器的输出数量)                                 kernel_size,  # 1维 卷积窗口的长度                                 strides=1,  # 卷积沿各个空间维度的步长                                 padding="valid", # 填充方式:'valid'为不填充,'same'为填充输入以使输出具有与原始输入相同的长度                                 data_format=None, # 输入的各个维度顺序:默认的'channels_last'对应输入尺寸:(batch, height, width, channels);'channels_first'对应尺寸:(batch, channels, height, width)                                 dilation_rate=1, # 膨胀卷积的膨胀率                                 depth_multiplier=1, # 每个输入通道的深度方向卷积输出通道的数量。 深度方向卷积输出通道的总数将等于 filterss_in * depth_multiplier                                 activation=None,                                 use_bias=True,                                 depthwise_initializer="glorot_uniform",  # 深度方向的核矩阵的初始化                                 pointwise_initializer="glorot_uniform",  #  逐点核矩阵的初始化                                 bias_initializer="zeros",                                 depthwise_regularizer=None,  #  正则化                                 pointwise_regularizer=None,                                   bias_regularizer=None,                                 activity_regularizer=None,                                 depthwise_constraint=None,  #  约束                                 pointwise_constraint=None,                                 bias_constraint=None,                                 **kwargs)

SeparableConv2D

  • 深度方向的可分离 2维 卷积:首先执行深度方向的空间卷积 (分别作用于每个输入通道),紧接一个将所得输出通道 混合在一起的逐点卷积
  • 输入输出均为 4维向量,具体形式由参数data_format确定
keras.layers.SeparableConv2D(filters,  # 输出空间的维度 (即卷积中滤波器的输出数量)                              kernel_size,  # 2维 卷积窗口的高度和宽度                              strides=(1, 1),  # 卷积沿各个空间维度的步长                              padding="valid", # 填充方式:'valid'为不填充,'same'为填充输入以使输出具有与原始输入相同的长度                              data_format=None, # 输入的各个维度顺序:默认的'channels_last'对应输入尺寸:(batch, height, width, channels);'channels_first'对应尺寸:(batch, channels, height, width)                              dilation_rate=(1, 1), # 扩张(空洞)卷积指明扩张率                              depth_multiplier=1, # 每个输入通道的深度方向卷积输出通道的数量。 深度方向卷积输出通道的总数将等于 filterss_in * depth_multiplier                              activation=None,                              use_bias=True,                              depthwise_initializer="glorot_uniform",  # 深度方向的核矩阵的初始化                              pointwise_initializer="glorot_uniform",  #  逐点核矩阵的初始化                              bias_initializer="zeros",                              depthwise_regularizer=None,  #  正则化                              pointwise_regularizer=None,                                bias_regularizer=None,                              activity_regularizer=None,                              depthwise_constraint=None,  #  约束                              pointwise_constraint=None,                              bias_constraint=None,                              **kwargs)

DepthwiseConv2D

  • 深度可分离 2维 卷积:仅执行深度空间卷积中的第一步(其分别作用于每个输入通道)
  • 输入输出均为 4维向量,具体形式由参数data_format确定
keras.layers.DepthwiseConv2D(kernel_size,  # 2维 卷积窗口的高度和宽度                              strides=(1, 1),  # 卷积沿各个空间维度的步长                              padding="valid", # 填充方式:'valid'为不填充,'same'为填充输入以使输出具有与原始输入相同的长度                              data_format=None, # 输入的各个维度顺序:默认的'channels_last'对应输入尺寸:(batch, height, width, channels);'channels_first'对应尺寸:(batch, channels, height, width)                              dilation_rate=(1, 1), # 扩张(空洞)卷积指明扩张率                              depth_multiplier=1, # 每个输入通道的深度方向卷积输出通道的数量。 深度方向卷积输出通道的总数将等于 filterss_in * depth_multiplier                              activation=None,                              use_bias=True,                              depthwise_initializer="glorot_uniform",  # 深度方向的核矩阵的初始化                              bias_initializer="zeros",                              depthwise_regularizer=None,  #  正则化                              bias_regularizer=None,                              activity_regularizer=None,                              depthwise_constraint=None,  #  约束                              bias_constraint=None,                              **kwargs)

Conv2DTranspose

  • 转置卷积层 (有时被成为反卷积):对转置卷积的需求一般来自希望使用 与正常卷积相反方向的变换, 即,将具有卷积输出尺寸的东西 转换为具有卷积输入尺寸的东西, 同时保持与所述卷积相容的连通性模式
  • 输入输出均为 4维向量,具体形式由参数data_format确定
keras.layers.Conv2DTranspose(filters,  # 输出空间的维度 (即卷积中滤波器的输出数量)                              kernel_size,  # 2维 卷积窗口的高度和宽度                              strides=(1, 1),  # 卷积沿各个空间维度的步长                              padding="valid", # 填充方式:'valid'为不填充,'same'为填充输入以使输出具有与原始输入相同的长度                              output_padding=None, # 沿输出各个张量维度的填充量。如果设置为 None (默认), 输出尺寸将自动推理出来                              data_format=None, # 输入的各个维度顺序:默认的'channels_last'对应输入尺寸:(batch, height, width, channels);'channels_first'对应尺寸:(batch, channels, height, width)                              dilation_rate=(1, 1), # 膨胀卷积的膨胀率                              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,                              input_shape, # 仅为第一层提供:不包括样本表示的轴,由参数 data_format 确定                              **kwargs)

Conv3DTranspose

  • 转置卷积层 (有时被成为反卷积):对转置卷积的需求一般来自希望使用 与正常卷积相反方向的变换, 即,将具有卷积输出尺寸的东西 转换为具有卷积输入尺寸的东西, 同时保持与所述卷积相容的连通性模式
  • 输入输出均为 5维向量,具体形式由参数data_format确定
keras.layers.Conv3DTranspose(filters,  # 输出空间的维度 (即卷积中滤波器的输出数量)                              kernel_size,  # 2维 卷积窗口的深度、高度和宽度                              strides=(1, 1, 1),  # 卷积沿各个空间维度的步长                              padding="valid", # 填充方式:'valid'为不填充,'same'为填充输入以使输出具有与原始输入相同的长度                              output_padding=None, # 沿输出各个张量维度的填充量。如果设置为 None (默认), 输出尺寸将自动推理出来                              data_format=None, # 输入的各个维度顺序:默认的'channels_last'对应输入尺寸:(batch, height, width, channels);'channels_first'对应尺寸:(batch, channels, height, width)                              dilation_rate=(1, 1, 1), # 膨胀卷积的膨胀率                              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,                              input_shape, # 仅为第一层提供:不包括样本表示的轴,由参数 data_format 确定                              **kwargs)

MaxPooling1D

  • 对于时序数据的最大池化
    • 输入输出均为 3维向量,具体形式由参数data_format确定
      • 输出 padding=“valid”:output_shape = (input_shape - pool_size + 1) / strides)
      • 输出 padding=“same”:output_shape = input_shape / strides
    keras.layers.MaxPooling1D(pool_size=2,  #  最大池化的窗口大小:缩小比例的因数。 如,2 会使得输入张量缩小一半                          strides=None,  #  步长                          padding="valid",                           data_format="channels_last",  # 输入的各个维度顺序:默认的'channels_last'对应输入尺寸:(batch, steps, features);'channels_first'对应尺寸:(batch, features, steps)                          **kwargs)

MaxPooling2D

  • 对于空间数据的最大池化
    • 输入输出均为 4维向量,具体形式由参数data_format确定
      • 输出 padding=“valid”:output_shape = (input_shape - pool_size + 1) / strides)
      • 输出 padding=“same”:output_shape = input_shape / strides
    keras.layers.MaxPooling2D(pool_size=(2, 2),  #  沿各维度方向缩小比例的因数                          strides=None,  #  步长                          padding="valid",                           data_format=None,  # 输入的各个维度顺序:默认的'channels_last'对应输入尺寸:(batch, height, width, channels);'channels_first'对应尺寸:(batch, channels, height, width)                          **kwargs)

MaxPooling3D

  • 对于 三维(空间,或时空间)数据的最大池化
  • 输入输出均为 5维向量,具体形式由参数data_format确定
keras.layers.MaxPooling3D(pool_size=(2, 2, 2),  #  沿各维度方向缩小比例的因数                          strides=None,  #  步长                          padding="valid",                           data_format=None,  # 输入的各个维度顺序:默认的'channels_last'对应输入尺寸:(batch, spatial_dim1, spatial_dim2, spatial_dim3, channels);'channels_first'对应尺寸:(batch, channels, spatial_dim1, spatial_dim2, spatial_dim3)                          **kwargs)

AveragePooling1D

  • 对于时序数据的平均池化
  • 输入输出均为 3维向量,具体形式由参数data_format确定
keras.layers.AveragePooling1D(pool_size=2,  #  平均池化的窗口大小:缩小比例的因数。 如,2 会使得输入张量缩小一半                              strides=None,  #  步长                              padding="valid",                               data_format="channels_last",  # 输入的各个维度顺序:默认的'channels_last'对应输入尺寸:(batch, steps, features);'channels_first'对应尺寸:(batch, features, steps)                              **kwargs)

AveragePooling2D

  • 对于空间数据的平均池化
  • 输入输出均为 4维向量,具体形式由参数data_format确定
keras.layers.AveragePooling2D(pool_size=(2, 2),  #  沿各维度方向缩小比例的因数                              strides=None,  #  步长                              padding="valid",                               data_format="channels_last",  # 输入的各个维度顺序:默认的'channels_last'对应输入尺寸:(batch, height, width, channels);'channels_first'对应尺寸:(batch, channels, height, width)                              **kwargs)

AveragePooling3D

  • 对于三维(空间,或时空间)数据的平均池化
  • 输入输出均为 5维向量,具体形式由参数data_format确定
keras.layers.AveragePooling3D(pool_size=(2, 2, 2),  #  沿各维度方向缩小比例的因数                              strides=None,  #  步长                              padding="valid",                               data_format="channels_last",  # 输入的各个维度顺序:默认的'channels_last'对应输入尺寸:(batch, height, width, channels);'channels_first'对应尺寸:(batch, channels, height, width)                              **kwargs)

GlobalMaxPooling1D

  • 对于时序数据的全局最大池化
  • 输入:3维向量,具体形式由参数data_format确定
  • 输出:2维向量:(batch_size, features)
keras.layers.GlobalMaxPooling1D(data_format="channels_last",  # 输入的各个维度顺序:默认的'channels_last'对应输入尺寸:(batch, steps, features);'channels_first'对应尺寸:(batch, features, steps)                               **kwargs)

GlobalMaxPooling2D

  • 对于空域数据的全局最大池化
  • 输入:4维向量,具体形式由参数data_format确定
  • 输出:2维向量:(batch_size, channels)
keras.layers.GlobalMaxPooling2D(data_format="channels_last",  # 输入的各个维度顺序:默认的'channels_last'对应输入尺寸:(batch, height, width, channels);'channels_first'对应尺寸:(batch, channels, height, width)                               **kwargs)

GlobalMaxPooling3D

  • 对于三维(空间,或时空间)数据的全局最大池化
  • 输入:5维向量,具体形式由参数data_format确定
  • 输出:2维向量:(batch_size, channels)
keras.layers.GlobalMaxPooling3D(data_format="channels_last",  # 输入的各个维度顺序:默认的'channels_last'对应输入尺寸:(batch, spatial_dim1, spatial_dim2, spatial_dim3, channels);'channels_first'对应尺寸:(batch, channels, spatial_dim1, spatial_dim2, spatial_dim3)                               **kwargs)

GlobalAveragePooling1D

  • 对于时序数据的全局平均池化
  • 输入:3维向量,具体形式由参数data_format确定
  • 输出:2维向量:(batch_size, features)
keras.layers.GlobalAveragePooling1D(data_format="channels_last",  # 输入的各个维度顺序:默认的'channels_last'对应输入尺寸:(batch, steps, features);'channels_first'对应尺寸:(batch, features, steps)                                    **kwargs)

GlobalAveragePooling2D

  • 对于空域数据的全局平均池化
  • 输入:4维向量,具体形式由参数data_format确定
  • 输出:2维向量:(batch_size, channels)
keras.layers.GlobalAveragePooling2D(data_format="channels_last",  # 输入的各个维度顺序:默认的'channels_last'对应输入尺寸:(batch, height, width, channels);'channels_first'对应尺寸:(batch, channels, height, width)                                    **kwargs)

GlobalAveragePooling3D

  • 对于三维(空间,或时空间)数据的全局平均池化
  • 输入:5维向量,具体形式由参数data_format确定
  • 输出:2维向量:(batch_size, channels)
keras.layers.GlobalAveragePooling3D(data_format="channels_last",  # 输入的各个维度顺序:默认的'channels_last'对应输入尺寸:(batch, spatial_dim1, spatial_dim2, spatial_dim3, channels);'channels_first'对应尺寸:(batch, channels, spatial_dim1, spatial_dim2, spatial_dim3)                                    **kwargs)

Base RNN

  • 输入:(batch_size, time_steps, input_dim) / (time_steps, batch_size, input_dim)
  • 输出
    • return_state=True:(batch_size, units)
    • return_sequences=True: (batch_size, time_steps, units)
    • else: (batch_size, units)
keras.layers.RNN(cell,  #  一个 RNN 单元实例                  return_sequences=True, # 是返回输出序列中的最后一个输出,还是全部序列                  return_state=False,  # 除了输出之外是否返回最后一个状态                  go_backwards=False,  # 默认 False。 如果为 True,则向后处理输入序列并返回相反的序列                  stateful=False,  # 默认 False。 如果为 True,则批次中索引 i 处的每个样品的最后状态 将用作下一批次中索引 i 样品的初始状态                  unroll=False, # 默认 False。 如果为 True,则网络将展开,否则将使用符号循环。 展开可以加速 RNN,但它往往会占用更多的内存。 展开只适用于短序列                  time_major=False,                   inputs, # [batch_size, time_steps, input_dim]                  **kwargs)

SimpleRNN:全连接的 RNN,其输出将被反馈到输入

keras.layers.SimpleRNN(units,  #  输出空间的维度                    activation="tanh",                    recurrent_activation="sigmoid", # 用于循环时间步的激活函数。默认 sigmoid, None 为 f(x) = x                    use_bias=True,                    kernel_initializer="glorot_uniform",  #  初始化                    recurrent_initializer="orthogonal",                    bias_initializer="zeros",                    kernel_regularizer=None,  # 正则                    recurrent_regularizer=None,                    bias_regularizer=None,                    activity_regularizer=None,                    kernel_constraint=None,  #  约束                    recurrent_constraint=None,                    bias_constraint=None,                    dropout=0.0, # 单元的丢弃比例,用于输入的线性转换                    recurrent_dropout=0.0,  # 单元的丢弃比例,用于循环层状态的线性转换                    return_sequences=False, # 是返回输出序列中的最后一个输出,还是全部序列                    return_state=False,  # 除了输出之外是否返回最后一个状态                    go_backwards=False,  # 默认 False。 如果为 True,则向后处理输入序列并返回相反的序列                    stateful=False,  # 默认 False。 如果为 True,则批次中索引 i 处的每个样品的最后状态 将用作下一批次中索引 i 样品的初始状态                    unroll=False, # 默认 False。 如果为 True,则网络将展开,否则将使用符号循环。 展开可以加速 RNN,但它往往会占用更多的内存。 展开只适用于短序列                    inputs, # [batch_size, time_steps, features]                    **kwargs)

SimpleRNNCell:SimpleRNN 的单元类。

keras.layers.SimpleRNNCell(units,  #  输出空间的维度                    activation="tanh",                    recurrent_activation="sigmoid", # 用于循环时间步的激活函数。默认 sigmoid, None 为 f(x) = x                    use_bias=True,                    kernel_initializer="glorot_uniform",  #  初始化                    recurrent_initializer="orthogonal",                    bias_initializer="zeros",                    kernel_regularizer=None,  # 正则                    recurrent_regularizer=None,                    bias_regularizer=None,                    activity_regularizer=None,                    kernel_constraint=None,  #  约束                    recurrent_constraint=None,                    bias_constraint=None,                    dropout=0.0, # 单元的丢弃比例,用于输入的线性转换                    recurrent_dropout=0.0,  # 单元的丢弃比例,用于循环层状态的线性转换                    inputs, # [batch_size, features]                    **kwargs)

LSTM

keras.layers.LSTM(units,  #  输出空间的维度                    activation="tanh",                    recurrent_activation="sigmoid", # 用于循环时间步的激活函数。默认 sigmoid, None 为 f(x) = x                    use_bias=True,                    kernel_initializer="glorot_uniform",  #  初始化                    recurrent_initializer="orthogonal",                    bias_initializer="zeros",                    unit_forget_bias=True,  #  True: 初始化时,将忘记门的偏置加 1, 同时还会强制 bias_initializer="zeros"                    kernel_regularizer=None,  # 正则                    recurrent_regularizer=None,                    bias_regularizer=None,                    activity_regularizer=None,                    kernel_constraint=None,  #  约束                    recurrent_constraint=None,                    bias_constraint=None,                    dropout=0.0, # 单元的丢弃比例,用于输入的线性转换                    recurrent_dropout=0.0,  # 单元的丢弃比例,用于循环层状态的线性转换                    implementation=2, # 实现模式,1 或 2。 模式 1 将把它的操作结构化为更多的小的点积和加法操作, 而模式 2 将把它们分批到更少,更大的操作中。 这些模式在不同的硬件和不同的应用中具有不同的性能配置文件                    return_sequences=False, # 是返回输出序列中的最后一个输出,还是全部序列                    return_state=False,  # 除了输出之外是否返回最后一个状态                    go_backwards=False,  # 默认 False。 如果为 True,则向后处理输入序列并返回相反的序列                    stateful=False,  # 默认 False。 如果为 True,则批次中索引 i 处的每个样品的最后状态 将用作下一批次中索引 i 样品的初始状态                    time_major=False,  # 输入和输出张量的形状格式。 如果为True,则输入和输出的形状为[steps,batch_size,features],而如果为False,则输入和输出的形状为[batch_size,steps,features]。 使用time_major = True会更有效率,因为它避免了RNN计算开始和结束的转置。 但是,大多数TensorFlow数据都是批量生产的,因此默认情况下,此功能接受输入并以批量生产的形式发出输出。                    unroll=False, # 默认 False。 如果为 True,则网络将展开,否则将使用符号循环。 展开可以加速 RNN,但它往往会占用更多的内存。 展开只适用于短序列                    inputs, # [batch_size, time_steps, features]                    **kwargs)

LSTMCell:LSTM 层的单元类

keras.layers.LSTMCell(units,  #  输出空间的维度                   activation="tanh",                   recurrent_activation="sigmoid", # 用于循环时间步的激活函数。默认 sigmoid, None 为 f(x) = x                   use_bias=True,                   kernel_initializer="glorot_uniform",  #  初始化                   recurrent_initializer="orthogonal",                   bias_initializer="zeros",                   unit_forget_bias=True,  #  True: 初始化时,将忘记门的偏置加 1, 同时还会强制 bias_initializer="zeros"                   kernel_regularizer=None,  # 正则                   recurrent_regularizer=None,                   bias_regularizer=None,                   activity_regularizer=None,                   kernel_constraint=None,  #  约束                   recurrent_constraint=None,                   bias_constraint=None,                   dropout=0.0, # 单元的丢弃比例,用于输入的线性转换                   recurrent_dropout=0.0,  # 单元的丢弃比例,用于循环层状态的线性转换                   implementation=2, # 实现模式,1 或 2。 模式 1 将把它的操作结构化为更多的小的点积和加法操作, 而模式 2 将把它们分批到更少,更大的操作中。 这些模式在不同的硬件和不同的应用中具有不同的性能配置文件                   inputs, # [batch_size, features]                   **kwargs)

ConvLSTM2D:卷积 LSTM:类似于 LSTM 层,但输入变换和循环变换都是卷积的

  • 输入:5维向量,具体形式由参数data_format确定
  • 输出: output_row, output_col取决于 filter 和 padding 的尺寸
    • return_sequences = True:5维 向量:(samples, time, filters, output_row, output_col) / (samples, time, output_row, output_col, filters)
    • return_sequences = False:4维 向量:(samples, filters, output_row, output_col) / (samples, output_row, output_col, filters)
keras.layers.ConvLSTM2D(filters,  # 输出空间的维度 (即卷积中滤波器的输出数量)                        kernel_size,  # 卷积窗口的维度                        strides=(1, 1),  # 卷积的步长                        padding="valid",                        data_format=None,  # channels_last 对应 (batch, time, ..., channels), channels_first 对应 (batch, time, channels, ...)                        dilation_rate=(1, 1),  # 膨胀卷积的膨胀率                        activation="tanh",                        recurrent_activation="hard_sigmoid",                        use_bias=True,                        kernel_initializer="glorot_uniform",                        recurrent_initializer="orthogonal",                        bias_initializer="zeros",                        unit_forget_bias=True, # 如果为 True,初始化时,将忘记门的偏置加 1。 将其设置为 True 同时还会强制 bias_initializer="zeros"                        kernel_regularizer=None,                        recurrent_regularizer=None,                        bias_regularizer=None,                        activity_regularizer=None,                        kernel_constraint=None,                        recurrent_constraint=None,                        bias_constraint=None,                        return_sequences=False, # 是返回输出序列中的最后一个输出,还是全部序列                        return_state=False,                        go_backwards=False, #  如果为 True,则向后处理输入序列并返回相反的序列                        stateful=False, # 如果为 True,则批次中索引 i 处的每个样品的最后状态 将用作下一批次中索引 i 样品的初始状态                        dropout=0.0,                        recurrent_dropout=0.0, # 单元的丢弃比例,用于循环层状态的线性转换                        **kwargs)

GRU:门限循环单元网络

keras.layers.GRU(units,  #  输出空间的维度                     activation="tanh",                     recurrent_activation="sigmoid", # 用于循环时间步的激活函数。默认 sigmoid, None 为 f(x) = x                     use_bias=True,                     kernel_initializer="glorot_uniform",  #  初始化                     recurrent_initializer="orthogonal",                     bias_initializer="zeros",                     kernel_regularizer=None,  # 正则                     recurrent_regularizer=None,                     bias_regularizer=None,                     activity_regularizer=None,                     kernel_constraint=None,  #  约束                     recurrent_constraint=None,                     bias_constraint=None,                     dropout=0.0, # 单元的丢弃比例,用于输入的线性转换                     recurrent_dropout=0.0,  # 单元的丢弃比例,用于循环层状态的线性转换                     implementation=2, # 实现模式,1 或 2。 模式 1 将把它的操作结构化为更多的小的点积和加法操作, 而模式 2 将把它们分批到更少,更大的操作中。 这些模式在不同的硬件和不同的应用中具有不同的性能配置文件                     return_sequences=False, # 是返回输出序列中的最后一个输出,还是全部序列                     return_state=False,  # 除了输出之外是否返回最后一个状态                     go_backwards=False,  # 默认 False。 如果为 True,则向后处理输入序列并返回相反的序列                     stateful=False,  # 默认 False。 如果为 True,则批次中索引 i 处的每个样品的最后状态 将用作下一批次中索引 i 样品的初始状态                     time_major=False,  # 输入和输出张量的形状格式。 如果为True,则输入和输出的形状为[steps,batch_size,features],而如果为False,则输入和输出的形状为[batch_size,steps,features]。 使用time_major = True会更有效率,因为它避免了RNN计算开始和结束的转置。 但是,大多数TensorFlow数据都是批量生产的,因此默认情况下,此功能接受输入并以批量生产的形式发出输出。                     unroll=False, # 默认 False。 如果为 True,则网络将展开,否则将使用符号循环。 展开可以加速 RNN,但它往往会占用更多的内存。 展开只适用于短序列                     reset_after=True, # 公约: 是否在矩阵乘法之前或者之后使用重置门。 False =before(默认),Ture =after ( CuDNN 兼容)。                     inputs, # [batch_size, time_steps, features]                     **kwargs)

GRUCell:GRU 层的单元类

keras.layers.GRUCell(units,  #  输出空间的维度                  activation="tanh",                  recurrent_activation="sigmoid", # 用于循环时间步的激活函数。默认 sigmoid, None 为 f(x) = x                  use_bias=True,                  kernel_initializer="glorot_uniform",  #  初始化                  recurrent_initializer="orthogonal",                  bias_initializer="zeros",                  kernel_regularizer=None,  # 正则                  recurrent_regularizer=None,                  bias_regularizer=None,                  activity_regularizer=None,                  kernel_constraint=None,  #  约束                  recurrent_constraint=None,                  bias_constraint=None,                  dropout=0.0, # 单元的丢弃比例,用于输入的线性转换                  recurrent_dropout=0.0,  # 单元的丢弃比例,用于循环层状态的线性转换                  implementation=2, # 实现模式,1 或 2。 模式 1 将把它的操作结构化为更多的小的点积和加法操作, 而模式 2 将把它们分批到更少,更大的操作中。 这些模式在不同的硬件和不同的应用中具有不同的性能配置文件                  reset_after=True, # 公约: 是否在矩阵乘法之前或者之后使用重置门。 False =before(默认),Ture =after ( CuDNN 兼容)。                  inputs, # [batch_size, features]                  **kwargs)

CuDNNGRU:由 CuDNN 支持的快速 GRU 实现,只能以 TensorFlow 后端运行在 GPU 上

TimeDistributed:这个封装器将一个层应用于输入的每个时间片

keras.layers.TimeDistributed(layer, **kwargs)

Bidirectional:RNN 的双向封装器,对序列进行前向和后向计算

keras.layers.Bidirectional(layer,                             merge_mode="concat",  # 前向和后向 RNN 的输出的结合模式。 为 {'sum', 'mul', 'concat', 'ave', None} 其中之一。 如果是 None,输出不会被结合,而是作为一个列表被返回                            weights=None,                             backward_layer=None,                             **kwargs)

core

TextVectorization:文本管理:将一批字符串转换为 1维 tensor,样本token 或 token indices

  • adapt()可以分析数据集,确认词频,并据此创建 词汇表
    • 样本处理步骤
      • 标准化每个样本(通常用小写+标点符合来strip)
      • split每个样本为单词
      • 将单词重组为tokens(通常用ngram)
      • 索引token:将每个token设置一个唯一值
      • 按此索引,将每个样本转换为向量(int/float)
    keras.layers.experimental.preprocessing.TextVectorization(max_tokens=None, # 词汇表最大大小(值为:max_tokens - 1 - (1 if out_out == 'int' else 0))。若为None,则词汇量无上限。                                                        standardize="lower_and_strip_punctuation",  # 文本标准化规范:None:无标准化;lower_and_strip_punctuation(默认):小写并删除标点符号;callable                                                       split="whitespace",                                                       ngrams=None, # 从可能分割的输入文本创建ngram规范:None:不创建规范;整数:将创建ngram直到该整数;整数元组:将为元组中的指定值创建ngram                                                       output_mode="int", # in:0保留给被屏蔽的位置;binary:将vocab的大小减小为max_tokens - 2,每批输出int数组,其size为vocab_size /max_tokens size;count:近似binary,只是int 数组包含该索引上token出现的次数;tf-idf:近似binary,只是TF-IDF算法在每个token slot中查找值                                                       output_sequence_length=None, # int模式,会发生填充/截断为精确的output_sequence_length                                                       pad_to_max_tokens=True, # 非int模式。True时,当词汇表中唯一token少于max_tokens时,填充至max_tokens                                                       **kwargs)

Normalization:归一化

  • 将输入强制为center为0,std为1的分布
  • adap时,计算数据集的均值和方差,存储作为层的weights
  • fitevalutepredict前需要adap

keras.layers.experimental.preprocessing.Normalization(axis=-1, dtype=None, **kwargs)

分类

CategoryEncoding

keras.layers.experimental.preprocessing.CategoryEncoding(max_tokens=None, # 词汇表最大大小。None为无上限                                                          output_mode="binary",  # 同上                                                          sparse=False,  # True为返回稀疏tensor, False(默认)返回密集(dense)tensor                                                          **kwargs)

Hashing:分类特征hash/hashing trick

  • 默认情况下使用FarmHash64,它通过完全混合输入位,在不同平台上提供一致的哈希输出。若要混淆散列的输出,还可以在构造函数中传递随机的salt参数。 此情况下,该层将使用SipHash64哈希函数,salt值用作哈希函数的附加输入。
keras.layers.experimental.preprocessing.Hashing(num_bins,  # hash bins数                                              salt=None,   # 若存在int值,则使用SipHash64哈希函数,否则使用默认的FarmHash64函数                                              name=None,  # layer的命名                                              **kwargs)

Discretization:离散化

keras.layers.experimental.preprocessing.Discretization(bins, **kwargs)

StringLookup:将字符串基于词汇表进行映射

keras.layers.experimental.preprocessing.StringLookup(max_tokens=None,                                                       num_oov_indices=1,  # out-of-vocabulary tokens 数量,默认值为1                                                       mask_token="", # mapped to index 0。默认值为"";若为None,则不添加mask 和 oov token                                                       oov_token="[UNK]", # out-of-vocabulary token,默认值:[UNK]                                                       vocabulary=None,  # 词汇表                                                       encoding=None, # 默认utf8                                                       invert=False, # 若为True:map的索引至词汇表的items,而非词汇表items to 索引                                                       **kwargs)

IntegerLookup:将整数按词汇表map至整数索引

keras.layers.experimental.preprocessing.IntegerLookup(max_values=None,  # 词汇表的最大大小。若为None:则无上限;注意:此词汇表包含OOV和mask,故有效数值为: max_values - num_oov_values - (1 if mask_token else 0)                                                    num_oov_indices=1,                                                    mask_value=0, # 默认0                                                    oov_value=-1, # 默认-1                                                    vocabulary=None,                                                    invert=False,                                                    **kwargs)

CategoryCrossing: 将多个分类输入连接到一个分类输出中(类似于笛卡尔积),一一对应,shape一致

keras.layers.experimental.preprocessing.CategoryCrossing(depth=None,  # 交叉深度。默认None,所有的输入corssed 成 1个输出;数字/tuple/list:不大于输入数组的长度,输出为depth <= 当前参数的排序组合                                                        name=None, # layer的命名                                                        separator=None,                                                         **kwargs)

图像

Resizing:resize图片大小:将输入的图片批量resize成指定的高和宽。input为 NHWC 格式的 4维 tensor

keras.layers.experimental.preprocessing.Resizing(height,                                                 width,                                                 interpolation="bilinear",  # 插值方法:bilinear(双线性,默认);nearest(距离);bicubic(双三次);area;lanczos3;lanczos5;gaussian(高斯);mitchellcubic(米切尔立方)                                                name=None,                                                 **kwargs)

Rescaling:对输入 乘以 常值scale 再加上 常值offset。等同于按指定比例缩放,然后再平移

keras.layers.experimental.preprocessing.Rescaling(scale,                                                     offset=0.0,                                                     name=None,                                                     **kwargs)

CenterCrop:将图像的center部分裁剪成指定的高和宽

*  输入: 4维 tensor:(samples, height, width, channels),data_format='channels_last'。*  输出:4维 tensor:(samples, target_height, target_width, channels)
keras.layers.experimental.preprocessing.CenterCrop(height,                                                     width,                                                     name=None,                                                     **kwargs)

RandomCrop:将图像随机的裁剪成指定的高和宽

keras.layers.experimental.preprocessing.RandomCrop(height,                                                     width,                                                     seed=None,                                                     name=None,                                                     **kwargs)

RandomFlip:水平和垂直随机翻转每个图像。该层将基于mode属性翻转图像。 在推断时间内,输出将与输入相同。 使用training = True调用图层以翻转输入。

  • 输入:4维 tensor:(samples, height, width, channels), data_format=‘channels_last’.
  • 输出:同输入
keras.layers.experimental.preprocessing.RandomFlip(mode="horizontal_and_vertical",  # 翻转模式:horizontal(水平左右);vertical(垂直上下);horizontal_and_vertical(默认);                                                      seed=None,                                                       name=None,                                                       **kwargs)

RandomTranslation:training期间随机translate每个图像

  • 输入:4维 tensor,(samples, height, width, channels), data_format=‘channels_last’
  • 输出:同输入
keras.layers.experimental.preprocessing.RandomTranslation(height_factor, # 上下移动的上下限:单个值表示上下限相同;浮点数表示移动比例;负值表示向上,正值表示向下                                                           width_factor, # 左右移动限                                                           fill_mode="reflect", # 输入边界外的点的填充模式:constant(常值填充);reflect(反射填充:倒序填充);wrap(环绕填充:整体填充);nearest(最近填充:按最近一个元素来作为常值填充)                                                           interpolation="bilinear", # 插值方法:nearest(距离);bilinear(双线性)                                                           seed=None,                                                           name=None,                                                           **kwargs)

RandomRotation:随机旋转每个图像

  • 一般情形下,train时随机旋转,predict时不操作。若需要predict时随机旋转,则在调用图层时将train设置为True
  • 输入:4维 tensor: (samples, height, width, channels), data_format=‘channels_last’.
  • 输出:同输入
keras.layers.experimental.preprocessing.RandomRotation(factor,  # 基准单位为:2倍pi;浮点数表示旋转幅度百分比,旋转幅度 = 旋转幅度百分比 * 2 * pi;正值:逆时针旋转;负值:顺时针旋转                                                      fill_mode="reflect",  # 填充模式:constant(常值填充);reflect(反射填充);wrap(环绕填充);nearest(最近填充)                                                      interpolation="bilinear", # 插值方法:nearest(距离);bilinear(双线性)                                                      seed=None,                                                       name=None,                                                       **kwargs)

RandomZoom:训练中随机缩放(zoom)每个图像

  • 输入:4维 tensor: (samples, height, width, channels), data_format=‘channels_last’.
  • 输出:同输入
keras.layers.experimental.preprocessing.RandomZoom(height_factor,  # 上下缩放                                                      width_factor=None,  # 左右缩放                                                      fill_mode="reflect",  # 填充模式:constant(常值填充);reflect(反射填充);wrap(环绕填充);nearest(最近填充)                                                      interpolation="bilinear", # 插值方法:nearest(距离);bilinear(双线性)                                                      seed=None,                                                       name=None,                                                       **kwargs)

RandomHeight:训练中随机改变一批图像的高度

  • 通过随机因子来调整一批图像的高度
  • predict时默认非激活/inactive
  • 输入:4维 tensor: (samples, height, width, channels), data_format=‘channels_last’.
  • 输出:同输入
keras.layers.experimental.preprocessing.RandomHeight(factor,  # 正浮点数/size为2的tuple,表示上下调整的边界幅度的百分比                                                     interpolation="bilinear", # 插值方法:bilinear(双线性,默认);nearest(距离);bicubic(双三次);area;lanczos3;lanczos5;gaussian(高斯);mitchellcubic(米切尔立方)                                                     seed=None,                                                      name=None,                                                      **kwargs)

RandomWidth:训练中随机改变一批图像的宽度

  • 通过随机因子来调整一批图像的宽度
  • predict时默认非激活/inactive
  • 输入:4维 tensor: (samples, height, width, channels), data_format=‘channels_last’.
  • 输出:同输入
keras.layers.experimental.preprocessing.RandomWidth(factor,  # 正浮点数/size为2的tuple,表示上下调整的边界幅度的百分比                                                     interpolation="bilinear", # 插值方法:bilinear(双线性,默认);nearest(距离);bicubic(双三次);area;lanczos3;lanczos5;gaussian(高斯);mitchellcubic(米切尔立方)                                                     seed=None,                                                      name=None,                                                      **kwargs)

sequence

时序/Timeseries

TimeseriesGenerator:生成批量时序数据
  • 由相等间隔以及一些时间序列参数(例如步长、历史长度等)汇集的数据点作为输入,以生成用于训练/验证的批次数据
    keras.preprocessing.TimeseriesGenerator(data, # 2维可索引的数据集(list, array等,包含times_steps),且第0个轴为时间维度                                                targets, # 对应于data的time_step的目标值,与data的长度相等                                                length, # 输出序列长度                                                stride=1, # 连续输出序列之间的周期/步长:如果周期为a, 则输出样本为 data[i], data[i+a]                                                sampling_rate=1,  # 序列内连续各个时间步之间的周期。如果周期为b,则生成样本序列的时间步为:data[i], data[i-b]                                                batch_size=128, # 每个批次中的时间序列样本数                                                shuffle=False,                                                reverse=False,                                                start_index=None,                                                end_index=None)keras.preprocessing.sequence.TimeseriesGenerator
pad_sequences:将多个序列截断或补齐为相同长度
  • 将一个num_size的序列(列表)转化为 2维 numpy数组,其尺寸为 (num_size, num_time_steps),num_time_stepsmaxlan参数,或 最长序列的长度。
    • 填充/截取
      • num_time_steps短的,以value值填充
      • 长的,截取以满足长度
    • 输出:(len(sequences), maxlen)
    keras.preprocessing.sequence.pad_sequences(sequences,  # 列表的列表,每一个元素是一个序列                                        maxlen=None, # 转为 2维 数组的 shape[1]                                        dtype="int32",  # 输出序列的类型                                        padding="pre",  # 补齐方式:pre: 前端补齐; post:末端补齐                                        truncating="pre",  # 截取方式:pre: 前端截取; post:末端截取                                        value=0.0) # 填充值
timeseries_dataset_from_array:在以数组形式提供的时间序列上创建滑动窗口的数据集
keras.preprocessing.timeseries_dataset_from_array(data, # 2维可索引的数据集(list, array等,包含times_steps),且第0个轴为时间维度                                                targets, # 与数据中的时间步相对应的目标。 它的长度应与数据相同。 target [i]应该是与从索引i开始的窗口相对应的目标。 如果没有目标数据,则传递None(在这种情况下,数据集将仅产生输入数据)。                                                sequence_length, # 输出序列长度                                                sequence_stride=1, # 连续输出序列之间的周期/步长:如果周期为a, 则输出样本为 data[i], data[i+a]                                                sampling_rate=1,  # 序列内连续各个时间步之间的周期。如果周期为b,则生成样本序列的时间步为:data[i], data[i+b]                                                batch_size=128, # 每个批次中的时间序列样本数                                                shuffle=False,                                                seed=None,                                                start_index=None,                                                end_index=None)
skipgrams:生成 skipgram 词对:将一个单词索引序列(整数列表)转化为以下形式的单词元组
  • (单词, 同窗口的单词),标签为 1(正样本)
  • (单词, 来自词汇表的随机单词),标签为 0(负样本)
keras.preprocessing.sequence.skipgrams(sequence, # 一个编码为单词索引(整数)列表的词序列(句子)。若使用一个 `sampling_table`,词索引应该以一个相关数据集的词的排名匹配                                    vocabulary_size, # 大可能词索引 + 1                                    window_size=4, # 采样窗口大小(技术上是半个窗口)。词`w_i`的窗口为`[i - window_size, i + window_size + 1]`                                    negative_samples=1.0, # 大于等于 0 的浮点数。0 表示非负(即随机)采样。1 表示与正样本数相同                                    shuffle=True,                                    categorical=False, # False:标签将为整数(例如 [0, 1, 1 .. ]);True:标签将为分类,例如 [[1,0],[0,1],[0,1] .. ]                                    seed=None,                                    sampling_table=None)  # 尺寸为`vocabulary_size`的一维数组:第 i 项编码了排名为 i 的词的采样概率
  • 输出
    • couples:整数对
    • labels:0/1
make_sampling_table:生成一个基于单词的概率采样表
  • 采样概率根据 word2vec 中使用的采样分布生成:p(word) = (min(1, sqrt(word_frequency / sampling_factor) / (word_frequency / sampling_factor)))
  • 单词频率遵循zipf定律(s=1),其frequency(rank)近似值:frequency(rank) ~ 1/(rank * (log(rank) + gamma) + 1/2 - 1/(12*rank))。其中gamma为Euler-Mascheroni常量
keras.preprocessing.sequence.make_sampling_table(size, # 可能采样的单词数量。                                                sampling_factor=1e-05) # word2vec 公式中的采样因子

图像

image_dataset_from_directory:从目录的图像文件生成tf.data.Dataset
  • 支持的image format:jpeg, png, bmp, gif(截取到第一帧)
  • 对于文件夹下的分文件夹image,每个文件夹为一个class,参数设置:labels=‘inferred’
  • 输出:tf.data.Dataset对象
    • label_mode = None:tensor shape:(batch_size, image_size[0], image_size[1], num_channels), type=float32
      • color_mode = grayscale(灰度):channel = 1
      • color_model = rgb: channel = 3
      • color_model = rgba: channel = 4
    • label_mode != None:tensor shape:(image, label)。其中 image 的 shape:(batch_size, image_size[0], image_size[1], num_channels); label 如下
      • label_model = int: tensor shape: (batch_size, ), type = int32
      • label_model = binary:tensor shape: (batch_size, 1), type = float32
      • label_model = categorial:tensor shape: (batch_size, num_classes), type = float32
tf.keras.preprocessing.image_dataset_from_directory(directory,                                                    labels="inferred", # "inferred" 或 表示 images文件数量的tuple/list                                                    label_mode="int", # int:encode为integer(如:损失函数sparse_categorical_crossentropy);categorical:encoded为分类向量(categorical_crossentropy);binary:encode为二值化0/1(binary_crossentropy); None:没有label                                                    class_names=None, # labels="inferred"时有效。指定列和顺序                                                    color_mode="rgb", # "grayscale", "rgb"(Default), "rgba"                                                    batch_size=32,                                                    image_size=(256, 256), # resize,默认值                                                    shuffle=True,                                                    seed=None,                                                    validation_split=None,                                                    subset=None,  # "training", "validation"                                                    interpolation="bilinear", # 插值方法 bilinear(Default), nearest, bicubic, area, lanczos3, lanczos5, gaussian, mitchellcubic                                                    follow_links=False) # 是否访问符号链接指向的子目录。 默认为False
load_img:load image 成 PIL 格式
  • 输出: PIL 图像 instance
tf.keras.preprocessing.image.load_img(path,                                    grayscale=False,  # 此参数已淘汰                                    color_mode="rgb", # "grayscale", "rgb"(Default), "rgba"                                    target_size=None, # None(Default), (img_height, img_width)                                    interpolation="nearest") # 插值方法 nearest(Default), bilinear, bicubic, lanczos5, box, hamming
img_to_array: PIL图像转换为array
  • 输出:三维数组
tf.keras.preprocessing.image.img_to_array(img,                                    data_format=None,  # channels_first;channels_last;None                                    dtype=None)
ImageDataGenerator # 通过实时数据增强生成张量图像数据批次。数据按批次不断循环
keras.preprocessing.image.ImageDataGenerator(featurewise_center=False, # 将输入数据的均值设置为 0,逐特征进行                                               samplewise_center=False,  # 将每个样本的均值设置为 0                                               featurewise_std_normalization=False,  # 将输入除以数据标准差,逐特征进行                                               samplewise_std_normalization=False,  # 将每个输入除以其标准差。                                               zca_whitening=False,  # 是否应用 ZCA 白化                                               zca_epsilon=1e-06, # ZCA 白化的 epsilon 值,默认为 1e-6                                               rotation_range=0,  # 随机旋转的度数范围                                               width_shift_range=0.0, # float: <1 则除以总宽度的值; >=1 则为像素值;1维数组:数组中的随机元素;int:来自间隔(-width_shift_range, +width_shift_range)之间的整数个像素                                               height_shift_range=0.0,                                               brightness_range=None,  # 选择亮度偏移值的范围。                                               shear_range=0.0, # 剪切强度(以弧度逆时针方向剪切角度)                                               zoom_range=0.0, # 浮点数 或 [lower, upper]。随机缩放范围。如果是浮点数,[lower, upper] = [1-zoom_range, 1+zoom_range]                                               channel_shift_range=0.0, # 随机通道转换的范围                                               fill_mode="nearest", # 填充模式:"constant", "nearest", "reflect" , "wrap"                                               cval=0.0,  # 当 fill_mode = "constant"是,此值为填充值                                               horizontal_flip=False,  # 随机水平翻转                                               vertical_flip=False, # 随机垂直翻转                                               rescale=None, # 重缩放因子。默认为 None。如果是 None 或 0,不进行缩放,否则将数据乘以所提供的值(在应用任何其他转换之前)                                               preprocessing_function=None, # 应用于每个输入的函数。这个函数会在任何其他改变之前运行。这个函数需要一个参数:一张图像(秩为 3 的 Numpy 张量),并且应该输出一个同尺寸的 Numpy 张量                                               data_format=None, # "channels_first": (samples, channels, height, width); "channels_last": (samples, height, width, channels)                                               validation_split=0.0, # Float. 保留用于验证的图像的比例(严格在0和1之间)                                               dtype=None) # 生成数组使用的数据类型
flow:采集数据和标签数组,生成批量增强数据
  • 输出:生成tuple (x, y)的 iterator。其中:x:图像数据的numpy数组(单张)/数组list(多张);y:对应标签的numpy数组。若sample_weight不为None,则生成的数组为:(x, y, sample_weight);若y为None,则返回numpy数组x
    ImageDataGenerator.flow(x, # 输入数据。秩为 4 的 Numpy 矩阵或元组。对于灰度数据,图像数组的通道轴的值应该为 1,而对于 RGB 数据,其值应该为 3                     y=None, # 标签                     batch_size=32,                     shuffle=True,                     sample_weight=None,  # 样本权重                     seed=None,                     save_to_dir=None,                     save_prefix="",  # 字符串(默认 '')。保存图片的文件名前缀(仅当 save_to_dir 设置时可用)。                     save_format="png", # "png"(默认), "jpeg"                     subset=None) # 数据子集 ("training" 或 "validation"),如果 在 ImageDataGenerator 中设置了 validation_split
flow_from_dataframe:输入 dataframe 和目录的路径,并生成批量的增强/标准化的数据
  • 输出:生成tuple (x, y) 的 dataframe iterator。x:尺寸为(batch_size, *target_size, channels)的图像样本的numpy数组;y:对应的标签的numpy数组
    ImageDataGenerator.flow_from_dataframe(dataframe, # pandas dataframe。class_mode="categorical":df 包含 y,每个图像的类别;class_mode in ('binary', 'sparse'):df 包含 y,strings类型的类别;class_mode in ('raw', 'multi_output'):df 包含 y,specified 列;class_mode in ('input', None):无需额外的 列                                     directory=None,  # 目标目录的路径                                     x_col="filename", # dataframe包含文件名称的列,若为None,则绝对路径                                     y_col="class", # target                                     weight_col=None, # 样本权重                                     target_size=(256, 256), #  整数元组 (height, width),默认为 (256, 256)。 所有找到的图都会调整到这个维度                                     color_mode="rgb", # "grayscale", "rbg" (default)                                     classes=None, # 可选的类别列表 默认:None。 如未提供,类比列表将自动从 y_col 中推理出来,y_col 将会被映射为类别索引)。 包含从类名到类索引的映射的字典可以通过属性 class_indices 获得                                     class_mode="categorical", # "categorical"(default):二维数组的one-hot encoded标签, "binary":一维数组的二进制标签, (多标签)"input":与输入图像相同的图像(主要用于自动编码器), "multi_output":columns的list, "raw":y的numpy数组, "sparse":一维数组的int标签, None:没有target,不返回标签:生成器只会产生批量的图像数据                                     batch_size=32,                                     shuffle=True,                                     seed=None,                                     save_to_dir=None,                                     save_prefix="", # 保存图片的文件名前缀(仅当 save_to_dir 设置时可用)                                     save_format="png", # "png"(默认), "jpeg"                                     subset=None,                                     interpolation="nearest", # "nearest"(default), "bilinear", "bicubic"。1.1.3及以上版本的PIL,支持 "lanczos"; 3.4.0以上的PIL,支持 "box" 和 "hamming"                                     validate_filenames=True,                                     **kwargs)
flow_from_directory:from path 并生成批量扩充数据。
  • 输出:生成tuple (x, y) 的 Directory iterator。x:尺寸为(batch_size, *target_size, channels)的图像样本的numpy数组;y:对应的标签的numpy数组
ImageDataGenerator.flow_from_directory(directory=None,  # 目标目录的路径                                     target_size=(256, 256), #  整数元组 (height, width),默认为 (256, 256)。 所有找到的图都会调整到这个维度                                     color_mode="rgb", # "grayscale", "rbg" (default)                                     classes=None, # 可选的类别列表 默认:None。 如未提供,类比列表将自动从 y_col 中推理出来,y_col 将会被映射为类别索引)。 包含从类名到类索引的映射的字典可以通过属性 class_indices 获得                                     class_mode="categorical", # "categorical"(default):二维数组的one-hot encoded标签, "binary":一维数组的二进制标签, (多标签)"input":与输入图像相同的图像(主要用于自动编码器), "multi_output":columns的list, "raw":y的numpy数组, "sparse":一维数组的int标签, None:没有target,不返回标签:生成器只会产生批量的图像数据                                     batch_size=32,                                     shuffle=True,                                     seed=None,                                     save_to_dir=None,                                     save_prefix="", # 保存图片的文件名前缀(仅当 save_to_dir 设置时可用)                                     save_format="png", # "png"(默认), "jpeg"                                     follow_links=False, # 是否跟踪类子目录中的符号链接(默认为 False)                                     subset=None,                                     interpolation="nearest") # "nearest"(default), "bilinear", "bicubic"。1.1.3及以上版本的PIL,支持 "lanczos"; 3.4.0以上的PIL,支持 "box" 和 "hamming"
apply_transform:根据给定的参数将变换应用于图像
  • 输出:输入的转换后版本(相同尺寸)。
ImageDataGenerator.apply_transform(x,  # 3D 张量,单张图像。                                    transform_parameters) # dict:描述转换:'theta': float。旋转角度(度);'tx': float。在 x 方向上移动;'ty': float。在 y 方向上移动;'shear': float。剪切角度(度);'zx': float。放大 x 方向;'zy': float。放大 y 方向;'flip_horizontal': bool。水平翻转;'flip_vertical': bool。垂直翻转;'channel_shift_intencity': float。频道转换强度;'brightness': float。亮度转换强度
fit:将数据生成器用于某些示例数据
  • 它基于一组样本数据,计算与数据转换相关的内部数据统计。当且仅当 featurewise_centerfeaturewise_std_normalizationzca_whitening 设置为 True 时才需要
ImageDataGenerator.fit(x,  # 样本数据。秩应该为 4。对于灰度数据,通道轴的值应该为 1;对于 RGB 数据,值应该为 3                        augment=False, # 是否使用随机样本扩张                        rounds=1, # 若数据数据增强(augment=True),表明在数据上进行多少次增强(默认为 1)                        seed=None)
get_random_transform:为转换生成随机参数
  • 输出:包含随机选择的描述变换的参数的字典。
ImageDataGenerator.get_random_transform(img_shape,  # 整数元组。被转换的图像的尺寸                                        seed=None)
random_transform:将随机变换应用于图像。
  • 输出:输入的随机转换版本(相同形状)。
ImageDataGenerator.random_transform(x,  # 3D 张量,单张图像。                                    seed=None)
standardize:将标准化配置应用于一批输入。
  • 输出:标准化后的输入。
ImageDataGenerator.standardize(x)

文本

text_dataset_from_directory:从目录的文本文件生成tf.data.Dataset。整体类似image_dataset_from_directory
tf.keras.preprocessing.text_dataset_from_directory(directory,                                                 labels="inferred",                                                 label_mode="int",                                                 class_names=None,                                                 batch_size=32,                                                 max_length=None,                                                 shuffle=True,                                                 seed=None,                                                 validation_split=None,                                                 subset=None,                                                 follow_links=False)
Tokenizer:文本标记实用类
  • 向量化文本语料库
    • 将每个文本转化为一个整数序列(每个整数都是词典中标记的索引)
    • 将其转化为一个向量,其中每个标记的系数可以是二进制值、词频、TF-IDF权重等
keras.preprocessing.text.Tokenizer(num_words=None, # 要保留的最大词数,基于词频。只有最常出现的 num_words 词会被保留                                filters='!"#$%&()*+,-./:;<=>?@[\\]^_`{|}~\t\n',  # 一个字符串,其中每个元素是一个将从文本中过滤掉的字符。默认值是所有标点符号,加上制表符和换行符,减去 ' 字符                                lower=True,                                split=" ",                                char_level=False,  # 如果为 True,则每个字符都将被视为标记。                                oov_token=None,  # 如果给出,它将被添加到 word_index 中,并用于在 text_to_sequence 调用期间替换词汇表外的单词                                document_count=0,                                **kwargs)
hashing_trick:将文本转换为固定大小散列空间中的索引序列
  • 输出:整数词索引列表(唯一性无法保证)。0不分配,保留索引
keras.preprocessing.text.hashing_trick(text,   # 输入文本                                       n,  # 散列空间维度                                       hash_function=None, # 散列函数:默认 hash(不稳定,hash值一致的概率随着数量的增加而提高), 或 md5(稳定)                                       filters='!"#$%&()*+,-./:;<=>?@[\]^_`{|}~ ',  # 要过滤的字符列表(或连接),如标点符号。默认:!"#$%&()*+,-./:;<=>?@[\]^_{|}~,包含基本标点符号,制表符和换行符                                       lower=True,                                        split=' ')
one_hot:将文本编码为大小为 n 的单词索引列表
  • hashing_trick 函数的一个封装, 使用 hash 作为散列函数;单词索引映射无保证唯一性
  • 输出:[1, n] 之间的整数列表。每个整数编码一个词(唯一性无法保证)
keras.preprocessing.text.one_hot(text,   # 输入文本                               n,  # 词汇表尺寸                               filters='!"#$%&()*+,-./:;<=>?@[\]^_`{|}~ ',  # 要过滤的字符列表(或连接),如标点符号。默认:!"#$%&()*+,-./:;<=>?@[\]^_{|}~,包含基本标点符号,制表符和换行符                               lower=True,                                split=' ')
text_to_word_sequence:将文本转换为单词(或标记)的序列
  • 输出:词或标记的列表
keras.preprocessing.text.text_to_word_sequence(text,   # 输入文本                                               filters='!"#$%&()*+,-./:;<=>?@[\]^_`{|}~ ',  # 要过滤的字符列表(或连接),如标点符号。默认:!"#$%&()*+,-./:;<=>?@[\]^_{|}~,包含基本标点符号,制表符和换行符                                               lower=True,                                                split=' ')

normalization

BatchNormalization:批量标准化层

  • 对层输入进行进行标准化:mean = 0, std=1
  • 输入:任意。如果将这一层作为模型的第一层, 则需要指定 input_shape 参数 (整数元组,不包含样本数量的维度)
  • 输出:shape与输入相同
keras.layers.BatchNormalization(axis=-1, # 需要标准化的轴 (通常是特征轴).如:在 data_format="channels_first" 的 Conv2D 层之后, 在 BatchNormalization 中设置 axis=1                              momentum=0.99, #  移动均值和移动方差的动量                              epsilon=0.001, # 避免除以零                              center=True, # 如果为 True,把 beta 的偏移量加到标准化的张量上。 如果为 False, beta 被忽略                              scale=True, # 如果为 True,乘以 gamma。 如果为 False,gamma 不使用。 当下一层为线性层(或者例如 nn.relu), 这可以被禁用,因为缩放将由下一层完成                              beta_initializer="zeros", # beta初始化                              gamma_initializer="ones",                              moving_mean_initializer="zeros",  # 移动均值初始化                              moving_variance_initializer="ones",                              beta_regularizer=None,  # beta正则                              gamma_regularizer=None,                              beta_constraint=None,  # beta约束                              gamma_constraint=None,                              renorm=False,  # 是否使用批量重归一化                              renorm_clipping=None, # 将键“ rmax”,“ rmin”,“ dmax”映射到标量张量,该标量张量用于裁剪重新规范校正。矫正(r, d): corrected_value = normalized_value * r + d,其中 r = [rmin, rmax],d = [-dmax, dmax],缺少的rmax,rmin和dmax分别设置为inf,0,inf                              renorm_momentum=0.99, # 重新定义移动均值和std的动量                              fused=None, # true: fused implementation; false: 不使用fused implementation;None:如果可能,使用fused implementation                              trainable=True, # true:变量将被标记为可训练。                              virtual_batch_size=None,                              adjustment=None,                              name=None,                              **kwargs)

LayerNormalization:归一化层

  • 单独对每个eg进行归一化,而不是像batch那样批归一化。即应用一种转换来保持每个eg接近均值=0,std=1
keras.layers.LayerNormalization(axis=-1,                              epsilon=0.001,                              center=True,                              scale=True,                              beta_initializer="zeros",                              gamma_initializer="ones",                              beta_regularizer=None,                              gamma_regularizer=None,                              beta_constraint=None,                              gamma_constraint=None,                              trainable=True, # true:变量将被标记为可训练。                              name=None,                              **kwargs)

regularization

Dropout:每次更新时, 将输入单元的按比率随机设置为 0, 这有助于防止过拟合

keras.layers.Dropout(rate,  # 需要丢弃的输入比例。在 0 和 1 之间                    noise_shape=None,  # 一维整数tensor,表示将与输入相乘的二进制 dropout 掩层的形状                    seed=None,                     **kwargs)

SpatialDropout1D:Dropout 的 一维 版本

  • 丢弃整个一维的特征图而不是丢弃单个元素。如果特征图中相邻的帧是强相关的(通常是靠前的卷积层中的情况),那么常规的 dropout 将无法使激活正则化,且导致有效的学习速率降低。在这种情况下,SpatialDropout1D 将有助于提高特征图之间的独立性,应该使用它来代替 Dropout
  • 输入:3维tensor:(samples, timesteps, channels)
  • 输出:同输入

keras.layers.SpatialDropout1D(rate) # 需要丢弃的输入比例

SpatialDropout2D:同 SpatialDropout1D

  • 输入:4维tensor:data_format=channels_first: (samples, channels, rows, cols);data_format=channels_last:(samples, rows, cols, channels)
  • 输出:同输入

keras.layers.SpatialDropout2D(rate, data_format=None)

SpatialDropout3D:同 SpatialDropout1D

  • 输入:5维tensor:data_format=channels_first: (samples, channels, dim1, dim2, dim3);data_format=channels_last:(samples, dim1, dim2, dim3, channels)
  • 输出:同输入

keras.layers.SpatialDropout3D(rate, data_format=None)

GaussianDropout:应用以 1 为中心的 乘性高斯噪声

keras.layers.GaussianDropout(rate)

GaussianNoise:以 0 为中心的加性高斯噪声

  • 这对缓解过拟合很有用 (你可以将其视为随机数据增强的一种形式)。 高斯噪声(GS)是对真实输入的腐蚀过程的自然选择

keras.layers.GaussianNoise(stddev) # 噪声分布的标准差

ActivityRegularization:对基于代价函数的输入活动应用一个更新

keras.layers.ActivityRegularization(l1=0.0, #  L1 正则化因子 (正数浮点型)                                   l2=0.0,  # L2 正则化因子 (正数浮点型)。                                   **kwargs)

AlphaDropout

  • 保持输入的平均值和方差与原来的值不变, 以确保即使在 dropout 后也能实现自我归一化。 通过随机将激活设置为负饱和值, Alpha Dropout 非常适合按比例缩放的指数线性单元(SELU)
keras.layers.AlphaDropout(rate,  # 丢弃概率(与 Dropout 相同)。 这个乘性噪声的标准差为 sqrt(rate / (1 - rate))                           noise_shape=None,                            seed=None)

merging:融合层

Concatenate:连接层

  • 输出:tensor:所有输入张量通过 axis 轴串联起来的输出张量

keras.layers.concatenate(inputs, axis=-1)

Average: keras.layers.Average()

Maximum: 张量列表的(逐元素间的)最大值

Minimum

Add:keras.layers.Add()([x1, x2])

Subtract: keras.layers.Subtract()

Multiply: keras.layers.Multiply(): 所有输入张量的逐元素乘积, return tensor

Dot: 两个张量之间样本的点积

转载地址:https://blog.csdn.net/fish2009122/article/details/108886065 如侵犯您的版权,请留言回复原文章的地址,我们会给您删除此文章,给您带来不便请您谅解!

上一篇:详解VB中系统热键使用
下一篇:python操作hdfs

发表评论

最新留言

网站不错 人气很旺了 加油
[***.192.178.218]2024年03月05日 12时02分59秒

关于作者

    喝酒易醉,品茶养心,人生如梦,品茶悟道,何以解忧?唯有杜康!
-- 愿君每日到此一游!

推荐文章

s2-045 php exp,S2-045-EXP.py --Struts2任意代码执行漏洞 (S2-045,CVE-2017-5638) 2019-04-21
linux sdk 窗口句柄,Venus: 针对Linux平台上,对常用的系统API进行面向对象的封装SDK。... 2019-04-21
c语言程序设计 科学出版社习题答案,C语言程序设计(科学出版社)第4章 课后习题参考答案.doc... 2019-04-21
c语言 无错 但只运行一半,求哈夫曼编码时程序运行到一半就终止了,编译无错... 2019-04-21
deepin linux 2014安装,2014.2版本的Deepin虚拟机安装浅谈(就是深度Linux) 2019-04-21
android 限速工具,Android下载器之限速篇 2019-04-21
html刷新ajax实现原理,AJAX的原理—如何做到异步和局部刷新 2019-04-21
html中列表菜单加文字请选择,html中下拉菜单 2019-04-21
读书郎平板中android,读书郎学生平板电脑怎么用 使用方法详解【图文】 2019-04-21
html5 调用摄像头 支持IE,JS调用本地摄像头拍照(兼容各大浏览器及IE8+) 2019-04-21
rust和gta5哪个吃配置_盘点4款Steam“自由度”很高的游戏,GTA5众所周知,目前最热门... 2019-04-21
es审计日志_elasticsearch 事务日志translog 2019-04-21
dw1510_超低温种子储存柜 2019-04-21
文件未找到mathpage.wll_解决MathPage.wll文件找不到的问题(找了好久的良心之作)... 2019-04-21
java 使用或覆盖了已过时的api_JAVA使用或覆盖了已过时的 API 2019-04-21
java 图片旋转保存_Java 对图片90度旋转 2019-04-21
用java实现文学研究助手_数据结构文学研究助手 C语言代码实现(带源码+解析)... 2019-04-21
java gc的几种方式_GC 的三种基本实现方式 2019-04-21
wget linux java 32_通过wget在Linux上下载Java JDK会显示在许可证页面上 2019-04-21
babylonjs 设置面板位置_babylonjs 空间坐标转为屏幕坐标 2019-04-21