角点检测特征提取

综述

  • corner point:角点,邻域各方向上灰度变化值足够高的点, 是图像边缘曲线上曲率极大值的点

分类

  • 基于灰度图像的角点检测

    • 基于梯度:计算边缘曲率判断角点
    • 基于模板:考虑像素邻域点的灰度变化,将领域点亮度对比 足够大的点定义为角点
    • 基于模板、梯度组合
  • 基于二值图像的角点检测:将二值图像作为单独的检测目标, 可使用各种基于灰度图像的角点检测方法

  • 基于轮廓曲线的角点检测:通过角点强度、曲线曲率提取角点

思想、步骤

  • 使用角点检测算子,对图像每个像素计算 cornner response function

    • $w(x,y)$:window function,窗口函数
    • $I(x,y)$:图像梯度
    • $E(x,y)$:角点响应函数,体现灰度变化剧烈程度,变化 程度剧烈则窗口中心就是角点
  • 阈值化角点响应函数值

    • 根据实际情况选择阈值$T$
    • 小于阈值$T$者设置为0
  • 在窗口范围内对角点响应函数值进行非极大值抑制

    • 窗口内非响应函数值极大像素点置0
  • 获取非零点作为角点

Moravec

todo

步骤

  • 取偏移量$(\Delta x, \Delta y)$为 $(1,0), (1,1), (0,1), (-1,1)$,分别计算每个像素点灰度 变化

  • 对每个像素点(x_i, y_i)$计算角点响应函数 $R(x) = min {E}$

  • 设定阈值$T$,小于阈值者置0

  • 进行非极大值抑制,选择非0点作为角点检测结果

特点

  • 二值窗口函数:角点响应函数不够光滑
  • 只在4个方向(偏移量)上计算灰度值变化:角点响应函数会在 多处都有较大响应值
  • 对每个点只考虑响应函数值最小值:算法对边缘敏感

Harris

Good Features to Track

Feature from Accelerated Segment Test

FAST:加速分割测试获得特征

NLP 总述

文本挖掘

  • 文本处理:将非结构化数据转换为结构化数据

  • 预测建模

    • 文本分类:根据观察到的对象特征值预测其他特征值
  • 描述建模

    • 文本聚类:对数据对象进行概括,以看到数据对象的最重要 特征
      • 适应范围非常广
    • 聚类分析
  • 基于相似度方法

    • 需要用户显式指定相似度函数
    • 聚类算法根据相似度的计算结果将相似文本分在同一个组
    • 每个文本只能属于一个组,因此也成为“硬聚类”
  • 基于模型的方法

    • 文本有多个标签,也成为“软聚类”

话题检测

找出文档中的K个话题,计算每个文档对话题的覆盖率

话题表示方法

基于单个词

基于词分布

问题描述
  • 输入
    • N个文档构成的文本集C
    • 话题个数K
    • 词典V
  • 输出
    • K个话题的分布 $(\theta_1, \theta2, \cdots, \theta_K)$
    • N个文档在K个话题上的概率分布 $(\pi_1, \pi_2, \cdots, \pi_N)$

语言模型

词向量:将向量表示词

  • 1-of-N representation/one hot representation:one-hot 表示词

    word_vector

    • 词向量维度为整个词汇表大小
    • 简单、效率不高
  • distributed representation:embedding思想,通过训练, 将词映射到较短词向量中

    word_vector

    • 词向量维度自定义
    • 容易分析词之间关系

Continuous Bag-of-Words

CBOW:输入特征词上下文相关词对应词向量,输出特征词的词向量

  • CBOW使用词袋模型
    • 特征词上下文相关从平等,不考虑和关注的词之间的距离

Skip-Gram

Skip-Gram:输入特征词词向量,输出softmax概率靠前的词向量

神经网络词向量

神经网络词向量:使用神经网络训练词向量

  • 一般包括三层:输入层、隐层、输出softmax层

  • 从隐藏层到输出softmax层计算量很大

    • 需要计算所有词的softmax概率,再去找概率最大值

Spark MLLib

MLLib

Spark MLLib:Spark平台的机器学习库

  • 能直接操作RDD数据集,可以和其他BDAS其他组件无缝集成, 使得在全量数据上进行学习成为可能

  • 实现包括以下算法

    • Classification
    • Regression
    • Clustering
    • Collaborative Filtering
    • Dimensionality Reduction
  • MLLib是MLBase中的一部分

    • MLLib
    • MLI
    • MLOptimizer
    • MLRuntime
  • 从Spark1.2起被分为两个模块

    • spark.mllib:包含基于RDD的原始算法API
    • spark.ml:包含基于DataFrame的高层次API
      • 可以用于构建机器学习PipLine
      • ML PipLine API可以方便的进行数据处理、特征转换、 正则化、联合多个机器算法,构建单一完整的机器学习 流水线
  • MLLib算法代码可以在examples目录下找到,数据则在data 目录下
  • 机器学习算法往往需要多次迭代到收敛为止,Spark内存计算、 DAG执行引擎象相较MapReduce更理想
  • 由于Spark核心模块的高性能、通用性,Mahout已经放弃 MapReduce计算模型,选择Spark作为执行引擎

