TensorFlow 基本操作

分手后的思念是犯贱 2022-06-12 23:21 246阅读 0赞

## 转自：http://blog.csdn.net/jerry81333/article/details/52931412 ##

# #

## 会话控制 Session： ##

TensorFlow中的Session主要用于执行命令，不管你前面做了什么，比如使用add()，mul()方法，相加也好，相乘也好，不执行Session().run()就不会执行相应的操作。

例子如下：

**\[python\]** [view plain][] [copy][view plain]

1.  **import** tensorflow as tf  
2.    
3.  matrix1 = tf.constant(\[\[3,3\]\]) \#创建一行两列矩阵  
4.  matrix2 = tf.constant(\[\[2\],\[2\]\]) \#创建两行一列矩阵  
5.    
6.  product = tf.matmul(matrix1,matrix2) \#矩阵乘法  
7.    
8.  \#方法1  
9.  sess = tf.Session()   
10. result = sess.run(product) \#启用Session().run()才算执行  
11. **print**(result)  
12. sess.close()  
13.   
14. \#方法2  
15. with tf.Session() as sess:  
16.     result2 = sess.run(product)  
17.     **print**(result2)

方法1是常规的Session使用方法，方法2中可以看出，Session还支持Python中的上下文管理协议with。

## 变量 Variable 常量 constant： ##

TensorFlow中创建变量，虽不需要指出变量类型，但是要在创建时表明这个是变量。变量创建方法Variable()，常量创建方法constant()。

例子如下：

**\[python\]** [view plain][] [copy][view plain]

1.  **import** tensorflow as tf  
2.    
3.  state = tf.Variable(0,name='counter') \#初始值0，名字counter  
4.  **print**(state.name)  
5.  one = tf.constant(1) \#常量  
6.    
7.  new\_value = tf.add(state, one)  
8.  update = tf.assign(state, new\_value) \#new\_value参数替换state  
9.    
10. init = tf.initialize\_all\_variables() \#初始化变量,变量才会起作用  
11.   
12. with tf.Session() as sess:  
13.     sess.run(init)  
14.     **for** i **in** range(3): \#循环执行sess.run()三次，累加三次  
15.         sess.run(update)  
16.         **print**(sess.run(state)) \#不能直接输出state，必须使用sess.run(state)

### 1、tensorflow的基本运作 ###

为了快速的熟悉TensorFlow编程，下面从一段简单的代码开始：

import tensorflow as tf #定义‘符号’变量，也称为占位符 a = tf.placeholder("float") b = tf.placeholder("float") y = tf.mul(a, b) #构造一个op节点 sess = tf.Session()#建立会话 #运行会话，输入数据，并计算节点，同时打印结果 print sess.run(y, feed_dict={a: 3, b: 3}) # 任务完成, 关闭会话. sess.close()

其中tf.mul(a, b)函数便是tf的一个基本的算数运算，接下来介绍跟多的相关函数。

### 2、tf函数 ###

