tensorflow API学习笔记

https://www.w3cschool.cn/tensorflow_python/ （tf基本api学习）
https://www.jianshu.com/p/fec63783ae5c （tf常用api排行榜）

tf基本算术运算符api：
tf.add、tf.subtract、tf.multiply、tf.scalar_mul、tf.div、tf.divide、tf.truediv、tf.floordiv、tf.realdiv、tf.truncatediv、tf.floor_div、tf.truncatemod、tf.floormod或tf.mod、tf.cross等；

tf其他数学函数api：
tf.add_n、tf.abs、tf.negative、tf.sign、tf.reciprocal、tf.square、tf.round、tf.sqrt、tf.rsqrt、tf.pow、tf.exp、tf.expm1、tf.log、tf.log1p、tf.ceil、tf.floor、tf.maximum、tf.minimum、tf.cos、tf.sin、tf.lbeta、tf.tan、tf.acos、tf.asin、tf.atan、tf.cosh、tf.sinh、tf.asinh、tf.acosh、tf.atanh、tf.lgamma、tf.digamma、tf.erf、tf.squared_difference、tf.igamma、tf.igammac、tf.zeta、tf.polygamma、tf.betainc、tf.rint、tf.greater等；

tf.add、tf.add_n、tf.nn.bias_adds三者的区别
tf.add是两个参数；
tf.add_n只有一个参数，是一个张量或list（tf.add_n([input1, input2])等价于input1 + input2）
tf.nn.bias_add是tf.add的一个特例；（见后面tf.nn部分）
https://blog.csdn.net/mieleizhi0522/article/details/80416668
https://www.jianshu.com/p/018c0d5c26ff

tf矩阵数学函数api：
tf.diag、tf.diag_part、tf.trace、tf.transpose、tf.eye、tf.matrix_diag、tf.matrix_diag_part、tf.matrix_band_part、tf.matrix_set_diag、tf.matmul、tf.matrix_transpose、tf.norm、tf.matrix_determinant、tf.matrix_inverse、tf.cholesky、tf.cholesky_solve、tf.matrix_solve、tf.matrix_triangular_solve、tf.matrix_solve_ls、tf.qr、tf.self_adjoint_eig、tf.self_adjoint_eigvals、tf.svd等；

tf复数函数api：
tf.complex、tf.conj、tf.imag、tf.angle、tf.real等；

tf减少张量维度的api（即Reduction）：
tf.reduce_sum、tf.reduce_prod、tf.reduce_min、tf.reduce_max、tf.reduce_mean、tf.reduce_all、tf.reduce_any、tf.reduce_logsumexp、tf.count_nonzero、tf.accumulate_n、tf.einsum等；

tf.reduce_sum是压缩求和，用于降维，例如：
x=tf.constant([[1,1,1],[1,1,1]])
sess=tf.Session()
print(sess.run(tf.reduce_sum(x)))#6
print(sess.run(tf.reduce_sum(x,0)))#[2 2 2]
print(sess.run(tf.reduce_sum(x,1)))#[3 3]
print(sess.run(tf.reduce_sum(x,1,keep_dims=True)))#[[3] [3]]
print(sess.run(tf.reduce_sum(x,[0,1])))#6

tf.reduce_prod是压缩累积，和tf.reduce_sum类似，把加改为乘；

tf.reduce_min是压缩求最小值，和tf.reduce_sum类似，把加改为求最小；

tf.reduce_max是压缩求最大值，和tf.reduce_sum类似，把加改为求最大；

tf.reduce_mean是压缩求平均值，和tf.reduce_sum类似，把加改为求均值；
（reduction_indices参数用于控制reduce的轴，可以是reduction_indices=[1]或[0]，若不写，将得到唯一的值；）
（loss = tf.reduce_mean(tf.square(y_target - model_output))代表MSE代价；）

tf.reduce_all是压缩求逻辑与，需要把变量改为x = tf.constant([[True, True], [False, False]])

tf.reduce_any是压缩求逻辑或，和tf.reduce_all类似；

tf.reduce_logsumexp是计算log(sum(exp(elements across dimensions of a tensor))).

tf.count_nonzero是计算各维度非零元素的个数；

tf.accumulate_n和tf.add_n类似，也是求和；
x = tf.constant([[1,2],[3,4]])
y = tf.constant([[1,2],[3,4]])
result = tf.accumulate_n([x,y])#[[2 4] [6 8]]

