Python

Python3包管理安装

• CentOS7依赖缺失
  • zlib-devel
  • bzip2-devel
  • readline-devel
  • openssl-devel
  • sqlite(3)-devel

• 根据包用途、名称可以确认对应的应用，缺少就是相应 -devel(-dev)

Python Implementation

名称中flag体现该发行版中python特性

• -d：with pydebug

• -m：with pymalloc

• -u：with wide unicode

• pymalloc是specialized object allocator

  • 比系统自带的allocator快，且对python项目典型内存 分配模式有更少的开销
  • 使用c的malloc函数获得更大的内存池

• 原文：Pymalloc, a specialized object allocator written by Vladimir Marangozov, was a feature added to Python2.1. Pymalloc is intended to be faster than the system malloc() and to have less memory overhead for allocation patterns typical of Python programs. The allocator uses C’s malloc() function to get large pools of memory and then fulfills smaller memory requests from these pools.J

  注意：有时也有可能只是hard link

Python配置

Python相关环境变量

• PYTHONPATH：python库查找路径
• PYTHONSTARTUP：python自动执行脚本

自动补全

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

import readline
import rlcompleter
	# 为自动补全`rlcompleter`不能省略
import atexit
readline.parse_and_bind("tab:complete")
	# 绑定`<tab>`为自动补全

try:
	readline.read_history("/path/to/python_history")
		# 读取上次存储的python历史
except:
	pass
atexit.register(
	readline.write_history_file,
	"/path/to/python_history"
)
	# 将函数注册为推出python环境时执行
	# 将python历史输入存储在的自定以文件中
	# 这部分存储、读取历史其实不必要

del readline, rlcompleter

• 每次在python解释器中执行生效

• 保存为文件python_startup.py，将添加到环境变量 PYTHONSTARTUP中，每次开启python自动执行

  1 2 3

  # .bashrc export PYTHONSTARTUP=pythonstartup.py # 这个不能像*PATH一样添加多个文件，只能由一个文件

Pip

python包、依赖管理工具

• pip包都是源码包

  • 需要在安装时编译，因此可能在安装时因为系统原因出错
  • 现在有了wheels也可以安装二进制包

安装

• 编译安装python一般包括pip、setuptools
• 系统自带python无pip时，可用apt、yum等工具可以直接安装
• 虚拟python环境，无般法使用系统包管理工具安装pip，则只能 下载pip包使用setuptools安装

配置

配置文件：~/.config/pip/pip.conf

1
2
3
4
5

[global]
index-url = https:?//pypi.tuna.tsinghua.edu.cn/simple/
	# pypi源地址
format = columns
	# pip list输出格式（legacy，columns）

依赖管理

pip通过纯文本文件（一般命名为requirements.txt）来记录、 管理python项目依赖

• $ pip freeze：按照package_name=version的格式输出 已安装包 $ pip install -r：可按照指定文件（默认requirements.txt） 安装依赖

Virtualenv/Venv

虚拟python环境管理器，使用pip直接安装

• 将多个项目的python依赖隔离开，避免多个项目的包依赖、 python版本冲突
• 包依赖可以安装在项目处，避免需要全局安装python包的权限 要求、影响

实现原理

$ virtualenv venv-dir复制python至创建虚拟环境的文件夹中， $ source venv-dir/bin/activate即激活虚拟环境，修改系统环境 变量，把python、相关的python包指向当前虚拟环境夹

Virtualenv使用

Pyenv

python版本管理器，包括各种python发行版

安装

不需要事先安装python

• 从github获取pyenv：git://github.com/yyuu/pyenv.git

• 将以下配置写入用户配置文件（建议是.bashrc)，也可以在 shell里面直接执行以暂时使用

  1 2 3

  export PYENV_ROOT="$HOME/pyenv路径" export PATH="$PYENV_ROOT/bin:$PATH" eval "$(pyenv init -)"

  以上配置可参见home_config/bashrc_addon，以项目详情为准

Pyenv安装Python发行版问题

使用pyenv安装python时一般是从PYTHON_BUILD_MIRROR_URL表示 的地址下载安装文件（或者说整个系统都是从这个地址下载），缺省 是http://pypi.python.org，但国内很慢

#todo

• 设置这个环境变量为国内的镜像站，如 http://mirrors.sohu.com/python，但这个好像没用
• 在镜像站点下载安装包，放在pyenv/cache文件夹下（没有就 新建）

pyenv安装python时和使用一般安装应用一样，只是安装prefix不是 /usr/bin/之类的地方，而是pyenv安装目录，因此pyenv编译安装 python也需要先安装依赖

实现原理

修改$PATH环境变量

• 用户配置文件将PYENV_ROOT/bin放至$PATH首位
• 初始化pyenv时会将PYENV_ROOT/shims放至$PATH首位

shims、bin放在最前，优先使用pyenv中安装的命令

• bin中包含的是pyenv自身命令（还有其他可执行文件，但是 无法直接执行?）

• shims则包含的是所有已经安装python组件

  • 包括python、可以执行python包、无法直接执行的python包

  • 这些组件是内容相同的脚本文件，仅名称是pyenv所有安装 的python包

    • 用于截取python相关的命令
    • 并根据设置python发行版做出相应的反应
    • 因此命令行调用安装过的python包，pyenv会给提示 即使不是安装在当前python环境中

因此一般将命令放在.profile文件中，这样每次登陆都会设置好 pyenv放在.bashrc中会设置两次（没有太大关系）

使用指定Python发行版

• $ pyenv local py-version指定是在文件夹下生成 .python-version文件，写明python版本

• 所有的python相关的命令都被shims中的脚本文件截取

pyenv应该是逐层向上查找.python-version文件，查找到文件则 按照相应的python发行版进行执行，否则按global版本

Conda

通用包管理器

• 管理任何语言、类型的软件

  • conda默认可以从http://repo.continuum.io安装已经 编译好二进制包

  • conda包和pip包只是部分重合，有些已安装conda包 甚至无法被pip侦测到（非python脚本包）

  • python本身也作为conda包被管理

• 创建、管理虚拟python环境（包括python版本）

安装

• conda在Miniconda，Anaconda发行版中默认安装

  • Miniconda是只包括conda的发行版，没有Anaconda中默认 包含的包丰富

  • 在其他的发行版中可以直接使用pip安装，但是这样安装的 conda功能不全，可能无法管理包

• Miniconda、Anaconda安装可以自行设置安装位置，无需介怀

配置

conda配置文件为$HOME/.condarc，其中可以设置包括源在内 配置

1
2
3
4
5

channels:
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
  - defaults
show_channel_urls: true

添加国内源

conda源和pypi源不同（以下为清华源配置，当然可以直接修改 配置文件）

1
2
3

$ conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
$ conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
$ conda config --set show_channel_urls yes

• conda源不是pypi源，不能混用

Win平台设置

• 添加菜单项

  1 2 3

  # 可用于恢复菜单项 $ cd /path/to/conda_root $ python .\Lib\_nsis.py mkmenus

• VSCode是通过查找、执行activate.bat激活虚拟环境

  • 所以若虚拟环境中未安装conda（无activate.bat） 则虚拟环境无法自动激活

常用命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

$ conda create [--clone ori_env] -n env [packages[packages]]
	# 创建虚拟环境
	# python也是conda包，可指定`python=x.x`
$ conda remove -n env --all
	# 删除虚拟环境

$ conda info -e
$ conda env list
	# 列出虚拟环境
$ conda info
	# 列出conda配置

$ conda activate env
	# 激活env环境
$ conda deactivate
	# 退出当前环境

$ conda list -n env
	# 列出env环境/当前环境安装conda包
$ conda search package
	# 搜索包
$ conda install [-n env] packages
	# env环境/当前环境安装conda包
$ conda update [-n env] packages
	# env环境/当前环境升级conda包
$ conda remove [-n env] packages
	# env环境/当前环境移除包

• 使用conda而不是pip安装包更合适，方便管理

• 创建新环境时，默认不安装任何包，包括pip，此时切换到 虚拟环境后，pip等命令都是默认环境的命令

Pipenv

pip、virtualenv、Pipfile（版本控制）功能的综合，事实上就 依赖于pip、virtualenv（功能封装）

• $ pipenv sync/install替代$ pip install
• $ pipenv shell替代$ activate
• $ pipenv run甚至可以不用激活虚拟环境运行某些命令
• Pipfile控制dev、release包管理，Pipfile.lock锁定包依赖

安装

• 使用pip直接安装
• 系统安装源里有pipenv，也可以用系统包管理工具安装

实现原理

Python版本

pipenv和virtualenv一样指定python版本也需要已经安装该python 版本

• $PATH中的路径无法寻找到相应的python版本就需要手动 指定

• 不是有版本转换，将当前已安装版本通过类似2to3的“中 间层”转换为目标版本

虚拟环境

pipenv会在~/.local/share/virtualenv文件夹下为所有的虚拟 python环境生成文件夹

• 文件夹名字应该是“虚拟环境文件夹名称-文件夹全路径hash”

• 包括已安装的python包和python解释器

• 结构和virtualenv的内容类似，但virtualenv是放在项目目录下

• $ python shell启动虚拟环境就是以上文件夹路径放在 $PATH最前

依赖管理

pipenv通过Pipfile管理依赖（环境）

• 默认安装：$ pipenv install pkg

  • 作为默认包依赖安装pkg，并记录于Pipfile文件 [packages]条目下

  • 相应的$ pipenv install则会根据Pipfile文件 [packages]条目安装默认环境包依赖

• 开发环境安装：$ pipenv install --dev pkg

  • 作为开发环境包依赖安装pkg，并记录于Pipfile 文件[dev-packages]条目下

  • 相应的$ pipenv intall --dev则会根据Pipfile 文件中[dev-packages]安装开发环境包依赖

Pipfile和Pipfile.lock

• Pipfile中是包依赖可用（install时用户指定）版本
• Pipfile.lock则是包依赖具体版本
  • 是pipenv安装包依赖时具体安装的版本，由安装时包源的 决定
  • Pipfile.lock中甚至还有存储包的hash值保证版本一致
  • Pipfile是用户要求，Pipfile.lock是实际情况

因此

• $ pipenv install/sync优先依照Pipfile.lock安装具体 版本包，即使有更新版本的包也满足Pipfile的要求

• Pipfile和Pipfile.lock是同时更新、内容“相同”， 而不是手动锁定且手动更新Pipfile，再安装包时会默认更新 Pipfile.lock

Pipenv用法

详情https://docs.pipenv.org

创建新环境

具体查看$pipenv --help，只是记住$pipenv --site-packages 表示虚拟环境可以共享系统python包

默认环境和开发环境切换

pipenv没有像git那样的切换功能

• 默认环境“切换”为dev环境：$ pipenv install --dev
• dev环境“切换”为默认环境：$ pipenv uninstall --all-dev

同步

$ pipenv sync

官方是说从Pipfile.lock读取包依赖安装，但是手动修改Pipfile 后$ pipenv sync也会先更新Pipfile.lock，然后安装包依赖， 感觉上和$ pipenv install差不多

Pipenv特性

和Pyenv的配合

pipenv可以找到pyenv已安装的python发行版，且不是通过$PATH 中shims获得实际路径

• pipenv能够找到pyenv实际安装python发行版的路径versions， 而不是脚本目录shims

• pipenv能自行找到pyenv安装的python发行版，即使其当时没有 被设置为local或global

  • pyenv已安装Anaconda3和3.6并指定local为3.6的情况下 $ pipenv --three生成的虚拟python使用Anaconda3

  • 后系统全局安装python34，无local下pipenv --three 仍然是使用Aanconda3

  • 后注释pyenv的初始化命令重新登陆，pipenv --three就 使用python34

目前还是无法确定pipenv如何选择python解释器，但是根据以上测试 和github上的feature介绍可以确定的是和pyenv命令有关

pipenv和pyenv一起使用可以出现一些很蠢的用法，比如：pyenv指定 的local发行版中安装pipenv，然后用这pipenv可以将目录设置为 另外版本虚拟python环境（已经系统安装或者是pyenv安装）

总结

除了以上的包管理、配置工具，系统包管理工具也可以看作是python 的包管理工具

• 事实上conda就可以看作是pip和系统包管理工具的交集
• 系统python初始没有pip一般通过系统包管理工具安装

使用场景

优先级：pip > conda > 系统包管理工具

• 纯python库优先使用pip安装，需要额外编译的库使用conda
• conda源和系统源都有的二进制包，优先conda，版本比较新

2018/04/06经验

最后最合适的多版本管理是安装pipenv

• 系统一般自带python2.7，所以用系统包管理工具安装一个 python3

• 使用新安装的python3安装pipenv，因为系统自带的python2.7 安装的很多包版过低

• 最后如果对python版本要求非常严格

  • 还可以再使用pyenv安装其他版本
  • 然后仅手动启用pyenv用于指示pipenv使用目标python版本

2019/02/20经验

直接全局（如/opt/miniconda）安装Miniconda也是很好的选择