mllib.classification

Classification

Logistic Regression

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from pyspark.mllib.classification import \
LogisticRegressionWithLBFGS, LogisticRegressionModel
from pyspark.mllib.regression import LabledPoint

def parse_point(line):
value = [float(i) for i line.split(", \r\n\t")

data = sc.textFile("data/mllib/sample_svm_data.txt")
parsed_data = data.map(parse_point)
# map `parse_point` to all data

model = LogisticRegressionWithLBFGS.train(parsed_data)
labels_and_preds = parsed_data.map(lambda p: (p.label, model.predict(p.features)))
train_err = labels_and_preds \
.filter(lambda lp: lp[0] != lp[1]) \
.count() / float(parsed_data.count())

model.save(sc, "model_path")
same_model = LogisticRegressionModel.load(sc, "model.path")
  • Decision Tree
  • Random Forest
  • Gradient
  • boosted tree
  • Multilaye Perceptron
  • Support Vector Machine
  • One-vs-Rest Classifier
  • Naive Bayes

Clustering

K-means

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import numpy as np
from pyspark.mllib.clustering import KMeans, KMeansModel

data = sc.textFile("data/mllib/kmeans_data.txt")
parsed_data = data.map(lambda line: np.array([float(i) for i in line.split()]))

cluster_model = KMeans.train(
parsed_data,
maxIteration=10,
initializationMode="random"
)
def error(point):
center = cluster_model.centers[cluster.predict(point)]
return np.sqrt(sum([i**2 for i in (point - center)]))
WSSSE = parsed_data \
.map(lambda point.error(point)) \
.reduce(lambd x, y: x + y)

cluster_model.save(sc, "model_path")
same_model = KMeansModel.load(sc, "model_path")

Gaussian Mixture Model(GMM)

  • 混合密度模型
    • 有限混合模型:正态分布混合模型可以模拟所有分布
    • 迪利克莱混合模型:类似于泊松过程
  • 应用
    • 聚类:检验聚类结果是否合适
    • 预测:

      todo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import numpy as np
from pyspark.mllib.clustering import GussianMixture, \
GussianMixtureModel

data = sc.textFile("data/mllib/gmm_data.txt")
parsed_data = data.map(lambda line: np.array[float(i) for i in line.strip()]))

gmm = GaussianMixture.train(parsed_data, 2)
for w, g in zip(gmm.weights, gmm.gaussians):
print("weight = ", w,
"mu = ", g.mu,
"sigma = ", g.sigma.toArray())

gmm.save(sc, "model_path")
same_model = GussainMixtureModel.load(sc, "model_path")

Latent Dirichlet Allocation(LDA)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from pyspark.mllib.clustering import LDA, LDAModel
from pyspark.mllib.linalg import Vectors

data = sc.textFile("data/mllib/sample_lda_data.txt")
parsed_data = data.map(lambda line: Vector.dense([float(i) for i in line.strip()]))