tf.einsum可以求外积、点积、转置，分别代替tf.multiply、tf.matmul、tf.transpose；
分别是tf.einsum(‘ij,ij->ij’, x, y)、tf.einsum(‘ij,jk->ik’, x, z)、tf.einsum(‘ij->ji’, x)
https://blog.csdn.net/u013841196/article/details/81140835
https://blog.csdn.net/qq_35203425/article/details/81560118

tf张量分割api：
tf.segment_sum、tf.segment_prod、tf.segment_min、tf.segment_max、tf.segment_mean、tf.unsorted_segment_sum、tf.sparse_segment_sum、tf.sparse_segment_mean、tf.sparse_segment_sqrt_n等；

用法如c = tf.constant([1,2,3,4])、print(sess.run(tf.segment_sum(c, tf.constant([0, 0, 1, 1]))))得到[3 7]

tf序列比较和索引api：
tf.argmin、tf.argmax、tf.setdiff1d、tf.where、tf.unique、tf.edit_distance、tf.invert_permutation等；

import tensorflow as tf
x = tf.constant([[0, 2, 1], [2, 1, 3]])
sess = tf.Session()
print(sess.run(tf.argmin(x, 0)))#[0 1 0]
print(sess.run(tf.argmin(x, 1)))#[0 1]
tensorflow中的argmin、argmax和numpy中的argmin、argmax是一样的，都是返回索引；

import tensorflow as tf
import numpy as np
sess=tf.Session()
a=np.array([[1,0,0],[0,1,1]])
a1=np.array([[3,2,3],[4,5,6]])
print(sess.run(tf.where(tf.equal(a,1),a1,1-a1)))#[[ 3 -1 -2] [-3 5 6]]
print(sess.run(tf.where(tf.equal(a,0),a1,1-a1)))#[[-2 2 3] [ 4 -4 -5]]

tf.where是当condition满足时（如tf.equal(a,1)），返回第一个对应的值（a1），不满足返回第二个对应的值（1-a1）；
https://www.cnblogs.com/lyc-seu/p/8565997.html

tf.unique是为了Finds unique elements in a 1-D tensor，例如：
c=tf.constant([1,2,3,3,2,4])
with tf.Session() as sess:
print(sess.run(tf.unique©))
y, idx = tf.unique©
print(sess.run(y),sess.run(idx))
输出为：Unique(y=array([1, 2, 3, 4]), idx=array([0, 1, 2, 2, 1, 3]))
[1 2 3 4] [0 1 2 2 1 3]

tf.setdiff1d计算两个数字或字符串列表之间的差异；
import tensorflow as tf
x=[2,3,1,4,2,5]
y=[2,5,6,7,8,3,9]
z,idx=tf.setdiff1d(x,y)#在x中出现，但在y中没有出现的元素
sess=tf.Session()
print(“不同数据：\n”,sess.run(z))# [1 4]
print(“不同数据在x中的位置：\n”,sess.run(idx))#[2 3]

tf.edit_distance计算序列之间的编辑距离；

tf.invert_permutation计算张量的逆置换；
即y[x[i]] = i for i in [0, 1, …, len(x) - 1]
例如num1 = tf.Variable([1, 2, 0, 3], dtype=tf.int32)、invert1 = tf.invert_permutation(num1)得到[2 0 1 3]

tf文件读取相关：
tf.read_file、tf.write_file、tf.matching_files用法：
tf.read_file(filename)用于读取文件
tf.write_file(filename, contents, name=None)用于写文件
tf.matching_files(pattern, name=None)用于匹配文件

tf.FixedLengthRecordReader读取固定长度字节，下次会接着上次读取的位置继续读取文件，而不会从头读取
tf.TFRecordReader读取TFRecords file（https://blog.csdn.net/happyhorizion/article/details/77894055）
tf.TextLineReader输出由换行符分隔的文件行的读取器
tf.WholeFileReader读取整个文件作为一个值
tf.LMDBReader读取LMDB file
tf.IdentityReader是A Reader that outputs the queued work as both the key and value

tf训练相关api：（tf.train）
tf.train.ExponentialMovingAverage、tf.train.shuffle_batch、tf.train.batch_join、tf.train.batch、tf.train.maybe_batch、tf.train.exponential_decay、tf.train.import_meta_graph、tf.train.write_graph、tf.train.export_meta_graph、tf.train.RMSPropOptimizer、tf.train.MomentumOptimizer、tf.train.AdagradOptimizer、tf.train.AdadeltaOptimizer、tf.train.AdamOptimizer、tf.train.QueueRunner、tf.train.GradientDescentOptimizer、tf.train.get_checkpoint_state、tf.train.Coordinator、tf.train.Saver、tf.train.latest_checkpoint、tf.train.Server、tf.train.FloatList、tf.train.Feature、tf.train.Features、tf.train.string_input_producer构造队列、tf.train.start_queue_runners启动队列、tf.train.ClusterSpec、tf.train.BytesList、tf.train.Example、tf.train.SequenceExample等100多个；