TensorFlow 将图形定义转换成分布式执行的操作, 以充分利用可用的计算资源(如 CPU 或 GPU。一般你不需要显式指定使用 CPU 还是 GPU, TensorFlow 能自动检测。如果检测到 GPU, TensorFlow 会尽可能地利用找到的第一个 GPU 来执行操作.
    并行计算能让代价大的算法计算加速执行，TensorFlow也在实现上对复杂操作进行了有效的改进。大部分核相关的操作都是设备相关的实现，比如GPU。下面是一些重要的操作/核：

<table> 
 <thead> 
  <tr> 
   <th>操作组</th> 
   <th>操作</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#C0C0C0;">Maths</td> 
   <td style="border-color:#C0C0C0;">Add, Sub, Mul, Div, Exp, Log, Greater, Less, Equal</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">Array</td> 
   <td style="border-color:#C0C0C0;">Concat, Slice, Split, Constant, Rank, Shape, Shuffle</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">Matrix</td> 
   <td style="border-color:#C0C0C0;">MatMul, MatrixInverse, MatrixDeterminant</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">Neuronal Network</td> 
   <td style="border-color:#C0C0C0;">SoftMax, Sigmoid, ReLU, Convolution2D, MaxPool</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">Checkpointing</td> 
   <td style="border-color:#C0C0C0;">Save, Restore</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">Queues and syncronizations</td> 
   <td style="border-color:#C0C0C0;">Enqueue, Dequeue, MutexAcquire, MutexRelease</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">Flow control</td> 
   <td style="border-color:#C0C0C0;">Merge, Switch, Enter, Leave, NextIteration</td> 
  </tr> 
 </tbody> 
</table>

TensorFlow的算术操作如下：

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.add(x, y, name=None)</td> 
   <td style="border-color:#C0C0C0;">求和</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.sub(x, y, name=None)</td> 
   <td style="border-color:#C0C0C0;">减法</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.mul(x, y, name=None)</td> 
   <td style="border-color:#C0C0C0;">乘法</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.div(x, y, name=None)</td> 
   <td style="border-color:#C0C0C0;">除法</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.mod(x, y, name=None)</td> 
   <td style="border-color:#C0C0C0;">取模</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.abs(x, name=None)</td> 
   <td style="border-color:#C0C0C0;">求绝对值</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.neg(x, name=None)</td> 
   <td style="border-color:#C0C0C0;">取负 (y = -x).</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.sign(x, name=None)</td> 
   <td style="border-color:#C0C0C0;">返回符号 y = sign(x) = -1 if x &lt; 0; 0 if x == 0; 1 if x &gt; 0.</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.inv(x, name=None)</td> 
   <td style="border-color:#C0C0C0;">取反</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.square(x, name=None)</td> 
   <td style="border-color:#C0C0C0;">计算平方 (y = x * x = x^2).</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.round(x, name=None)</td> 
   <td style="border-color:#C0C0C0;">舍入最接近的整数<br> # ‘a’ is [0.9, 2.5, 2.3, -4.4]<br> tf.round(a) ==&gt; [ 1.0, 3.0, 2.0, -4.0 ]</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.sqrt(x, name=None)</td> 
   <td style="border-color:#C0C0C0;">开根号 (y = \sqrt{x} = x^{1/2}).</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.pow(x, y, name=None)</td> 
   <td style="border-color:#C0C0C0;">幂次方&nbsp;<br> # tensor ‘x’ is [[2, 2], [3, 3]]<br> # tensor ‘y’ is [[8, 16], [2, 3]]<br> tf.pow(x, y) ==&gt; [[256, 65536], [9, 27]]</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.exp(x, name=None)</td> 
   <td style="border-color:#C0C0C0;">计算e的次方</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.log(x, name=None)</td> 
   <td style="border-color:#C0C0C0;">计算log，一个输入计算e的ln，两输入以第二输入为底</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.maximum(x, y, name=None)</td> 
   <td style="border-color:#C0C0C0;">返回最大值 (x &gt; y ? x : y)</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.minimum(x, y, name=None)</td> 
   <td style="border-color:#C0C0C0;">返回最小值 (x &lt; y ? x : y)</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.cos(x, name=None)</td> 
   <td style="border-color:#C0C0C0;">三角函数cosine</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.sin(x, name=None)</td> 
   <td style="border-color:#C0C0C0;">三角函数sine</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.tan(x, name=None)</td> 
   <td style="border-color:#C0C0C0;">三角函数tan</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.atan(x, name=None)</td> 
   <td style="border-color:#C0C0C0;">三角函数ctan</td> 
  </tr> 
 </tbody> 
</table>

--------------------

张量操作Tensor Transformations

*  数据类型转换Casting

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.string_to_number<br> (string_tensor, out_type=None, name=None)</td> 
   <td style="border-color:#C0C0C0;">字符串转为数字</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.to_double(x, name=’ToDouble’)</td> 
   <td style="border-color:#C0C0C0;">转为64位浮点类型–float64</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.to_float(x, name=’ToFloat’)</td> 
   <td style="border-color:#C0C0C0;">转为32位浮点类型–float32</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.to_int32(x, name=’ToInt32’)</td> 
   <td style="border-color:#C0C0C0;">转为32位整型–int32</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.to_int64(x, name=’ToInt64’)</td> 
   <td style="border-color:#C0C0C0;">转为64位整型–int64</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.cast(x, dtype, name=None)</td> 
   <td style="border-color:#C0C0C0;">将x或者x.values转换为dtype<br> # tensor&nbsp;<code>a</code>&nbsp;is [1.8, 2.2], dtype=tf.float<br> tf.cast(a, tf.int32) ==&gt; [1, 2] # dtype=tf.int32</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">&nbsp;</td> 
   <td style="border-color:#C0C0C0;">&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

*  形状操作Shapes and Shaping

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.shape(input, name=None)</td> 
   <td style="border-color:#C0C0C0;">返回数据的shape<br> # ‘t’ is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]<br> shape(t) ==&gt; [2, 2, 3]</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.size(input, name=None)</td> 
   <td style="border-color:#C0C0C0;">返回数据的元素数量<br> # ‘t’ is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]]<br> size(t) ==&gt; 12</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.rank(input, name=None)</td> 
   <td style="border-color:#C0C0C0;">返回tensor的rank<br> 注意：此rank不同于矩阵的rank，<br> tensor的rank表示一个tensor需要的索引数目来唯一表示任何一个元素<br> 也就是通常所说的 “order”, “degree”或”ndims”<br> #’t’ is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]<br> # shape of tensor ‘t’ is [2, 2, 3]<br> rank(t) ==&gt; 3</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.reshape(tensor, shape, name=None)</td> 
   <td style="border-color:#C0C0C0;">改变tensor的形状<br> # tensor ‘t’ is [1, 2, 3, 4, 5, 6, 7, 8, 9]<br> # tensor ‘t’ has shape [9]<br> reshape(t, [3, 3]) ==&gt;&nbsp;<br> [[1, 2, 3],<br> [4, 5, 6],<br> [7, 8, 9]]<br> #如果shape有元素[-1],表示在该维度打平至一维<br> # -1 将自动推导得为 9:<br> reshape(t, [2, -1]) ==&gt;&nbsp;<br> [[1, 1, 1, 2, 2, 2, 3, 3, 3],<br> [4, 4, 4, 5, 5, 5, 6, 6, 6]]</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.expand_dims(input, dim, name=None)</td> 
   <td style="border-color:#C0C0C0;">插入维度1进入一个tensor中<br> #该操作要求-1-input.dims()<br> # ‘t’ is a tensor of shape [2]<br> shape(expand_dims(t, 0)) ==&gt; [1, 2]<br> shape(expand_dims(t, 1)) ==&gt; [2, 1]<br> shape(expand_dims(t, -1)) ==&gt; [2, 1] &lt;= dim &lt;= input.dims()</td> 
  </tr> 
 </tbody> 
</table>

*  切片与合并（Slicing and Joining）

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.slice(input_, begin, size, name=None)</td> 
   <td style="border-color:#C0C0C0;">对tensor进行切片操作<br> 其中size[i] = input.dim_size(i) - begin[i]<br> 该操作要求 0 &lt;= begin[i] &lt;= begin[i] + size[i] &lt;= Di for i in [0, n]<br> #’input’ is&nbsp;<br> #[[[1, 1, 1], [2, 2, 2]],[[3, 3, 3], [4, 4, 4]],[[5, 5, 5], [6, 6, 6]]]<br> tf.slice(input, [1, 0, 0], [1, 1, 3]) ==&gt; [[[3, 3, 3]]]<br> tf.slice(input, [1, 0, 0], [1, 2, 3]) ==&gt;&nbsp;<br> [[[3, 3, 3],<br> [4, 4, 4]]]<br> tf.slice(input, [1, 0, 0], [2, 1, 3]) ==&gt;&nbsp;<br> [[[3, 3, 3]],<br> [[5, 5, 5]]]</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.split(split_dim, num_split, value, name=’split’)</td> 
   <td style="border-color:#C0C0C0;">沿着某一维度将tensor分离为num_split tensors<br> # ‘value’ is a tensor with shape [5, 30]<br> # Split ‘value’ into 3 tensors along dimension 1<br> split0, split1, split2 = tf.split(1, 3, value)<br> tf.shape(split0) ==&gt; [5, 10]</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.concat(concat_dim, values, name=’concat’)</td> 
   <td style="border-color:#C0C0C0;">沿着某一维度连结tensor<br> t1 = [[1, 2, 3], [4, 5, 6]]<br> t2 = [[7, 8, 9], [10, 11, 12]]<br> tf.concat(0, [t1, t2]) ==&gt; [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]<br> tf.concat(1, [t1, t2]) ==&gt; [[1, 2, 3, 7, 8, 9], [4, 5, 6, 10, 11, 12]]<br> 如果想沿着tensor一新轴连结打包,那么可以：<br> tf.concat(axis, [tf.expand_dims(t, axis) for t in tensors])<br> 等同于tf.pack(tensors, axis=axis)</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.pack(values, axis=0, name=’pack’)</td> 
   <td style="border-color:#C0C0C0;">将一系列rank-R的tensor打包为一个rank-(R+1)的tensor<br> # ‘x’ is [1, 4], ‘y’ is [2, 5], ‘z’ is [3, 6]<br> pack([x, y, z]) =&gt; [[1, 4], [2, 5], [3, 6]]&nbsp;<br> # 沿着第一维pack<br> pack([x, y, z], axis=1) =&gt; [[1, 2, 3], [4, 5, 6]]<br> 等价于tf.pack([x, y, z]) = np.asarray([x, y, z])</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.reverse(tensor, dims, name=None)</td> 
   <td style="border-color:#C0C0C0;">沿着某维度进行序列反转<br> 其中dim为列表，元素为bool型，size等于rank(tensor)<br> # tensor ‘t’ is&nbsp;<br> [[[[ 0, 1, 2, 3],<br> #[ 4, 5, 6, 7],<br><br> #[ 8, 9, 10, 11]],<br> #[[12, 13, 14, 15],<br> #[16, 17, 18, 19],<br> #[20, 21, 22, 23]]]]<br> # tensor ‘t’ shape is [1, 2, 3, 4]<br> # ‘dims’ is [False, False, False, True]<br> reverse(t, dims) ==&gt;<br> [[[[ 3, 2, 1, 0],<br> [ 7, 6, 5, 4],<br> [ 11, 10, 9, 8]],<br> [[15, 14, 13, 12],<br> [19, 18, 17, 16],<br> [23, 22, 21, 20]]]]</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.transpose(a, perm=None, name=’transpose’)</td> 
   <td style="border-color:#C0C0C0;">调换tensor的维度顺序<br> 按照列表perm的维度排列调换tensor顺序，<br> 如为定义，则perm为(n-1…0)<br> # ‘x’ is [[1 2 3],[4 5 6]]<br> tf.transpose(x) ==&gt; [[1 4], [2 5],[3 6]]<br> # Equivalently<br> tf.transpose(x, perm=[1, 0]) ==&gt; [[1 4],[2 5], [3 6]]</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.gather(params, indices, validate_indices=None, name=None)</td> 
   <td style="border-color:#C0C0C0;">合并索引indices所指示params中的切片<br><img alt="tf.gather" src="https://img-blog.csdn.net/20160808174705034"></td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.one_hot<br> (indices, depth, on_value=None, off_value=None,&nbsp;<br> axis=None, dtype=None, name=None)</td> 
   <td style="border-color:#C0C0C0;">indices = [0, 2, -1, 1]<br> depth = 3<br> on_value = 5.0&nbsp;<br> off_value = 0.0&nbsp;<br> axis = -1&nbsp;<br> #Then output is [4 x 3]:&nbsp;<br> output =&nbsp;<br> [5.0 0.0 0.0] // one_hot(0)&nbsp;<br> [0.0 0.0 5.0] // one_hot(2)&nbsp;<br> [0.0 0.0 0.0] // one_hot(-1)&nbsp;<br> [0.0 5.0 0.0] // one_hot(1)</td> 
  </tr> 
 </tbody> 
</table>

--------------------

矩阵相关运算

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.diag(diagonal, name=None)</td> 
   <td style="border-color:#C0C0C0;">返回一个给定对角值的对角tensor<br> # ‘diagonal’ is [1, 2, 3, 4]<br> tf.diag(diagonal) ==&gt;&nbsp;<br> [[1, 0, 0, 0]<br> [0, 2, 0, 0]<br> [0, 0, 3, 0]<br> [0, 0, 0, 4]]</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.diag_part(input, name=None)</td> 
   <td style="border-color:#C0C0C0;">功能与上面相反</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.trace(x, name=None)</td> 
   <td style="border-color:#C0C0C0;">求一个2维tensor足迹，即对角值diagonal之和</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.transpose(a, perm=None, name=’transpose’)</td> 
   <td style="border-color:#C0C0C0;">调换tensor的维度顺序<br> 按照列表perm的维度排列调换tensor顺序，<br> 如为定义，则perm为(n-1…0)<br> # ‘x’ is [[1 2 3],[4 5 6]]<br> tf.transpose(x) ==&gt; [[1 4], [2 5],[3 6]]<br> # Equivalently<br> tf.transpose(x, perm=[1, 0]) ==&gt; [[1 4],[2 5], [3 6]]</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.matmul(a, b, transpose_a=False,&nbsp;<br> transpose_b=False, a_is_sparse=False,&nbsp;<br> b_is_sparse=False, name=None)</td> 
   <td style="border-color:#C0C0C0;">矩阵相乘</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.matrix_determinant(input, name=None)</td> 
   <td style="border-color:#C0C0C0;">返回方阵的行列式</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.matrix_inverse(input, adjoint=None, name=None)</td> 
   <td style="border-color:#C0C0C0;">求方阵的逆矩阵，adjoint为True时，计算输入共轭矩阵的逆矩阵</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.cholesky(input, name=None)</td> 
   <td style="border-color:#C0C0C0;">对输入方阵cholesky分解，<br> 即把一个对称正定的矩阵表示成一个下三角矩阵L和其转置的乘积的分解A=LL^T</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.matrix_solve(matrix, rhs, adjoint=None, name=None)</td> 
   <td style="border-color:#C0C0C0;">求解tf.matrix_solve(matrix, rhs, adjoint=None, name=None)<br> matrix为方阵shape为[M,M],rhs的shape为[M,K]，output为[M,K]</td> 
  </tr> 
 </tbody> 
</table>

--------------------

复数操作

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.complex(real, imag, name=None)</td> 
   <td style="border-color:#C0C0C0;">将两实数转换为复数形式<br> # tensor ‘real’ is [2.25, 3.25]<br> # tensor&nbsp;<code>imag</code>&nbsp;is [4.75, 5.75]<br> tf.complex(real, imag) ==&gt; [[2.25 + 4.75j], [3.25 + 5.75j]]</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.complex_abs(x, name=None)</td> 
   <td style="border-color:#C0C0C0;">计算复数的绝对值，即长度。<br> # tensor ‘x’ is [[-2.25 + 4.75j], [-3.25 + 5.75j]]<br> tf.complex_abs(x) ==&gt; [5.25594902, 6.60492229]</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.conj(input, name=None)</td> 
   <td style="border-color:#C0C0C0;">计算共轭复数</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.imag(input, name=None)<br> tf.real(input, name=None)</td> 
   <td style="border-color:#C0C0C0;">提取复数的虚部和实部</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.fft(input, name=None)</td> 
   <td style="border-color:#C0C0C0;">计算一维的离散傅里叶变换，输入数据类型为complex64</td> 
  </tr> 
 </tbody> 
</table>

--------------------

归约计算(Reduction)

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.reduce_sum(input_tensor, reduction_indices=None,&nbsp;<br> keep_dims=False, name=None)</td> 
   <td style="border-color:#C0C0C0;">计算输入tensor元素的和，或者安照reduction_indices指定的轴进行求和<br> # ‘x’ is [[1, 1, 1]<br> # [1, 1, 1]]<br> tf.reduce_sum(x) ==&gt; 6<br> tf.reduce_sum(x, 0) ==&gt; [2, 2, 2]<br> tf.reduce_sum(x, 1) ==&gt; [3, 3]<br> tf.reduce_sum(x, 1, keep_dims=True) ==&gt; [[3], [3]]<br> tf.reduce_sum(x, [0, 1]) ==&gt; 6</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.reduce_prod(input_tensor,&nbsp;<br> reduction_indices=None,&nbsp;<br> keep_dims=False, name=None)</td> 
   <td style="border-color:#C0C0C0;">计算输入tensor元素的乘积，或者安照reduction_indices指定的轴进行求乘积</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.reduce_min(input_tensor,&nbsp;<br> reduction_indices=None,&nbsp;<br> keep_dims=False, name=None)</td> 
   <td style="border-color:#C0C0C0;">求tensor中最小值</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.reduce_max(input_tensor,&nbsp;<br> reduction_indices=None,&nbsp;<br> keep_dims=False, name=None)</td> 
   <td style="border-color:#C0C0C0;">求tensor中最大值</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.reduce_mean(input_tensor,&nbsp;<br> reduction_indices=None,&nbsp;<br> keep_dims=False, name=None)</td> 
   <td style="border-color:#C0C0C0;">求tensor中平均值</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.reduce_all(input_tensor,&nbsp;<br> reduction_indices=None,&nbsp;<br> keep_dims=False, name=None)</td> 
   <td style="border-color:#C0C0C0;">对tensor中各个元素求逻辑’与’<br> # ‘x’ is&nbsp;<br> # [[True, True]<br> # [False, False]]<br> tf.reduce_all(x) ==&gt; False<br> tf.reduce_all(x, 0) ==&gt; [False, False]<br> tf.reduce_all(x, 1) ==&gt; [True, False]</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.reduce_any(input_tensor,&nbsp;<br> reduction_indices=None,&nbsp;<br> keep_dims=False, name=None)</td> 
   <td style="border-color:#C0C0C0;">对tensor中各个元素求逻辑’或’</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.accumulate_n(inputs, shape=None,&nbsp;<br> tensor_dtype=None, name=None)</td> 
   <td style="border-color:#C0C0C0;">计算一系列tensor的和<br> # tensor ‘a’ is [[1, 2], [3, 4]]<br> # tensor&nbsp;<code>b</code>&nbsp;is [[5, 0], [0, 6]]<br> tf.accumulate_n([a, b, a]) ==&gt; [[7, 4], [6, 14]]</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.cumsum(x, axis=0, exclusive=False,&nbsp;<br> reverse=False, name=None)</td> 
   <td style="border-color:#C0C0C0;">求累积和<br> tf.cumsum([a, b, c]) ==&gt; [a, a + b, a + b + c]<br> tf.cumsum([a, b, c], exclusive=True) ==&gt; [0, a, a + b]<br> tf.cumsum([a, b, c], reverse=True) ==&gt; [a + b + c, b + c, c]<br> tf.cumsum([a, b, c], exclusive=True, reverse=True) ==&gt; [b + c, c, 0]</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">&nbsp;</td> 
   <td style="border-color:#C0C0C0;">&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

--------------------

分割(Segmentation)

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.segment_sum(data, segment_ids, name=None)</td> 
   <td style="border-color:#C0C0C0;">根据segment_ids的分段计算各个片段的和<br> 其中segment_ids为一个size与data第一维相同的tensor<br> 其中id为int型数据，最大id不大于size<br> c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])<br> tf.segment_sum(c, tf.constant([0, 0, 1]))<br> ==&gt;[[0 0 0 0]&nbsp;<br> [5 6 7 8]]<br> 上面例子分为[0,1]两id,对相同id的data相应数据进行求和,<br> 并放入结果的相应id中，<br> 且segment_ids只升不降</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.segment_prod(data, segment_ids, name=None)</td> 
   <td style="border-color:#C0C0C0;">根据segment_ids的分段计算各个片段的积</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.segment_min(data, segment_ids, name=None)</td> 
   <td style="border-color:#C0C0C0;">根据segment_ids的分段计算各个片段的最小值</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.segment_max(data, segment_ids, name=None)</td> 
   <td style="border-color:#C0C0C0;">根据segment_ids的分段计算各个片段的最大值</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.segment_mean(data, segment_ids, name=None)</td> 
   <td style="border-color:#C0C0C0;">根据segment_ids的分段计算各个片段的平均值</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.unsorted_segment_sum(data, segment_ids,<br> num_segments, name=None)</td> 
   <td style="border-color:#C0C0C0;">与tf.segment_sum函数类似，<br> 不同在于segment_ids中id顺序可以是无序的</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.sparse_segment_sum(data, indices,&nbsp;<br> segment_ids, name=None)</td> 
   <td style="border-color:#C0C0C0;">输入进行稀疏分割求和<br> c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])<br> # Select two rows, one segment.<br> tf.sparse_segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))&nbsp;<br> ==&gt; [[0 0 0 0]]<br> 对原data的indices为[0,1]位置的进行分割，<br> 并按照segment_ids的分组进行求和</td> 
  </tr> 
 </tbody> 
</table>

--------------------

序列比较与索引提取(Sequence Comparison and Indexing)

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.argmin(input, dimension, name=None)</td> 
   <td style="border-color:#C0C0C0;">返回input最小值的索引index</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.argmax(input, dimension, name=None)</td> 
   <td style="border-color:#C0C0C0;">返回input最大值的索引index</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.listdiff(x, y, name=None)</td> 
   <td style="border-color:#C0C0C0;">返回x，y中不同值的索引</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.where(input, name=None)</td> 
   <td style="border-color:#C0C0C0;">返回bool型tensor中为True的位置<br> # ‘input’ tensor is&nbsp;<br> #[[True, False]<br> #[True, False]]<br> # ‘input’ 有两个’True’,那么输出两个坐标值.<br> # ‘input’的rank为2, 所以每个坐标为具有两个维度.<br> where(input) ==&gt;<br> [[0, 0],<br> [1, 0]]</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.unique(x, name=None)</td> 
   <td style="border-color:#C0C0C0;">返回一个元组tuple(y,idx)，y为x的列表的唯一化数据列表，<br> idx为x数据对应y元素的index<br> # tensor ‘x’ is [1, 1, 2, 4, 4, 4, 7, 8, 8]<br> y, idx = unique(x)<br> y ==&gt; [1, 2, 4, 7, 8]<br> idx ==&gt; [0, 0, 1, 2, 2, 2, 3, 4, 4]</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.invert_permutation(x, name=None)</td> 
   <td style="border-color:#C0C0C0;">置换x数据与索引的关系<br> # tensor&nbsp;<code>x</code>&nbsp;is [3, 4, 0, 2, 1]<br> invert_permutation(x) ==&gt; [2, 4, 3, 0, 1]</td> 
  </tr> 
 </tbody> 
</table>

--------------------

神经网络(Neural Network)

*  激活函数（Activation Functions）

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.relu(features, name=None)</td> 
   <td style="border-color:#C0C0C0;">整流函数：max(features, 0)</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.relu6(features, name=None)</td> 
   <td style="border-color:#C0C0C0;">以6为阈值的整流函数：min(max(features, 0), 6)</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.elu(features, name=None)</td> 
   <td style="border-color:#C0C0C0;">elu函数，exp(features) - 1 if &lt; 0,否则features<br><a href="http://arxiv.org/abs/1511.07289" rel="nofollow">Exponential Linear Units (ELUs)</a></td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.softplus(features, name=None)</td> 
   <td style="border-color:#C0C0C0;">计算softplus：log(exp(features) + 1)</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.dropout(x, keep_prob,&nbsp;<br> noise_shape=None, seed=None, name=None)</td> 
   <td style="border-color:#C0C0C0;">计算dropout，keep_prob为keep概率<br> noise_shape为噪声的shape</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.bias_add(value, bias, data_format=None, name=None)</td> 
   <td style="border-color:#C0C0C0;">对value加一偏置量<br> 此函数为tf.add的特殊情况，bias仅为一维，<br> 函数通过广播机制进行与value求和,<br> 数据格式可以与value不同，返回为与value相同格式</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.sigmoid(x, name=None)</td> 
   <td style="border-color:#C0C0C0;">y = 1 / (1 + exp(-x))</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.tanh(x, name=None)</td> 
   <td style="border-color:#C0C0C0;">双曲线切线激活函数</td> 
  </tr> 
 </tbody> 
</table>

*  卷积函数（Convolution）

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.conv2d(input, filter, strides, padding,&nbsp;<br> use_cudnn_on_gpu=None, data_format=None, name=None)</td> 
   <td style="border-color:#C0C0C0;">在给定的4D input与 filter下计算2D卷积<br> 输入shape为 [batch, height, width, in_channels]</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.conv3d(input, filter, strides, padding, name=None)</td> 
   <td style="border-color:#C0C0C0;">在给定的5D input与 filter下计算3D卷积<br> 输入shape为[batch, in_depth, in_height, in_width, in_channels]</td> 
  </tr> 
 </tbody> 
</table>

*  池化函数（Pooling）

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.avg_pool(value, ksize, strides, padding,&nbsp;<br> data_format=’NHWC’, name=None)</td> 
   <td style="border-color:#C0C0C0;">平均方式池化</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.max_pool(value, ksize, strides, padding,&nbsp;<br> data_format=’NHWC’, name=None)</td> 
   <td style="border-color:#C0C0C0;">最大值方法池化</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.max_pool_with_argmax(input, ksize, strides,<br> padding, Targmax=None, name=None)</td> 
   <td style="border-color:#C0C0C0;">返回一个二维元组(output,argmax),最大值pooling，返回最大值及其相应的索引</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.avg_pool3d(input, ksize, strides,&nbsp;<br> padding, name=None)</td> 
   <td style="border-color:#C0C0C0;">3D平均值pooling</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.max_pool3d(input, ksize, strides,&nbsp;<br> padding, name=None)</td> 
   <td style="border-color:#C0C0C0;">3D最大值pooling</td> 
  </tr> 
 </tbody> 