corpus = parsed_data.zipWithIndex() \
.map(lambda x: [x[1], x[0]).cache()
ldaModel = LDA.train(corpus, k=3)

topics = ldaModel.topicsMatrix()

for word in range(0, ldaModel.vocabSize()):
for topic in word:
print(topic)

ldaModel.save(sc, "model_path")
same_model = LDAModel.load("model_path")
  • Disecting K-means

Regression

Linear Regression

  • 耗时长、无法计算解析解(无意义)
  • 使用MSE作为极小化目标函数,使用SGD算法求解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from pyspark.mllib.regression import LabledPoint, \
LinearRegressionWithSGD, LinearRegressionModel

def parse_point(line):
value = [float(i) for i line.split(", \r\n\t")

data = sc.textFile("data/mllib/ridge-data/lpsa.data")
parsed_data = data.map(parse_point)
# map `parse_point` to all data

model = LinearRegressionWithSGD.train(
parsed_data,
iteration=100,
step=0.00000001
)
values_and_preds = parsed_data.map(lambda p:(p.label, model.predict(p.features)))
MSE = values_and_preds \
.map(lambda vp: (vp[0] - vp[1]) ** 2) \
.reduce(lambda x, y: x + y) / values_and_preds.count()

model.save(sc, "model_path")
# save model
same_model = LinearRegressionModel.load(sc, "model_path")
# load saved model
  • Generalized Linear Regression
  • Decision Tree Regression
  • Random Forest Regression
  • Gradient-boosted Tree Regression
  • Survival Regression
  • Isotonic Regression

Collaborative Filtering

Keras 后端

Keras后端

Keras是一个模型级的库,提供了快速构建深度学习网络的模块

  • Keras并不处理如张量乘法、卷积等底层操作,而是依赖于某种 特定的、优化良好的张量操作库

  • Keras依赖于处理张量的库就称为“后端引擎”

    • [Theano][Theano]:开源的符号主义张量操作框架,由 蒙特利尔大学LISA/MILA实验室开发
    • [Tensorflow][Tensorflow]:符号主义的张量操作框架, 由Google开发
    • [CNTK][CNTK]:由微软开发的商业级工具包
  • Keras将其函数统一封装,使得用户可以以同一个接口调用不同 后端引擎的函数

切换后端

  • 修改Keras配置文件
  • 定义环境变量KERAS_BACKEND覆盖配置文件中设置(见python 修改环境变量的3中方式)

Keras后端抽象

可以通过Keras后端接口来编写代码,使得Keras模块能够同时在 Theano和TensorFlow两个后端上使用

  • 大多数张量操作都可以通过统一的Keras后端接口完成,不必 关心具体执行后端
1
2
3
4
5
6
7
8
9
10
11
12
13
from keras import backend as K

input = K.placeholder(shape=(2, 4, 5))
input = K.placeholder(shape=(None, 4, 5))
input = K.placeholder(ndim=3)
# 实例化输出占位符

val = np.random.random((3, 4, 5))
var = K.variable(value=val)
# 实例化共享变量
# 等价于`tf.Variable`、`theano.shared`
var = K.zeros(shape=(3, 4, 5))
var = K.ones(shape=(3, 4, 5))

配置相关函数

backend

返回当前后端

epsilon

1
K.epsilon()

返回数字表达式使用fuzz factor

set_epsilon

1
K.set_epsilon(e(float))

设置模糊因子的值

floatx

1
K.floatx()

返回默认的浮点数数据类型

  • float16
  • float32
  • float64

set_floatx

1
2
3
K.set_floatx(
floatx="float16"/"float32"/"float64"
)

设置默认的浮点数数据类型(字符串表示)

cast_to_floatx

1
K.cast_to_floatx(x)

将NDA转换为默认的Keras floatx类型(的NDA)

  • 例子

    1
    2
    3
    4
    5
    6
    7
    8
    K.floatx()
    # "float32"
    arr = np.array([1.0, 2.0], dtype="flaot64")
    arr.dtype
    # "float64"
    new_arr = K.cast_to_float(arr)
    new_arr.dtype
    # "float32"

image_data_format

1
K.image_data_format()

返回图像的默认维度顺序

  • channels_last
  • channels_first

set_image_data_format

1
2
3
K.set_image_data_format(
data_format="channel_first"/"channel_last"
)

设置图像的默认维度顺序

辅助函数

is_keras_tensor

判断是否是Keras Tensor对象

1
2
3
4
5
6
7
8
9
10
11
np_var = np.array([1, 2])
K.is_keras_tensor(np_var)
# False
keras_var = K.variable(np_var)
K.is_keras_tensor(keras_var)
# A variable is not a Tensor.
# False
keras_placeholder = K.placeholder(shape=(2, 4, 5))
K.is_keras_tensor(keras_placeholder)
# A placeholder is a Tensor.
# True

get_uid

1
K.get_uid(prefix=''/str)

获得默认计算图的uid

  • 说明

    • 依据给定的前缀提供一个唯一的UID
  • 参数

    • prefix:图的可选前缀
  • 返回值:图的唯一标识符

reset_uids

1
K.reset_uids()

重置图的标识符

clear_session

1
K.clear_session()

结束当前的TF计算图,并创建新图

  • 说明
    • 有效的避免模型/网络层的混乱

manual_variable_initialization

1
2
3
K.manual_variable_initialization(
value=False/True
)

设置变量手动初始化标志

  • 参数

    • value

      • False:默认,变量在实例时出事的(由其默认值 初始化)

      • True:用户自行初始化,如 tf.initialize_all_variables()

learning_phase

返回学习阶段标致

  • 返回值:布尔张量

    • 0:测试模式
    • 1:训练模式

set_learning_phase

1
2
3
K.set_learning_phase(
value=0/1
)

设置学习阶段为固定值

  • 参数
    • value:学习阶段值
      • 0:测试模式
      • 1:训练模式

OPs、Tensors

is_sparse

判断一个Tensor是不是一个稀疏的Tensor

  • 返回值:布尔值

稀不稀疏由Tensor的类型决定,而不是Tensor实际上有多稀疏

1
2
3
4
5
6
7
from keras import backend as K
a = K.placeholder((2, 2), sparse=False)
print(K.is_sparse(a))
# False
b = K.placeholder((2, 2), sparse=True)
print(K.is_sparse(b))
# True

to_dense

将一个稀疏tensor转换一个不稀疏的tensor并返回

variable

1
2
3
4
5
def variable(
value,
dtype='float32'/str,
name=None
)

实例化一个张量,返回之

  • 参数
    • value:用来初始化张量的值
    • dtype:张量数据类型
    • name:张量的名字(可选)

placeholder

1
2
3
4
5
6
def placeholder(
shape=None,
ndim=None,
dtype='float32'/str,
name=None
)

实例化一个占位符

  • 参数

    • shape:占位符的shape(整数tuple,可能包含None)
    • ndim: 占位符张量的阶数
      • 要初始化占位符,至少指定shapendim之一, 如果都指定则使用shape
    • dtype: 占位符数据类型
    • name: 占位符名称(可选)

shape

1
def shape(x)

返回张量的符号shape

  • 返回值:OPs(需要执行才能得到值)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
from keras import backend as K
tf_session = K.get_session()
val = np.array([[1, 2], [3, 4]])
kvar = K.variable(value=val)
input = keras.backend.placeholder(shape=(2, 4, 5))
K.shape(kvar)
# <tf.Tensor 'Shape_8:0' shape=(2,) dtype=int32>
K.shape(input)
# <tf.Tensor 'Shape_9:0' shape=(3,) dtype=int32>
# To get integer shape (Instead, you can use K.int_shape(x))
K.shape(kvar).eval(session=tf_session)
# array([2, 2], dtype=int32)
K.shape(input).eval(session=tf_session)
# array([2, 4, 5], dtype=int32)

int_shape

1
def int_shape(x)

返回张量shape

  • 返回值:tuple(int)/None
1
2
3
4
5
6
7
8
from keras import backend as K
input = K.placeholder(shape=(2, 4, 5))
K.int_shape(input)
# (2, 4, 5)
val = np.array([[1, 2], [3, 4]])
kvar = K.variable(value=val)
K.int_shape(kvar)
# (2, 2)

ndim

1
def ndim(x)

返回张量的阶数

  • 返回值:int
1
2
3
4
5
6
7
8
from keras import backend as K
input = K.placeholder(shape=(2, 4, 5))
val = np.array([[1, 2], [3, 4]])
kvar = K.variable(value=val)
K.ndim(input)
# 3
K.ndim(kvar)
# 2

dtype

1
def dtype(x)

返回张量的数据类型

  • 返回值:str
    • float32
    • float32_ref
1
2
3
4
5
6
7
8
9
10
11
12
13
14
from keras import backend as K
K.dtype(K.placeholder(shape=(2,4,5)))
# 'float32'
K.dtype(K.placeholder(shape=(2,4,5), dtype='float32'))
# 'float32'
K.dtype(K.placeholder(shape=(2,4,5), dtype='float64'))
# 'float64'__Keras variable__

kvar = K.variable(np.array([[1, 2], [3, 4]]))
K.dtype(kvar)
# 'float32_ref'
kvar = K.variable(np.array([[1, 2], [3, 4]]), dtype='float32')
K.dtype(kvar)
# 'float32_ref'

eval

1
def eval(x)

求得张量的值

  • 返回值:NDA
1
2
3
4
5
from keras import backend as K
kvar = K.variable(np.array([[1, 2], [3, 4]]), dtype='float32')
K.eval(kvar)
# array([[ 1., 2.],
# [ 3., 4.]], dtype=float32)

`zeros

1
2
3
4
5
def zeros(
shape,
dtype='float32',
name=None
)

生成shape大小的全0张量

1
2
3
4
5
6
from keras import backend as K
kvar = K.zeros((3,4))
K.eval(kvar)
# array([[ 0., 0., 0., 0.],
# [ 0., 0., 0., 0.],
# [ 0., 0., 0., 0.]], dtype=float32)

ones

1
2
3
4
5
def ones(
shape,
dtype='float32',
name=None
)

生成shape大小的全1张量

eye

1
2
3
4
5
def eye(
size,
dtype='float32',
name=None
)

生成size大小的单位阵

zeros_like

1
2
3
4
def zeros_like(
x,
name=None
)

生成与x shape相同的全0张量

ones_like

1
2
3
4
def ones_like(
x,
name=None
)

生成与x shape相同的全1张量

随机常量OPs

random_uniform_variable

1
2
3
4
5
6
7
8
def random_uniform_variable(
shape,
low,
high,
dtype=None,
name=None,
seed=None
)

初始化均匀分布常量OPs

  • 参数
    • low:浮点数,均匀分布之下界
    • high:浮点数,均匀分布之上界
    • dtype:数据类型
    • name:张量名
    • seed:随机数种子

count_params

1
def count_params(x)

返回张量中标量的个数

cast

1
def cast(x, dtype)

改变张量的数据类型

  • 参数
    • dtypefloat16/float32/float64

update

1
def update(x, new_x)

new_x更新x

update_add

1
def update_add(x, increment)

x增加increment并更新x

update_sub

1
def update_sub(x, decrement)

x减少decrement并更新x

moving_average_update

1
2
3
4
5
def moving_average_update(
x,
value,
momentum
)

使用移动平均更新x

dot

1
def dot(x, y)

求两个张量的点乘

1
2
3
4
5
x = K.placeholder(shape=(2, 3))
y = K.placeholder(shape=(3, 4))
xy = K.dot(x, y)
xy
# <tf.Tensor 'MatMul_9:0' shape=(2, 4) dtype=float32>
  • 当试图计算两个N阶张量的乘积时,与Theano行为相同 (2, 3).(4, 3, 5) = (2, 4, 5))

    1
    2
    3
    4
    5
    x = K.placeholder(shape=(32, 28, 3))
    y = K.placeholder(shape=(3, 4))
    xy = K.dot(x, y)
    xy
    # <tf.Tensor 'MatMul_9:0' shape=(32, 28, 4) dtype=float32>
    1
    2
    3
    4
    5
    x = K.random_uniform_variable(shape=(2, 3), low=0, high=1)
    y = K.ones((4, 3, 5))
    xy = K.dot(x, y)
    K.int_shape(xy)
    # (2, 4, 5)

batch_dot

1
def batch_dot(x, y, axes=None)

按批进行张量xy的点积

  • 参数
    • x:按batch分块的数据
    • y;同x
    • axes:指定进行点乘的轴
1
2
3
4
5
x_batch = K.ones(shape=(32, 20, 1))
y_batch = K.ones(shape=(32, 30, 20))
xy_batch_dot = K.batch_dot(x_batch, y_batch, axes=[1, 2])
K.int_shape(xy_batch_dot)
# (32, 1, 30)

transpose

1
def transpose(x)

张量转置

gather

1
def gather(reference, indices)

在给定的张量中检索给定下标的向量

  • 参数

    • reference:张量
    • indices:整数张量,其元素为要查询的下标
  • 返回值:同reference数据类型相同的张量

max

1
2
3
4
5
def max(
x,
axis=None/int,
keepdims=False
)

求张量中的最大值

min

1
def min(x, axis=None, keepdims=False)

求张量中的最小值

sum

1
sum(x, axis=None, keepdims=False)

计算张量中元素之和

prod

1
prod(x, axis=None, keepdims=False)

计算张量中元素之积

cumsum

1
def cumsum(x, axis=0)

在给定轴上求张量的累积和

cumprod

1
cumprod(x, axis=0)

在给定轴上求张量的累积积

var

1
def var(x, axis=None, keepdims=False)

在给定轴上计算张量方差

std

1
def std(x, axis=None, keepdims=False)

在给定轴上求张量元素之标准差

mean

1
def mean(x, axis=None, keepdims=False)

在给定轴上求张量元素之均值

any

1
def any(x, axis=None, keepdims=False)

按位或,返回数据类型为uint8的张量(元素为0或1)

all

1
def any(x, axis=None, keepdims=False)

按位与,返回类型为uint8de tensor

argmax

1
def argmax(x, axis=-1)

在给定轴上求张量之最大元素下标

argmin

1
def argmin(x, axis=-1)

在给定轴上求张量之最小元素下标

Element-Wise OPs

square

1
def square(x)

逐元素平方

abs

1
def abs(x)

逐元素绝对值

sqrt

1
sqrt(x)

逐元素开方

exp

1
def exp(x)

逐元素求自然指数

log

1
def log(x)

逐元素求自然对数

logsumexp

1
def logsumexp(x, axis=None, keepdims=False)

在给定轴上计算log(sum(exp()))

  • 该函数在数值稳定性上超过手动计算log(sum(exp())),可以 避免由explog导致的上溢和下溢

round

1
def round(x)

逐元素四舍五入

sign

1
def sign(x)

逐元素求元素的符号

  • 返回值
    • +1
    • -1

pow

1
def pow(x, a)

逐元素求x的a次方

clip

1
2
3
4
5
def clip(
x,
min_value,
max_value
)

逐元素clip(将超出指定范围的数强制变为边界值)

equal

1
def equal(x, y)

逐元素判相等关系

  • 返回值:布尔张量OP

not_equal

1
def not_equal(x, y)

逐元素判不等关系

greater

1
def greater(x,y)

逐元素判断x>y关系

greater_equal

1
def greater_equal(x,y)

逐元素判断x>=y关系

lesser

1
def lesser(x,y)

逐元素判断x<y关系

lesser_equal

1
def lesser_equal(x,y)

逐元素判断x<=y关系

maximum

1
def maximum(x, y)

逐元素取两个张量的最大值

minimum

1
def minimum(x, y)

逐元素取两个张量的最小值

sin

1
def sin(x)

逐元素求正弦值

cos

1
def cos(x)

逐元素求余弦值

变换OPs

batch_normalization

1
2
3
4
5
6
7
8
def batch_normalization(
x,
mean,
var,
beta,
gamma,
epsilon=0.0001
)

对batch的数据进行batch_normalization,计算公式为: $output = (x-mean)/(\sqrt(var)+\epsilon)*\gamma+\beta$

  • 手动指定meanvar

normalize_batch_in_training

1
2
3
4
5
6
7
def normalize_batch_in_training(
x,
gamma,
beta,
reduction_axes,
epsilon=0.0001
)

对batch数据先计算其均值和方差,然后再进行 batch_normalization

concatenate

1
def concatenate(tensors, axis=-1)

在给定轴上将一个列表中的张量串联为一个张量

reshape

1
def reshape(x, shape)

将张量的shape变换为指定shape

permute_dimensions

1
2
3
4
def permute_dimensions(
x,
pattern(tuple(int))
)

按照给定的模式重排一个张量的轴

  • 参数
    • pattern:代表维度下标的tuple如(0, 2, 1)

resize_images

1
2
3
4
5
6
def resize_images(
X,
height_factor(uint),
width_factor(uint),
dim_ordering=None/'th'/'tf'
)

依据给定的缩放因子height_factorwidth_factor,改变batch 数据(图片)的shape

  • 参数
    • height_factor/width_factor:正整数

resize_volumes

1
2
3
4
5
6
7
def resize_volumes(
X,
depth_factor,
height_factor,
width_factor,
dim_ordering
)

依据给定的缩放因子,改变一个5D张量数据的shape

repeat_elements

1
def repeat_elements(x, rep, axis)

在给定轴上重复张量元素rep

  • np.repeat类似

repeat

1
def repeat(x, n)

重复2D张量

arange

1
2
3
4
5
6
def arange(
start,
stop=None,
step=1,
dtype="int32"
)

生成1D的整数序列张量

  • 参数:同np.arange

    • 如果只有一个参数被提供了,则0~stop
  • 返回值:默认数据类型是int32的张量

tile

1
def tile(x, n)

x在各个维度上重复n[i]

batch_flatten

1
def batch_flatten(x)

将n阶张量转变为2阶张量,第一维度保留不变

expand_dims

1
def expand_dims(x, dim=-1)

dim指定轴后增加一维(轴)

squeeze

1
def squeeze(x, axis)

axis指定的轴从张量中移除(保留轴上首组张量切片)

temporal_padding

1
def temporal_padding(x, padding=1)

向3D张量中间那个维度的左右两端填充padding个0值

asymmetric_temporal_padding

1
2
3
4
5
def asymmetric_temporal_padding(
x,
left_pad=1,
right_pad=1
)

向3D张量中间的那个维度的左右分别填充0值

spatial_2d_padding

1
2
3
4
5
def spatial_2d_padding(
x,
padding=(1, 1),
dim_ordering='th'
)

向4D张量高度、宽度左右两端填充padding[0]padding[1] 个0值

spatial_3d_padding

1
2
3
4
5
def spatial_3d_padding(
x,
padding=(1, 1, 1),
dim_ordering='th'
)

向5D张量深度、高度、宽度三个维度上填充0值

stack

1
def stack(x, axis=0)

将列表x中张量堆积起来形成维度+1的新张量

one_hot

1
def one_hot(indices, nb_classes)

为张量indices进行one_hot编码

  • 参数
    • indices:n维的整数张量
    • nb_classesone_hot编码列表
  • 输出:n+1维整数张量,最后维为编码

reverse

1
def reverse(x, axes)

将一个张量在给定轴上反转

get_value

1
def get_value(x)

以NDA的形式返回张量的值

batch_get_value

1
def batch_get_value(x)

[NDA]的形式返回多个张量的值

set_value

1
def set_value(x, value)

从NDA将值载入张量中

batch_set_value

1
def batch_set_value(tuples)

将多个值载入多个张量变量中

1
def print_tensor(x, message='')

在求值时打印张量的信息,并返回原张量

function

1
def function(inputs, outputs, updates=[])

实例化一个Keras函数

  • 参数
    • inputs:列表,其元素为占位符或张量变量
    • outputs:输出张量的列表
    • updates:张量列表

gradients

1
def gradients(loss, variables)

返回loss函数关于variables的梯度

stop_gradient

1
def stop_gradient(variables)

Returns variables but with zero gradient with respect to every other variables.

rnn

1
2
3
4
5
6
7
8
9
10
def rnn(
step_function,
inputs,
initial_states,
go_backwards=False,
mask=None,
constants=None,
unroll=False,
input_length=None
)

在张量的时间维上迭代

  • 参数:

    • inputs:时域信号的张量,阶数至少为3

    • step_function:每个时间步要执行的函数

      参数

      • input:不含时间维张量,代表某时间步batch样本
      • states:张量列表

      返回值

      • output:形如(samples, ...)的张量
      • new_states:张量列表,与states的长度相同
    • initial_states:包含step_function状态初始值

    • go_backwards:逆向迭代序列

    • mask:需要屏蔽的数据元素上值为1

    • constants:按时间步传递给函数的常数列表

    • unroll

      • 当使用TF时,RNN总是展开的’
      • 当使用Theano时,设置该值为True将展开递归网络
    • input_length

      • TF:不需要此值
      • Theano:如果要展开递归网络,必须指定输入序列
  • 返回值:形如(last_output, outputs, new_states)的张量

    • last_output:RNN最后的输出
    • outputs:每个在[s,t]点的输出对应于样本s在t时间的输出
    • new_states: 每个样本的最后一个状态列表

switch

1
2
3
4
5
def switch(
condition,
then_expression,
else_expression
)

依据给定condition(整数或布尔值)在两个表达式之间切换

  • 参数
    • condition:标量张量
    • then_expression:TensorFlow表达式
    • else_expression: TensorFlow表达式

in_train_phase

1
def in_train_phase(x, alt)

如果处于训练模式,则选择x,否则选择alt

  • 注意alt应该与xshape相同

in_test_phase

1
def in_test_phase(x, alt)

如果处于测试模式,则选择x,否则选择alt

  • 注意:alt应该与x的shape相同

预定义(激活)函数

relu

1
2
3
4
5
def relu(
x,
alpha=0.0,
max_value=None
)

修正线性单元

  • 参数
    • alpha:负半区斜率
    • max_value: 饱和门限

elu

1
def elu(x, alpha=1.0)

指数线性单元

  • 参数
    • x:输入张量
    • alpha: 标量

softmax

1
def softmax(x)

计算张量的softmax值

softplus

1
def softplus(x)

返回张量的softplus值

softsign

1
def softsign(x)

返回张量的softsign值

sigmoid

1
def sigmoid(x)

逐元素计算sigmoid值

hard_sigmoid

1
def hard_sigmoid(x)

分段线性近似的sigmoid,计算速度更快

tanh

1
def tanh(x)

逐元素计算tanh值

预定义目标函数

categorical_crossentropy

1
2
3
4
5
def categorical_crossentropy(
output,
target,
from_logits=False
)

计算outputtarget的Categorical Crossentropy(类别交叉熵)

  • 参数
    • output/target:shape相等

sparse_categorical_crossentropy

1
2
3
4
5
def sparse_categorical_crossentropy(
output,
target,
from_logits=False
)

计算outputtarget的Categorical Crossentropy(类别交叉熵)

  • 参数
    • output
    • target:同output shape相等,需为整形张量

binary_crossentropy

1
2
3
4
5
def binary_crossentropy(
output,
target,
from_logits=False
)

计算输出张量和目标张量的交叉熵

dropout

1
def dropout(x, level, seed=None)

随机将x中一定比例的值设置为0,并放缩整个Tensor

l2_normalize

1
def l2_normalize(x, axis)

在给定轴上对张量进行L2范数规范化

in_top_k

1
def in_top_k(predictions, targets, k)

判断目标是否在predictions的前k大值位置

参数

  • predictions:预测值张量
  • targets:真值张量
  • k:整数

conv1d

1
2
3
4
5
6
7
8
def conv1d(
x,
kernel,
strides=1,
border_mode="valid"/"same",
image_shape=None,
filter_shape=None
)

1D卷积

  • 参数
    • kernel:卷积核张量
    • strides:步长,整型
    • border_mode
      • “same”:
      • “valid”:

conv2d

1
2
3
4
5
6
7
8
9
def conv2d(
x,
kernel,
strides=(1, 1),
border_mode="valid"/"same",
dim_ordering="th"/"tf",
image_shape=None,
filter_shape=None
)

2D卷积

  • 参数
    • kernel:卷积核张量
    • strides:步长,长为2的tuple

deconv2d

1
2
3
4
5
6
7
8
9
10
def deconv2d(
x,
kernel,
output_shape,
strides=(1, 1),
border_mode="valid"/"same",
dim_ordering="th"/"tf",
image_shape=None,
filter_shape=None
)

2D反卷积(转置卷积)

  • 参数
    • x:输入张量
    • kernel:卷积核张量
    • output_shape: 输出shape的1D的整数张量
    • strides:步长,tuple类型

conv3d

1
2
3
4
5
6
7
8
9
def conv3d(
x,
kernel,
strides=(1, 1, 1),
border_mode="valid"/"same",
dim_ordering="th"/"tf",
volume_shape=None,
filter_shape=None
)

3D卷积

pool2d

1
2
3
4
5
6
7
8
def pool2d(
x,
pool_size,
strides=(1, 1),
border_mode="valid"/"same",
dim_ordering="th"/"tf",
pool_mode="max"/"avg"
)

2D池化

  • 参数
    • pool_size:含有两个整数的tuple,池的大小
    • strides:含有两个整数的tuple,步长
    • pool_mode: “max”,“avg”之一,池化方式

pool3d

1
2
3
4
5
6
7
8
def pool3d(
x,
pool_size,
strides=(1, 1, 1),
border_mode="valid"/"same",
dim_ordering="th"/"tf",
pool_mode="max"/"avg"
)

3D池化

bias_add

1
def bias_add(x, bias, data_format=None)

为张量增加一个偏置项

random_normal

1
2
3
4
5
6
7
def random_normal(
shape,
mean=0.0,
stddev=1.0,
dtype=None,
seed=None
)

生成服从正态分布的张量

  • 参数
    • mean:均值
    • stddev:标准差

random_uniform

1
2
3
4
5
6
7
def random_uniform(
shape,
minval=0.0,
maxval=1.0,
dtype=None,
seed=None
)

生成服从均匀分布值的张量

  • 参数
    • minval:上界
    • maxval:上界

random_binomial

1
2
3
4
5
6
def random_binomial(
shape,
p=0.0,
dtype=None,
seed=None
)

返回具有二项分布值的张量

  • 参数
    • p:二项分布参数

truncated_normall

1
2
3
4
5
6
7
def truncated_normal(
shape,
mean=0.0,
stddev=1.0,
dtype=None,
seed=None
)

生成服从截尾正态分布值的张量,即在距离均值两个标准差之外的 数据将会被截断并重新生成

ctc_label_dense_to_sparse

1
def ctc_label_dense_to_sparse(labels, label_lengths)

将ctc标签从稠密形式转换为稀疏形式

ctc_batch_cost

1
2
3
4
5
6
def ctc_batch_cost(
y_true,
y_pred,
input_length,
label_length
)

在batch上运行CTC损失算法

  • 参数

    • y_true:包含标签的真值张量
    • y_pred:包含预测值或输出的softmax值的张量
    • input_length:包含y_pred中每个batch的序列长
    • label_length:包含y_true中每个batch的序列长张量
  • 返回值:包含了每个元素的CTC损失的张量

ctc_decode

1
2
3
4
5
6
7
8
def ctc_decode(
y_pred,
input_length,
greedy=True,
beam_width=None,
dict_seq_lens=None,
dict_values=None
)

使用贪婪算法或带约束的字典搜索算法解码softmax的输出

  • 参数

    • y_pred:包含预测值或输出的softmax值的张量
    • input_length:包含y_pred中每个batch序列长的张量
    • greedy:使用贪婪算法
    • dict_seq_lensdic_values列表中各元素的长度
    • dict_values:列表的列表,代表字典
  • 返回值:包含了路径可能性(以softmax概率的形式)张量

  • 注意仍然需要一个用来取出argmax和处理空白标签的函数

map_fn

1
def map_fn(fn, elems, name=None)

元素elems在函数fn上的映射,并返回结果

  • 参数

    • fn:函数
    • elems:张量
    • name:节点的名字
  • 返回值:张量的第一维度等于elems,第二维度取决于fn

foldl

1
2
3
4
5
6
def foldl(
fn,
elems,
initializer=None,
name=None
)

用fn从左到右连接它们,以减少elems

  • 参数

    • fn:函数,例如:lambda acc, x: acc + x
    • elems:张量
    • initializer:初始化的值(elems[0])
    • name:节点名
  • 返回值:与initializer类型和形状一致

foldr

1
2
3
4
5
6
def foldr(
fn,
elems,
initializer=None,
name=None
)

减少elems,用fn从右到左连接它们

  • 参数

    • fn:函数,例如:lambda acc, x: acc + x
    • elems:张量
    • initializer:初始化的值(elems[-1])
    • name:节点名
  • 返回值:与initializer类型和形状一致

_width=None, dict_seq_lens=None, dict_values=None )

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

使用贪婪算法或带约束的字典搜索算法解码softmax的输出

- 参数

- `y_pred`:包含预测值或输出的softmax值的张量
- `input_length`:包含`y_pred`中每个batch序列长的张量
- `greedy`:使用贪婪算法
- `dict_seq_lens`:`dic_values`列表中各元素的长度
- `dict_values`:列表的列表,代表字典

- 返回值:包含了路径可能性(以softmax概率的形式)张量

- 注意仍然需要一个用来取出argmax和处理空白标签的函数

#### `map_fn`

```python
def map_fn(fn, elems, name=None)

元素elems在函数fn上的映射,并返回结果

  • 参数

    • fn:函数
    • elems:张量
    • name:节点的名字
  • 返回值:张量的第一维度等于elems,第二维度取决于fn

foldl

1
2
3
4
5
6
def foldl(
fn,
elems,
initializer=None,
name=None
)

用fn从左到右连接它们,以减少elems

  • 参数

    • fn:函数,例如:lambda acc, x: acc + x
    • elems:张量
    • initializer:初始化的值(elems[0])
    • name:节点名
  • 返回值:与initializer类型和形状一致

foldr

1
2
3
4
5
6
def foldr(
fn,
elems,
initializer=None,
name=None
)

减少elems,用fn从右到左连接它们

  • 参数

    • fn:函数,例如:lambda acc, x: acc + x
    • elems:张量
    • initializer:初始化的值(elems[-1])
    • name:节点名
  • 返回值:与initializer类型和形状一致

  • name:节点名

  • 返回值:与initializer类型和形状一致

卷积层

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
)

该层是反卷积操作(转置卷积)

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为后端时可用

?时可用

Layers 总述

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 < 0alpha * x
    • x >= 0x
  • 输入尺寸

    • 可以是任意的。如果将该层作为模型的第一层,需要指定 input_shape参数(整数元组,不包含样本数量的维度)
  • 输出尺寸:与输入相同

  • 参数

    • alphafloat >= 0,负斜率系数。
  • 参考文献

PReLU

1
2
3
4
5
6
keras.layers.PReLU(
alpha_initializer='zeros',
alpha_regularizer=None,
alpha_constraint=None,
shared_axes=None
)

参数化的修正线性单元。

  • 返回值

    • x < 0alpha * x
    • x >= 0x
  • 参数

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

ELU

1
keras.layers.ELU(alpha=1.0)

指数线性单元

ThresholdedReLU

1
keras.layers.ThresholdedReLU(theta=1.0)

带阈值的修正线性单元。

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

  • 参数

    • 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))

```

LocallyConnceted 局部连接层

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: