tensorflow学习笔记（三）

在学习YOLO-tensorflow代码的过程中，继续学习了关于tensorflow的一些内容。随笔记下：

1  tf.pad

import tensorflow as tf

#定义一个二维和三维的数据
t1 = tf.constant([[1, 2, 3], [4, 5, 6]])
t2 = tf.constant([[[1,2,3], [4,5,6], [7,8,9]]])

with tf.Session() as sess:
    # 例子1 二维
    op = tf.pad(t1, tf.constant([[1, 1], [1, 1]]), "CONSTANT")
    #第一个[1,1]代表在第一维度pad，即在t2的第一维上填充，其数字1代表填充一排
    #第二个[1,1]代表在第二维度pad，即在t2的第二维上填充，其数字1代表填充一排
    print(t1.shape)
    print(sess.run(op))

    # 例子2 三维
    print(t2.shape)
    op = tf.pad(t2, tf.constant([[2, 2], [2, 2], [2, 2]]), "CONSTANT")
    # 第一个[2,2]代表在第二维度pad，即在t2的第一维上填充，其数字2代表填充两排
    # 第二个[2,2]代表在第二维度pad，即在t2的第二维上填充，其数字2代表填充两排
    # 第三个[2,2]代表在第二维度pad，即在t2的第三维上填充，其数字2代表填充两排
    print(sess.run(op))
    print(op.shape)

2  ...的意义

在yolo源码中看到了许多...，开始并不知道是什么意思，然后自己去仿写了一段代码，然后输出。... 表示一种省略，下面附上一段代码，自己体会。

t3 = np.array([[[1,2,3],
                [4,5,6]],
               [[7,8,9],
                [10,11,12]]])
print('t3[...,2] : ',t3[...,1,1])
print('t3.shape :' , t3.shape)
print('t3[0,1,1] :', t3[0,1,1])

result：
t3[...,2] :  [ 5 11]
t3.shape : (2, 2, 3)
t3[0,1,1] : 5

3   tf.nn.leaky_relu(input,alpha,name)

一般来讲leaky_relu后面直接把input丢进去即可，然而当你想要改变其他参数的时候，就要搞明白意义，alpha默认值为0.2，这个alpha一开始我也不知道干嘛的，然后自己搞了个输入，然后经过leaky_relu输出一下：

可以发现这个alpha就是leaky_relu小于零的部分的斜率。

t4 = np.array([[[1,-2,3],
                [4,-5,6]],
               [[7,8,-9],
                [-10,11,12]]])
t4 = tf.nn.leaky_relu(t4, alpha=0.01)
print("t4 = {}".format(tf.Session().run(t4)))

result：
t4 = [[[ 1.         -0.02        3.        ]
      [ 4.         -0.05        6.        ]]
      [[ 7.          8.         -0.09      ]
       [-0.09999999 11.         12.        ]]]

4  np.transpose(input , array )

np.transpose()实现矩阵的转至，我们都知道，对于一个二维矩阵[x,y]，转至后变为[y,x]，也就是x轴和y轴交换了位置。那么当输入是一个三维甚至更高维度的矩阵的时候呢？array的作用又是什么呢？下面我们实际去测试一下。通过shape的改变看一看，矩阵是如何进行转至的。

一个三维的矩阵的shape为（x，y，z），类比二维的转至从（x，y）到（y，x），三维默认的转至是从（x，y，z）转至为(z,y,x)，你可以把三维的shape（x，y，z）的三个维度的索引想象成（0,1,2），那么转至后就是（2,1,0），这个（2,1,0）也就是默认的array，如果你想以其他方式转至，那么比如说你设置array为（1,2,0），那转至后就是（y，z，x）。可能我表述的还不够清楚，下面的代码可以加深你的理解。

import numpy

t5 = np.arange(24).reshape(2, 3, 4) #t5.shape: (2, 3, 4)
print("t5.shape:",t5.shape)         #这个是我自己生成的初始矩阵
print("t5 : ",t5)

t6= np.transpose(t5)                #t6.shape: (4, 3, 2)
print("t6.shape:",t6.shape)         #不设置array，使用默认的array，转至后形状为（4,3,2）
print("t6 : {} ".format(t6))

t7= np.transpose(t5,(2,1,0))        #t7.shape: (4, 3, 2)
print("t7.shape:",t7.shape)         #设置array为（2,1,0），转至后形状与t6相同，说明默认的                          
print("t7 : {} ".format(t7))        #array为（2,1,0）

t8= np.transpose(t5,(0,1,2))        #t8.shape: (2, 3, 4)
print("t8.shape:",t8.shape)         #那么如果我把array设置为（0,1,2）会是怎么样呢？
print("t8 : {} ".format(t8))        #结果就是（0,1,2）相当于没有进行转至

t9=np.transpose(t5,(1,2,0))         #t9.shape: (3, 4, 2)
print("t9.shape:",t9.shape)         #相当于x轴变为了z轴，y轴变为x轴，z轴变为y轴
print("t9 : {} ".format(t9))

#更高维度以此类推

5  tf.stack([   , ] ，axis= )

tf.stack()用于矩阵的叠加，axis参数表示在第几个维度上堆叠，axis=0表示在第0个维度上堆叠起来。

a1=np.array([[0,1,2,3],[2,3,4,5],[2,3,4,5]])
a2=np.array([[2,3,4,5],[3,4,5,6],[2,3,4,5]])
a = tf.stack([a1,a2],axis=1)
print('a : {}'.format(tf.Session().run(a)))
print(a1.shape)        #a1.shape = （3,4）
print(a2.shape)        #a2.shape = （3,4）
print(a.shape)        #a.shape=（3,2,4）

axis=0 时，a.shape=(2,3,4) 表示在第一个维度上堆叠

axis=1 时，a.shape=(3,2,4) 表示在第二个维度上堆叠

axis=2 时，a.shape=(3,4,2) 表示在第三个维度上堆叠

【注】如果被堆叠的矩阵的维度为2，那么堆叠后的维度为3，axis的索引最多等于2。文字表述不清楚，靠代码去理解，注意我用彩色标注出来的维度。这个就是堆叠后新添的那个维度。

6  tf.cast()

cast(
    x,
    dtype,
    name=None
)
#类型转换函数，x为输入，比如x中的数为浮点数，然后你设置dtype为整形数，那么转换完之后，x为整形数。

7  tf.tile() 

tf.tile()与tf.stack有点类似，但是，stack是增加了一个维度，而tile只是把原矩阵在其某一个维度上进行扩充

import tensorflow as tf
import numpy as np

labels= np.arange(120).reshape(2,3,4,5)
#在这个地方我用到了上面的...，表示前面几个维度我不动，最后一个维度上我索引[1:3],也就是两个值，那么
#下面我reshape的时候，就可以只把某个地方的内容拿出来，单独reshape
boxes = tf.reshape(labels[..., 1:3],    
                [2, 3, 4, 1, 2])        
boxes=tf.Session().run(boxes)                
print('boxes.shape',boxes.shape)    # boxes.shape (2, 3, 4, 1, 2)
b= tf.tile(boxes,[1,1,1,2,1])      #这个矩阵中1表示原来的维度不变，第四个位置上的2表示在第四个
b=tf.Session().run(b)              #维度上扩充两倍
print('b.shape',b.shape)            # b.shape (2, 3, 4, 2, 2)

8  tf.maximum（）和tf.minimum（）

tf.maximum（）和tf.minimum（）本身是求括号内的最大最小值的，但是引入高维矩阵后，怎么比较大小呢？手敲了一遍后，发现是这样子的，相同维度的矩阵可以比较大小，具体是相应位置的数值比较大小然后返回相同的shape。

import tensorflow
lu = tf.maximum([1,6,30,10,50], [4,5,100,7,8])
rd = tf.minimum([1,4,6,7], [8,3,7,1],)
sess=tf.Session()
print("maximum",sess.run(lu))
print("minimum",sess.run(rd))


# result：
# maximum [  4   6 100  10  50]
# minimum [1 3 6 1]

9  tf.summary

 tf.summary.merge_all 可以将所有summary全部保存到磁盘，以便tensorboard显示。

tf.summary.FileWriter 指定一个文件用来保存图。格式：tf.summary.FileWritter(path,sess.graph)

关于tf.summary()的更多用法参考

https://www.cnblogs.com/mtcnn/p/9411703.html

 https://www.cnblogs.com/lyc-seu/p/8647792.html

10  tf.train.exponential_decay函数(指数衰减法)

在Tensorflow中，为解决设定学习率(learning rate)问题，提供了指数衰减法来解决。

通过tf.train.exponential_decay函数实现指数衰减学习率。

步骤：1.首先使用较大学习率(目的：为快速得到一个比较优的解);

           2.然后通过迭代逐步减小学习率(目的：为使模型在训练后期更加稳定);

其中，initial_learning_rate为事先设定的初始学习率；decay_rate为衰减系数； decay_steps为衰减速度。

11 tf.train.Saver.save(sess, save_path, global_step=None, latest_filename=None, meta_graph_suffix='meta', write_meta_graph=True)

• sess:  用于保存变量的Session
• save_path:  checkpoint 文件的路径。如果saver 是共享的，这是共享checkpoint 文件名的前缀。
• global_step:  如果提供了global step number，将会追加到 save_path 后面去创建checkpoint 的文件名。可选参数可以是一个Tensor，一个name Tensor或integer Tensor.