tf的数据读取机制：涉及大量图像的训练，都需要‘文件名队列+内存队列’的双队列？
管理epoch，解决gpu因io而空闲，负责读文件和负责训练是两个分开的线程；
（其中用户只需要构造文件名队列，tf会自动构造内存队列）
https://www.jianshu.com/p/0f9f2bb962f4

tf image相关api：（tf.image）
tf.image.resize_image_with_crop_or_pad、tf.image.random_flip_left_right、tf.image.random_brightness、tf.image.random_contrast、tf.image.decode_image、tf.image.per_image_standardization、tf.image.rgb_to_hsv、tf.image.flip_up_down、tf.image.transpose_image、tf.image.flip_left_right、tf.image.non_max_suppression等50多个；

tf nn相关api：（tf.nn）
tf.nn.relu、tf.nn.relu_layer、tf.nn.leaky_relu、tf.nn.conv2d、tf.nn.conv2d_transpose、tf.nn.bias_add、tf.nn.dropout、tf.nn.conv3d、tf.nn.conv3d_transpose、tf.nn.convolution、tf.nn.l2_loss、tf.nn.l2_normalize、tf.nn.max_pool、tf.nn.avg_pool、tf.nn.softmax、tf.nn.sigmoid、tf.nn.nce_loss、tf.nn.batch_normalization、tf.nn.lrn、tf.nn.moments、tf.nn.sparse_softmax_cross_entropy_with_logits、tf.nn.top_k、tf.nn.seq2seq.embedding_attention_seq2seq、tf.nn.seq2seq.model_with_buckets、tf.nn.dynamic_rnn、tf.nn.bidirectional_dynamic_rnn、tf.nn.embedding_lookup、tf.nn.softmax_cross_entropy_with_logits、tf.nn.sigmoid_cross_entropy_with_logits、tf.nn.weighted_cross_entropy_with_logits等90多个；

tf.nn.softmax_cross_entropy_with_logits（多个神经元、多分类）
注意：这个函数的返回值并不是一个数，而是一个向量，如要求交叉熵，需要再加一步tf.reduce_sum操作；如要求loss，则要加一步tf.reduce_mean操作；
cross_entropy=tf.reduce_sum(tf.nn.softmax_cross_entropy_with_logits(labels=y_ ,logits=logits))等价于cross_entropy=-tf.reduce_sum(y_ * tf.log(y)) ！！！
（其中y = tf.nn.softmax(logits)，即softmax_cross_entropy_with_logits已经同时包含了softmax层和 -a*log(b) 的操作； ）
（注意：真实标记y_ 在外面，而预测值y在log里面，不能交换；如果交换，有什么问题？还是交叉熵吗？）
https://www.cnblogs.com/welhzh/p/6595032.html
https://blog.csdn.net/qq_35203425/article/details/79773459

tf.nn.softmax_cross_entropy_with_logits_v2是新的api，和前者效果一样；

tf.nn.sparse_softmax_cross_entropy_with_logits
这个函数是将稀疏表示的label与输出层计算结果做对比；和tf.nn.softmax_cross_entropy_with_logits不同，传给它的labels必须是one-hot的；
其中tf.sparse_to_dense可以将一个稀疏的张量变为密集的；
https://blog.csdn.net/ZJRN1027/article/details/80199248
https://blog.csdn.net/xiewenbo/article/details/80507082?utm_source=blogxgwz6

tf.nn.sigmoid_cross_entropy_with_logits（单个神经元、二分类；但可以推广到多层多神经元的网络）
同样返回的是向量，需要加上tf.reduce_mean或tf.reduce_sum得到一个值；（发现np.mean和tf.reduce_mean对等，np.sum和tf.reduce_sum对等；）
tf.nn.sigmoid_cross_entropy_with_logits(labels=y, logits=logits)等价于-y * np.log(y_pred) - (1 - y) * np.log(1 - y_pred)
（其中y_pred = sigmoid(logits)，即sigmoid_cross_entropy_with_logits同时包含了sigmoid和 -a*log(b)-(1-a)*log(1-b) 的操作；）
（同样，真实标记y 在外面，而预测值y_pred在log里面；）

tf.nn.weighted_cross_entropy_with_logits
计算a weighted cross entropy，即在sigmoid_cross_entropy_with_logits基础上加pos_weight；
公式变为targets * -log(sigmoid(logits)) * pos_weight +(1 - targets) * -log(1 - sigmoid(logits))

tf.nn.top_k
这个函数用于找到输入张量的最后一个维度的最大的k个值和它的下标，如；
a = tf.constant(np.random.rand(3, 4))
b = tf.nn.top_k(a, k=2)
得到的张量类型是TopKV2
https://blog.csdn.net/m0_37393514/article/details/82380109

tf.nn.in_top_k
这个函数返回一个布尔向量，说明目标值是否存在于top K个预测值之中，如；
input = tf.constant(np.random.rand(3,4), tf.float32)
k = 2 #targets对应的索引是否在最大的前k个数据中
output = tf.nn.in_top_k(input, [3,3,3], k)
https://www.jianshu.com/p/343c2eaacd18

tf.nn.bias_add
这个函数用于Adds bias to value，是tf.add的一个特例（tf.add两个参数shape一样，tf.nn.bias_add中bias一定是1维的张量）；
（一个叫bias的向量加到一个叫value的矩阵上，是向量与矩阵的每一行进行相加，得到的结果和value矩阵大小相同）
a = tf.constant([[1, 1], [2, 2], [3, 3]], dtype=tf.float32)
b = tf.constant([1, -1], dtype=tf.float32)
print(sess.run(tf.nn.bias_add(a, b)))得到[[ 2. 0.] [ 3. 1.] [ 4. 2.]]
https://blog.csdn.net/mieleizhi0522/article/details/80416668
https://www.jianshu.com/p/018c0d5c26ff

tf.nn.moments
这个函数用来计算均值和方差，是BN中主要使用的两个api之一；（另一个是tf.nn.batch_normalization）
W = tf.constant([[-2.,12.,6.],[3.,2.,8.]] )
mean,var = tf.nn.moments(W, axes = [0])#计算出来的值被tf.nn.batch_normalization使用
…
W = tf.nn.batch_normalization(W, mean, var, shift, scale, epsilon)
https://blog.csdn.net/eclipsesy/article/details/77597965

tf.nn.seq2seq.model_with_buckets所在位置是tensorflow/contrib/legacy_seq2seq/python/ops/seq2seq.py
（无法跳转，因为tf1.2开始改为tf.contrib.legacy_seq2seq.model_with_buckets）
（那么从tf.contrib.legacy_seq2seq到tf.contrib.seq2seq发生了哪些变化呢？）
https://blog.csdn.net/starzhou/article/details/77925863
https://blog.csdn.net/j754379117/article/details/77623508

conv2d输入形状 [batch, in_height, in_width, in_channels]，过滤器形状[filter_height, filter_width, in_channels, out_channels]；
（NHWC对应[batch, height, width, channels]；NCHW对应[batch, channels, height, width]；）

conv3d输入为5D，即输入为[batch, in_depth, in_height, in_width, in_channels]，过滤器为[filter_depth, filter_height, filter_width, in_channels,out_channels]；
（NDHWC对应[batch, depth, height, width, channels]；NCDHW对应[batch, channels, depth, height, width]；）

卷积三种模式：full、same、valid，运动范围依次减小（tf没有full模式？）
卷积核尺寸为偶数如2*2时，same模式怎么搞？？如x=[4,4],conv2d=[2,2]，步长为1，padding=same，补到[5,5]？补左边or右边or上边or下边？
https://blog.csdn.net/leviopku/article/details/80327478

max_pool和conv2d的padding=SAME一样吗，都是保持形状不变？
那x=[4,4]，max_pool=[2,2]步长为2，padding=same，问需要补多少层？补到[8,8]吗？

tf.contrib：（真实路径）
tf.contrib.rnn.MultiRNNCell、tf.contrib.learn.preprocessing.VocabularyProcessor、tf.contrib.rnn.BasicRNNCell、tf.contrib.slim.conv2d等；