</table>

*  数据标准化（Normalization）

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.l2_normalize(x, dim, epsilon=1e-12, name=None)</td> 
   <td style="border-color:#C0C0C0;">对维度dim进行L2范式标准化<br> output = x / sqrt(max(sum(x**2), epsilon))</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.sufficient_statistics(x, axes, shift=None,&nbsp;<br> keep_dims=False, name=None)</td> 
   <td style="border-color:#C0C0C0;">计算与均值和方差有关的完全统计量<br> 返回4维元组,*元素个数，*元素总和，*元素的平方和，*shift结果<br><a href="https://www.google.com/url?q=https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Computing_shifted_data&amp;usg=AFQjCNG5RoY7Xvpv4xg-Wy-UJvAPh2zDQw" rel="nofollow">参见算法介绍</a></td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.normalize_moments(counts, mean_ss, variance_ss, shift, name=None)</td> 
   <td style="border-color:#C0C0C0;">基于完全统计量计算均值和方差</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.moments(x, axes, shift=None,&nbsp;<br> name=None, keep_dims=False)</td> 
   <td style="border-color:#C0C0C0;">直接计算均值与方差</td> 
  </tr> 
 </tbody> 
</table>

*  损失函数（Losses）

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.l2_loss(t, name=None)</td> 
   <td style="border-color:#C0C0C0;">output = sum(t ** 2) / 2</td> 
  </tr> 
 </tbody> 
</table>

*  分类函数（Classification）

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.sigmoid_cross_entropy_with_logits<br> (logits, targets, name=None)*</td> 
   <td style="border-color:#C0C0C0;">计算输入logits, targets的交叉熵</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.softmax(logits, name=None)</td> 
   <td style="border-color:#C0C0C0;">计算softmax<br> softmax[i, j] = exp(logits[i, j]) / sum_j(exp(logits[i, j]))</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.log_softmax(logits, name=None)</td> 
   <td style="border-color:#C0C0C0;">logsoftmax[i, j] = logits[i, j] - log(sum(exp(logits[i])))</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.softmax_cross_entropy_with_logits<br> (logits, labels, name=None)</td> 
   <td style="border-color:#C0C0C0;">计算logits和labels的softmax交叉熵<br> logits, labels必须为相同的shape与数据类型</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.sparse_softmax_cross_entropy_with_logits<br> (logits, labels, name=None)</td> 
   <td style="border-color:#C0C0C0;">计算logits和labels的softmax交叉熵</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.weighted_cross_entropy_with_logits<br> (logits, targets, pos_weight, name=None)</td> 
   <td style="border-color:#C0C0C0;">与sigmoid_cross_entropy_with_logits()相似，<br> 但给正向样本损失加了权重pos_weight</td> 
  </tr> 
 </tbody> 
</table>

*  符号嵌入（Embeddings）

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.embedding_lookup<br> (params, ids, partition_strategy=’mod’,&nbsp;<br> name=None, validate_indices=True)</td> 
   <td style="border-color:#C0C0C0;">根据索引ids查询embedding列表params中的tensor值<br> 如果len(params) &gt; 1，id将会安照partition_strategy策略进行分割<br> 1、如果partition_strategy为”mod”，<br> id所分配到的位置为p = id % len(params)<br> 比如有13个ids，分为5个位置，那么分配方案为：<br> [[0, 5, 10], [1, 6, 11], [2, 7, 12], [3, 8], [4, 9]]<br> 2、如果partition_strategy为”div”,那么分配方案为：<br> [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10], [11, 12]]</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.embedding_lookup_sparse(params,&nbsp;<br> sp_ids, sp_weights, partition_strategy=’mod’,&nbsp;<br> name=None, combiner=’mean’)</td> 
   <td style="border-color:#C0C0C0;">对给定的ids和权重查询embedding<br> 1、sp_ids为一个N x M的稀疏tensor，<br> N为batch大小，M为任意，数据类型int64<br> 2、sp_weights的shape与sp_ids的稀疏tensor权重，<br> 浮点类型，若为None，则权重为全’1’</td> 
  </tr> 
 </tbody> 
</table>

*  循环神经网络（Recurrent Neural Networks）

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.rnn(cell, inputs, initial_state=None, dtype=None,&nbsp;<br> sequence_length=None, scope=None)</td> 
   <td style="border-color:#C0C0C0;">基于RNNCell类的实例cell建立循环神经网络</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.dynamic_rnn(cell, inputs, sequence_length=None,&nbsp;<br> initial_state=None, dtype=None, parallel_iterations=None,&nbsp;<br> swap_memory=False, time_major=False, scope=None)</td> 
   <td style="border-color:#C0C0C0;">基于RNNCell类的实例cell建立动态循环神经网络<br> 与一般rnn不同的是，该函数会根据输入动态展开<br> 返回(outputs,state)</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.state_saving_rnn(cell, inputs, state_saver, state_name,&nbsp;<br> sequence_length=None, scope=None)</td> 
   <td style="border-color:#C0C0C0;">可储存调试状态的RNN网络</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.bidirectional_rnn(cell_fw, cell_bw, inputs,&nbsp;<br> initial_state_fw=None, initial_state_bw=None, dtype=None,<br> sequence_length=None, scope=None)</td> 
   <td style="border-color:#C0C0C0;">双向RNN, 返回一个3元组tuple<br> (outputs, output_state_fw, output_state_bw)</td> 
  </tr> 
 </tbody> 
</table>

> --------------------

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

*  求值网络（Evaluation）

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.top_k(input, k=1, sorted=True, name=None)</td> 
   <td style="border-color:#C0C0C0;">返回前k大的值及其对应的索引</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.in_top_k(predictions, targets, k, name=None)</td> 
   <td style="border-color:#C0C0C0;">返回判断是否targets索引的predictions相应的值<br> 是否在在predictions前k个位置中，<br> 返回数据类型为bool类型，len与predictions同</td> 
  </tr> 
 </tbody> 
</table>

*  [监督候选采样网络（Candidate Sampling）][Candidate Sampling]

对于有巨大量的多分类与多标签模型，如果使用全连接softmax将会占用大量的时间与空间资源，所以采用候选采样方法仅使用一小部分类别与标签作为监督以加速训练。

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#C0C0C0;"><strong><em>Sampled Loss Functions</em></strong></td> 
   <td style="border-color:#C0C0C0;">&nbsp;</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.nce_loss(weights, biases, inputs, labels, num_sampled,<br> num_classes, num_true=1, sampled_values=None,<br> remove_accidental_hits=False, partition_strategy=’mod’,<br> name=’nce_loss’)</td> 
   <td style="border-color:#C0C0C0;">返回noise-contrastive的训练损失结果</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.sampled_softmax_loss(weights, biases, inputs, labels,&nbsp;<br> num_sampled, num_classes, num_true=1, sampled_values=None,<br> remove_accidental_hits=True, partition_strategy=’mod’,&nbsp;<br> name=’sampled_softmax_loss’)</td> 
   <td style="border-color:#C0C0C0;">返回sampled softmax的训练损失<br><a href="http://arxiv.org/pdf/1412.2007.pdf" rel="nofollow">参考- Jean et al., 2014第3部分</a></td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;"><strong><em>Candidate Samplers</em></strong></td> 
   <td style="border-color:#C0C0C0;">&nbsp;</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.uniform_candidate_sampler(true_classes, num_true,&nbsp;<br> num_sampled, unique, range_max, seed=None, name=None)</td> 
   <td style="border-color:#C0C0C0;">通过均匀分布的采样集合<br> 返回三元tuple<br> 1、sampled_candidates 候选集合。<br> 2、期望的true_classes个数，为浮点值<br> 3、期望的sampled_candidates个数，为浮点值</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.log_uniform_candidate_sampler(true_classes, num_true,<br> num_sampled, unique, range_max, seed=None, name=None)</td> 
   <td style="border-color:#C0C0C0;">通过log均匀分布的采样集合，返回三元tuple</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.learned_unigram_candidate_sampler<br> (true_classes, num_true, num_sampled, unique,&nbsp;<br> range_max, seed=None, name=None)</td> 
   <td style="border-color:#C0C0C0;">根据在训练过程中学习到的分布状况进行采样<br> 返回三元tuple</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.nn.fixed_unigram_candidate_sampler(true_classes, num_true,<br> num_sampled, unique, range_max, vocab_file=”,&nbsp;<br> distortion=1.0, num_reserved_ids=0, num_shards=1,&nbsp;<br> shard=0, unigrams=(), seed=None, name=None)</td> 
   <td style="border-color:#C0C0C0;">基于所提供的基本分布进行采样</td> 
  </tr> 
 </tbody> 
</table>

# 保存与恢复变量 #

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#C0C0C0;">类tf.train.Saver(Saving and Restoring Variables)</td> 
   <td style="border-color:#C0C0C0;">&nbsp;</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.train.Saver.__init__(var_list=None, reshape=False,&nbsp;<br> sharded=False, max_to_keep=5,&nbsp;<br> keep_checkpoint_every_n_hours=10000.0,&nbsp;<br> name=None, restore_sequentially=False,<br> saver_def=None, builder=None)</td> 
   <td style="border-color:#C0C0C0;">创建一个存储器Saver<br> var_list定义需要存储和恢复的变量</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.train.Saver.save(sess, save_path, global_step=None,&nbsp;<br> latest_filename=None, meta_graph_suffix=’meta’,<br> write_meta_graph=True)</td> 
   <td style="border-color:#C0C0C0;">保存变量</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.train.Saver.restore(sess, save_path)</td> 
   <td style="border-color:#C0C0C0;">恢复变量</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.train.Saver.last_checkpoints</td> 
   <td style="border-color:#C0C0C0;">列出最近未删除的checkpoint 文件名</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.train.Saver.set_last_checkpoints(last_checkpoints)</td> 
   <td style="border-color:#C0C0C0;">设置checkpoint文件名列表</td> 
  </tr> 
  <tr> 
   <td style="border-color:#C0C0C0;">tf.train.Saver.set_last_checkpoints_with_time(last_checkpoints_with_time)</td> 
   <td style="border-color:#C0C0C0;">设置checkpoint文件名列表和时间戳</td> 
  </tr> 
 </tbody> 
</table>

--------------------

**相关链接：**

\[1\] 安装Tensorflow（[Linux][] ubuntu） [http://blog.csdn.net/lenbow/article/details/51203526][http_blog.csdn.net_lenbow_article_details_51203526]   
\[2\] ubuntu下CUDA编译的GCC降级安装 [http://blog.csdn.net/lenbow/article/details/51596706][http_blog.csdn.net_lenbow_article_details_51596706]   
\[3\] ubuntu手动安装最新Nvidia显卡驱动 [http://blog.csdn.net/lenbow/article/details/51683783][http_blog.csdn.net_lenbow_article_details_51683783]   
\[4\] Tensorflow的CUDA升级，以及相关配置 [http://blog.csdn.net/lenbow/article/details/52118116][http_blog.csdn.net_lenbow_article_details_52118116]   
\[5\] 基于gensim的Doc2Vec简析 [http://blog.csdn.net/lenbow/article/details/52120230][http_blog.csdn.net_lenbow_article_details_52120230]   
\[6\] TensorFlow的分布式学习框架简介 [http://blog.csdn.net/lenbow/article/details/52130565][http_blog.csdn.net_lenbow_article_details_52130565]

转载来自：http://blog.csdn.net/lenbow/article/details/52152766

## 传入值 placeholder： ##

可以从外界传入数值的方法，用placeholder保留一个数据的位置，之后可以在Session().run()的时候进行赋值。

例子如下：

**\[python\]** [view plain][] [copy][view plain]

1.  **import** tensorflow as tf  
2.    
3.  \#placeholder类似input  
4.  input1 = tf.placeholder(tf.float32) \#需要保证placeholer的类型  
5.  input2 = tf.placeholder(tf.float32)  
6.    
7.  output = tf.mul(input1,input2) \#乘法运算  
8.    
9.  with tf.Session() as sess:  
10.     **print**(sess.run(output,feed\_dict=\{input1:\[7.\],input2:p\[2.\]\})) \#以feed\_dict形式传入数值

[view plain]: http://blog.csdn.net/jerry81333/article/details/52931412#
[Candidate Sampling]: https://www.tensorflow.org/versions/r0.10/extras/candidate_sampling.pdf
[Linux]: http://lib.csdn.net/base/linux
[http_blog.csdn.net_lenbow_article_details_51203526]: http://blog.csdn.net/lenbow/article/details/51203526
[http_blog.csdn.net_lenbow_article_details_51596706]: http://blog.csdn.net/lenbow/article/details/51596706
[http_blog.csdn.net_lenbow_article_details_51683783]: http://blog.csdn.net/lenbow/article/details/51683783
[http_blog.csdn.net_lenbow_article_details_52118116]: http://blog.csdn.net/lenbow/article/details/52118116
[http_blog.csdn.net_lenbow_article_details_52120230]: http://blog.csdn.net/lenbow/article/details/52120230
[http_blog.csdn.net_lenbow_article_details_52130565]: http://blog.csdn.net/lenbow/article/details/52130565