为了快速的熟悉TensorFlow编程，下面从一段简单的代码开始：
1 2 3 4 5 6 7 8 9 10 11 12 import tensorflow as tf a = tf.placeholder("float" ) b = tf.placeholder("float" ) y = tf.mul(a, b) sess = tf.Session() print sess.run(y, feed_dict={a: 3 , b: 3 }) sess.close()
其中tf.mul(a, b)函数便是tf的一个基本的算数运算，接下来介绍跟多的相关函数。
TensorFlow 将图形定义转换成分布式执行的操作, 以充分利用可用的计算资源(如 CPU 或 GPU。一般你不需要显式指定使用 CPU 还是 GPU, TensorFlow 能自动检测。如果检测到 GPU, TensorFlow 会尽可能地利用找到的第一个 GPU 来执行操作.
操作组
操作
Maths
Add, Sub, Mul, Div, Exp, Log, Greater, Less, Equal
Array
Concat, Slice, Split, Constant, Rank, Shape, Shuffle
Matrix
MatMul, MatrixInverse, MatrixDeterminant
Neuronal Network
SoftMax, Sigmoid, ReLU, Convolution2D, MaxPool
Checkpointing
Save, Restore
Queues and syncronizations
Enqueue, Dequeue, MutexAcquire, MutexRelease
Flow control
Merge, Switch, Enter, Leave, NextIteration
操作
描述
tf.add(x, y, name=None)
求和
tf.sub(x, y, name=None)
减法
tf.mul(x, y, name=None)
乘法
tf.div(x, y, name=None)
除法
tf.mod(x, y, name=None)
取模
tf.abs(x, name=None)
求绝对值
tf.neg(x, name=None)
取负 (y = -x).
tf.sign(x, name=None)
返回符号 y = sign(x) = -1 if x < 0; 0 if x == 0; 1 if x > 0.
tf.inv(x, name=None)
取反
tf.square(x, name=None)
计算平方 (y = x * x = x^2).
tf.round(x, name=None)
舍入最接近的整数 # ‘a’ is [0.9, 2.5, 2.3, -4.4] tf.round(a) ==> [ 1.0, 3.0, 2.0, -4.0 ]
tf.sqrt(x, name=None)
开根号 (y = $\sqrt{x}$ = $x^{1/2}$).
tf.pow(x, y, name=None)
幂次方 # tensor ‘x’ is [[2, 2], [3, 3]] # tensor ‘y’ is [[8, 16], [2, 3]] tf.pow(x, y) ==> [[256, 65536], [9, 27]]
tf.exp(x, name=None)
计算e的次方
tf.log(x, name=None)
计算log，一个输入计算e的ln，两输入以第二输入为底
tf.maximum(x, y, name=None)
返回最大值 (x > y ? x : y)
tf.minimum(x, y, name=None)
返回最小值 (x < y ? x : y)
tf.cos(x, name=None)
三角函数cosine
tf.sin(x, name=None)
三角函数sine
tf.tan(x, name=None)
三角函数tan
tf.atan(x, name=None)
三角函数ctan
操作
描述
tf.string_to_number (string_tensor, out_type=None, name=None)
字符串转为数字
tf.to_double(x, name=’ToDouble’)
转为64位浮点类型–float64
tf.to_float(x, name=’ToFloat’)
转为32位浮点类型–float32
tf.to_int32(x, name=’ToInt32’)
转为32位整型–int32
tf.to_int64(x, name=’ToInt64’)
转为64位整型–int64
tf.cast(x, dtype, name=None)
将x或者x.values转换为dtype # tensor a is [1.8, 2.2], dtype=tf.float tf.cast(a, tf.int32) ==> [1, 2] # dtype=tf.int32
操作
描述
tf.shape(input, name=None)
返回数据的shape # ‘t’ is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]] shape(t) ==> [2, 2, 3]
tf.size(input, name=None)
返回数据的元素数量 # ‘t’ is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]] size(t) ==> 12
tf.rank(input, name=None)
返回tensor的rank 注意：此rank不同于矩阵的rank， tensor的rank表示一个tensor需要的索引数目来唯一表示任何一个元素 也就是通常所说的 “order”, “degree”或”ndims” #’t’ is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]] # shape of tensor ‘t’ is [2, 2, 3] rank(t) ==> 3
tf.reshape(tensor, shape, name=None)
改变tensor的形状 # tensor ‘t’ is [1, 2, 3, 4, 5, 6, 7, 8, 9] # tensor ‘t’ has shape [9] reshape(t, [3, 3]) ==> [[1, 2, 3], [4, 5, 6], [7, 8, 9]] #如果shape有元素[-1],表示在该维度打平至一维 # -1 将自动推导得为 9: reshape(t, [2, -1]) ==> [[1, 1, 1, 2, 2, 2, 3, 3, 3], [4, 4, 4, 5, 5, 5, 6, 6, 6]]
tf.expand_dims(input, dim, name=None)
插入维度1进入一个tensor中 #该操作要求-1-input.dims() # ‘t’ is a tensor of shape [2] shape(expand_dims(t, 0)) ==> [1, 2] shape(expand_dims(t, 1)) ==> [2, 1] shape(expand_dims(t, -1)) ==> [2, 1] <= dim <= input.dims()
切片与合并（Slicing and Joining）
操作
描述
tf.slice(input_, begin, size, name=None)
对tensor进行切片操作 其中size[i] = input.dim_size(i) - begin[i] 该操作要求 0 <= begin[i] <= begin[i] + size[i] <= Di for i in [0, n] #’input’ is #[[[1, 1, 1], [2, 2, 2]],[[3, 3, 3], [4, 4, 4]],[[5, 5, 5], [6, 6, 6]]] tf.slice(input, [1, 0, 0], [1, 1, 3]) ==> [[[3, 3, 3]]] tf.slice(input, [1, 0, 0], [1, 2, 3]) ==> [[[3, 3, 3], [4, 4, 4]]] tf.slice(input, [1, 0, 0], [2, 1, 3]) ==> [[[3, 3, 3]], [[5, 5, 5]]]
tf.split(split_dim, num_split, value, name=’split’)
沿着某一维度将tensor分离为num_split tensors # ‘value’ is a tensor with shape [5, 30] # Split ‘value’ into 3 tensors along dimension 1 split0, split1, split2 = tf.split(1, 3, value) tf.shape(split0) ==> [5, 10]
tf.concat(concat_dim, values, name=’concat’)
沿着某一维度连结tensor t1 = [[1, 2, 3], [4, 5, 6]] t2 = [[7, 8, 9], [10, 11, 12]] tf.concat(0, [t1, t2]) ==> [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]] tf.concat(1, [t1, t2]) ==> [[1, 2, 3, 7, 8, 9], [4, 5, 6, 10, 11, 12]] 如果想沿着tensor一新轴连结打包,那么可以： tf.concat(axis, [tf.expand_dims(t, axis) for t in tensors]) 等同于tf.pack(tensors, axis=axis)
tf.pack(values, axis=0, name=’pack’)
将一系列rank-R的tensor打包为一个rank-(R+1)的tensor # ‘x’ is [1, 4], ‘y’ is [2, 5], ‘z’ is [3, 6] pack([x, y, z]) => [[1, 4], [2, 5], [3, 6]] # 沿着第一维pack pack([x, y, z], axis=1) => [[1, 2, 3], [4, 5, 6]] 等价于tf.pack([x, y, z]) = np.asarray([x, y, z])
tf.reverse(tensor, dims, name=None)
沿着某维度进行序列反转 其中dim为列表，元素为bool型，size等于rank(tensor) # tensor ‘t’ is [[[[ 0, 1, 2, 3], #[ 4, 5, 6, 7], #[ 8, 9, 10, 11]], #[[12, 13, 14, 15], #[16, 17, 18, 19], #[20, 21, 22, 23]]]] # tensor ‘t’ shape is [1, 2, 3, 4] # ‘dims’ is [False, False, False, True] reverse(t, dims) ==> [[[[ 3, 2, 1, 0], [ 7, 6, 5, 4], [ 11, 10, 9, 8]], [[15, 14, 13, 12], [19, 18, 17, 16], [23, 22, 21, 20]]]]
tf.transpose(a, perm=None, name=’transpose’)
调换tensor的维度顺序 按照列表perm的维度排列调换tensor顺序， 如为定义，则perm为(n-1…0) # ‘x’ is [[1 2 3],[4 5 6]] tf.transpose(x) ==> [[1 4], [2 5],[3 6]] # Equivalently tf.transpose(x, perm=[1, 0]) ==> [[1 4],[2 5], [3 6]]
tf.gather(params, indices, validate_indices=None, name=None)
合并索引indices所指示params中的切片
tf.one_hot (indices, depth, on_value=None, off_value=None, axis=None, dtype=None, name=None)
indices = [0, 2, -1, 1] depth = 3 on_value = 5.0 off_value = 0.0 axis = -1 #Then output is [4 x 3]: output = [5.0 0.0 0.0] // one_hot(0) [0.0 0.0 5.0] // one_hot(2) [0.0 0.0 0.0] // one_hot(-1) [0.0 5.0 0.0] // one_hot(1)
操作
描述
tf.diag(diagonal, name=None)
返回一个给定对角值的对角tensor # ‘diagonal’ is [1, 2, 3, 4] tf.diag(diagonal) ==> [[1, 0, 0, 0] [0, 2, 0, 0] [0, 0, 3, 0] [0, 0, 0, 4]]
tf.diag_part(input, name=None)
功能与上面相反
tf.trace(x, name=None)
求一个2维tensor足迹，即对角值diagonal之和
tf.transpose(a, perm=None, name=’transpose’)
调换tensor的维度顺序 按照列表perm的维度排列调换tensor顺序， 如为定义，则perm为(n-1…0) # ‘x’ is [[1 2 3],[4 5 6]] tf.transpose(x) ==> [[1 4], [2 5],[3 6]] # Equivalently tf.transpose(x, perm=[1, 0]) ==> [[1 4],[2 5], [3 6]]
tf.matmul(a, b, transpose_a=False, transpose_b=False, a_is_sparse=False, b_is_sparse=False, name=None)
矩阵相乘
tf.matrix_determinant(input, name=None)
返回方阵的行列式
tf.matrix_inverse(input, adjoint=None, name=None)
求方阵的逆矩阵，adjoint为True时，计算输入共轭矩阵的逆矩阵
tf.cholesky(input, name=None)
对输入方阵cholesky分解， 即把一个对称正定的矩阵表示成一个下三角矩阵L和其转置的乘积的分解A=LL^T
tf.matrix_solve(matrix, rhs, adjoint=None, name=None)
求解tf.matrix_solve(matrix, rhs, adjoint=None, name=None) matrix为方阵shape为[M,M],rhs的shape为[M,K]，output为[M,K]
操作
描述
tf.complex(real, imag, name=None)
将两实数转换为复数形式 # tensor ‘real’ is [2.25, 3.25] # tensor imag is [4.75, 5.75] tf.complex(real, imag) ==> [[2.25 + 4.75j], [3.25 + 5.75j]]
tf.complex_abs(x, name=None)
计算复数的绝对值，即长度。 # tensor ‘x’ is [[-2.25 + 4.75j], [-3.25 + 5.75j]] tf.complex_abs(x) ==> [5.25594902, 6.60492229]
tf.conj(input, name=None)
计算共轭复数
tf.imag(input, name=None) tf.real(input, name=None)
提取复数的虚部和实部
tf.fft(input, name=None)
计算一维的离散傅里叶变换，输入数据类型为complex64
操作
描述
tf.reduce_sum(input_tensor, reduction_indices=None, keep_dims=False, name=None)
计算输入tensor元素的和，或者安照reduction_indices指定的轴进行求和 # ‘x’ is [[1, 1, 1] # [1, 1, 1]] tf.reduce_sum(x) ==> 6 tf.reduce_sum(x, 0) ==> [2, 2, 2] tf.reduce_sum(x, 1) ==> [3, 3] tf.reduce_sum(x, 1, keep_dims=True) ==> [[3], [3]] tf.reduce_sum(x, [0, 1]) ==> 6
tf.reduce_prod(input_tensor, reduction_indices=None, keep_dims=False, name=None)
计算输入tensor元素的乘积，或者安照reduction_indices指定的轴进行求乘积
tf.reduce_min(input_tensor, reduction_indices=None, keep_dims=False, name=None)
求tensor中最小值
tf.reduce_max(input_tensor, reduction_indices=None, keep_dims=False, name=None)
求tensor中最大值
tf.reduce_mean(input_tensor, reduction_indices=None, keep_dims=False, name=None)
求tensor中平均值
tf.reduce_all(input_tensor, reduction_indices=None, keep_dims=False, name=None)
对tensor中各个元素求逻辑’与’ # ‘x’ is # [[True, True] # [False, False]] tf.reduce_all(x) ==> False tf.reduce_all(x, 0) ==> [False, False] tf.reduce_all(x, 1) ==> [True, False]
tf.reduce_any(input_tensor, reduction_indices=None, keep_dims=False, name=None)
对tensor中各个元素求逻辑’或’
tf.accumulate_n(inputs, shape=None, tensor_dtype=None, name=None)
计算一系列tensor的和 # tensor ‘a’ is [[1, 2], [3, 4]] # tensor b is [[5, 0], [0, 6]] tf.accumulate_n([a, b, a]) ==> [[7, 4], [6, 14]]
tf.cumsum(x, axis=0, exclusive=False, reverse=False, name=None)
求累积和 tf.cumsum([a, b, c]) ==> [a, a + b, a + b + c] tf.cumsum([a, b, c], exclusive=True) ==> [0, a, a + b] tf.cumsum([a, b, c], reverse=True) ==> [a + b + c, b + c, c] tf.cumsum([a, b, c], exclusive=True, reverse=True) ==> [b + c, c, 0]
操作
描述
tf.segment_sum(data, segment_ids, name=None)
根据segment_ids的分段计算各个片段的和 其中segment_ids为一个size与data第一维相同的tensor 其中id为int型数据，最大id不大于size c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]]) tf.segment_sum(c, tf.constant([0, 0, 1])) ==>[[0 0 0 0] [5 6 7 8]] 上面例子分为[0,1]两id,对相同id的data相应数据进行求和, 并放入结果的相应id中， 且segment_ids只升不降
tf.segment_prod(data, segment_ids, name=None)
根据segment_ids的分段计算各个片段的积
tf.segment_min(data, segment_ids, name=None)
根据segment_ids的分段计算各个片段的最小值
tf.segment_max(data, segment_ids, name=None)
根据segment_ids的分段计算各个片段的最大值
tf.segment_mean(data, segment_ids, name=None)
根据segment_ids的分段计算各个片段的平均值
tf.unsorted_segment_sum(data, segment_ids, num_segments, name=None)
与tf.segment_sum函数类似， 不同在于segment_ids中id顺序可以是无序的
tf.sparse_segment_sum(data, indices, segment_ids, name=None)
输入进行稀疏分割求和 c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]]) # Select two rows, one segment. tf.sparse_segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0])) ==> [[0 0 0 0]] 对原data的indices为[0,1]位置的进行分割， 并按照segment_ids的分组进行求和
操作
描述
tf.argmin(input, dimension, name=None)
返回input最小值的索引index
tf.argmax(input, dimension, name=None)
返回input最大值的索引index
tf.listdiff(x, y, name=None)
返回x，y中不同值的索引
tf.where(input, name=None)
返回bool型tensor中为True的位置 # ‘input’ tensor is #[[True, False] #[True, False]] # ‘input’ 有两个’True’,那么输出两个坐标值. # ‘input’的rank为2, 所以每个坐标为具有两个维度. where(input) ==> [[0, 0], [1, 0]]
tf.unique(x, name=None)
返回一个元组tuple(y,idx)，y为x的列表的唯一化数据列表， idx为x数据对应y元素的index # tensor ‘x’ is [1, 1, 2, 4, 4, 4, 7, 8, 8] y, idx = unique(x) y ==> [1, 2, 4, 7, 8] idx ==> [0, 0, 1, 2, 2, 2, 3, 4, 4]
tf.invert_permutation(x, name=None)
置换x数据与索引的关系 # tensor x is [3, 4, 0, 2, 1] invert_permutation(x) ==> [2, 4, 3, 0, 1]
激活函数（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,否则features Exponential 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.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.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
操作
描述
tf.nn.l2_normalize(x, dim, epsilon=1e-12, name=None)
对维度dim进行L2范式标准化 output = x / sqrt(max(sum(x**2), 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.l2_loss(t, name=None)
output = sum(t ** 2) / 2
操作
描述
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
操作
描述
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’
循环神经网络（Recurrent Neural Networks）
操作
描述
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简要介绍* —
操作
描述
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)
创建一个存储器Saver var_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.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文件名列表和时间戳
第二部分 本节主要介绍建立tensorflow图的相关类或函数
tf.Graph
操作
描述
class tf.Graph
tensorflow中的计算以图数据流的方式表示 一个图包含一系列表示计算单元的操作对象 以及在图中流动的数据单元以tensor对象表现
tf.Graph.init ()
建立一个空图
tf.Graph.as_default()
一个将某图设置为默认图，并返回一个上下文管理器 如果不显式添加一个默认图，系统会自动设置一个全局的默认图。 所设置的默认图，在模块范围内所定义的节点都将默认加入默认图中
tf.Graph.as_graph_def (from_version=None, add_shapes=False)
返回一个图的序列化的GraphDef表示 序列化的GraphDef 可以导入至另一个图中(使用 import_graph_def()) 或者使用C++ Session API
tf.Graph.finalize()
完成图的构建，即将其设置为只读模式
tf.Graph.finalized
返回True，如果图被完成
tf.Graph.control_dependencies(control_inputs)
定义一个控制依赖，并返回一个上下文管理器 with g.control_dependencies([a, b, c]): # d 和 e 将在 a, b, 和c执行完之后运行. d = … e = …
tf.Graph.device(device_name_or_function)
定义运行图所使用的设备，并返回一个上下文管理器 with g.device('/gpu:0'): ... with g.device('/cpu:0'): ...
tf.Graph.name_scope(name)
为节点创建层次化的名称，并返回一个上下文管理器
tf.Graph.add_to_collection(name, value)
将value以name的名称存储在收集器(collection)中
tf.Graph.get_collection(name, scope=None)
根据name返回一个收集器中所收集的值的列表
tf.Graph.as_graph_element (obj, allow_tensor=True, allow_operation=True)
返回一个图中与obj相关联的对象，为一个操作节点或者tensor数据
tf.Graph.get_operation_by_name(name)
根据名称返回操作节点
tf.Graph.get_tensor_by_name(name)
根据名称返回tensor数据
tf.Graph.get_operations()
返回图中的操作节点列表
tf.Graph.gradient_override_map(op_type_map)
用于覆盖梯度函数的上下文管理器
1 2 3 4 5 6 7 8 9 10 11 g = tf.Graph() with g.as_default(): c = tf.constant(30.0 ) assert c.graph is g c = tf.constant(4.0 ) assert c.graph is tf.get_default_graph()
1 2 3 4 5 6 7 8 9 10 11 12 g = tf.Graph() with g.as_default(): c = tf.constant(5.0 ) assert c.graph is g with tf.Graph().as_default() as g: c = tf.constant(5.0 ) assert c.graph is g
1 2 3 4 5 6 7 8 9 10 11 12 13 14 def my_func (pred, tensor ): t = tf.matmul(tensor, tensor) with tf.control_dependencies([pred]): return t def my_func (pred, tensor ): with tf.control_dependencies([pred]): return tf.matmul(tensor, tensor)
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 with tf.Graph().as_default() as g: c = tf.constant(5.0 , name="c" ) assert c.op.name == "c" c_1 = tf.constant(6.0 , name="c" ) assert c_1.op.name == "c_1" with g.name_scope("nested" ) as scope: nested_c = tf.constant(10.0 , name="c" ) assert nested_c.op.name == "nested/c" with g.name_scope("inner" ): nested_inner_c = tf.constant(20.0 , name="c" ) assert nested_inner_c.op.name == "nested/inner/c" with g.name_scope("inner" ): nested_inner_1_c = tf.constant(30.0 , name="c" ) assert nested_inner_1_c.op.name == "nested/inner_1/c" with g.name_scope(scope): nested_d = tf.constant(40.0 , name="d" ) assert nested_d.op.name == "nested/d" with g.name_scope("" ): e = tf.constant(50.0 , name="e" ) assert e.op.name == "e"
tf.Operation
操作
描述
class tf.Operation
代表图中的一个节点，用于计算tensors数据 该类型将由python节点构造器产生(比如tf.matmul()) 或者Graph.create_op() 例如c = tf.matmul(a, b)创建一个Operation类 为类型为”MatMul”,输入为’a’,’b’，输出为’c’的操作类
tf.Operation.name 操作节点(op)的名称
tf.Operation.type
操作节点(op)的类型，比如”MatMul”
tf.Operation.inputs tf.Operation.outputs
操作节点的输入与输出
tf.Operation.control_inputs
操作节点的依赖
tf.Operation.run(feed_dict=None, session=None)
在会话(Session)中运行该操作
tf.Operation.get_attr(name)
获取op的属性值
tf.Tensor
操作
描述
class tf.Tensor
表示一个由操作节点op产生的值， TensorFlow程序使用tensor数据结构来代表所有的数据, 计算图中, 操作间传递的数据都是 tensor，一个tensor是一个符号handle, 里面并没有表示实际数据，而相当于数据流的载体
tf.Tensor.dtype
tensor中数据类型
tf.Tensor.name 该tensor名称
tf.Tensor.value_index
该tensor输出外op的index
tf.Tensor.graph
该tensor所处在的图
tf.Tensor.op
产生该tensor的op
tf.Tensor.consumers()
返回使用该tensor的op列表
tf.Tensor.eval(feed_dict=None, session=None)
在会话中求tensor的值 需要使用with sess.as_default()或者 eval(session=sess)
tf.Tensor.get_shape()
返回用于表示tensor的shape的类TensorShape
tf.Tensor.set_shape(shape)
更新tensor的shape
tf.Tensor.device
设置计算该tensor的设备
1 2 3 4 c = tf.constant([[1.0 , 2.0 , 3.0 ], [4.0 , 5.0 , 6.0 ]]) print (c.get_shape())==> TensorShape([Dimension(2 ), Dimension(3 )])
1 2 3 4 5 6 7 print (image.get_shape())==> TensorShape([Dimension(None ), Dimension(None ), Dimension(3 )]) image.set_shape([28 , 28 , 3 ]) print (image.get_shape())==> TensorShape([Dimension(28 ), Dimension(28 ), Dimension(3 )])
tf.DType
操作
描述
class tf.DType
数据类型主要包含 tf.float16，tf.float16,tf.float32,tf.float64, tf.bfloat16,tf.complex64,tf.complex128, tf.int8,tf.uint8,tf.uint16,tf.int16,tf.int32, tf.int64,tf.bool,tf.string
tf.DType.is_compatible_with(other)
判断other的数据类型是否将转变为该DType
tf.DType.name 数据类型名称
tf.DType.base_dtype
返回该DType的基础DType，而非参考的数据类型(non-reference)
tf.DType.as_ref
返回一个基于DType的参考数据类型
tf.DType.is_floating
判断是否为浮点类型
tf.DType.is_complex
判断是否为复数
tf.DType.is_integer
判断是否为整数
tf.DType.is_unsigned
判断是否为无符号型数据
tf.DType.as_numpy_dtype
返回一个基于DType的numpy.dtype类型
tf.DType.max tf.DType.min
返回这种数据类型能表示的最大值及其最小值
tf.as_dtype(type_value)
返回由type_value转变得的相应tf数据类型
操作
描述
tf.device(device_name_or_function)
基于默认的图，其功能便为Graph.device()
tf.container(container_name)
基于默认的图，其功能便为Graph.container()
tf.name_scope(name)
基于默认的图，其功能便为 Graph.name_scope()
tf.control_dependencies(control_inputs)
基于默认的图，其功能便为Graph.control_dependencies()
tf.convert_to_tensor (value, dtype=None, name=None, as_ref=False)
将value转变为tensor数据类型
tf.get_default_graph()
返回返回当前线程的默认图
tf.reset_default_graph()
清除默认图的堆栈，并设置全局图为默认图
tf.import_graph_def(graph_def, input_map=None, return_elements=None, name=None, op_dict=None, producer_op_list=None)
将graph_def的图导入到python中
操作
描述
tf.add_to_collection(name, value)
基于默认的图，其功能便为Graph.add_to_collection()
tf.get_collection(key, scope=None)
基于默认的图，其功能便为Graph.get_collection()
tf.RegisterGradient
操作
描述
class tf.RegisterGradient
返回一个用于寄存op类型的梯度函数的装饰器
tf.NoGradient(op_type)
设置操作节点类型op_type的节点没有指定的梯度
class tf.RegisterShape
返回一个用于寄存op类型的shape函数的装饰器
class tf.TensorShape
表示tensor的shape
tf.TensorShape.merge_with(other)
与other合并shape信息，返回一个TensorShape类
tf.TensorShape.concatenate(other)
与other的维度相连结
tf.TensorShape.ndims
返回tensor的rank
tf.TensorShape.dims
返回tensor的维度
tf.TensorShape.as_list()
以list的形式返回tensor的shape
tf.TensorShape.is_compatible_with(other)
判断shape是否为兼容 TensorShape(None)与其他任何shape值兼容
class tf.Dimension
tf.Dimension.is_compatible_with(other)
判断dims是否为兼容
tf.Dimension.merge_with(other)
与other合并dims信息
tf.op_scope(values, name, default_name=None)
在python定义op时，返回一个上下文管理器
1 2 3 4 5 6 7 @tf.RegisterGradient("Sub" def _sub_grad (unused_op, grad ): return grad, tf.neg(grad)
1 2 3 4 5 6 7 8 9 def my_op (a, b, c, name=None ): with tf.op_scope([a, b, c], name, "MyOp" ) as scope: a = tf.convert_to_tensor(a, name="a" ) b = tf.convert_to_tensor(b, name="b" ) c = tf.convert_to_tensor(c, name="c" ) return foo_op(..., name=scope)
本节主要介绍tensorflow中数据的读入相关类或函数
tf提供一种占位符操作，在执行时需要为其提供数据data。
操作
描述
tf.placeholder(dtype, shape=None, name=None)
为一个tensor插入一个占位符 eg:x = tf.placeholder(tf.float32, shape=(1024, 1024))
tf.placeholder_with_default(input, shape, name=None)
当输出没有fed时，input通过一个占位符op
tf.sparse_placeholder(dtype, shape=None, name=None)
为一个稀疏tensor插入一个占位符
tf提供一系列读取各种数据格式的类。对于多文件输入，可以使用函数tf.train.string_input_producer ，该函数将创建一个保持文件的FIFO队列，以供reader使用。或者如果输入的这些文件名有相雷同的字符串，也可以使用函数tf.train.match_filenames_once 。
操作
描述
class tf.ReaderBase
不同的读取器类型的基本类
tf.ReaderBase.read(queue, name=None)
返回下一个记录对(key, value),queue为tf文件队列FIFOQueue
tf.ReaderBase.read_up_to(queue, num_records, name=None)
返回reader产生的num_records对(key, value)
tf.ReaderBase.reader_ref
返回应用在该reader上的Op
tf.ReaderBase.reset(name=None)
恢复reader为初始状态
tf.ReaderBase.restore_state(state, name=None)
恢复reader为之前的保存状态state
tf.ReaderBase.serialize_state(name=None)
返回一个reader解码后产生的字符串tansor
class tf.TextLineReader
tf.TextLineReader.num_records_produced(name=None)
返回reader已经产生的记录(records )数目
tf.TextLineReader.num_work_units_completed(name=None)
返回该reader已经完成的处理的work数目
tf.TextLineReader.read(queue, name=None)
返回reader所产生的下一个记录对 (key, value)，该reader可以限定新产生输出的行数
tf.TextLineReader.reader_ref
返回应用在该reader上的Op
tf.TextLineReader.reset(name=None)
恢复reader为初始状态
tf.TextLineReader.restore_state(state, name=None)
恢复reader为之前的保存状态state
tf.TextLineReader.serialize_state(name=None)
返回一个reader解码后产生的字符串tansor
class tf.WholeFileReader
一个阅读器，读取整个文件，返回文件名称key,以及文件中所有的内容value,该类的方法同上，不赘述
class tf.IdentityReader
一个reader，以key和value的形式，输出一个work队列。该类其他方法基本同上
class tf.TFRecordReader
读取TFRecord格式文件的reader。该类其他方法基本同上
class tf.FixedLengthRecordReader
输出
tf提供一系列方法将各种格式数据转换为tensor表示。
操作
描述
tf.decode_csv(records, record_defaults, field_delim=None, name=None)
将csv转换为tensor，与tf.TextLineReader搭配使用
tf.decode_raw(bytes, out_type, little_endian=None, name=None)
将bytes转换为一个数字向量表示，bytes为一个字符串类型的tensor 与函数 tf.FixedLengthRecordReader搭配使用，详见tf的CIFAR-10例子
选取与要输入的文件格式相匹配的reader，并将文件队列提供给reader的读方法( read method)。读方法将返回文件唯一标识的key，以及一个记录(record)（有助于对出现一些另类的records时debug），以及一个标量的字符串值。再使用一个（或多个）解码器(decoder) 或转换操作(conversion ops)将字符串转换为tensor类型。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 filename_queue = tf.train.string_input_producer(["file0.csv" , "file1.csv" ]) reader = tf.TextLineReader() key, value = reader.read(filename_queue) record_defaults = [[1 ], [1 ], [1 ], [1 ], [1 ]] col1, col2, col3, col4, col5 = tf.decode_csv( value, record_defaults=record_defaults) features = tf.pack([col1, col2, col3, col4]) with tf.Session() as sess: coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(coord=coord) for i in range (1200 ): example, label = sess.run([features, col5]) coord.request_stop() coord.join(threads)
提供了一些Example protocol buffers ，tf所推荐的用于训练样本的数据格式 ，它们包含特征信息，详情可见 。Features 域)的TFRecords文件。参见MNIST例子 ，将MNIST 数据转换为该类型数据。参见MNIST例子
操作
描述
class tf.VarLenFeature
解析变长的输入特征feature相关配置
class tf.FixedLenFeature
解析定长的输入特征feature相关配置
class tf.FixedLenSequenceFeature
序列项目中的稠密(dense )输入特征的相关配置
tf.parse_example(serialized, features, name=None, example_names=None) 将一组Example protos解析为tensor的字典形式 解析serialized所给予的序列化的一些Example protos 返回一个由特征keys映射Tensor和SparseTensor值的字典
tf.parse_single_example(serialized, features, name=None, example_names=None) 解析一个单独的Example proto，与tf.parse_example方法雷同
tf.decode_json_example(json_examples, name=None)
将JSON编码的样本记录转换为二进制protocol buffer字符串
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 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 serialized = [ features { feature { key: "ft" value { float_list { value: [1.0 , 2.0 ] } } } }, features { feature []}, features { feature { key: "ft" value { float_list { value: [3.0 ] } } } ] {"ft" : SparseTensor(indices=[[0 , 0 ], [0 , 1 ], [2 , 0 ]], values=[1.0 , 2.0 , 3.0 ], shape=(3 , 2 )) } [ features { feature { key: "kw" value { bytes_list { value: [ "knit" , "big" ] } } } feature { key: "gps" value { float_list { value: [] } } } }, features { feature { key: "kw" value { bytes_list { value: [ "emmy" ] } } } feature { key: "dank" value { int64_list { value: [ 42 ] } } } feature { key: "gps" value { } } } ] example_names: ["input0" , "input1" ], features: { "kw" : VarLenFeature(tf.string), "dank" : VarLenFeature(tf.int64), "gps" : VarLenFeature(tf.float32), } { "kw" : SparseTensor( indices=[[0 , 0 ], [0 , 1 ], [1 , 0 ]], values=["knit" , "big" , "emmy" ] shape=[2 , 2 ]), "dank" : SparseTensor( indices=[[1 , 0 ]], values=[42 ], shape=[2 , 1 ]), "gps" : SparseTensor( indices=[], values=[], shape=[2 , 0 ]), } [ features { feature { key: "age" value { int64_list { value: [ 0 ] } } } feature { key: "gender" value { bytes_list { value: [ "f" ] } } } }, features { feature { key: "age" value { int64_list { value: [] } } } feature { key: "gender" value { bytes_list { value: [ "f" ] } } } } ] example_names: ["input0" , "input1" ], features: { "age" : FixedLenFeature([], dtype=tf.int64, default_value=-1 ), "gender" : FixedLenFeature([], dtype=tf.string), } { "age" : [[0 ], [-1 ]], "gender" : [["f" ], ["f" ]], }
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 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 import osimport tensorflow as tffrom tensorflow.contrib.learn.python.learn.datasets import mnistSOURCE_URL = 'http://yann.lecun.com/exdb/mnist/' TRAIN_IMAGES = 'train-images-idx3-ubyte.gz' TRAIN_LABELS = 'train-labels-idx1-ubyte.gz' TEST_IMAGES = 't10k-images-idx3-ubyte.gz' TEST_LABELS = 't10k-labels-idx1-ubyte.gz' tf.app.flags.DEFINE_string('directory' , '/tmp/data' , 'Directory to download data files and write the ' 'converted result' ) tf.app.flags.DEFINE_integer('validation_size' , 5000 , 'Number of examples to separate from the training ' 'data for the validation set.' ) FLAGS = tf.app.flags.FLAGS def _int64_feature (value ): return tf.train.Feature(int64_list=tf.train.Int64List(value=[value])) def _bytes_feature (value ): return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value])) def convert_to (data_set, name ): images = data_set.images labels = data_set.labels num_examples = data_set.num_examples if images.shape[0 ] != num_examples: raise ValueError('Images size %d does not match label size %d.' % (images.shape[0 ], num_examples)) rows = images.shape[1 ] cols = images.shape[2 ] depth = images.shape[3 ] filename = os.path.join(FLAGS.directory, name + '.tfrecords' ) print ('Writing' , filename) writer = tf.python_io.TFRecordWriter(filename) for index in range (num_examples): image_raw = images[index].tostring() example = tf.train.Example(features=tf.train.Features(feature={ 'height' : _int64_feature(rows), 'width' : _int64_feature(cols), 'depth' : _int64_feature(depth), 'label' : _int64_feature(int (labels[index])), 'image_raw' : _bytes_feature(image_raw)})) writer.write(example.SerializeToString()) writer.close() def main (argv ): data_sets = mnist.read_data_sets(FLAGS.directory, dtype=tf.uint8, reshape=False ) convert_to(data_sets.train, 'train' ) convert_to(data_sets.validation, 'validation' ) convert_to(data_sets.test, 'test' ) if __name__ == '__main__' : tf.app.run()
tensorflow提供了几个队列应用，用来将tf计算图与tensors的阶段流水组织到一起。队列是使用tensorflow计算的一个强大的机制，正如其他Tensorflow的元素一样，一个队列也是tf图中的一个节点(node),它是一个有状态的node，就像一个变量：其他节点可以改变其内容。
操作
描述
class tf.QueueBase
基本的队列应用类.队列(queue)是一种数据结构， 该结构通过多个步骤存储tensors, 并且对tensors进行入列(enqueue)与出列(dequeue)操作
tf.QueueBase.enqueue(vals, name=None)
将一个元素编入该队列中。如果在执行该操作时队列已满， 那么将会阻塞直到元素编入队列之中
tf.QueueBase.enqueue_many(vals, name=None)
将零个或多个元素编入该队列中
tf.QueueBase.dequeue(name=None)
将元素从队列中移出。如果在执行该操作时队列已空， 那么将会阻塞直到元素出列，返回出列的tensors的tuple
tf.QueueBase.dequeue_many(n, name=None)
将一个或多个元素从队列中移出
tf.QueueBase.size(name=None)
计算队列中的元素个数
tf.QueueBase.close (cancel_pending_enqueues=False, name=None)
关闭该队列
f.QueueBase.dequeue_up_to(n, name=None)
从该队列中移出n个元素并将之连接
tf.QueueBase.dtypes
列出组成元素的数据类型
tf.QueueBase.from_list(index, queues)
根据queues[index]的参考队列创建一个队列
tf.QueueBase.name 返回最队列下面元素的名称
tf.QueueBase.names
返回队列每一个组成部分的名称
class tf.FIFOQueue 在出列时依照先入先出顺序，其他方法与tf.QueueBase雷同
class tf.PaddingFIFOQueue
一个FIFOQueue ，同时根据padding支持batching变长的tensor
class tf.RandomShuffleQueue 该队列将随机元素出列，其他方法与tf.QueueBase雷同
操作
描述
tf.matching_files(pattern, name=None)
返回与pattern匹配模式的文件名称
tf.read_file(filename, name=None) 读取并输出输入文件的整个内容
用于设置输入预取数的管道TF函数，函数 “producer”添加一个队列至图中，同时一个相应用于运行队列中子图(subgraph)的QueueRunner
操作
描述
tf.train.match_filenames_once(pattern, name=None)
保存与pattern的文件列表
tf.train.limit_epochs(tensor, num_epochs=None, name=None)
返回一个num_epochs次数，然后报告OutOfRange错误
tf.train.input_producer(input_tensor, element_shape=None, num_epochs=None, shuffle=True, seed=None, capacity=32, shared_name=None, summary_name=None, name=None)
为一个输入管道输出input_tensor中的多行至一个队列中
tf.train.range_input_producer(limit, num_epochs=None, shuffle=True, seed=None, capacity=32, shared_name=None, name=None)
产生一个从1至limit-1的整数至队列中
tf.train.slice_input_producer(tensor_list, num_epochs=None, shuffle=True, seed=None, capacity=32, shared_name=None, name=None)
对tensor_list中的每一个tensor切片
tf.train.string_input_producer(string_tensor, num_epochs=None, shuffle=True, seed=None, capacity=32, shared_name=None, name=None) 为一个输入管道输出一组字符串(比如文件名)至队列中
该相关函数增添一个队列至图中以将数据一样本打包为batch。它们也会添加 一个QueueRunner，以便执行的已经被填满队列的子图
操作
描述
tf.train.batch(tensors, batch_size, num_threads=1, capacity=32, enqueue_many=False, shapes=None, dynamic_pad=False, allow_smaller_final_batch=False, shared_name=None, name=None)
在输入的tensors中创建一些tensor数据格式的batch， 若输入为shape[*, x, y, z]，那么输出则为[batch_size, x, y, z] 返回一个列表或者一个具有与输入tensors相同类型tensors的字典
tf.train.batch_join(tensors_list, batch_size, capacity=32, enqueue_many=False, shapes=None, dynamic_pad=False, allow_smaller_final_batch=False, shared_name=None, name=None)
将一个tensors的列表添加至一个队列中以创建样本的batches len(tensors_list)个线程将启动， 线程i将tensors_list[i]的tensors入列 tensors_list[i1][j]与tensors_list[i2][j]有相同的类型和shape
tf.train.shuffle_batch(tensors, batch_size, capacity, min_after_dequeue, num_threads=1, seed=None, enqueue_many=False, shapes=None, allow_smaller_final_batch=False, shared_name=None, name=None) 使用随机乱序的方法创建batches tensors:用于入列的一个list或者dict capacity:一个整数，表示队列中元素最大数目
tf.train.shuffle_batch_join(tensors_list, batch_size, capacity, min_after_dequeue, seed=None, enqueue_many=False, shapes=None, allow_smaller_final_batch=False, shared_name=None, name=None)
随机乱序的tensors创建batches， 其中tensors_list参数为tensors元组或tensors字典的列表 len(tensors_list)个线程将启动， 线程i将tensors_list[i]的tensors入列 tensors_list[i1][j]与tensors_list[i2][j]有相同的类型和shape
1 2 3 4 5 6 7 image_batch, label_batch = tf.train.shuffle_batch( [single_image, single_label], batch_size=32 , num_threads=4 , capacity=50000 , min_after_dequeue=10000 )
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 def read_my_file_format (filename_queue ): reader = tf.SomeReader() key, record_string = reader.read(filename_queue) example, label = tf.some_decoder(record_string) processed_example = some_processing(example) return processed_example, label def input_pipeline (filenames, batch_size, num_epochs=None ): filename_queue = tf.train.string_input_producer( filenames, num_epochs=num_epochs, shuffle=True ) example, label = read_my_file_format(filename_queue) min_after_dequeue = 10000 capacity = min_after_dequeue + 3 * batch_size example_batch, label_batch = tf.train.shuffle_batch( [example, label], batch_size=batch_size, capacity=capacity, min_after_dequeue=min_after_dequeue) return example_batch, label_batch
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 def read_my_file_format (filename_queue ): def input_pipeline (filenames, batch_size, read_threads, num_epochs=None ): filename_queue = tf.train.string_input_producer( filenames, num_epochs=num_epochs, shuffle=True ) example_list = [read_my_file_format(filename_queue) for _ in range (read_threads)] min_after_dequeue = 10000 capacity = min_after_dequeue + 3 * batch_size example_batch, label_batch = tf.train.shuffle_batch_join( example_list, batch_size=batch_size, capacity=capacity, min_after_dequeue=min_after_dequeue) return example_batch, label_batch
摘要：本系列主要对tf的一些常用概念与方法进行描述。本文主要针对tensorflow的数据IO、图的运行等相关函数进行讲解。为‘Tensorflow一些常用基本概念与函数’系列之三。
本文所讲的内容主要为以下相关函数：
操作组
操作
Data IO (Python functions)
TFRecordWrite，rtf_record_iterator
Running Graphs
Session management，Error classes
一个TFRecords 文件为一个字符串序列。这种格式并非随机获取，它比较适合大规模的数据流，而不太适合需要快速分区或其他非序列获取方式。
操作
描述
class tf.python_io.TFRecordWriter
一个用于将记录(records)写入TFRecords文件的类
tf.python_io.TFRecordWriter.init (path, options=None)
打开文件路径，并创建一个TFRecordWriter以供写入
tf.python_io.TFRecordWriter.write(record)
将一个字符串records写入文件中
tf.python_io.TFRecordWriter.close()
关闭文件
tf.python_io.tf_record_iterator(path, options=None)
从TFRecords文件中读取记录的迭代器
操作
描述
class tf.Session
运行TF操作的类, 一个Session对象将操作节点op封装在一定的环境内运行， 同时tensor对象将被计算求值
tf.Session.init (target=”, graph=None, config=None)
创建一个新的会话
tf.Session.run(fetches, feed_dict=None, options=None, run_metadata=None)
运行fetches中的操作节点并求其值
tf.Session.close()
关闭会话
tf.Session.graph
返回加载值该会话的图(graph)
tf.Session.as_default() 设置该对象为默认会话，并返回一个上下文管理器
tf.Session.reset(target, containers=None, config=None)
重设target的资源容器，并关闭所有连接的会话 在0.10版本该功能仅应用在分布会话中 target:为执行引擎所连接的目标，其包含有资源容器， 该资源容器分布在同一个集群的所有works上
class tf.InteractiveSession
使用在交互式上下文环境的tf会话，比如shell，ipython
tf.InteractiveSession.close()
关闭一个InteractiveSession
tf.get_default_session()
返回当前线程的默认会话
*tf.Session*
1 2 3 4 5 6 7 8 9 10 11 a = tf.constant(5.0 ) b = tf.constant(6.0 ) c = a * b sess = tf.Session() print (sess.run(c))
1 2 3 4 5 6 7 8 9 10 sess = tf.Session() sess.run(...) sess.close() with tf.Session() as sess: sess.run(...)
tf.Session()的变量设置， ConfigProto protocol buffer为会话提供了不同的配置选项。比如，创建一个会话，对设备布局使用软约束条件，以及对分布
1 2 3 4 sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True , log_device_placement=True ))
*tf.Session.run*
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 a = tf.constant([10 , 20 ]) b = tf.constant([1.0 , 2.0 ]) v = session.run(a) v = session.run([a, b]) MyData = collections.namedtuple('MyData' , ['a' , 'b' ]) v = session.run({'k1' : MyData(a, b), 'k2' : [b, a]})
*tf.Session.as_default()* Operation.run() 或Tensor.eval() ，以得到运行的tensor结果
1 2 3 4 5 6 c = tf.constant(..) sess = tf.Session() with sess.as_default(): assert tf.get_default_session() is sess print (c.eval ())
使用函数tf.get_default_session()来得到当前默认的会话
1 2 3 4 5 6 7 8 9 10 c = tf.constant(...) sess = tf.Session() with sess.as_default(): print (c.eval ()) with sess.as_default(): print (c.eval ()) sess.close()
*tf.InteractiveSession*
1 2 3 4 5 6 7 sess = tf.InteractiveSession() a = tf.constant(5.0 ) b = tf.constant(6.0 ) c = a * b print (c.eval ())sess.close()
以上的例子，在非交互会话的版本中为，
1 2 3 4 5 6 a = tf.constant(5.0 ) b = tf.constant(6.0 ) c = a * b with tf.Session(): print (c.eval ())
操作
描述
class tf.OpError
一个基本的错误类型，在当TF执行失败时候报错
tf.OpError.op
返回执行失败的操作节点， 有的操作如Send或Recv可能不会返回，那就要用用到node_def方法
tf.OpError.node_def 以NodeDef proto形式表示失败的op
tf.OpError.error_code
描述该错误的整数错误代码
tf.OpError.message
返回错误信息
class tf.errors.CancelledError
当操作或者阶段呗取消时候报错
class tf.errors.UnknownError
未知错误类型
class tf.errors.InvalidArgumentError
在接收到非法参数时候报错
class tf.errors.NotFoundError
当发现不存在所请求的一个实体时候，比如文件或目录
class tf.errors.AlreadyExistsError
当创建的实体已经存在的时候报错
class tf.errors.PermissionDeniedError
没有执行权限做某操作的时候报错
class tf.errors.ResourceExhaustedError
资源耗尽时报错
class tf.errors.FailedPreconditionError
系统没有条件执行某个行为时候报错
class tf.errors.AbortedError
操作中止时报错，常常发生在并发情形
class tf.errors.OutOfRangeError
超出范围报错
class tf.errors.UnimplementedError
某个操作没有执行时报错
class tf.errors.InternalError
当系统经历了一个内部错误时报出
class tf.errors.DataLossError
当出现不可恢复的错误 例如在运行 tf.WholeFileReader.read() 读取整个文件的同时文件被删减
tf.errors.XXXXX.init (node_def, op, message)
使用该形式方法创建以上各种错误类
摘要：本系列主要对tf的一些常用概念与方法进行描述。本文主要针对tensorflow的模型训练Training与测试Testing等相关函数进行讲解。为‘Tensorflow一些常用基本概念与函数’系列之四。
本文所讲的内容主要为以下列表中相关函数。函数training()通过梯度下降法为最小化损失函数增加了相关的优化操作，在训练过程中，先实例化一个优化函数，比如 tf.train.GradientDescentOptimizer，并基于一定的学习率进行梯度优化训练：
1 optimizer = tf.train.GradientDescentOptimizer(learning_rate)
然后，可以设置 一个用于记录全局训练步骤的单值。以及使用minimize()操作，该操作不仅可以优化更新训练的模型参数，也可以为全局步骤(global step)计数。与其他tensorflow操作类似，这些训练操作都需要在tf.session 会话中进行
1 2 global_step = tf.Variable(0 , name ='global_step' , trainable=False) train_op = optimizer.minimize(loss, global_step=global_step)
操作组
操作
Training
Optimizers，Gradient Computation，Gradient Clipping，Distributed execution
Testing
Unit tests，Utilities，Gradient checking
一个TFRecords 文件为一个字符串序列。这种格式并非随机获取，它比较适合大规模的数据流，而不太适合需要快速分区或其他非序列获取方式。
tf中各种优化类提供了为损失函数计算梯度的方法，其中包含比较经典的优化算法，比如GradientDescent 和Adagrad。
▶▶*class tf.train.Optimizer*
操作
描述
class tf.train.Optimizer
基本的优化类，该类不常常被直接调用，而较多使用其子类， 比如GradientDescentOptimizer, AdagradOptimizer 或者MomentumOptimizer
tf.train.Optimizer.init (use_locking, name)
创建一个新的优化器， 该优化器必须被其子类(subclasses)的构造函数调用
tf.train.Optimizer.minimize(loss, global_step=None, var_list=None, gate_gradients=1, aggregation_method=None, colocate_gradients_with_ops=False, name=None, grad_loss=None) 添加操作节点，用于最小化loss，并更新var_list 该函数是简单的合并了compute_gradients()与apply_gradients()函数 返回为一个优化更新后的var_list，如果global_step非None，该操作还会为global_step做自增操作
tf.train.Optimizer.compute_gradients(loss,var_list=None, gate_gradients=1, aggregation_method=None, colocate_gradients_with_ops=False, grad_loss=None)
对var_list中的变量计算loss的梯度 该函数为函数minimize()的第一部分，返回一个以元组(gradient, variable)组成的列表
tf.train.Optimizer.apply_gradients(grads_and_vars, global_step=None, name=None)
将计算出的梯度应用到变量上，是函数minimize()的第二部分，返回一个应用指定的梯度的操作Operation，对global_step做自增操作
tf.train.Optimizer.get_name()
获取名称
▷ class tf.train.Optimizer
1 2 3 4 5 6 7 opt = GradientDescentOptimizer(learning_rate=0.1 ) opt_op = opt.minimize(cost, var_list=<list of variables>) opt_op.run()
▶▶*在使用它们之前处理梯度*
1 2 3 1 、使用函数compute_gradients ()计算梯度2 、按照自己的愿望处理梯度3 、使用函数apply_gradients ()应用处理过后的梯度
例如：
1 2 3 4 5 6 7 8 9 10 11 12 opt = GradientDescentOptimizer(learning_rate=0.1 ) grads_and_vars = opt.compute_gradients(loss, <list of variables>) capped_grads_and_vars = [(MyCapper(gv[0 ]), gv[1 ]) for gv in grads_and_vars] opt.apply_gradients(capped_grads_and_vars)
▶▶*选通梯度(Gating Gradients)*
其值可以取：GATE_NONE, GATE_OP 或 GATE_GRAPH
一些optimizer的之类，比如 MomentumOptimizer 和 AdagradOptimizer 分配和管理着额外的用于训练的变量。这些变量称之为’Slots’，Slots有相应的名称，可以向optimizer访问的slots名称。有助于在log debug一个训练算法以及报告slots状态
操作
描述
tf.train.Optimizer.get_slot_names()
返回一个由Optimizer所创建的slots的名称列表
tf.train.Optimizer.get_slot(var, name)
返回一个name所对应的slot，name是由Optimizer为var所创建 var为用于传入 minimize() 或 apply_gradients()的变量
class tf.train.GradientDescentOptimizer 使用梯度下降算法的Optimizer
tf.train.GradientDescentOptimizer.init (learning_rate, use_locking=False, name=’GradientDescent’)
构建一个新的梯度下降优化器(Optimizer)
class tf.train.AdadeltaOptimizer 使用Adadelta算法 的Optimizer
tf.train.AdadeltaOptimizer.init (learning_rate=0.001, rho=0.95, epsilon=1e-08, use_locking=False, name=’Adadelta’)
创建Adadelta优化器
class tf.train.AdagradOptimizer 使用Adagrad算法 的Optimizer
tf.train.AdagradOptimizer.init (learning_rate, initial_accumulator_value=0.1, use_locking=False, name=’Adagrad’)
创建Adagrad优化器
class tf.train.MomentumOptimizer
使用Momentum 算法的Optimizer
tf.train.MomentumOptimizer.init (learning_rate, momentum, use_locking=False, name=’Momentum’, use_nesterov=False)
创建momentum优化器 momentum：动量，一个tensor或者浮点值
class tf.train.AdamOptimizer 使用Adam 算法 的Optimizer
tf.train.AdamOptimizer.init (learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-08, use_locking=False, name=’Adam’)
创建Adam优化器
class tf.train.FtrlOptimizer
使用FTRL 算法 的Optimizer
tf.train.FtrlOptimizer.init (learning_rate, learning_rate_power=-0.5, initial_accumulator_value=0.1, l1_regularization_strength=0.0, l2_regularization_strength=0.0, use_locking=False, name=’Ftrl’)
创建FTRL算法优化器
class tf.train.RMSPropOptimizer
使用RMSProp算法 的Optimizer
tf.train.RMSPropOptimizer.init (learning_rate, decay=0.9, momentum=0.0, epsilon=1e-10, use_locking=False, name=’RMSProp’)
创建RMSProp算法优化器
▷ tf.train.AdamOptimizer
1 2 3 m_0 <- 0 (Initialize initial 1 st moment vector) v_0 <- 0 (Initialize initial 2 nd moment vector) t <- 0 (Initialize timestep)
在论文 中的 section2 的末尾所描述了更新规则，该规则使用梯度g来更新变量：
1 2 3 4 5 6 t <- t + 1 lr_t <- learning_rate * sqrt ( 1 - beta2^ t) / ( 1 - beta1^ t) m_t <- beta1 * m_{ t- 1 } + ( 1 - beta1) * g v_t <- beta2 * v_{ t- 1 } + ( 1 - beta2) * g * g variable <- variable - lr_t * m_t / ( sqrt ( v_t) + epsilon)
其中epsilon 的默认值1e-8可能对于大多数情况都不是一个合适的值。例如，当在ImageNet上训练一个 Inception network时比较好的选择为1.0或者0.1。
TensorFlow 提供了计算给定tf计算图的求导函数，并在图的基础上增加节点。优化器(optimizer )类可以自动的计算网络图的导数，但是优化器中的创建器(creators )或者专业的人员可以通过本节所述的函数调用更底层的方法。
操作
描述
tf.gradients(ys, xs, grad_ys=None, name=’gradients’, colocate_gradients_with_ops=False, gate_gradients=False, aggregation_method=None)
构建一个符号函数，计算ys关于xs中x的偏导的和， 返回xs中每个x对应的sum(dy/dx)
tf.stop_gradient(input, name=None)
停止计算梯度， 在EM算法、Boltzmann机等可能会使用到
tf.clip_by_value(t, clip_value_min, clip_value_max, name=None)
基于定义的min与max对tesor数据进行截断操作， 目的是为了应对梯度爆发或者梯度消失的情况
tf.clip_by_norm(t, clip_norm, axes=None, name=None)
使用L2范式标准化tensor最大值为clip_norm 返回 t * clip_norm / l2norm(t)
tf.clip_by_average_norm(t, clip_norm, name=None)
使用平均L2范式规范tensor数据t， 并以clip_norm为最大值 返回 t * clip_norm / l2norm_avg(t)
tf.clip_by_global_norm(t_list, clip_norm, use_norm=None, name=None)
返回t_list[i] * clip_norm / max(global_norm, clip_norm) 其中global_norm = sqrt(sum([l2norm(t)**2 for t in t_list]))
tf.global_norm(t_list, name=None)
返回global_norm = sqrt(sum([l2norm(t)**2 for t in t_list]))
操作
描述
tf.train.exponential_decay(learning_rate, global_step, decay_steps, decay_rate, staircase=False, name=None)
对学习率进行指数衰退
▷ tf.train.exponential_decay
1 2 3 4 5 6 7 8 9 10 11 12 13 decayed_learning_rate = learning_rate * decay_rate ^ (global_step / decay_steps) global_step = tf.Variable(0 , trainable=False ) starter_learning_rate = 0.1 learning_rate = tf.train.exponential_decay(starter_learning_rate, global_step, 100000 , 0.96 , staircase=True ) learning_step = ( tf.train.GradientDescentOptimizer(learning_rate) .minimize(...my loss..., global_step=global_step) )
一些训练优化算法，比如GradientDescent 和Momentum 在优化过程中便可以使用到移动平均方法。使用移动平均常常可以较明显地改善结果。
操作
描述
class tf.train.ExponentialMovingAverage
将指数衰退加入到移动平均中
tf.train.ExponentialMovingAverage.apply(var_list=None)
对var_list变量保持移动平均
tf.train.ExponentialMovingAverage.average_name(var)
返回var均值的变量名称
tf.train.ExponentialMovingAverage.average(var)
返回var均值变量
tf.train.ExponentialMovingAverage.variables_to_restore(moving_avg_variables=None)
返回用于保存的变量名称的映射
▷ tf.train.ExponentialMovingAverage
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 var0 = tf.Variable(...) var1 = tf.Variable(...) ... opt_op = opt.minimize(my_loss, [var0, var1]) ema = tf.train.ExponentialMovingAverage(decay=0.9999 ) maintain_averages_op = ema.apply([var0, var1]) with tf.control_dependencies([opt_op]): training_op = tf.group(maintain_averages_op) ...train the model by running training_op... shadow_var0_name = ema.average_name(var0) shadow_var1_name = ema.average_name(var1) saver = tf.train.Saver({shadow_var0_name: var0, shadow_var1_name: var1}) saver.restore(...checkpoint filename...)
▷ tf.train.ExponentialMovingAverage.variables_to_restore
1 2 3 variables_to_restore = ema.variables_to_restore() saver = tf.train.Saver(variables_to_restore)
查看queue 中，queue相关的内容，了解tensorflow中队列的运行方式。
操作
描述
class tf.train.Coordinator
线程的协调器
tf.train.Coordinator.clear_stop()
清除停止标记
tf.train.Coordinator.join(threads=None, stop_grace_period_secs=120)
等待线程终止 threads:一个threading.Threads的列表，启动的线程，将额外加入到registered的线程中
tf.train.Coordinator.register_thread(thread)
Register一个用于join的线程
tf.train.Coordinator.request_stop(ex=None)
请求线程结束
tf.train.Coordinator.should_stop()
检查是否被请求停止
tf.train.Coordinator.stop_on_exception()
上下文管理器，当一个例外出现时请求停止
tf.train.Coordinator.wait_for_stop(timeout=None)
等待Coordinator提示停止进程
class tf.train.QueueRunner 持有一个队列的入列操作列表，用于线程中运行 queue:一个队列 enqueue_ops: 用于线程中运行的入列操作列表
tf.train.QueueRunner.create_threads(sess, coord=None, daemon=False, start=False)
创建运行入列操作的线程，返回一个线程列表
tf.train.QueueRunner.from_proto(queue_runner_def)
返回由queue_runner_def创建的QueueRunner对象
tf.train.add_queue_runner(qr, collection=’queue_runners’)
增加一个QueueRunner到graph的收集器(collection )中
tf.train.start_queue_runners(sess=None, coord=None, daemon=True, start=True, collection=’queue_runners’)
启动所有graph收集到的队列运行器(queue runners)
▷ class tf.train.Coordinator
1 2 3 4 5 6 7 8 9 10 11 12 13 14 try : ... coord = Coordinator() ...start thread 1. ..(coord, ...) ...start thread N...(coord, ...) coord.join(threads, stop_grace_period_secs=10 ) except RuntimeException: ...one of the threads took more than 10s to stop after request_stop() ...was called. except Exception: ...exception that was passed to coord.request_stop()
▷ tf.train.Coordinator.stop_on_exception()
1 2 3 4 5 6 7 8 9 10 with coord.stop_on_exception(): ...body... try : ...body... exception Exception as ex: coord.request_stop(ex)
可以阅读TensorFlow的分布式学习框架简介 查看更多tensorflow分布式细节。
操作
描述
class tf.train.Server 一个进程内的tensorflow服务，用于分布式训练
tf.train.Server.init (server_or_cluster_def, job_name=None, task_index=None, protocol=None, config=None, start=True)
创建一个新的服务，其中job_name, task_index, 和protocol为可选参数， 优先级高于server_or_cluster_def中相关信息 server_or_cluster_def : 为一个tf.train.ServerDef 或 tf.train.ClusterDef 协议(protocol)的buffer， 或者一个tf.train.ClusterSpec对象
tf.train.Server.create_local_server(config=None, start=True) 创建一个新的运行在本地主机的单进程集群
tf.train.Server.target 返回tf.Session所连接的目标服务器
tf.train.Server.server_def
返回该服务的tf.train.ServerDef
tf.train.Server.start() 开启服务
tf.train.Server.join()
阻塞直到服务已经关闭
#
class tf.train.Supervisor
一个训练辅助器，用于checkpoints模型以及计算的summaries。该监视器只是一个小的外壳(wrapper),用于Coordinator, a Saver, 和a SessionManager周围
tf.train.Supervisor.init (graph=None, ready_op=0, is_chief=True, init_op=0, init_feed_dict=None, local_init_op=0, logdir=None, summary_op=0, saver=0, global_step=0, save_summaries_secs=120, save_model_secs=600, recovery_wait_secs=30, stop_grace_secs=120, checkpoint_basename=’model.ckpt’, session_manager=None, summary_writer=0, init_fn=None) 创建一个监视器Supervisor
tf.train.Supervisor.managed_session(master=”, config=None, start_standard_services=True, close_summary_writer=True)
返回一个管路session的上下文管理器
tf.train.Supervisor.prepare_or_wait_for_session(master=”, config=None, wait_for_checkpoint=False, max_wait_secs=7200, start_standard_services=True)
确保model已经准备好
tf.train.Supervisor.start_standard_services(sess) 为sess启动一个标准的服务
tf.train.Supervisor.start_queue_runners(sess, queue_runners=None)
为QueueRunners启动一个线程，queue_runners为一个QueueRunners列表
tf.train.Supervisor.summary_computed(sess, summary, global_step=None)
指示计算的summary
tf.train.Supervisor.stop(threads=None, close_summary_writer=True)
停止服务以及协调器(coordinator),并没有关闭session
tf.train.Supervisor.request_stop(ex=None)
参考Coordinator.request_stop()
tf.train.Supervisor.should_stop()
参考Coordinator.should_stop()
tf.train.Supervisor.stop_on_exception()
参考 Coordinator.stop_on_exception()
tf.train.Supervisor.Loop(timer_interval_secs, target, args=None, kwargs=None)
开启一个循环器线程用于调用一个函数 每经过timer_interval_secs秒执行，target(*args, **kwargs)
tf.train.Supervisor.coord
返回监督器(Supervisor)使用的协调器(Coordinator )
#
class tf.train.SessionManager
训练的辅助器，用于从checkpoint恢复数据以及创建一个session
tf.train.SessionManager.init (local_init_op=None, ready_op=None, graph=None, recovery_wait_secs=30)
创建一个SessionManager
tf.train.SessionManager.prepare_session(master, init_op=None, saver=None, checkpoint_dir=None, wait_for_checkpoint=False, max_wait_secs=7200, config=None, init_feed_dict=None, init_fn=None)
创建一个session，并确保model可以被使用
tf.train.SessionManager.recover_session(master, saver=None, checkpoint_dir=None, wait_for_checkpoint=False, max_wait_secs=7200, config=None)
创建一个session，如果可以的话，使用恢复方法创建
tf.train.SessionManager.wait_for_session(master, config=None, max_wait_secs=inf)
创建一个session，并等待model准备完成
#
class tf.train.ClusterSpec 将一个集群表示为一系列“tasks”，并整合至“jobs”中
tf.train.ClusterSpec.as_cluster_def()
返回该cluster中一个tf.train.ClusterDef协议的buffer
tf.train.ClusterSpec.as_dict()
返回一个字典，由job名称对应于网络地址
tf.train.ClusterSpec.job_tasks(job_name)
返回一个给定的job对应的task列表
tf.train.ClusterSpec.jobs
返回该cluster的job名称列表
tf.train.replica_device_setter(ps_tasks=0, ps_device=’/job:ps’, worker_device=’/job:worker’, merge_devices=True, cluster=None, ps_ops=None) 返回一个设备函数(device function)，以在建立一个副本graph的时候使用，设备函数(device function)用在with tf.device(device_function)中
▷ tf.train.Server
1 2 3 server = tf.train.Server(...) with tf.Session(server.target):
▷ tf.train.Supervisor
1 2 3 4 5 6 7 8 9 10 11 12 with tf.Graph().as_default(): ...add operations to the graph... sv = Supervisor(logdir='/tmp/mydir' ) with sv.managed_session(FLAGS.master) as sess: while not sv.should_stop(): sess.run(<my_train_op>)
使用在多副本运行情况中
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 is_chief = (server_def.task_index == 0 ) server = tf.train.Server(server_def) with tf.Graph().as_default(): ...add operations to the graph... sv = Supervisor(logdir='/shared_directory/...' , is_chief=is_chief) with sv.managed_session(server.target) as sess: while not sv.should_stop(): sess.run(<my_train_op>)
如果有task崩溃或重启，managed_session() 将检查是否Model被初始化。如果已经初始化，它只需要创建一个session并将其返回至正在训练的正常代码中。如果model需要被初始化，主task将对它进行重新初始化，而其他task将等待模型初始化完成。
▷ supervisor中master的字符串形式
定义为 ” ，要求一个进程内且没有使用RPC的session
定义为 ‘local’，要求一个使用基于RPC的主服务接口(“Master interface” )的session来运行tensorflow程序。更多细节可以查看 tf.train.Server.create_local_server()相关内容。
定义为 ‘grpc://hostname:port’，要求一个指定的RPC接口的session，同时运行内部进程的master接入远程的tensorflow workers。可用server.target返回该形式
▷ supervisor高级用法
启动额外的服务
1 2 3 4 5 6 7 ... sv = Supervisor(logdir='/tmp/mydir' ) with sv.managed_session(FLAGS.master) as sess: sv.loop(60 , print_loss, (sess)) while not sv.should_stop(): sess.run(my_train_op)
启动更少的的服务
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 在chief中每100 个step，创建summaries sv = Supervisor(logdir='/tmp/mydir' , is_chief=is_chief, summary_op=None ) with sv.managed_session(FLAGS.master) as sess: for step in xrange(1000000 ): if sv.should_stop(): break if is_chief and step % 100 == 0 : sv.summary_computed(sess, sess.run(my_summary_op)) else : sess.run(my_train_op)
▷ tf.train.Supervisor.managed_session
1 2 3 4 5 6 7 8 def train (): sv = tf.train.Supervisor(...) with sv.managed_session(<master>) as sess: for step in xrange(..): if sv.should_stop(): break sess.run(<my training op>) ...do other things needed at each training step...
▷ tf.train.SessionManager
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 with tf.Graph().as_default(): ...add operations to the graph... sm = SessionManager() sess = sm.prepare_session(master, init_op, saver, checkpoint_dir) while True : sess.run(<my_train_op>) with tf.Graph().as_default(): ...add operations to the graph... sm = SessionManager() sess = sm.wait_for_session(master) while True : sess.run(<my_train_op>)
▷ tf.train.ClusterSpec
1 2 3 4 5 cluster = tf.train.ClusterSpec({"worker" : ["worker0.example.com:2222" , "worker1.example.com:2222" , "worker2.example.com:2222" ], "ps" : ["ps0.example.com:2222" , "ps1.example.com:2222" ]})
▷ tf.train.replica_device_setter
1 2 3 4 5 6 7 8 9 10 11 cluster_spec = { "ps" : ["ps0:2222" , "ps1:2222" ], "worker" : ["worker0:2222" , "worker1:2222" , "worker2:2222" ]} with tf.device(tf.replica_device_setter(cluster=cluster_spec)): v1 = tf.Variable(...) v2 = tf.Variable(...) v3 = tf.Variable(...)
我们可以在一个session中获取summary操作的输出，并将其传输到SummaryWriter以添加至一个事件记录文件中。
操作
描述
tf.scalar_summary(tags, values, collections=None, name=None)
输出一个标量值的summary协议buffer tag的shape需要与values的相同，用来做summaries的tags，为字符串
tf.image_summary(tag, tensor, max_images=3, collections=None, name=None)
输出一个图像tensor的summary协议buffer
tf.audio_summary(tag, tensor, sample_rate, max_outputs=3, collections=None, name=None)
输出一个音频tensor的summary协议buffer
tf.histogram_summary(tag, values, collections=None, name=None)
输出一个直方图的summary协议buffer
tf.nn.zero_fraction(value, name=None)
返回0在value中的小数比例
tf.merge_summary(inputs, collections=None, name=None)
合并summary
tf.merge_all_summaries(key=’summaries’)
合并在默认graph中手机的summaries
▶▶*将记录汇总写入文件中(Adding Summaries to Event Files)*
操作
描述
class tf.train.SummaryWriter
将summary协议buffer写入事件文件中
tf.train.SummaryWriter.init (logdir, graph=None, max_queue=10, flush_secs=120, graph_def=None)
创建一个SummaryWriter实例以及新建一个事件文件
tf.train.SummaryWriter.add_summary(summary, global_step=None)
将一个summary添加到事件文件中
tf.train.SummaryWriter.add_session_log(session_log, global_step=None)
添加SessionLog到一个事件文件中
tf.train.SummaryWriter.add_event(event)
添加一个事件到事件文件中
tf.train.SummaryWriter.add_graph(graph, global_step=None, graph_def=None)
添加一个Graph到时间文件中
tf.train.SummaryWriter.add_run_metadata(run_metadata, tag, global_step=None)
为一个单一的session.run()调用添加一个元数据信息
tf.train.SummaryWriter.flush()
刷新时间文件到硬盘中
tf.train.SummaryWriter.close()
将事件问价写入硬盘中并关闭该文件
tf.train.summary_iterator(path)
一个用于从时间文件中读取时间协议buffer的迭代器
▷ tf.train.SummaryWriter
1 2 3 4 5 ...create a graph... sess = tf.Session() writer = tf.train.SummaryWriter(<some-directory>, sess.graph)
▷ tf.train.summary_iterator
1 2 3 4 5 6 7 8 9 10 11 12 13 for e in tf.train.summary_iterator(path to events file): print (e) for e in tf.train.summary_iterator(path to events file): for v in e.summary.value: if v.tag == 'loss' : print (v.simple_value)1
操作
描述
tf.train.global_step(sess, global_step_tensor)
一个用于获取全局step的小辅助器
tf.train.write_graph(graph_def, logdir, name, as_text=True)
将一个graph proto写入一个文件中
#
:—
class tf.train.LooperThread
可重复地执行代码的线程
tf.train.LooperThread.init (coord, timer_interval_secs, target=None, args=None, kwargs=None)
创建一个LooperThread
tf.train.LooperThread.is_alive()
返回是否该线程是活跃的
tf.train.LooperThread.join(timeout=None)
等待线程结束
tf.train.LooperThread.loop(coord, timer_interval_secs, target, args=None, kwargs=None)
启动一个LooperThread，用于周期地调用某个函数 调用函数target(args)
tf.py_func(func, inp, Tout, stateful=True, name=None)
将python函数包装成tf中操作节点
▷ tf.train.global_step
1 2 3 4 5 6 7 8 9 global_step_tensor = tf.Variable(10 , trainable=False , name='global_step' ) sess = tf.Session() sess.run(global_step_tensor.initializer) print ('global_step: %s' % tf.train.global_step(sess, global_step_tensor)) global_step: 10
▷ tf.train.write_graph
1 2 3 v = tf.Variable(0 , name='my_variable' ) sess = tf.Session() tf.train.write_graph(sess.graph_def, '/tmp/my-model' , 'train.pbtxt' )
▷ tf.py_func
1 2 3 4 5 6 7 8 9 def my_func (x ): return np.sinh(x) inp = tf.placeholder(tf.float32, [...]) y = py_func(my_func, [inp], [tf.float32])
TensorFlow 提供了一个方便的继承unittest.TestCase类的方法，该类增加有关TensorFlow 测试的方法。如下例子：
1 2 3 4 5 6 7 8 9 10 11 12 13 import tensorflow as tf class SquareTest (tf.test.TestCase): def testSquare (self ): with self.test_session(): x = tf.square([2 , 3 ]) self.assertAllEqual(x.eval (), [4 , 9 ]) if __name__ == '__main__' : tf.test.main()
操作
描述
tf.test.main()
运行所有的单元测试
tf.test.assert_equal_graph_def(actual, expected)
断言 两个GraphDefs 是否几乎一样
tf.test.get_temp_dir()
返回测试期间使用的临时目录
tf.test.is_built_with_cuda()
返回是否Tensorflow支持CUDA(GPU)的build
可对比compute_gradient 和compute_gradient_error函数的用法
操作
描述
tf.test.compute_gradient(x, x_shape, y, y_shape, x_init_value=None, delta=0.001, init_targets=None)
计算并返回理论的和数值的Jacobian矩阵
tf.test.compute_gradient_error(x, x_shape, y, y_shape, x_init_value=None, delta=0.001, init_targets=None)
计算梯度的error。在计算所得的与数值估计的Jacobian中 为dy/dx计算最大的error
相关链接：
[1] 安装Tensorflow（Linux ubuntu） ubuntu下CUDA编译的GCC降级安装 ubuntu手动安装最新Nvidia显卡驱动 Tensorflow的CUDA升级，以及相关配置 基于gensim的Doc2Vec简析 TensorFlow的分布式学习框架简介 Tensorflow一些常用基本概念与函数（1） Tensorflow一些常用基本概念与函数（2) Tensorflow一些常用基本概念与函数（3）