为啥tf.contrib.slim.conv2d找不到也跳转不到？但import tensorflow.contrib.slim as slim，然后slim.conv2d就可以跳转到tensorflow/contrib/layers/python/layers/layers.py了；
具体是convolution2d的别名，而convolution2d = convolution，再跳转过去，就跑到def convolution(inputs…这一行了；
虽然tf.contrib.slim.conv2d跳转不到，但项目中这样写应该没有错，所以只能解释为IDE的无能，而语法上没有问题？yes
注意：import tensorflow.contrib.slim.conv2d若这样写，还是无法跳转，只能分成两步，果然是IDE的问题！！！
那么，为啥slim.conv2d会跳转到tensorflow/contrib/layers呢？可以在tensorflow/contrib/slim/init.py找到答案，即有from tensorflow.contrib.layers.python.layers import *
也就是说，tf.contrib.slim是依赖tf.contrib.layers实现的！！！即前者比后者更高层的api；
也就是说，tf.contrib.slim和tf.contrib.layers这种都是真实的路径，是和源码结构对应的；而tf.layers.XXX这种是通过@tf_export定义的别名设置的虚拟路径，和源码路径是不对应的；
既然如此，就不一一列举tf.contrib的内容了，因为打开源码就能看到，很直观，内容太多了；

有意思的是，tf.contrib.slim.conv2d和tf.nn.conv2d对应的不是一个函数（源码不在一个地方），而tf.contrib.rnn.MultiRNNCell和tf.nn.rnn_cell.MultiRNNCell源码却在一个地方！

tf.contrib.rnn.BasicRNNCell和tf.nn.rnn_cell.BasicRNNCell也是一个东西！

tf slim：
tf slim虽然属于tf.contrib，但却是其中比较重要、比较特殊的一个目录，是一套独立的api；
通过import tensorflow.contrib.slim as slim，数了下一共有近200个函数或变量；

TF-Slim 是tf自带的，是内部代码（轻量级实现、为了使构建网络、训练、评估更简单，如slim.conv2d、slim.arg_scope，精简代码，不如直接keras？）；
另外一个slim是tensorflow/models的research下的模块，貌似更大，可以用来微调；
后者是专门做图像的；后者基于前者；参考https://blog.csdn.net/guvcolie/article/details/77686555

tf learn：（废弃）
tf learn也属于tf.contrib，也是比较特殊的，是一套独立的api？
通过import tensorflow.contrib.learn as learn，数了下一共有90多个函数或变量；

tflearn和tf自带的tf.contrib.learn的区别：
tflearn是在tf之上的高层API（和keras很像），github源码：https://github.com/tflearn/tflearn 目前版本0.3.2（基于tf1.0以上）
tf.contrib.learn已经废弃

tf.test：
tf.test.is_built_with_cuda、tf.test.test_src_dir_path、tf.test.TestCase、tf.test.main、tf.test.is_gpu_available、tf.test.compute_gradient、tf.test.create_local_cluster等；

tf.app：
tf.app.flags.DEFINE_string（或DEFINE_integer、DEFINE_boolean）的好处是可以使用python XXX.py通过传参改变各种配置如epoch数等
tf.app.run执行程序中main函数，并解析命令行参数！
https://www.jianshu.com/p/55cbd3753ee8

tf.layers：
tf.layers.Dropout、tf.layers.Flatten、tf.layers.Dense、tf.layers.Conv2D、tf.layers.Conv3DTranspose等30多个；
tf.layers.conv2d和tf.nn.conv2d区别？
https://stackoverflow.com/questions/42785026/tf-nn-conv2d-vs-tf-layers-conv2d
此外还有tf.contrib.slim.conv2d，见 http://blog.sina.com.cn/s/blog_6ca0f5eb0102wsuu.html

tf初始化相关api：
tf.truncated_normal_initializer、tf.constant_initializer、tf.global_variables_initializer、tf.local_variables_initializer、tf.zeros_initializer、tf.ones_initializer、tf.random_uniform_initializer、tf.orthogonal_initializer、tf.uniform_unit_scaling_initializer等；

tf计算图相关api：
tf.Graph、tf.GraphDef、tf.import_graph_def、tf.GraphKeys.REGULARIZATION_LOSSES、tf.get_default_graph；

https://www.jianshu.com/p/ca637520002f
https://www.jianshu.com/p/5264ff3b3db3
https://blog.csdn.net/zj360202/article/details/78539464

tf log相关api：
tf.logging.WARN、tf.logging.DEBUG、tf.logging.INFO、tf.logging.FATAL等10多个；
tf.logging.set_verbosity(tf.logging.INFO)
tf.logging.log_every_n( level, msg, n, *args)

tf.summary：
tf.summary.FileWriter、tf.summary.histogram、tf.summary.scalar、tf.summary.image、tf.summary.audio、tf.summary.merge_all、tf.summary.merge、tf.summary.text等10多个；
tf.summary负责汇总数据并写入事件文件，然后使用TensorBoard读取这些日志文件；
https://blog.csdn.net/hongxue8888/article/details/78610305
https://www.cnblogs.com/lyc-seu/p/8647792.html

tf.summary.scalar用于统计loss，如tf.summary.scalar(‘loss’,loss)
tf.summary.histogram统计每一层的参数如w、b、output等，如tf.summary.histogram(’/weights’,Weights)；
tf.summary.FileWriter将计算图保存到磁盘，如 writer = tf.summary.FileWriter(“logs/”, sess.graph)
最后执行merged=tf.summary.merge_all()

tf数据类型：
tf.int32、tf.int64、tf.int16、tf.int8、tf.uint8、tf.qint32、tf.qint8、tf.quint8、tf.float32、tf.float64、tf.bool、tf.string、tf.complex64；

tf.variable_scope、tf.get_variable、tf.Variable、tf.get_variable_scope、tf.placeholder、tf.name_scope、tf.constant用法：
tf.variable_scope是为了重用，如with tf.variable_scope(“foo”, reuse=True):
（如果使用全局变量，会打破封装性，这些变量必须文档化被其他代码文件引用，一旦代码变化，调用方也可能需要变化）
（同一空间不能重名但可以重用，不同空间可以重名）
（把变量交给变量空间自动管理，可以随时获取，不需要每次通过参数传递（特别是参数多的时候））
（reuse默认情况下为False或者和上一层保持一致，只要它的某一个外层是True那就是True）
（reuse的值还可以是None或tf.AUTO_REUSE，其中None和False等价？tf.AUTO_REUSE是最安全的用法）
tf.get_variable会先搜索变量，有就直接用，没有再新建，如v = tf.get_variable(“v”, [1])
（注意：如果搜索到了，但reuse为False，就会报错 ）
tf.Variable每次都会创建新变量，如a1 = tf.Variable(tf.random_normal(shape=[2, 3], mean=0, stddev=1), name=‘a1’)
tf.get_variable_scope获取当前环境的作用域，tf.get_variable_scope().reuse用于获取reuse的值，而tf.get_variable_scope().reuse_variables()直接设置reuse为True；
tf.name_scope用于管理图中各种op，它只影响算子的名称，不影响变量的名称；
（对于tf.Variable()创建的变量，具有相同的效果，都会在变量名称前面，加上域名称）
（对于tf.get_variable()创建的变量，不受tf.name_scope的影响！！！）
（tf.name_scope不能加reuse？）
（如果没有tf.name_scope，只有tf.variable_scope，会有哪些不方便？）
tf.placeholder是在构建graph时的占位符，在执行的时候再赋具体的值；
（tf.float32类型的tf.placeholder可以接受np的类型，这是为啥？比如np.random.rand构造的数组）
tf.constant定义一个常量张量；

https://www.cnblogs.com/MY0213/p/9208503.html
https://www.wengbi.com/thread_87302_1.html
https://www.cnblogs.com/hejunlin1992/p/7783881.html

tf.tensordot或tf.linalg.tensordot用法：
f1=tf.constant([1,1])
f2=tf.constant([1,2])
f13 = tf.tensordot(f1,f2,1)即张量的各点积进行求和，输出为3
https://www.jianshu.com/p/d7cddf6ea156

tf.Print用法：
tf.Print()打印tensor内容（输出中间值），是tensorflow中调试的一个手段；
https://blog.csdn.net/sjtuxx_lee/article/details/84571377
https://blog.csdn.net/qq_34484472/article/details/75049179

tf.stop_gradient、tf.gradients用法：
tf.gradients用于计算梯度，如
w1 = tf.Variable([[1, 2]])
w2 = tf.Variable([[3, 4]])
res = tf.matmul(w1, [[2], [1]])
grads = tf.gradients(res, [w1])
print(sess.run(grads))

tf.stop_gradient用于阻挡节点BP过程中的梯度更新；
（如a=1，b=1，c=a+b，d=a+b，e=c+d，如果c被冻结了（调用c_stoped = tf.stop_gradient©），求e对a和b的梯度，
仍可以计算，结果为[1.0, 1.0]，因为仍有一个分支可以计算，即d分支，而d对a和b的梯度都是1）

https://zhuanlan.zhihu.com/p/35003434
https://blog.csdn.net/wuguangbin1230/article/details/71169863

tf.logical_and、tf.logical_or、tf.logical_not、tf.logical_xor用法：
print(sess.run(tf.logical_xor([True, False], [True, False])))得到[False False]

tf.scatter_sub用法：
tf.scatter_sub(ref, indices, updates)将ref中特定位置的数分别进行减法运算；

tf.gather用法：
tf.gather(x,[[0,2]])用一个一维的索引数组,将张量中对应索引的向量提取出来；

tf.control_dependencies用法：
with tf.control_dependencies([a, b]):
c = …
d = …
即在执行完 a，b 操作之后，才能执行 c，d 操作；

tf.stack和tf.unstack用法：
c = tf.stack( [a,b], axis=1)#axis=0和1按行和列拼接；
c = tf.constant([[1, 2, 3],[4, 5, 6]])然后d = tf.unstack(c, axis=0)
说明：tf.stack是对矩阵进行拼接，tf.unstack则对矩阵进行分解；

tf.cond用法：
result = tf.cond(x < y, lambda: tf.add(x, z), lambda: tf.square(y))
tf.cond()类似于c语言中的if…else…，用来控制数据流向；

tf.py_func用法：
tf.py_func(add, [x,y], [tf.float32,tf.float32,tf.float32])
包裹一个python方法给tf使用，以numpy arrays作为输入和输出；

tf.identity、tf.group、tf.tuple用法：
tf.identity(image)返回和输入一样的tensor，即什么都没做；
tf.identity()和tf.group()均可将语句变为操作；
tf.group() Create an op that groups multiple operations.
tf.tuple()用于组合多个张量输入组成的列表，然后返回一个计算过后的张量列表；（即它返回不是操作，而是张量）
https://www.jianshu.com/p/ca0f94f61c72

tf.equal、tf.not_equal用法：
tf.equal(a,b)逐元素判断两个张量是否相等，返回的张量由True和False构成，且维度和输入一样；

tf.cast、tf.decode_raw用法：
a = tf.Variable([1,0,0,1,1])
b = tf.cast(a,dtype=tf.bool)
得到[ True False False True True]
对一个张量进行强制类型转换；

tf.decode_raw将原来编码为字符串类型的变量重新变回来；

tf.get_collection、tf.add_to_collection、tf.add_n用法：
v1 = tf.get_variable(name=‘v1’, shape=[1], initializer=tf.constant_initializer(12))
tf.add_to_collection(‘loss’, v1)
v2 = tf.get_variable(name=‘v2’, shape=[1], initializer=tf.constant_initializer(20))
tf.add_to_collection(‘loss’, v2)
v3 = tf.get_variable(name=‘v3’, shape=[1], initializer=tf.constant_initializer(30))
tf.add_to_collection(‘loss’, v3)
with tf.Session() as sess:
sess.run(tf.initialize_all_variables())
print(sess.run(tf.add_n(tf.get_collection(‘loss’))))
输出[ 62.]，即tf.add_n会将名为loss的collection所有项相加；

tf.get_default_session、tf.Session、tf.InteractiveSession用法：
tf.get_default_session returns the innermost session already active in the current running thread.
Hence you should already have an active session.（可以避免多个session对gpu的竞争）
tf.Session instead, creates a new session in the current running thread.
tf.InteractiveSession是一种交互式的session方式，它相当于sess=tf.Session()和with sess.as_default():
（另一个角度，We can just use ‘c.eval()’ without passing ‘sess’，即c.eval(session=sess)直接成c.eval()）

tf.ones_like、tf.zeros_like用法：
tensor=[[1, 2, 3], [4, 5, 6]]
x = tf.zeros_like(tensor)
sess=tf.InteractiveSession()
print(sess.run(x))
得到[[0 0 0] [0 0 0]]

tf.random_uniform、tf.random_shuffle、tf.random_crop、tf.random_gamma、tf.random_poisson、tf.random_normal、tf.truncated_normal用法：
print(sess.run(tf.random_uniform((3,4),-1,1)))生成shape为(3,4)的均匀分布的随机张量，每个值范围是[-1,1]；
（tf.random_uniform和np.random_uniform的区别是，后者生成的不是张量，而是普通变量，且只能产生一个值；）

tf.random_normal从正态分布中输出随机值，用法和tf.random_uniform类似；

tf.truncated_normal从截断的正态分布输出随机值，用法和tf.random_uniform类似；

tf.random_poisson用法tf.random_poisson([0.5, 1.5], [10])得到shape为[10, 2]的张量，其中[0.5, 1.5]是两个poisson分布的参数；（有点难）

tf.random_gamma用法tf.random_gamma([5], [0.5, 1.5])得到shape为[5,2]的张量，其中[0.5, 1.5]是两个gamma分布的参数；（有点难）

tf.random_shuffle随机打乱一个张量；

tf.random_crop对图像（已经转化为tensor）随机切割，是一种data augmentation方法；

tf.squeeze、tf.expand_dims用法：
import tensorflow as tf
inputs=[[[[[1],[2]],[[3],[4]],[[5],[6]]]]]
y = tf.squeeze(inputs, name=‘squeeze’)
sess=tf.InteractiveSession()
print(sess.run(tf.shape(inputs)))
print(sess.run(y))
把维度为[1 1 3 2 1]的tensor变为[3 2]，即删除所有大小是1的维度，最后输出[[1 2] [3 4] [5 6]]；
如果改为y = tf.squeeze(inputs,[0,1] ,name=‘squeeze’)，则只去除第0、1维，得到维度[3 2 1]，输出[[[1] [2]] [[3] [4]] [[5] [6]]]；

tf.expand_dims作用相反，目的是增加维度，使用tf.reshape也可以达到相同效果；
如z=tf.expand_dims(inputs, 1) print(sess.run(tf.shape(z)))

tf.reshape用法：
t = tf.constant([1, 2, 3, 4, 5, 6, 7, 8, 9])
with tf.Session() as sess:
print(sess.run(tf.reshape(t, [3, 3])))
注意：[3, 3]可以改为[-1, 3]或[3, -1]；直接[-1]会返回拉直的一维张量（这个例子没变化）
最多有一个维度可以填写为-1；

tf.slice用法：
import tensorflow as tf
t = tf.constant([[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]], [[5, 5, 5], [6, 6, 6]]])
y=tf.slice(t, [1, 0, 0], [1, 1, 3])
sess=tf.InteractiveSession()
print(sess.run(y))
输出[[[3 3 3]]]，即slice(input_, begin, size, name=None)从输入的begin代表的位置开始，获取各个维度为size代表的长度；
若改为y=tf.slice(t, [1, 0, 0], [1, 2, 3])，则输出[[[3 3 3] [4 4 4]]]
https://www.jianshu.com/p/71e6ef6c121b

tf.gfile.FastGFile、tf.gfile.GFile或tf.gfile.Open用法：
with tf.gfile.FastGFile(os.path.join(MODEL_DIR, MODEL_FILE), ‘rb’) as f 换成
with open(os.path.join(MODEL_DIR, MODEL_FILE), ‘rb’) as f 也没错！！！

tf.gfile还有tf.gfile.Copy、tf.gfile.DeleteRecursively、tf.gfile.Exists、tf.gfile.IsDirectory、tf.gfile.ListDirectory、tf.gfile.MkDir、
tf.gfile.MakeDirs、tf.gfile.Remove、tf.gfile.Rename、tf.gfile.Walk等10多个函数；

tf.device用法：
用于指定模型运行的具体设备，在GPU还是CUP上，如tf.device(’/gpu:1’) ；
（注意: CPU不区分设备号，统一使用 /cpu:0）

tf.ConfigProto、tf.GPUOptions用法：
tf.ConfigProto在创建session的时候，对session进行参数配置，如
with tf.Session(config=tf.ConfigProto(log_device_placement=True)) as sess
tf.GPUOptions是设置tf.ConfigProto时的一个参数选项，用于限制GPU资源的使用，如
gpu_options=tf.GPUOptions(per_process_gpu_memory_fraction=0.85)
config=tf.ConfigProto(gpu_options=gpu_options)

tf.cumsum、tf.cumprod用法：
tf.cumsum计算累积和，如tf.cumsum([a, b, c])得到 [a, a + b, a + b + c]
还可以加上exclusive=True、reverse=True等参数；
tf.cumprod计算累乘，如tf.cumprod([a, b, c]) # [a, a * b, a * b * c]
也可以加上exclusive=True、reverse=True等参数；

tf.convert_to_tensor用法：
tf.convert_to_tensor将python的数据类型转换成TensorFlow可用的tensor数据类型；
（这个value可以是tensor、numpy arrays、python list；）

tf.no_op用法：
tf.no_op什么都不做，只是一个占位符；
Does nothing. Only useful as a placeholder for control edges.

tf.set_random_seed用法：
这个函数用于设置graph级别的随机seed；（graph-level and operation-level seeds）
对于tf.random_uniform、tf.random_normal起作用，用法如下
tf.set_random_seed(1234)
a = tf.random_uniform([1])
b = tf.random_normal([1])
https://blog.csdn.net/eml_jw/article/details/72353470 （图级seed和操作seed的关系）

tf eager模式：
import tensorflow as tf
import tensorflow.contrib.eager as tfe
tfe.enable_eager_execution()
x = [[2.]]
m = tf.matmul(x, x)
print(m.numpy())
https://ai.googleblog.com/2017/10/eager-execution-imperative-define-by.html
相当于命令式编程（tf本身是符号式编程）