• 由conda管理虚拟环境，虚拟环境创建在用户目录下，登陆时 激活

Python原生数据结构

list

• 方法

  • ==：list 的 == 是逐值比较
  • __contains__：方法中使用 == 比较元素
    • in 判断列表包含时也是逐值比较

• 迭代技巧

  • 需要修改列表元素时尽量不直接迭代列表，考虑
    • 新建列表存储元素值
    • 迭代列表下标
  • 迭代过程会更改列表元素数量时
    • 使用 .pop 方法
    • 确定迭代数量

• 运算注意

  • .append：直接修改原列表，不返回
  • .extend：直接修改原列表，不返回
  • __add__：返回新列表

参数

• 勿使用列表、字典等指针类型作为默认参数，否则函数重入结果很可能出现问题
  • 原因：函数体中任何对参数的修改都会被保留
  • 替代方式：None + 函数体内判断

迭代器

• 需要多次迭代时，应该将迭代器转换为可重复迭代数据结构，如：列表
  • 迭代器值会被消耗

Conv1D

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

keras.layers.convolutional.Conv1D(
	filters(int),
	kernel_size(int),
	strides=1,
	padding='valid',
	dilation_rate=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
  • 该层生成将输入信号与卷积核按照单一的空域（或时域） 方向进行卷积
  • 可以将Convolution1D看作Convolution2D的快捷版

• 参数

  • filters：卷积核的数目（即输出的维度）

  • kernel_size：整数或由单个整数构成的list/tuple， 卷积核的空域或时域窗长度

  • strides：整数或由单个整数构成的list/tuple，为卷积 步长

    • 任何不为1的strides均与任何不为1的dilation_rate 均不兼容

  • padding：补0策略

  • activation：激活函数

  • dilation_rate：整数或由单个整数构成的list/tuple， 指定dilated convolution中的膨胀比例

    • 任何不为1的dilation_rate均与任何不为1的strides 均不兼容

  • use_bias：布尔值，是否使用偏置项

  • kernel_initializer：权值初始化方法

    • 预定义初始化方法名的字符串
    • 用于初始化权重的初始化器（参考initializers）

  • bias_initializer：偏置初始化方法

    • 为预定义初始化方法名的字符串
    • 用于初始化偏置的初始化器

  • kernel_regularizer：施加在权重上的正则项，为 Regularizer对象

  • bias_regularizer：施加在偏置向量上的正则项

  • activity_regularizer：施加在输出上的正则项

  • kernel_constraints：施加在权重上的约束项

  • bias_constraints：施加在偏置上的约束项

• 输入：形如(batch, steps, input_dim)的3D张量

• 输出：形如(batch, new_steps, filters)的3D张量

  • 因为有向量填充的原因，steps的值会改变

Conv2D

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

keras.layers.convolutional.Conv2D(
	filters,
	kernel_size,
	strides=(1, 1),
	padding='valid',
	data_format=None,
	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
)

二维卷积层，即对图像的空域卷积

• 说明

  • 该层对二维输入进行滑动窗卷积
  • 当使用该层作为第一层时，应提供

• 参数

  • filters：卷积核的数目（即输出的维度）

  • kernel_size：单个整数或由两个整数构成的list/tuple， 卷积核的宽度和长度

    • 如为单个整数，则表示在各个空间维度的相同长度

  • strides：单个整数或由两个整数构成的list/tuple， 卷积的步长

    • 如为单个整数，则表示在各个空间维度的相同步长
    • 任何不为1的strides均与任何不为1的dilation_rate 均不兼容

  • padding：补0策略

  • activation：激活函数

  • dilation_rate：单个或两个整数构成的list/tuple， 指定dilated convolution中的膨胀比例

    • 任何不为1的dilation_rate均与任何不为1的strides 均不兼容

• 输入：(batch, channels, rows, cols) （”channels_first”）4D张量

• 输出：(batch, filters, new_rows, new_cols) （”channels_first”）4D张量

  • 输出的行列数可能会因为填充方法而改变

SeparableConv2D

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

keras.layers.convolutional.SeparableConv2D(
	filters,
	kernel_size,
	strides=(1, 1),
	padding='valid',
	data_format=None,
	depth_multiplier=1,
	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
)

该层是在深度方向上的可分离卷积。

• 说明

  • 首先按深度方向进行卷积（对每个输入通道分别卷积）
  • 然后逐点卷积，将上步卷积结果混合到输出通道中
  • 直观来说，可分离卷积可以看做讲一个卷积核分解为两个小 卷积核，或看作Inception模块的一种极端情况

• 参数

  • depth_multiplier：按深度卷积的步骤中，每个输入通道 使用（产生）多少个输出通道

  • depthwise_regularizer：按深度卷积的权重上的正则项

  • pointwise_regularizer：按点卷积的权重上的正则项

  • depthwise_constraint：按深度卷积权重上的约束项

  • pointwise_constraint：在按点卷积权重的约束项

• 输入：(batch, channels, rows, cols)4DT （”channels_first”)

• 输出：(batch, filters, new_rows, new_cols)4DTK （”channels_first”）

  • 输出的行列数可能会因为填充方法而改变

Conv2DTranspose

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

keras.layers.convolutional.Conv2DTranspose(
	filters,
	kernel_size,
	strides=(1, 1),
	padding="valid",
	output_padding=None/int/tuple,
	data_format=None,
	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
)

该层是反卷积操作（转置卷积）

• 说明

  • 通常发生在用户想要对普通卷积的结果做反方向的变换
  • 参考文献
    • A guide to convolution arithmetic for deep learning
    • Transposed convolution arithmetic
    • Deconvolutional Networks

• 参数

  • output_padding：指定输出的长、宽padding
    • 必须小于相应的stride

• 输入：(batch, rows, cols, channels)4DT （”channels_last”)

• 输出：(batch, new_rows, new_cols, filters)4DT （”channels_last”）

  • 输出的行列数可能会因为填充方法而改变

Conv3D

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

keras.layers.convolutional.Conv3D(
	filters,
	kernel_size,
	strides=(1, 1, 1),
	padding='valid',
	data_format=None,
	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
)

三维卷积对三维的输入（视频）进行滑动窗卷积

• 输入：(batch, channels, conv_dim1, conv_dim2, conv_dim3) 5D张量（”channnels_first”）

Cropping1D

1
2
3

keras.layers.convolutional.Cropping1D(
	cropping=(1, 1)/tuple/int
)

在时间轴上对1D输入（即时间序列）进行裁剪

• 参数

  • cropping：指定在序列的首尾要裁剪掉多少个元素
    • 单值表示首尾裁剪相同

