tensorflow函数记录

tf.interactiveSession()与tf.Session():

     tf.Session()将操作节点op封装在一定的环境中运行，同时tensor对象将被计算求值。

     tf.Session()需要在启动session之前构建整个计算图，并且启动计算图。

     tf.interactiveSession()能够在运行图的时候插入一些计算图。计算图都是由某些操作(operations)构成。

 

tf.placeholder(dtype,shape=None,name=None):

     此函数可以被理解为形参，先声明定义但没有赋值。

     参数类型：

         dtype:数据类型，常用tf.float32等

         shape:数据形状，默认None，一维值，或者[2,3]

         name:名称

 

tf.matmul(a,b,name):

     参数类型:

         a,b:'Tensor' of type 'float16'..

     注意，a,b必须是矩阵维度大于2的tensor

            这是专门的矩阵乘法而不是矩阵元素对应相乘。

 

tf.Variable(initial_value,trainable=True,collections=None,validate_shape=True,name=Node):

     变量定义，能长期存放在显存中并在每轮迭代中更新在TensorFlow中，变量的初始化是分开的，所有关于图变量的赋值和计算都要通过 tf.Session的run来进行。将变量集体初始化应该使用tf.global_variables_initializer。

     参数类型：

         initial_value:初始值，必须赋值

         trainable:bool值：如果为True，会把它加入GraphKeys.TRAINABLE_VARIABLES，才能对它使用Optimizer

         collections:list类型:指定该图变量类型，默认为[GraphKeys.GLOBAL_VARIABLES]

         calidate_shape:True则进行类型和维度检查

 

tf.nn.softmax()

     tf.nn里面包含了大量的神经网络组件，注意，对于Softmax Regression算法，y=softmax(Wx+b)改写成tensorflow模式,则y=tf.nn.softmax(tf.manmul(x,W)+b)

 

tf.log(x):log(x)

 

tf.reduce_sum:求和

 

tf.reduce_mean(imput_tensor,axis..reduction_indices=None):对每个batch数据结果求平均值

     参数类型：

         imput_tensor:输入的张量

         axis:求平均数的维度，为None则张量的每一个数求平均，0则是列求平均，1则是行求平均

         reduction_indices与axe类似

 

tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy):使用梯度下降法进行优化，学习速率为0.5,优化目标为最小化cross_entropy。

返回值是是一个训练的操作train_step

 

tf.global_variables_initializer().run():使用全局参数初始化器，执行run命令

 

mnist.train.next_batch(100):建立一个100个样本的mini_batch，在minst.train（minst的训练集）

train_step.run({x: batch_xs, y_: batch_ys}):run的对象是字典，将x,y_ tensor的占位符，分别是image,label当作训练数据训练

 

tf.argmax(x, 1):从一个tensor中找最大值,1为参数axis

tf.equal():判断传入的参数是否相同，输出bool值

tf.cast(a, b):将a类型转化为b类型

 

accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels}):与.run()类似本质都是计算，只不过run()作用的对象是节点（operation），eval()作用 的对象是张量(tensor),对于这段话来说，accuracy是一个tensor,对其进行计算。

     参数类型：feed_dict:一个字典，用来表示被feed的值，一般来说这个值之前是使用placeholder来定义的。相当与在这一步将值传入之前定义的placeholder对象

                   Session:使用的Session

 

tf.truncated_normal(shape, mean=0.0, stddev=1.0 dtype=tf.float32, seed=None, name=None):从截断的正太分布中输出随机值生成的值服从指定的平均值和标准偏差的正太分布，如果生成的值大于平均值2个标准偏差的值则丢弃重新 选择

     参数类型：shape:一维的张量，也是输出的张量

                   mean:正太分布的均值

                   stddev:正太分布的标准差

                   dtype:输出的类型

                   seed:一个整数，设置之后每次生成的随机数都一样

与之类似的，有

tf.randow_normal(shape, mean=0.0, stddev=1.0 dtype=tf.float32, seed=None, name=None):从正太分布中直接输出随机值

 

tf.reshape(x, [-1,28,28,1]):重置shape

     参数类型:在这句中,[-1,28,28,1]代表了样本数为-1，即不确定，28*28的高和宽，1的通道数

 

tf.nn.conv2d(input, filter, strides, padding, use_cudnn_on_gpu=None, data_format=None, name=None):将输入input()（4维的样本数据矩阵）和filter(卷积核)作卷积运算，输出卷积后的矩阵

     参数类型：input的形状：[batch, in_height ,in_width, in_channels]
                    batch: 样本的数量
                    in_height ：每个样本的行数
                    in_width： 每个样本的列数
                    in_channels：每个样本的通道数，如果是RGB图像就是3

     就如同上面reshape的情况
                   filter的形状：[filter_height, filter_width, in_channels, out_channels]
                    filter_height：卷积核的高
                    filter_width：卷积核的宽
                    in_channels：输入的通道数
                    out_channels：输出的通道数

如：w_conv1 = weight_variable([5, 5, ,1, 32]),卷积核为5*5,1个通道，有32个卷积核，在cnn中，前一个卷积层的卷积核个数就是输出的通道数。
                   strides, padding:步长和填充

                   输出的形式与输入类型相同

                   

tf.nn.maxpool(value, ksize, strides, padding, name=None): 最大池化操作

     参数类型：value:需要池化的输入，一般池化层在卷积层的后面，多亿输入通常是feature map,同样是[batch, heigh, width, channels]这样的shape

                  ksize:池化窗口的大小，一般是[1, height, width, 1]，因为我们不想在batch和channels做池化，所以这两个维度设为了1

                  返回值是一个Tensor，类型不变，shape仍然与上述类型相同

 

tf.nn.relu(features, name=None)：relu激活函数，即将输入features元素变为大于0。

 

w_fc1 = weight_variable([7 * 7 * 64， 1024]):对于全连接层的，将之前的图像直接输入，输入的列表是[image_height * image_width * channel， 全连接节点数]

g_pool2_flat = tf.reshape(h_pool2, [-1, 7 * 7 * 64])：同样是对于全连接层，需要把上层的输出reshape为一维，大小是7 * 7 * 64

 

tf.nn.l2_loss(t, name=None):利用L2范数来计算张量的误差值，元素的平方和除以2，对于L2范数，是平方和开方。   

     output = sum(t**2) / 2

     其中t是一个Tensor

     返回值也是一个Tensor，为标量，类型与输入相同

 

tf.add_to_collection:向当前计算图中添加张量集合

tf.get_collection:返回当前计算图中手动添加的张量集合

 

tf.gfile.Exists(filename):判断目录或文件是否存在，filename可为目录路径或带文件名的路径，有该目录则返回True，否则False。

 

tf.train.string_input_producer(filename):把我们需要的全部文件打包为一个tf内部的queue类型，之后tf开文件就是从这个queue中取目录

 

tf.name_scope(name):相当与定义命名空间，可以给后续参数的名字加上"name/" 命名空间

 

tf.image.randow_crop(reshape_image, [height, width, 3]):tf的随机裁剪函数

     参数类型：reshape_image:裁剪后的图像存储，类型为Tensor,后面定义了这个Tensor的Shape

tf.image.randow_filp_left_right:以一定概率从左到右翻转

tf.image.randow_brightness:设置随机亮度

tf.image.randow_contrast:设置随机对比度

tf.image.standardization(image):将图片标准化，加速神经网络的训练

 

tf.nn.bias_add(value, bias, name = None):将偏差项bias加到value上，其中bias必须是一维的，value可以有任何维度，可以让bias的维度和value的最后一维不同，相当与不同维度的加法.

 

tf.nn.lrn（）：一种特殊的归一化方式，适合Relu这种没有边界的激活函数，使得里面比较大的值变得更大，并抑制其他反馈较小的神经元

 

tf.nn.sparse_sotfmax_cross_entropy_with_logits(logits, labels, name=None):将sotfmax的计算和cross entropy loss的计算整合在一起

 

tf.addn():实现列表对应元素的相加，这些元素可以是向量也可以是矩阵

 

tf.nn.in_top_k(predictions, targets, k, name=None):输出top k的那一类的准确度，一般是1

     参数类型：predictions:预测的结果，预测矩阵大小为样本数×标注的label类的个数的二维矩阵

                  targets:实际的标签，大小为样本数。比如为10类，最后输出的标签可能为[0.3,0.5,0.2...],数字最高表示该类的概率最高

                  k:top k

 

tf.train.start_queue_runners():启动图片数据增强的线程队列

 

tensor.op.name:tensor的名字

tensor.get_shape().as_list():tensor的尺寸，用List形式来表示

 

config=tf.configproto():一般是在创建session的时候，用来对session进行参数配置

config.gpu_options.allocator_type = 'BFC':使用BFC算法进行GPU内存的管理，具有内存分配，释放，碎片管理等基本功能

 

tf.gradient(ys, xs, grad_ys=None, name=None colocate_gradients_with_ops=False, gate_gradients=False, aggregation_method=None, stop_gradients=None):简单来说就是ys对xs求导

     参数类型 :ys,xs：tensor类型，所以可能是一个List，假设ys=[y1, y2, y3],xs=[x1, x2],则输出应该为grad=[grad1, grad2, grad3]

其中grad1=y1对x1求导加上y2对x1求导加上y3对x1求导，后面同理。在深度学习时，大多数情况是ys是Loss函数，而xs是参数，参数很多时候是List,这样就实现了反向梯度的方法。

                     后续的参数使用率不高

 

parser = argparse.ArgumentParser()：python中的命令解析器，该句是创建一个命令解析器的句柄

parse.add_argument():设置参数

FLAG， unparsed = parse.parse_known_args()：返回之前设置的参数

 

ft.app.run():用于在主函数执行启动tensorflow

 

tensor.get_shape()[-1].value:得到通道数

 

tf.contrib.layers.xavier.initializer_conv2d():Xavier初始化，会根据某一层网络的输入输出节点的数量自动调整最合适的分布

 

tf.contrib.slim:非官方的tensorflow接口，可以起到简化代码的作用。具体内容见slim解释

    slim.arg_scope：给函数的参数自动赋予某些默认值。傻逼用了slim.arg_scope后不需要每次都重复设置参数，只需要在有修改时设置。

    例如：with slim.arg_scope([slim.comv2d, slim.fully_connected], weights_regularizer=slim.l2_regularizer(weight_decay)

               对于slim.conv2d与slim.fully_connected这两个参数自动赋值

               weight_regularizer的值默认设为slim.l2_regularizer(weight_decay)

    slim.conv2d(tensor, channel, [w, h], stride, padding model):创建卷积层

            参数类型：tensor:输入的tensor

                              channel:输出的通道数

                              []:卷积核尺寸

                              stride:步长

                              padding model:padding模式

 

tf.shape()的理解：

    shape有二维和三维的形式，对于二维，如shape(2,3),可以表示为1维有两个数，二维有3个数，具体的表现形式为：

    a=[1,2,3,4,5,6],若reshape为shape(2,3),则a=[[1,2,3],[4,5,6]]

    对于三维形式，shape(2,2,3),可以表示为1维有两个数，2维有两个数，3维有3个数。

    若a=[1,2,3,4,5,6,7,8,9,10,11,12],reshape为shape(2,2,3),则a=[[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]]

    共同情况，对于矩阵形式，最外面的中括号代表第一维，之后第二层代表的是第二维，最里面一层的中括号代表的是第三维。

    写成图像形式，对于上述的shape与数组形式，转化为图像像素形式如下图

 

tf.concat([tensor1,tensor2..],values):按照values的模式连接不同的tensor

    两个二维tensor的连接：values=0:行 values=1:列

    如t1=[[1,2,3],[4,5,6]],t2=[[7,8,9],[1,2,3]],t1与t2的shape都是(2,3)

    则tf.concat([t1, t2],0)->[[1,2,3],[4,5,6],[7,8,9],[1,2,3]],shape为(4,3)

       tf.concat([t1, t2],1)->[[1,2,3,7,8,9],[4,5,6,1,2,3]],shape为(2,6)

    两个三维tensor的连接，values=0:行 values=1:列 values=2:通道数叠加

    如t1=[[[1,1,1],[2,2,2]],[[3,3,3],[4,4,4]]],shape为(2,2,3),对应图就是2×2×3的image

        t2=[[[5,5,5],[6,6,6]],[[7,7,7],[8,8,8]]],shape为(2,2,3)

    则tf.concat([t1, t2],0)->[[[1,1,1],[2,2,2]],[[3,3,3],[4,4,4]],[[5,5,5],[6,6,6]],[[7,7,7],[8,8,8]]],shape为(4,2,3)

       tf.concat([t1, t2],1)->[[[1,1,1],[2,2,2],[5,5,5],[6,6,6]],[[3,3,3],[4,4,4],[7,7,7],[8,8,8]]],shape为(2,4,3)

       tf.concat([t1, t2],2)->[[[1,1,1,5,5,5],[2,2,2,6,6,6]],[[3,3,3,7,7,7],[4,4,4,8,8,8]]],shape为(2,2,6)

       也可以这么理解，values值就是在这一值的维度上进行连接，如0,代表的是1维空间，就把1维空间代表的最外层的中括号去掉，将t1,t2连接后加上中括号。values为1，代表的是二维空间，分别把t1,t2的中间层的中括号去掉并连接，最后加上中括号。同理values为2,代表三维空间，把最里的中括号去掉连接，最后加上括号。就出现了如上的结果。

 

tf.squeeze(t, [1,2]):消除tensor t中指定位置的1维度，此例中删除前两个为1的维度

    如shape(t)=(1,3,4,5,2,1),则删除后为(3,4,5,2)

 

tf.pad(tensor, padding, mode, name):对输入的tensor进行填充操作

    参数类型：tensor:输入的张量

                      padding:也是一个张量，代表了每一维填充多少行/列

                      mode:分别为"CONSTANT", "REFLECT", "SYMMETRIC"

                                 CONSTANT:填充0

                                 REFLECT:映射填充:上下(1维)填充顺序和paddings是相反的，左右顺序补齐

                                 “STMMETRIC”:对称填充，上下填充顺序相同，左右对称补齐

     例子见tf.pad详解