tensorflow中一些函数用法

tf.nn.conv2d(input, filter, strides, padding, use_cudnn_on_gpu=None, name=None)
除去name参数用以指定该操作的name，与方法有关的一共五个参数：
第一个参数input：指需要做卷积的输入图像，它要求是一个Tensor，具有[batch, in_height, in_width, in_channels]这样的shape，具体含义是[训练时一个batch的图片数量, 图片高度, 图片宽度, 图像通道数]，注意这是一个4维的Tensor，要求类型为float32和float64其中之一
第二个参数filter：相当于CNN中的卷积核，它要求是一个Tensor，具有[filter_height, filter_width, in_channels, out_channels]这样的shape，具体含义是[卷积核的高度，卷积核的宽度，图像通道数，卷积核个数]，要求类型与参数input相同，有一个地方需要注意，第三维in_channels，就是参数input的第四维
第三个参数strides：卷积时在图像每一维的步长，这是一个一维的向量，长度4
第四个参数padding：string类型的量，只能是"SAME","VALID"其中之一，这个值决定了不同的卷积方式（后面会介绍）
第五个参数：use_cudnn_on_gpu:bool类型，是否使用cudnn加速，默认为true
结果返回一个Tensor，这个输出，就是我们常说的feature map，shape仍然是[batch, height, width, channels]这种形式。

tf.truncated_normal(shape, mean, stddev) :
shape表示生成张量的维度，mean是均值，stddev是标准差。这个函数产生正太分布，均值和标准差自己设定。这是一个截断的产生正太分布的函数，就是说产生正太分布的值如果与均值的差值大于两倍的标准差，那就重新生成。和一般的正太分布的产生随机数据比起来，这个函数产生的随机数与均值的差距不会超过两倍的标准差，但是一般的别的函数是可能的

shape函数是numpy.core.fromnumeric中的函数，它的功能是读取矩阵的长度，比如shape[0]就是读取矩阵第一维度的长度。它的输入参数可以使一个整数表示维度，也可以是一个矩阵
tf.name_scope 主要结合 tf.Variable() 来使用，方便参数命名管理。
tf.constant(value, dtype, shape, name)

tf.nn.bias_add(value,bias,name=none)：
通俗解释：一个叫bias的向量加到一个叫value的矩阵上，是向量与矩阵的每一行进行相加，得到的结果和value矩阵大小相同。


tf.nn.l2_loss(t, name=None)
tf.nn.l2_loss形如1/2Σw2,一般用于优化的目标函数中的正则项，防止参数太多复杂容易过拟合。
解释：这个函数的作用是利用 L2 范数来计算张量的误差值，但是没有开方并且只取 L2 范数的值的一半，具体如下:
output = sum(t ** 2) / 2
tensorflow中有一个计算梯度的函数tf.gradients(ys, xs)，要注意的是，xs中的x必须要与ys相关，不相关的话，会报错

tf.matmul() 和tf.multiply() 的区别
1.tf.multiply（）两个矩阵中对应元素各自相乘
格式: tf.multiply(x, y, name=None)
参数:
x: 一个类型为:half, float32, float64, uint8, int8, uint16, int16, int32, int64, complex64, complex128的张量。
y: 一个类型跟张量x相同的张量。
返回值： x * y element-wise.
注意：
（1）multiply这个函数实现的是元素级别的相乘，也就是两个相乘的数元素各自相乘，而不是矩阵乘法，注意和tf.matmul区别。
（2）两个相乘的数必须有相同的数据类型，不然就会报错。
2.tf.matmul（）将矩阵a乘以矩阵b，生成a * b。
格式: tf.matmul(a, b, transpose_a=False, transpose_b=False, adjoint_a=False, adjoint_b=False, a_is_sparse=False, b_is_sparse=False, name=None)
参数:
a: 一个类型为 float16, float32, float64, int32, complex64, complex128 且张量秩 > 1 的张量。
b: 一个类型跟张量a相同的张量。
transpose_a: 如果为真, a则在进行乘法计算前进行转置。
transpose_b: 如果为真, b则在进行乘法计算前进行转置。
adjoint_a: 如果为真, a则在进行乘法计算前进行共轭和转置。
adjoint_b: 如果为真, b则在进行乘法计算前进行共轭和转置。
a_is_sparse: 如果为真, a会被处理为稀疏矩阵。
b_is_sparse: 如果为真, b会被处理为稀疏矩阵。
name: 操作的名字（可选参数）
返回值： 一个跟张量a和张量b类型一样的张量且最内部矩阵是a和b中的相应矩阵的乘积。
注意：
（1）输入必须是矩阵（或者是张量秩 >２的张量，表示成批的矩阵），并且其在转置之后有相匹配的矩阵尺寸。
（2）两个矩阵必须都是同样的类型，支持的类型如下：float16, float32, float64, int32, complex64, complex128。
引发错误:
ValueError: 如果transpose_a 和 adjoint_a, 或 transpose_b 和 adjoint_b 都被设置为真

tf.ConfigProto()函数的功能和使用