• 输入：(batch, axis_to_crop, features)的3DT

• 输出：(batch, cropped_axis, features)的3DT

Cropping2D

1
2
3
4

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

对2D输入（图像）进行裁剪

• 说明

  • 将在空域维度，即宽和高的方向上裁剪

• 参数

  • cropping：长为2的整数tuple，分别为宽和高方向上头部 与尾部需要裁剪掉的元素数
    • 单值表示宽高、首尾相同
    • 单元组类似

• 输入：(batch, rows, cols, channels)4DT（”channels_last”）

• 输出：(batch, cropped_rows, cropped_cols, channels)

1
2
3
4
5
6
7
8

	# Crop the input 2D images or feature maps
model = Sequential()
model.add(Cropping2D(cropping=((2, 2), (4, 4)),
                     input_shape=(28, 28, 3)))
	# now model.output_shape == (None, 24, 20, 3)
model.add(Conv2D(64, (3, 3), padding='same'))
model.add(Cropping2D(cropping=((2, 2), (2, 2))))
	# now model.output_shape == (None, 20, 16, 64)

Cropping3D

1
2
3
4

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

对3D输入（空间、时空）进行裁剪

• 参数

  • cropping：长为3的整数tuple，分别为三个方向上头部 与尾部需要裁剪掉的元素数

• 输入：(batch, depth, first_axis_to_crop, second_axis_to_crop, third_axis_to_crop) （”channels_first”）

• 输出：(batch, depth, first_cropped_axis, second_cropped_axis, third_cropped_axis)

UpSampling1D

1
2
3

keras.layers.convolutional.UpSampling1D(
	size=2/integer
)

在时间轴上，将每个时间步重复size次

• 参数

  • size：轴上采样因子

• 输入：(batch, steps, features)的3D张量

• 输出：(batch, upsampled_steps, feature)的3D张量

UpSampling2D

1
2
3
4

keras.layers.convolutional.UpSampling2D(
	size=(2, 2)/tuple/int,
	data_format=None
)

将数据的行和列分别重复size[0]和size[1]次

• 参数

  • size：分别为行和列上采样因子

• 输入：(batch, channels, rows, cols)的4D张量 （”channels_first”）

• 输出：(batch, channels, upsampled_rows, upsampled_cols)

UpSampling3D

1
2
3
4

keras.layers.convolutional.UpSampling3D(
	size=(2, 2, 2)/tuple/int,
	data_format=None
)

将数据的三个维度上分别重复size次

• 说明

  • 本层目前只能在使用Theano为后端时可用

• 参数

  • size：代表在三个维度上的上采样因子

• 输入：(batch, dim1, dim2, dim3, channels)5DT （”channels_last”）

• 输出：(batch, upsampled_dim1, upsampled_dim2, upsampled_dim3, channels)

ZeroPadding1D

1
2
3

keras.layers.convolutional.ZeroPadding1D(
	padding=1/int
)

对1D输入的首尾端（如时域序列）填充0

• 说明

  • 以控制卷积以后向量的长度

• 参数

  • padding：整数，在axis 1起始和结束处填充0数目

• 输入：(batch, axis_to_pad, features)3DT

• 输出：(batch, paded_axis, features)3DT

ZeroPadding2D

1
2
3
4

keras.layers.convolutional.ZeroPadding2D(
	padding=(1, 1)/tuple/int,
	data_format=None
)

对2D输入（如图片）的边界填充0

• 说明

  • 以控制卷积以后特征图的大小

• 参数

  • padding：在要填充的轴的起始和结束处填充0的数目

ZeroPadding3D

1
2
3
4

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

将数据的三个维度上填充0

• 说明
  • 本层目前只能在使用Theano为后端时可用

结束处填充0的数目

ZeroPadding3D

1
2
3
4

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

将数据的三个维度上填充0

• 说明
  • 本层目前只能在使用Theano为后端时可用

?时可用

Layer方法

所有的Keras层对象都有如下方法：

• layer.get_weights()：返回层的权重NDA

• layer.set_weights(weights)：从NDA中将权重加载到该层中 ，要求NDA的形状与layer.get_weights()的形状相同

• layer.get_config()：返回当前层配置信息的字典，层也可以 借由配置信息重构

• layer.from_config(config)：根据config配置信息重构层

  1 2 3

  layer = Dense(32) config = layer.get_config() reconstructed_layer = Dense.from_config(config)

  1 2 3 4 5

  from keras import layers config = layer.get_config() layer = layers.deserialize({'class_name': layer.__class__.__name__, 'config': config})

非共享层

如果层仅有一个计算节点（即该层不是共享层），则可以通过下列 方法获得

• 输入张量：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)

参数

shape类型

• batch_size

  • batch_size在实际数据输入中为首维（0维）
  • shape类型参数传递的tuple中一般不包括batch_size维度
  • 输出时使用None表示(batch_size,...)

• time_step

  • 对时序数据，time_step在实际数据输入中第二维（1维）

input_shape

• 是Layer的初始化参数，所有Layer子类都具有

• 如果Layer是首层，需要传递该参数指明输入数据形状，否则 无需传递该参数

  • 有些子类有类似于input_dim等参数具有input_shape 部分功能

• None：表示该维度变长

输入、输出

• channels/depth/features：时间、空间单位上独立的数据， 卷积应该在每个channal分别“独立”进行

  • 对1维时序（时间），channels就是每时刻的features
  • 对2维图片（空间），channels就是色彩通道
  • 对3维视频（时空），channels就是每帧色彩通道
  • 中间数据，channnels就是每个filters的输出

• 1D：(batch, dim, channels)（channels_last）

• 2D：(batch, dim_1, dim_2, channels) （channels_last）

• 3D：(batch, dim_1, dim_2, dim_3, channels) （channels_last）

LeakyReLU

1

keras.layers.LeakyReLU(alpha=0.3)

带泄漏的修正线性单元。

• 返回值：当神经元未激活时，它仍可以赋予其一个很小的梯度

  • x < 0：alpha * x
  • x >= 0：x

• 输入尺寸

  • 可以是任意的。如果将该层作为模型的第一层，需要指定 input_shape参数（整数元组，不包含样本数量的维度）

• 输出尺寸：与输入相同

• 参数

  • alpha：float >= 0，负斜率系数。

• 参考文献

  • Rectifier Nonlinearities Improve Neural Network Acoustic Models

PReLU

1
2
3
4
5
6

keras.layers.PReLU(
	alpha_initializer='zeros',
	alpha_regularizer=None,
	alpha_constraint=None,
	shared_axes=None
)

参数化的修正线性单元。

• 返回值

  • x < 0：alpha * x
  • x >= 0：x

