Tensorflow中的tensorflow.nn模块是TensorFlow用于深度学习计算的核心模块。
激活函数(Activation Functions)
操作 | 描述 |
---|---|
tf.nn.relu(features, name=None) | 整流函数:max(features, 0) |
tf.nn.relu6(features, name=None) | 以6为阈值的整流函数:min(max(features, 0), 6) |
tf.nn.elu(features, name=None) | elu函数,exp(features) - 1 if < 0,否则featuresExponential Linear Units (ELUs) |
tf.nn.softplus(features, name=None) | 计算softplus:log(exp(features) + 1) |
tf.nn.dropout(x, keep_prob, noise_shape=None, seed=None, name=None) | 计算dropout,keep_prob为keep概率, noise_shape为噪声的shape |
tf.nn.bias_add(value, bias, data_format=None, name=None) | 对value加一偏置量 此函数为tf.add的特殊情况,bias仅为一维, 函数通过广播机制进行与value和, 数据格式可以与value不同,返回为与value相同格式 |
tf.sigmoid(x, name=None) | y = 1 / (1 + exp(-x)) |
tf.tanh(x, name=None) | tf.tanh(x, name=None) |
卷积函数(Convolution)
操作 | 描述 |
---|---|
tf.nn.conv2d(input, filter, strides, padding, use_cudnn_on_gpu=None, data_format=None, name=None) | 在给定的4D input与 filter下计算2D卷积输入shape为 [batch, height, width, in_channels] |
tf.nn.conv3d(input, filter, strides, padding, name=None) | 在给定的5D input与 filter下计算3D卷积输入shape为[batch, in_depth, in_height, in_width, in_channels] |
tf.nn.depthwise_conv2d(input, filter, strides, padding, name=None) | 卷积核能相互独立的在自己的通道上面进行卷积操作。 |
tf.nn.separable_conv2d(input, depthwise_filter, pointwise_filter, strides, padding, name=None) | 在纵深卷积 depthwise filter 之后进行逐点卷积 separable filter |
注意,虽然这些操作被称之为“卷积”操作,但是严格的说,他们只是互相关,因为卷积核没有做一个逆向的卷积过程
池化函数(Pooling)
操作 | 描述 |
---|---|
tf.nn.avg_pool(value, ksize, strides, padding, data_format=’NHWC’, name=None) | 平均方式池化 |
tf.nn.max_pool(value, ksize, strides, padding, data_format=’NHWC’, name=None) | 最大值方法池化 |
tf.nn.max_pool_with_argmax(input, ksize, strides,padding, Targmax=None, name=None) | 返回一个二维元组(output,argmax),最大值pooling,返回最大值及其相应的索引 |
tf.nn.avg_pool3d(input, ksize, strides, padding, name=None) | 3D平均值pooling |
tf.nn.max_pool3d(input, ksize, strides, padding, name=None) | 3D最大值pooling |
数据标准化(Normalization)
操作 | 描述 |
---|---|
tf.nn.l2_normalize(x, dim, epsilon=1e-12, name=None) | 对维度dim进行L2范式标准化output = x / sqrt(max(sum(x2), epsilon)) |
tf.nn.sufficient_statistics(x, axes, shift=None, keep_dims=False, name=None) | 计算与均值和方差有关的完全统计量返回4维元组,元素个数,元素总和,元素的平方和,shift结果参见算法介绍 |
tf.nn.normalize_moments(counts, mean_ss, variance_ss, shift, name=None) | 基于完全统计量计算均值和方差 |
tf.nn.moments(x, axes, shift=None, name=None, keep_dims=False) | 直接计算均值与方差 |
tf.nn.local_response_normalization(input, depth_radius=None, bias=None, alpha=None, beta=None, name=None) | 这个函数的作用是计算局部数据标准化。输入的数据 input 是一个四维的张量,但该张量被看做是一个一维的向量( input 的最后一维作为向量),向量中的每一个元素都是一个三维的数组(对应 input 的前三维)。向量的每一个元素都是独立的被标准化的。 |
损失函数(Losses)
操作 | 描述 |
---|---|
tf.nn.l2_loss(t, name=None) | output = sum(t ** 2) / 2 |
分类函数(Classification)
操作 | 描述 |
---|---|
tf.nn.sigmoid_cross_entropy_with_logits(logits, targets, name=None)* | 计算输入logits, targets的交叉熵 |
tf.nn.softmax(logits, name=None) | 计算softmax softmax[i, j] = exp(logits[i, j]) / sum_j(exp(logits[i, j])) |
tf.nn.log_softmax(logits, name=None) | logsoftmax[i, j] = logits[i, j] - log(sum(exp(logits[i]))) |
tf.nn.softmax_cross_entropy_with_logits(logits, labels, name=None) | 计算logits和labels的softmax交叉熵logits, labels必须为相同的shape与数据类型 |
tf.nn.sparse_softmax_cross_entropy_with_logits(logits, labels, name=None) | 计算logits和labels的softmax交叉熵 |
tf.nn.weighted_cross_entropy_with_logits(logits, targets, pos_weight, name=None) | 与sigmoid_cross_entropy_with_logits()相似,但给正向样本损失加了权重pos_weight |
符号嵌入(Embeddings)
操作 | 描述 |
---|---|
tf.nn.embedding_lookup(params, ids, partition_strategy=’mod’, name=None, validate_indices=True) | 根据索引ids查询embedding列表params中的tensor值, 如果len(params) > 1,id将会安照partition_strategy策略进行分割 1、如果partition_strategy为”mod”,id所分配到的位置为p = id % len(params)比如有13个ids,分为5个位置,那么分配方案为:[[0, 5, 10], [1, 6, 11], [2, 7, 12], [3, 8], [4, 9]] , 2、如果partition_strategy为”div”,那么分配方案为: [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10], [11, 12]] |
tf.nn.embedding_lookup_sparse(params, sp_ids, sp_weights, partition_strategy=’mod’, name=None, combiner=’mean’) | 对给定的ids和权重查询embedding 1、sp_ids为一个N x M的稀疏tensor,N为batch大小,M为任意,数据类型int64, 2、sp_weights的shape与sp_ids的稀疏tensor权重,浮点类型,若为None,则权重为全’1’ |
求值网络(Evaluation)
操作 | 描述 |
---|---|
tf.nn.top_k(input, k=1, sorted=True, name=None) | 返回前k大的值及其对应的索引 |
tf.nn.in_top_k(predictions, targets, k, name=None) | 返回判断是否targets索引的predictions相应的值是否在在predictions前k个位置中,返回数据类型为bool类型,len与predictions同 |
监督候选采样网络(Candidate Sampling)
对于有巨大量的多分类与多标签模型,如果使用全连接softmax将会占用大量的时间与空间资源,所以采用候选采样方法仅使用一小部分类别与标签作为监督以加速训练
操作 | 描述 |
---|---|
Sampled Loss Functions | |
tf.nn.nce_loss(weights, biases, inputs, labels, num_sampled,num_classes, num_true=1, sampled_values=None,remove_accidental_hits=False, partition_strategy=’mod’,name=’nce_loss’) | 返回noise-contrastive的训练损失结果 |
tf.nn.sampled_softmax_loss(weights, biases, inputs, labels, num_sampled, num_classes, num_true=1, sampled_values=None,remove_accidental_hits=True, partition_strategy=’mod’, name=’sampled_softmax_loss’) | 返回sampled softmax的训练损失 参考- Jean et al., 2014第3部分 |
Candidate Samplers | |
tf.nn.uniform_candidate_sampler(true_classes, num_true, num_sampled, unique, range_max, seed=None, name=None) | 通过均匀分布的采样集合返回三元tuple 1、sampled_candidates 候选集合。 2、期望的true_classes个数,为浮点值 3、期望的sampled_candidates个数,为浮点值 |
tf.nn.log_uniform_candidate_sampler(true_classes, num_true,num_sampled, unique, range_max, seed=None, name=None) | 通过log均匀分布的采样集合,返回三元tuple |
tf.nn.learned_unigram_candidate_sampler(true_classes, num_true, num_sampled, unique, range_max, seed=None, name=None) | 根据在训练过程中学习到的分布状况进行采样 返回三元tuple |
tf.nn.fixed_unigram_candidate_sampler(true_classes, num_true,num_sampled, unique, range_max, vocab_file=”, distortion=1.0, num_reserved_ids=0, num_shards=1, shard=0, unigrams=(), seed=None, name=None) | 基于所提供的基本分布进行采样 |
保存与恢复变量
操作 | 描述 |
---|---|
类tf.train.Saver(Saving and Restoring Variables) | |
tf.train.Saver.init(var_list=None, reshape=False, sharded=False, max_to_keep=5, keep_checkpoint_every_n_hours=10000.0, name=None, restore_sequentially=False,saver_def=None, builder=None) | 创建一个存储器Savervar_list定义需要存储和恢复的变量 |
tf.train.Saver.save(sess, save_path, global_step=None, latest_filename=None, meta_graph_suffix=’meta’,write_meta_graph=True) | 保存变量 |
tf.train.Saver.restore(sess, save_path) | tf.train.Saver.restore(sess, save_path) |
tf.train.Saver.last_checkpoints | 列出最近未删除的checkpoint 文件名 |
tf.train.Saver.set_last_checkpoints(last_checkpoints) | 设置checkpoint文件名列表 |
tf.train.Saver.set_last_checkpoints_with_time(last_checkpoints_with_time) | 设置checkpoint文件名列表和时间戳 |
操作 | 描述 |
---|---|
tf.nn.rnn(cell, inputs, initial_state=None, dtype=None, sequence_length=None, scope=None) | 基于RNNCell类的实例cell建立循环神经网络 |
tf.nn.dynamic_rnn(cell, inputs, sequence_length=None, initial_state=None, dtype=None, parallel_iterations=None, swap_memory=False, time_major=False, scope=None) | 基于RNNCell类的实例cell建立动态循环神经网络与一般rnn不同的是,该函数会根据输入动态展开返回(outputs,state) |
tf.nn.state_saving_rnn(cell, inputs, state_saver, state_name, sequence_length=None, scope=None) | 可储存调试状态的RNN网络 |
tf.nn.bidirectional_rnn(cell_fw, cell_bw, inputs,initial_state_fw=None, initial_state_bw=None, dtype=None,sequence_length=None, scope=None) | 双向RNN, 返回一个3元组tuple (outputs, output_state_fw, output_state_bw) |
-— tf.nn.rnn简要介绍—
cell: 一个RNNCell实例
inputs: 一个shape为[batch_size, input_size]的tensor
initial_state: 为RNN的state设定初值,可选
sequence_length:制定输入的每一个序列的长度,size为[batch_size],值范围为[0, T)的int型数据
其中T为输入数据序列的长度
@
@针对输入batch中序列长度不同,所设置的动态计算机制
@对于在时间t,和batch的b行,有
(output, state)(b, t) = ? (zeros(cell.output_size), states(b, sequence_length(b) - 1)) : cell(input(b, t), state(b, t - 1))
import tensorflow as tf
a = tf.constant([-2.0, -1.0, 2.0, 3.0])
with tf.Session() as sess:
b = tf.nn.relu(a)
print(sess.run(b))
## 输出: [0. 0. 2. 3.]
import tensorflow as tf
a = tf.constant([-2.0, -1.0, 1.0, 5.0, 10.0])
with tf.Session() as sess:
b = tf.nn.relu6(a)
print(sess.run(b))
## 输出: [0. 0. 1. 5. 6.]
import tensorflow as tf
a = tf.constant([0.0, 1.0])
with tf.Session() as sess:
b = tf.nn.softplus(a)
print(sess.run(b))
## 输出: [ 0.69314718 1.31326163]
import tensorflow as tf
a = tf.constant([[-1.0, 2.0, 3.0, 4.0]])
with tf.Session() as sess:
b = tf.nn.dropout(a, 0.5)
print(sess.run(b))
b = tf.nn.dropout(a, 0.5, noise_shape = [1,4])
print(sess.run(b))
b = tf.nn.dropout(a, 0.5, noise_shape = [1,1])
print(sess.run(b))
## 输出: [[-2. 0. 0. 8.]]
# [[-2. 4. 0. 0.]]
# [[-0. 0. 0. 0.]]
import tensorflow as tf
a = tf.constant([[1.0, 2.0],[1.0, 2.0],[1.0, 2.0]])
b = tf.constant([2.0,1.0])
c = tf.constant([1.0])
sess = tf.Session()
print(sess.run(tf.nn.bias_add(a, b)))
# 因为 a 最后一维的维度是 2 ,但是 c 的维度是 1,所以以下语句将发生错误
print(sess.run(tf.nn.bias_add(a, c)))
# 但是 tf.add() 可以正确运行
print(sess.run(tf.add(a, c)))
import tensorflow as tf
a = tf.constant([[1.0, 2.0], [1.0, 2.0], [1.0, 2.0]])
sess = tf.Session()
print(sess.run(tf.sigmoid(a)))
## 输出: [[0.7310586 0.880797 ]
# [0.7310586 0.880797 ]
# [0.7310586 0.880797 ]]
import tensorflow as tf
a = tf.constant([[1.0, 2.0],[1.0, 2.0],[1.0, 2.0]])
sess = tf.Session()
print(sess.run(tf.tanh(a)))
卷积操作是使用一个二维的卷积核在一个批处理的图片上进行不断扫描。具体操作是将一个卷积核在每张图片上按照一个合适的尺寸在每个通道上面进行扫描。为了达到好的卷积效率,需要在不同的通道和不同的卷积核之间进行权衡。
conv2d: 任意的卷积核,能同时在不同的通道上面进行卷积操作。
depthwise_conv2d: 卷积核能相互独立的在自己的通道上面进行卷积操作。
separable_conv2d: 在纵深卷积 depthwise filter 之后进行逐点卷积 separable filter 。
注意,虽然这些操作被称之为“卷积”操作,但是严格的说,他们只是互相关,因为卷积核没有做一个逆向的卷积过程。
卷积核的卷积过程是按照 strides 参数来确定的,比如 strides = [1, 1, 1, 1] 表示卷积核对每个像素点进行卷积,即在二维屏幕上面,两个轴方向的步长都是1。strides = [1, 2, 2, 1] 表示卷积核对每隔一个像素点进行卷积,即在二维屏幕上面,两个轴方向的步长都是2。
如果我们先暂且不考虑通道这个因素,那么卷积操作的空间含义定义如下:如果输入数据是一个四维的 input ,数据维度是 [batch, in_height, in_width, …],卷积核也是一个四维的卷积核,数据维度是 [filter_height, filter_width, …] ,那么:
shape(output) = [batch,
(in_height - filter_height + 1) / strides[1],
(in_width - filter_width + 1) / strides[2],
…]
output[b, i, j, :] =
sum_{di, dj} input[b, strides[1] * i + di, strides[2] * j + dj, …] *
filter[di, dj, …]
因为,input 数据是一个四维的,每一个通道上面是一个向量 input[b, i, j, :] 。对于 conv2d ,这些向量将会被卷积核 filter[di, dj, :, :] 相乘而产生一个新的向量。对于 depthwise_conv_2d ,每个标量分量 input[b, i, j, k] 将在 k 个通道上面独立的被卷积核 filter[di, dj, k] 进行卷积操作,然后把所有得到的向量进行连接组合成一个新的向量。
对于输出数据的维度 shape(output),这取决于填充参数 padding 的设置:
padding = ‘SAME’: 向下取舍,仅适用于全尺寸操作,即输入数据维度和输出数据维度相同。
padding = ‘VALID: 向上取舍,适用于部分窗口,即输入数据维度和输出数据维度不同。
import numpy as np
import tensorflow as tf
input_data = tf.Variable( np.random.rand(10,6,6,3), dtype = np.float32 )
filter_data = tf.Variable( np.random.rand(2, 2, 3, 1), dtype = np.float32)
y = tf.nn.conv2d(input_data, filter_data, strides = [1, 1, 1, 1], padding = 'SAME')
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
print(sess.run(y))
print(sess.run(tf.shape(y)))
import numpy as np
import tensorflow as tf
input_data = tf.Variable( np.random.rand(10, 6, 6, 3), dtype = np.float32 )
filter_data = tf.Variable( np.random.rand(2, 2, 3, 5), dtype = np.float32)
y = tf.nn.depthwise_conv2d(input_data, filter_data, strides = [1, 1, 1, 1], padding = 'SAME')
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
print(sess.run(y))
print(sess.run(tf.shape(y)))
import numpy as np
import tensorflow as tf
input_data = tf.Variable( np.random.rand(10, 6, 6, 3), dtype = np.float32 )
depthwise_filter = tf.Variable( np.random.rand(2, 2, 3, 5), dtype = np.float32)
pointwise_filter = tf.Variable( np.random.rand(1, 1, 15, 20), dtype = np.float32)
# out_channels >= channel_multiplier * in_channels
y = tf.nn.separable_conv2d(input_data, depthwise_filter, pointwise_filter, strides = [1, 1, 1, 1], padding = 'SAME')
with tf.Session() as sess:
init = tf.tf.global_variables_initializer()
sess.run(init)
print(sess.run(y))
print(sess.run(tf.shape(y)))
池化操作是利用一个矩阵窗口在输入张量上进行扫描,并且将每个矩阵窗口中的值通过取最大值,平均值或者XXXX来减少元素个数。每个池化操作的矩阵窗口大小是由 ksize 来指定的,并且根据步长参数 strides 来决定移动步长。比如,如果 strides 中的值都是1,那么每个矩阵窗口都将被使用。如果 strides 中的值都是2,那么每一维度上的矩阵窗口都是每隔一个被使用。以此类推。
更具体的输出结果是:
output[i] = reduce( value[ strides * i: strides * i + ksize ] )
输出数据维度是:
shape(output) = (shape(value) - ksize + 1) / strides
其中,取舍方向取决于参数 padding :
padding = ‘SAME’: 向下取舍,仅适用于全尺寸操作,即输入数据维度和输出数据维度相同。
padding = ‘VALID: 向上取舍,适用于部分窗口,即输入数据维度和输出数据维度不同。
import numpy as np
import tensorflow as tf
input_data = tf.Variable( np.random.rand(10,6,6,3), dtype = np.float32 )
filter_data = tf.Variable( np.random.rand(2, 2, 3, 10), dtype = np.float32)
y = tf.nn.conv2d(input_data, filter_data, strides = [1, 1, 1, 1], padding = 'SAME')
output = tf.nn.avg_pool(value = y, ksize = [1, 2, 2, 1], strides = [1, 1, 1, 1], padding = 'SAME')
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
print(sess.run(output))
print(sess.run(tf.shape(output)))
import numpy as np
import tensorflow as tf
input_data = tf.Variable( np.random.rand(10,6,6,3), dtype = np.float32 )
filter_data = tf.Variable( np.random.rand(2, 2, 3, 10), dtype = np.float32)
y = tf.nn.conv2d(input_data, filter_data, strides = [1, 1, 1, 1], padding = 'SAME')
output = tf.nn.max_pool(value = y, ksize = [1, 2, 2, 1], strides = [1, 1, 1, 1], padding = 'SAME')
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
print(sess.run(output))
print(sess.run(tf.shape(output)))
import numpy as np
import tensorflow as tf
input_data = tf.Variable( np.random.rand(10,6,6,3), dtype = tf.float32 )
filter_data = tf.Variable( np.random.rand(2, 2, 3, 10), dtype = np.float32)
y = tf.nn.conv2d(input_data, filter_data, strides = [1, 1, 1, 1], padding = 'SAME')
output, argmax = tf.nn.max_pool_with_argmax(input = y, ksize = [1, 2, 2, 1], strides = [1, 1, 1, 1], padding = 'SAME')
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
print(sess.run(output))
print(sess.run(tf.shape(output)))
标准化是能防止模型过拟合的好方法。特别是在大数据的情况下
import numpy as np
import tensorflow as tf
input_data = tf.Variable( np.random.rand(2, 3), dtype = tf.float32 )
output = tf.nn.l2_normalize(input_data, dim = 0)
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
print(sess.run(output))
print(sess.run(tf.shape(output)))
import numpy as np
import tensorflow as tf
input_data = tf.Variable( np.random.rand(1, 2, 3, 4), dtype = tf.float32 )
output = tf.nn.local_response_normalization(input_data)
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
print(sess.run(input_data))
print(sess.run(output))
print(sess.run(tf.shape(output)))
import numpy as np
import tensorflow as tf
input_data = tf.Variable( np.random.rand(2, 3), dtype = tf.float32 )
mean, variance = tf.nn.moments(input_data, [0])
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
print(sess.run(input_data))
print(sess.run(mean))
print(sess.run(tf.shape(mean)))
度量两个张量或者一个张量和零之间的损失误差
import numpy as np
import tensorflow as tf
input_data = tf.Variable( np.random.rand(2, 3), dtype = tf.float32 )
output = tf.nn.l2_loss(input_data)
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
print(sess.run(input_data))
print(sess.run(output))
print(sess.run(tf.shape(output)))
Tensorflow提供了操作,能帮助你更好的进行分类操作。
这个函数的作用是计算 logits 经 sigmoid 函数激活之后的交叉熵
。对于一个不相互独立的离散分类任务,这个函数作用是去度量概率误差。比如,比如,在一张图片中,同时包含多个分类目标(大象和狗),那么就可以使用这个函数。为了描述简洁,我们规定 x = logits,z = targets,那么 Logistic 损失值为: import numpy as np
import tensorflow as tf
input_data = tf.Variable( np.random.rand(1,3), dtype = tf.float32 )
output = tf.nn.sigmoid_cross_entropy_with_logits(input_data, [[1.0,0.0,0.0]])
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
print(sess.run(input_data))
print(sess.run(output))
print(sess.run(tf.shape(output)))
import numpy as np
import tensorflow as tf
input_data = tf.Variable( [[0.2, 0.1, 0.9]] , dtype = tf.float32 )
output = tf.nn.softmax(input_data)
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
print(sess.run(input_data))
print(sess.run(output))
print(sess.run(tf.shape(output)))
import numpy as np
import tensorflow as tf
input_data = tf.Variable( [[0.2, 0.1, 0.9]] , dtype = tf.float32 )
output = tf.nn.softmax_cross_entropy_with_logits(input_data, [[1,0,0]])
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
print(sess.run(input_data))
print(sess.run(output))
print(sess.run(tf.shape(output)))
Tensorflow 提供了从张量中嵌入查找的库。
import tensorflow as tf
import numpy as np
params = tf.constant(np.random.rand(3,4))
ids = tf.constant([0,2])
output = tf.nn.embedding_lookup(params, ids)
with tf.Session() as sess:
print('params: ', sess.run(params))
print('-------------------------------')
print('输出第0行和第2行: ', sess.run(output))
评估操作对于测量神经网络的性能是有用的。 由于它们是不可微分的,所以它们通常只是被用在评估阶段
import tensorflow as tf
import numpy as np
input = tf.constant(np.random.rand(3,4))
k = 2
output = tf.nn.top_k(input, k)
with tf.Session() as sess:
print(sess.run(input))
print('--------------------')
print(sess.run(output))
import tensorflow as tf
import numpy as np
input = tf.constant(np.random.rand(3,4), tf.float32)
k = 2
output = tf.nn.in_top_k(input, [3,3,3], k)
with tf.Session() as sess:
print(sess.run(input))
print('--------------------')
print(sess.run(output))