tf.truncated_normal()与tf.random_normal()的区别
1.两个函数的相同点：
两个函数都是用来产生服从正态分布的随机数字，参数shape表示生成张量的维度，mean是均值，stddev是标准差。
2. 两个函数的不同点：
truncated英文意思为：切去顶端的，缩短了的，被删节的。从字面意思可以理解，用tf.truncated_normal生成的随机数字和用tf.random_normal生成的随机数字相比应该被截断了一些数值，而被删减的数值是均值加减两个标准差以外的数值，即只保留（μ-2σ，μ+2σ）区间内的值，学过概率论的朋友都知道，正态分布的横坐标位于该区间对应的面积是95.449974%，也就是说被某个数字被截断的概率为4.55%。
容易看到，用tf.truncated_normal（）输出的值严格限制在（-2,2）之间（此时标准差为1），而tf.random_normal（）输出的值就是一个标准的正态分布，没有被截断。

**tf.argmax( , )**中有两个参数，第一个参数是矩阵，第二个参数是0或者1。0表示的是按列比较返回最大值的索引，1表示按行比较返回最大值的索引。

tensorflow中协调器 tf.train.Coordinator 和入队线程启动器 tf.train.start_queue_runners
TensorFlow的Session对象是支持多线程的，可以在同一个会话（Session）中创建多个线程，并行执行。在Session中的所有线程都必须能被同步终止，异常必须能被正确捕获并报告，会话终止的时候， 队列必须能被正确地关闭。

TensorFlow提供了两个类来实现对Session中多线程的管理：tf.Coordinator和 tf.QueueRunner，这两个类往往一起使用。

Coordinator类用来管理在Session中的多个线程，可以用来同时停止多个工作线程并且向那个在等待所有工作线程终止的程序报告异常，该线程捕获到这个异常之后就会终止所有线程。使用 tf.train.Coordinator()来创建一个线程管理器（协调器）对象。

QueueRunner类用来启动tensor的入队线程，可以用来启动多个工作线程同时将多个tensor（训练数据）推送入文件名称队列中，具体执行函数是 tf.train.start_queue_runners ， 只有调用 tf.train.start_queue_runners 之后，才会真正把tensor推入内存序列中，供计算单元调用，否则会由于内存序列为空，数据流图会处于一直等待状态。

tf中的数据读取机制如下图：
![在这
可参考（https://blog.****.net/weixin_42052460/article/details/80714539）

1.调用 tf.train.slice_input_producer，从 本地文件里抽取tensor，准备放入Filename Queue（文件名队列）中;

2.调用 tf.train.batch，从文件名队列中提取tensor，使用单个或多个线程，准备放入文件队列;

3.调用 tf.train.Coordinator() 来创建一个线程协调器，用来管理之后在Session中启动的所有线程;

4.调用tf.train.start_queue_runners, 启动入队线程，由多个或单个线程，按照设定规则，把文件读入Filename Queue中。函数返回线程ID的列表，一般情况下，系统有多少个核，就会启动多少个入队线程（入队具体使用多少个线程在tf.train.batch中定义）;

5.文件从 Filename Queue中读入内存队列的操作不用手动执行，由tf自动完成;

6.调用sess.run 来启动数据出列和执行计算;

7.使用 **coord.should_stop()**来查询是否应该终止所有线程，当文件队列（queue）中的所有文件都已经读取出列的时候，会抛出一个OutofRangeError 的异常，这时候就应该停止Sesson中的所有线程了;

8.使用coord.request_stop()来发出终止所有线程的命令，使用coord.join(threads)把线程加入主线程，等待threads结束。

以上对列（Queue）和 协调器（Coordinator）操作示例：
import tensorflow as tf
import numpy as np
#样本个数
sample_num=5
#迭代次数
epoch_num = 2
#设置一个批次中包含的样本个数
batch_size = 3
#计算每一轮epoch中含有的batch个数
batch_total = int(sample_num/batch_size)+1
#生成4个数据和标签
def generate_data(sample_num=sample_num):
labels = np.asarray(range(0, sample_num))
images = np.random.random([sample_num, 224, 224, 3])
print(‘image size {},label size :{}’.format(images.shape, labels.shape))
return images,labels

def get_batch_data(batch_size=batch_size):
images, label = generate_data()
# 数据类型转换为tf.float32
images = tf.cast(images, tf.float32)
label = tf.cast(label, tf.int32)

#从tensor列表中按顺序或随机抽取一个tensor准备放入文件名称队列  
input_queue = tf.train.slice_input_producer([images, label], num_epochs=epoch_num, shuffle=False)  

#从文件名称队列中读取文件准备放入文件队列  
image_batch, label_batch = tf.train.batch(input_queue, batch_size=batch_size, num_threads=2, capacity=64, allow_smaller_final_batch=False)  
return image_batch, label_batch  

image_batch, label_batch = get_batch_data(batch_size=batch_size)

with tf.Session() as sess:

# 先执行初始化工作  
sess.run(tf.global_variables_initializer())  
sess.run(tf.local_variables_initializer())  

# 开启一个协调器  
coord = tf.train.Coordinator()  
# 使用start_queue_runners 启动队列填充  
threads = tf.train.start_queue_runners(sess, coord)  

try:  
    while not coord.should_stop():  
        print '************'  
        # 获取每一个batch中batch_size个样本和标签  
        image_batch_v, label_batch_v = sess.run([image_batch, label_batch])  
        print(image_batch_v.shape, label_batch_v)  
except tf.errors.OutOfRangeError:  #如果读取到文件队列末尾会抛出此异常  
    print("done! now lets kill all the threads……")  
finally:  
    # 协调器coord发出所有线程终止信号  
    coord.request_stop()  
    print('all threads are asked to stop!')  
coord.join(threads) #把开启的线程加入主线程，等待threads结束  
print('all threads are stopped!')