• 参数

  • alpha_initializer: 权重的初始化函数。
  • alpha_regularizer: 权重的正则化方法。
  • alpha_constraint: 权重的约束。
  • shared_axes: 激活函数共享可学习参数的轴。 如果输入特征图来自输出形状为 (batch, height, width, channels) 的2D卷积层，而且你希望跨空间共享参数，以便每个滤波 器只有一组参数，可设置shared_axes=[1, 2]

• 参考文献

  • Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification

ELU

1

keras.layers.ELU(alpha=1.0)

指数线性单元

• 返回值

  • x < 0：alpha * (exp(x) - 1.)
  • x >= 0：x

• 参数

  • alpha：负因子的尺度。

• 参考文献

  • Fast and Accurate Deep Network Learning by Exponential Linear Units (ELUs)

ThresholdedReLU

1

keras.layers.ThresholdedReLU(theta=1.0)

带阈值的修正线性单元。

• 返回值

  • x > theta：x
  • x <= theta：0

• 参数

  • theta：float >= 0激活的阈值位。

• 参考文献

  • Zero-Bias Autoencoders and the Benefits of Co-Adapting Features

Softmax

1

keras.layers.Softmax(axis=-1)

Softmax激活函数

• 参数
  • axis: 整数，应用 softmax 标准化的轴。

ReLU

1

keras.layers.ReLU(max_value=None)

ReLU激活函数

• 参数
  • max_value：浮点数，最大的输出值。

常用层对应于core模块，core内部定义了一系列常用的网络层，包括 全连接、激活层等

Dense层

1
2
3
4
5
6
7
8
9
10
11
12

keras.layers.core.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
)

Dense就是常用的全连接层

• 用途：实现运算$output = activation(dot(input, kernel)+bias)$

  • activation：是逐元素计算的激活函数
  • kernel：是本层的权值矩阵
  • bias：为偏置向量，只有当use_bias=True才会添加

• 参数

  • units：大于0的整数，代表该层的输出维度。

  • activation：激活函数

    • 为预定义的激活函数名（参考激活函数）
    • 逐元素（element-wise）的Theano函数
    • 不指定该参数，将不会使用任何激活函数 （即使用线性激活函数：a(x)=x）

  • use_bias: 布尔值，是否使用偏置项

  • kernel_initializer：权值初始化方法

    • 预定义初始化方法名的字符串
    • 用于初始化权重的初始化器（参考initializers）

  • bias_initializer：偏置向量初始化方法

    • 为预定义初始化方法名的字符串
    • 用于初始化偏置向量的初始化器（参考initializers）

  • kernel_regularizer：施加在权重上的正则项，为 Regularizer对象

  • bias_regularizer：施加在偏置向量上的正则项，为 Regularizer对象

  • activity_regularizer：施加在输出上的正则项，为 Regularizer对象

  • kernel_constraints：施加在权重上的约束项，为
    Constraints对象

  • bias_constraints：施加在偏置上的约束项，为 Constraints对象

• 输入

  • 形如(batch_size, ..., input_dim)的NDT，最常见情况 为(batch_size, input_dim)的2DT
  • 数据的维度大于2，则会先被压为与kernel相匹配的大小

• 输出

  • 形如(batch_size, ..., units)的NDT，最常见的情况为 $(batch_size, units)$的2DT

Activation层

1
2
3
4

keras.layers.core.Activation(
	activation,
	input_shape
)

激活层对一个层的输出施加激活函数

• 参数

  • activation：将要使用的激活函数
    • 预定义激活函数名
    • Tensorflow/Theano的函数（参考激活函数）

• 输入：任意，使用激活层作为第一层时，要指定input_shape

• 输出：与输入shape相同

Dropout层

1
2
3
4
5

keras.layers.core.Dropout(
	rate,
	noise_shape=None,
	seed=None
)

为输入数据施加Dropout

• 说明

  • Dropout将在训练过程中每次更新参数时按一定概率rate 随机断开输入神经元

  • 可以用于防止过拟合

  • 参考文献：Dropout: A Simple Way to Prevent Neural Networks from Overfitting

• 参数

  • rate：0~1的浮点数，控制需要断开的神经元的比例

  • noise_shape：整数张量，为将要应用在输入上的二值 Dropout mask的shape

  • seed：整数，使用的随机数种子

• 输入

  • 例：(batch_size, timesteps, features)，希望在各个 时间步上Dropout mask都相同，则可传入 noise_shape=(batch_size, 1, features)

Flatten层

1

keras.layers.core.Flatten()

Flatten层用来将输入“压平”，把多维的输入一维化

• 常用在从卷积层到全连接层的过渡
• Flatten不影响batch的大小。

1
2
3
4
5
6
7
8

model = Sequential()
model.add(Convolution2D(64, 3, 3,
            border_mode='same',
            input_shape=(3, 32, 32)))
	# now: model.output_shape == (None, 64, 32, 32)

model.add(Flatten())
	# now: model.output_shape == (None, 65536)

Reshape层

1
2
3
4

keras.layers.core.Reshape(
	target_shape,
	input_shape
)

Reshape层用来将输入shape转换为特定的shape

• 参数

  • target_shape：目标shape，为整数的tuple，不包含样本 数目的维度（batch大小）
    • 包含-1表示推断该维度大小

• 输入：输入的shape必须固定（和target_shape积相同）

• 输出：(batch_size, *target_shape)

• 例

  1 2 3 4 5 6 7 8 9 10 11

  model = Sequential() model.add(Reshape((3, 4), input_shape=(12,))) # now: model.output_shape == (None, 3, 4) # note: `None` is the batch dimension model.add(Reshape((6, 2))) # now: model.output_shape == (None, 6, 2) # also supports shape inference using `-1` as dimension model.add(Reshape((-1, 2, 2))) # now: model.output_shape == (None, 3, 2, 2)

Permute层

1
2
3

keras.layers.core.Permute(
	dims(tuple)
)

Permute层将输入的维度按照给定模式进行重排

• 说明

  • 当需要将RNN和CNN网络连接时，可能会用到该层。

• 参数

  • dims：指定重排的模式，不包含样本数的维度（即下标 从1开始）

• 输出shape

  • 与输入相同，但是其维度按照指定的模式重新排列

• 例

  1 2 3

  model = Sequential() model.add(Permute((2, 1), input_shape=(10, 64))) # now: model.output_shape == (None, 64, 10)

RepeatVector层

1
2
3

keras.layers.core.RepeatVector(
	n(int)
)

RepeatVector层将输入重复n次

• 参数

  • n：整数，重复的次数

• 输入：形如(batch_size, features)的张量

• 输出：形如(bathc_size, n, features)的张量

• 例

  1 2 3 4 5 6

  model = Sequential() model.add(Dense(32, input_dim=32)) # now: model.output_shape == (None, 32) model.add(RepeatVector(3)) # now: model.output_shape == (None, 3, 32)

Lambda层

1
2
3
4
5
6

keras.layers.core.Lambda(
	function,
	output_shape=None,
	mask=None,
	arguments=None
)

对上一层的输出施以任何Theano/TensorFlow表达式

• 参数

  • function：要实现的函数，该函数仅接受一个变量，即 上一层的输出

  • output_shape：函数应该返回的值的shape，可以是一个 tuple，也可以是一个根据输入shape计算输出shape的函数

  • mask: 掩膜

  • arguments：可选，字典，用来记录向函数中传递的其他 关键字参数

• 输出：output_shape参数指定的输出shape，使用TF时可自动 推断

• 例

  1 2	model.add(Lambda(lambda x: x ** 2)) # add a x -> x^2 layer

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

  # add a layer that returns the concatenation # of the positive part of the input and # the opposite of the negative part def antirectifier(x): x -= K.mean(x, axis=1, keepdims=True) x = K.l2_normalize(x, axis=1) pos = K.relu(x) neg = K.relu(-x) return K.concatenate([pos, neg], axis=1) def antirectifier_output_shape(input_shape): shape = list(input_shape) assert len(shape) == 2 # only valid for 2D tensors shape[-1] *= 2 return tuple(shape) model.add(Lambda(antirectifier, output_shape=antirectifier_output_shape))

ActivityRegularizer层

1
2
3
4

keras.layers.core.ActivityRegularization(
	l1=0.0,
	l2=0.0
)

经过本层的数据不会有任何变化，但会基于其激活值更新损失函数值

• 参数
  • l1：1范数正则因子（正浮点数）
  • l2：2范数正则因子（正浮点数）

Masking层

1

keras.layers.core.Masking(mask_value=0.0)

使用给定的值对输入的序列信号进行“屏蔽”

• 说明

  • 用以定位需要跳过的时间步
  • 对于输入张量的时间步，如果输入张量在该时间步上都等于 mask_value，则该时间步将在模型接下来的所有层 （只要支持masking）被跳过（屏蔽）。
  • 如果模型接下来的一些层不支持masking，却接受到masking 过的数据，则抛出异常

• 输入：形如(samples,timesteps,features)的张量

• 例：缺少时间步为3和5的信号，希望将其掩盖
  • 方法：赋值x[:,3,:] = 0., x[:,5,:] = 0.
  • 在LSTM层之前插入mask_value=0.的Masking层

    1 2 3

    model = Sequential() model.add(Masking(mask_value=0., input_shape=(timesteps, features))) model.add(LSTM(32))

.`的Masking层

1
2
3

model = Sequential()
model.add(Masking(mask_value=0., input_shape=(timesteps, features)))
model.add(LSTM(32))

```

LocallyConnnected和Conv差不多，只是Conv每层共享卷积核， 这里不同位置卷积核独立

LocallyConnected1D层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

keras.layers.local.LocallyConnected1D(
	filters,
	kernel_size,
	strides=1,
	padding="valid",
	data_format=None,
	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
)

类似于Conv1D，单卷积核权重不共享

LocallyConnected2D层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

keras.layers.local.LocallyConnected2D(
	filters,
	kernel_size,
	strides=(1, 1),
	padding="valid",
	data_format=None,
	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
)

类似Conv2D，区别是不进行权值共享

• 说明
  • 输出的行列数可能会因为填充方法而改变
• 例

  1 2 3 4 5 6 7 8 9 10

  model = Sequential() model.add(LocallyConnected2D(64, (3, 3), input_shape=(32, 32, 3))) # apply a 3x3 unshared weights convolution with 64 output filters on a 32x32 image # with `data_format="channels_last"`: # now model.output_shape == (None, 30, 30, 64) # notice that this layer will consume (30*30)*(3*3*3*64) + (30*30)*64 parameters model.add(LocallyConnected2D(32, (3, 3))) # now model.output_shape == (None, 28, 28, 32) # add a 3x3 unshared weights convolution on top, with 32 output filters:

MaxPooling1D

1
2
3
4
5
6

keras.layers.pooling.MaxPooling1D(
	pool_size=2/int,
	strides=None/int,
	padding="valid"
	data_format=None
)

对时域1D信号进行最大值池化

• 参数

  • pool_size：整数，池化窗口大小
  • strides：整数或None，下采样因子，例如设2将会使得 输出shape为输入的一半，若为None则默认值为pool_size。

MaxPooling2D

1
2
3
4
5
6

keras.layers.pooling.MaxPooling2D(
	pool_size=(2, 2),
	strides=None/int/(int),
	padding="valid"/"same",
	data_format=None
)

为空域2D信号施加最大值池化

MaxPooling3D层

1
2
3
4
5
6

keras.layers.pooling.MaxPooling3D(
	pool_size=(2, 2, 2),
	strides=None/int/(int),
	padding="valid"/"same",
	data_format=None
)

为3D信号（空域或时空域）施加最大值池化

AveragePooling1D层

1
2
3
4
5
6

keras.layers.pooling.AveragePooling1D(
	pool_size=2,
	strides=None,
	padding="valid"
	data_format=None
)

对1D信号（时域）进行平均值池化

AveragePooling2D层

1
2
3
4
5
6

keras.layers.pooling.AveragePooling2D(
	pool_size=(2, 2),
	strides=None,
	padding="valid",
	data_format=None
)

为2D（空域）信号施加平均值池化

AveragePooling3D层

1
2
3
4
5
6

keras.layers.pooling.AveragePooling3D(
	pool_size=(2, 2, 2),
	strides=None,
	padding="valid",
	data_format=None
)

为3D信号（空域或时空域）施加平均值池化

GlobalMaxPooling1D层

1
2
3

keras.layers.pooling.GlobalMaxPooling1D(
	data_format="channels_last"
)

对于1D（时间）信号的全局最大池化

GlobalAveragePooling1D层

1
2
3

keras.layers.pooling.GlobalAveragePooling1D(
	data_forma="channels_last"
)

为时域信号施加全局平均值池化

GlobalMaxPooling2D层

1
2
3

keras.layers.pooling.GlobalMaxPooling2D(
	data_format=None
)

为空域信号施加全局最大值池化

GlobalAveragePooling2D层

1
2
3

keras.layers.pooling.GlobalAveragePooling2D(
	data_format=None
)

为2D（空域）信号施加全局平均值池化

RNN

1
2
3
4
5
6
7
8

keras.layers.RNN(
	cell,
	return_sequences=False,
	return_state=False,
	go_backwards=False,
	stateful=False,
	unroll=False
)

循环神经网络层基类：抽象类、无法实例化对象

• 参数

  • cell：RNN单元实例、列表，为RNN单元列表时，单元 堆叠放置，实现高效堆叠RNN

  • return_sequences：返回输出序列最后值/全部序列

  • return_state：是否返回最后一个状态

  • go_backwards：是否向后处理输入序列并返回相反的序列。

  • stateful：批次中索引i处的每个样品的最后状态将 用作下一批次中索引i样品的初始状态

  • unroll：是否将网络展开（否则将使用符号循环）

    • 展开可以加速 RNN，但它往往会占用更多的内存
    • 展开只适用于短序列

  • input_dim：输入的维度（整数）

    • 将此层用作模型中的第一层时，此参数是必需的 （或者关键字参数 input_shape）

  • input_length： 输入序列的长度，在恒定时指定

    • 如果你要在上游连接 Flatten 和 Dense 层，则 需要此参数（没有它，无法计算全连接输出的尺寸）
    • 如果循环神经网络层不是模型中的第一层，则需要在 第一层的层级指定输入长度 （或通过关键字参数input_shape）

• 输入：(batch_size, timesteps, input_dim)3D张量

• 输出

  • return_state=True：则返回张量列表，第一个张量为 输出、剩余的张量为最后的状态，每个张量的尺寸为 (batch_size, units)。
  • return_state=False：(batch_size, units)2D张量

说明

• 屏蔽覆盖：支持以可变数量的时间步长对输入数据进行屏蔽覆盖

• 使用状态：可以将 RNN 层设置为 stateful（有状态的）

  • 这意味着针对一批中的样本计算的状态将被重新用作下一批 样品的初始状态

  • 这假定在不同连续批次的样品之间有一对一的映射。

  • 为了使状态有效：

    • 在层构造器中指定 stateful=True。
    • 为模型指定一个固定的批次大小
      • 顺序模型：为模型的第一层传递一个 batch_input_shape=(...) 参数
      • 带有Input层的函数式模型，为的模型的所有i 第一层传递一个batch_shape=(...)，这是输入 预期尺寸，包括批量维度
    • 在调用 fit() 是指定 shuffle=False。

  • 要重置模型的状态，请在特定图层或整个模型上调用 .reset_states()

• 初始状态

  • 通过使用关键字参数initial_state调用它们来符号化地 指定 RNN 层的初始状态（值应该是表示RNN层初始状态的 张量或张量列表）
  • 通过调用带有关键字参数states的reset_states方法 来数字化地指定 RNN 层的初始状态（值应该是一个代表RNN 层初始状态的NDA/[NDA]）

• RNN单元对象需要具有

  • call(input_at_t, states_at_t)方法，它返回 (output_at_t, states_at_t_plus_1)，单元的调用 方法也可以采用可选参数 constants
  • state_size属性
    • 单个整数（单个状态）：在这种情况下，它是循环层 状态大小（应该与单元输出的大小相同）
    • 整数的列表/元组（每个状态一个大小）：第一项应该 与单元输出的大小相同

• 传递外部常量

  • 使用RNN.call以及RNN.call的constants关键字 参数将外部常量传递给单元
  • 要求cell.call方法接受相同的关键字参数constants， 这些常数可用于调节附加静态输入（不随时间变化）上的 单元转换，也可用于注意力机制

例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

class MinimalRNNCell(keras.layers.Layer):
	# 定义RNN细胞单元（网络层子类）
	def init(self, units, **kwargs):
		self.units = units
		self.state_size = units
		super(MinimalRNNCell, self).init(**kwargs)

	def build(self, input_shape):
		self.kernel = self.add_weight(
			shape=(input_shape[-1], self.units),
			initializer="uniform",
			name="kernel"
		)
		self.recurrent_kernel = self.add_weight(
			shape=(self.units, self.units),
			initializer="uniform",
			name="recurrent_kernel")
		self.built = True

	def call(self, inputs, states):
		prev_output = states[0]
		h = K.dot(inputs, self.kernel)
		output = h + K.dot(prev_output, self.recurrent_kernel)
		return output, [output]

cell = MinimalRNNCell(32)
	# 在RNN层使用这个单元：
x = keras.Input((None, 5))
layer = RNN(cell)
y = layer(x)


cells = [MinimalRNNCell(32), MinimalRNNCell(64)]
	# 用单元格构建堆叠的RNN的方法：
x = keras.Input((None, 5))
layer = RNN(cells)
y = layer(x)

SimpleRNN

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

keras.layers.SimpleRNN(
	units,
	activation="tanh",
	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,
	stateful=False,
	unroll=False
)

完全连接的RNN，其输出将被反馈到输入。

• 参数

  • units：正整数，输出空间的维度。

  • activation：要使用的激活函数

    • tanh：默认
    • None：则不使用激活函数，即线性激活：a(x) = x

  • use_bias：布尔值，该层是否使用偏置向量。

  • kernel_initializer：kernel权值矩阵的初始化器

  • recurrent_initializer：recurrent_kernel权值矩阵

  • bias_initializer：偏置向量的初始化器

  • kernel_regularizer：运用到kernel权值矩阵的正则化 函数

  • recurrent_regularizer：运用到 recurrent_kernel 权值 矩阵的正则化函数

  • bias_regularizer：运用到偏置向量的正则化函数

  • activity_regularizer：运用到层输出（它的激活值）的 正则化函数

  • kernel_constraint：运用到kernel权值矩阵的约束函数

  • recurrent_constraint：运用到recurrent_kernel权值矩阵 的约束函数

  • bias_constraint： 运用到偏置向量的约束函数

  • dropout：单元的丢弃比例，用于输入的线性转换

    • 在0-1之间的浮点数

  • recurrent_dropout：单元的丢弃比例，用于循环层状态线性 转换

  • return_sequences：返回输出序列中的全部序列

    • 默认：返回最后最后一个输出

  • return_state：除输出之外是否返回最后一个状态

  • go_backwards：向后处理输入序列并返回相反的序列

  • stateful：批次中索引 i 处的每个样品的最后状态，将用作 下一批次中索引 i 样品的初始状态

  • unroll：展开网络

GRU

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

keras.layers.GRU(
	units,
	activation="tanh",
	recurrent_activation="hard_sigmoid",
	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=1,
	return_sequences=False,
	return_state=False,
	go_backwards=False,
	stateful=False,
	unroll=False,
	reset_after=False
)

门限循环单元网络

• 说明：有两种变体

  • 默认的基于1406.1078v3，并且在矩阵乘法之前将复位门 应用于隐藏状态

  • 另一种基于1406.1078v1并且顺序倒置

    • 兼容CuDNNGRU(GPU-only)，并且允许在 CPU 上进行 推理

    • 对于kernel和recurrent_kernel有可分离偏置 reset_after=True和recurrent_activation=sigmoid 。

• 参数

  • recurrent_activation：用于循环时间步的激活函数

  • implementation：实现模式

    • 1：将把它的操作结构化为更多的小的点积和加法操作

    • 2：将把它们分批到更少，更大的操作中

    • 这些模式在不同的硬件和不同的应用中具有不同的性能配置 文件

  • reset_after：GRU公约，在矩阵乘法之后使用重置门

• 参考文献

  • Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation
  • On the Properties of Neural Machine Translation：Encoder-Decoder Approaches
  • Empirical Evaluation of Gated Recurrent Neural Networks on Sequence Modeling
  • A Theoretically Grounded Application of Dropout in Recurrent Neural Networks

LSTM

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

keras.layers.LSTM(
	units,
	activation="tanh",
	recurrent_activation="hard_sigmoid",
	use_bias=True,
	kernel_initializer="glorot_uniform",
	recurrent_initializer="orthogonal",
	bias_initializer="zeros",
	unit_forget_bias=True,
	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=1,
	return_sequences=False,
	return_state=False,
	go_backwards=False,
	stateful=False,
	unroll=False
)

长短期记忆网络层（Hochreiter 1997）

• 参数

  • unit_forget_bias
    • True：初始化时，将忘记门的偏置加 1，同时还会强制 bias_initializer="zeros"（这个建议来自 Jozefowicz et al.）

• 参考文献

  • Long short-term memory (original 1997 paper)
  • Learning to forget：Continual prediction with LSTM
  • Supervised sequence labeling with recurrent neural networks
  • A Theoretically Grounded Application of Dropout in Recurrent Neural Networks

ConvLSTM2D

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

keras.layers.ConvLSTM2D(
	filters(int),
	kernel_size(tuple(int, int)),
	strides=(1, 1),
	padding='valid',
	data_format=None,
	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,
	kernel_regularizer=None,
	recurrent_regularizer=None,
	bias_regularizer=None,
	activity_regularizer=None,
	kernel_constraint=None,
	recurrent_constraint=None,
	bias_constraint=None,
	return_sequences=False,
	go_backwards=False,
	stateful=False,
	dropout=0.0,
	recurrent_dropout=0.0
)

卷积LSTM：它类似于LSTM层，但输入变换和循环变换都是卷积的

• 说明

  • 当前的实现不包括单元输出的反馈回路

• 参数

  • dilation_rate：用于膨胀卷积的膨胀率
    • stride!=1与dilation_rate!=1两者不兼容。

• 输入尺寸

  • data_format="channels_first"：尺寸为 (batch, time, channels, rows, cols)
  • data_format="channels_last"：尺寸为 (batch, time, rows, cols, channels)

• 输出尺寸

  • return_sequences=True

    • data_format="channels_first"：返回尺寸为 (batch, time, filters, output_row, output_col)

    • data_format="channels_last"：返回尺寸为 (batch, time, output_row, output_col, filters)

  • return_seqences=False

    • data_format ="channels_first"：返回尺寸为 (batch, filters, output_row, output_col)

    • data_format="channels_last"：返回尺寸为 (batch, output_row, output_col, filters)

• 参考文献

  • Convolutional LSTM Network：A Machine Learning Approach for Precipitation Nowcasting

SimpleRNNCell

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

keras.layers.SimpleRNNCell(
	units,
	activation='tanh',
	use_bias=True,
	kernel_initializer='glorot_uniform',
	recurrent_initializer='orthogonal',
	bias_initializer='zeros',
	kernel_regularizer=None,
	recurrent_regularizer=None,
	bias_regularizer=None,
	kernel_constraint=None,
	recurrent_constraint=None,
	bias_constraint=None,
	dropout=0.0,
	recurrent_dropout=0.0
)

SimpleRNN的单元类

GRUCell

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

keras.layers.GRUCell(
	units,
	activation='tanh',
	recurrent_activation='hard_sigmoid',
	use_bias=True,
	kernel_initializer='glorot_uniform',
	recurrent_initializer='orthogonal',
	bias_initializer='zeros',
	kernel_regularizer=None,
	recurrent_regularizer=None,
	bias_regularizer=None,
	kernel_constraint=None,
	recurrent_constraint=None,
	bias_constraint=None,
	dropout=0.0,
	recurrent_dropout=0.0,
	implementation=1
)

GRU层的单元类

LSTMCell

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

keras.layers.LSTMCell(
	units,
	activation='tanh',
	recurrent_activation='hard_sigmoid',
	use_bias=True,
	kernel_initializer='glorot_uniform',
	recurrent_initializer='orthogonal',
	bias_initializer='zeros',
	unit_forget_bias=True,
	kernel_regularizer=None,
	recurrent_regularizer=None,
	bias_regularizer=None,
	kernel_constraint=None,
	recurrent_constraint=None,
	bias_constraint=None,
	dropout=0.0,
	recurrent_dropout=0.0,
	implementation=1
)

LSTM层的单元类

StackedRNNCells

1

keras.layers.StackedRNNCells(cells)

将一堆RNN单元表现为一个单元的封装器

• 说明

  • 用于实现高效堆叠的 RNN。

• 参数

  • cells：RNN 单元实例的列表

例子

1
2
3
4
5
6
7
8

cells = [
    keras.layers.LSTMCell(output_dim),
    keras.layers.LSTMCell(output_dim),
    keras.layers.LSTMCell(output_dim),
]

inputs = keras.Input((timesteps, input_dim))
x = keras.layers.RNN(cells)(inputs)

CuDNNGRU

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

keras.layers.CuDNNGRU(
	units,
	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,
	return_sequences=False,
	return_state=False,
	stateful=False
)

由 CuDNN 支持的快速GRU实现

• 说明

  • 只能以TensorFlow后端运行在GPU上

CuDNNLSTM

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

keras.layers.CuDNNLSTM(
	units,
	kernel_initializer='glorot_uniform',
	recurrent_initializer='orthogonal',
	bias_initializer='zeros',
	unit_forget_bias=True,
	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,
	stateful=False
)

由 CuDNN 支持的快速LSTM实现

• 说明

  • 只能以TensorFlow后端运行在GPU上