tf.reverse()和tf.transpose()-优快云博客

本文介绍TensorFlow中tf.reverse()与tf.transpose()函数的使用方法，通过多个实例展示了如何利用这两个函数实现数据翻转及转置操作，特别适用于图像处理场景。

参考 tf.reverse()和tf.transpose() - 云+社区 - 腾讯云

一、tf.reverse()

tf.reverse(
    tensor,
    axis,
    name=None
)

参数：

tensor: 需要进行反转的张量，类型必须为其中的一个uint8, int8, uint16, int16, int32, int64, bool, bfloat16, half, float32, float64, complex64, complex128, string。最高维度为8-D
axis: 需要反转的axis，注意axis的范围是[-rank(tensor),rank(tensor))之间
name: 可选的

很显然可以看出，axis=[3]的时候也就是在最里面那一层进行reverse，axis=[2]的时候就是在倒数第二层进行reverse，那么就是对两个三维数组分别进行reverse，颠倒顺序，axis=[1]的时候在最外层进行颠倒，那么就将两个三维数组直接互换位置即可。

例1：

import tensorflow as tf
t=tf.constant([[
                [[ 0,  1,  2,  3],
                 [ 4,  5,  6,  7],
                 [ 8,  9, 10, 11]],
                    
                 [[12, 13, 14, 15],
                  [16, 17, 18, 19],
                  [20, 21, 22, 23]]
              ]])

# tensor 't' shape is [1, 2, 3, 4]
     
with tf.Session() as sess:
   print("t")
   print(sess.run(t))
   print("reverse at axis=[3]")
   print(sess.run(tf.reverse(t,axis=[3])))
   print("reverse at axis=[1]")
   print(sess.run(tf.reverse(t,axis=[1])))
   print("reverse at axis=[2]")
   print(sess.run(tf.reverse(t,axis=[2])))

Output:
---------------------
t
[[[[ 0  1  2  3]
   [ 4  5  6  7]
   [ 8  9 10 11]]

  [[12 13 14 15]
   [16 17 18 19]
   [20 21 22 23]]]]
reverse at axis=[3]
[[[[ 3  2  1  0]
   [ 7  6  5  4]
   [11 10  9  8]]

  [[15 14 13 12]
   [19 18 17 16]
   [23 22 21 20]]]]
reverse at axis=[1]
[[[[12 13 14 15]
   [16 17 18 19]
   [20 21 22 23]]

  [[ 0  1  2  3]
   [ 4  5  6  7]
   [ 8  9 10 11]]]]
reverse at axis=[2]
[[[[ 8  9 10 11]
   [ 4  5  6  7]
   [ 0  1  2  3]]

  [[20 21 22 23]
   [16 17 18 19]
   [12 13 14 15]]]]
-----------------------

例2：

在一般的数据处理中，我们会先图像进行翻转，也就是左右的颠倒，假设原始的图像的shape [batch_size,height,width,channel]翻转后shape不变，但是翻转后的变成

flips[i][j][width-k][l] = inputs[i][j][k][l]

对axis=[2]进行reverse

import tensorflow as tf
import numpy as np
     
A=np.arange(24).reshape([2,2,2,3])
Y=tf.reverse(A,axis=[2])
     
with tf.Session() as sess:
   print("A")
   print(A)
   print("Y")
   print(sess.run(Y))
   print("第一个图像样本的第一个channel的对应矩阵为A[0,:,:,0]:")
   print(A[0,:,:,0])
   print("将其左右进行翻转后的结果Y[0,:,:,0]:")
   print(sess.run(Y)[0,:,:,0])



OUtput:
-------------------------------------------------------
A
[[[[ 0  1  2]
   [ 3  4  5]]

  [[ 6  7  8]
   [ 9 10 11]]]


 [[[12 13 14]
   [15 16 17]]

  [[18 19 20]
   [21 22 23]]]]
Y
[[[[ 3  4  5]
   [ 0  1  2]]

  [[ 9 10 11]
   [ 6  7  8]]]


 [[[15 16 17]
   [12 13 14]]

  [[21 22 23]
   [18 19 20]]]]
第一个图像样本的第一个channel的对应矩阵为A[0,:,:,0]:
[[0 3]
 [6 9]]
将其左右进行翻转后的结果Y[0,:,:,0]:
[[3 0]
 [9 6]]
-----------------------------------------------------

例3：

将图像进行上下的翻转。

import tensorflow as tf
import numpy as np
     
A = np.arange(24).reshape([2,2,2,3])
Y = tf.reverse(A,axis=[1])
     


with tf.Session() as sess:
   print("A")
   print(A)
   print("Y")
   print(sess.run(Y))
   print("第一个图像样本的第一个channel的对应矩阵为A[0,:,:,0]:")
   print(A[0,:,:,0])
   print("将其上下进行翻转后的结果Y[0,:,:,0]:")
   print(sess.run(Y)[0,:,:,0])


Output:
-------------------------------------------------------------
A
[[[[ 0  1  2]
   [ 3  4  5]]

  [[ 6  7  8]
   [ 9 10 11]]]


 [[[12 13 14]
   [15 16 17]]

  [[18 19 20]
   [21 22 23]]]]
Y
[[[[ 6  7  8]
   [ 9 10 11]]

  [[ 0  1  2]
   [ 3  4  5]]]


 [[[18 19 20]
   [21 22 23]]

  [[12 13 14]
   [15 16 17]]]]
第一个图像样本的第一个channel的对应矩阵为A[0,:,:,0]:
[[0 3]
 [6 9]]
将其上下进行翻转后的结果Y[0,:,:,0]:
[[6 9]
 [0 3]]
--------------------------------------------------------

例4：

图像处理--将图像翻转90度。

import tensorflow as tf
import numpy as np
     
A = np.arange(24).reshape([2,2,2,3])
X = tf.transpose(A,perm=[0,2,1,3])
Y = tf.reverse(X,axis=[1])
     
with tf.Session() as sess:
   print("A")
   print(A)
   print("Y")
   print(sess.run(Y))
   print("第一个图像样本的第一个channel的对应矩阵为A[0,:,:,0]:")
   print(A[0,:,:,0])
   print("将其旋转90度的结果Y[0,:,:,0]:")
   print(sess.run(Y)[0,:,:,0])


Output:
---------------------------------------------------------
A
[[[[ 0  1  2]
   [ 3  4  5]]

  [[ 6  7  8]
   [ 9 10 11]]]

 [[[12 13 14]
   [15 16 17]]

  [[18 19 20]
   [21 22 23]]]]
Y
[[[[ 3  4  5]
   [ 9 10 11]]

  [[ 0  1  2]
   [ 6  7  8]]]

 [[[15 16 17]
   [21 22 23]]

  [[12 13 14]
   [18 19 20]]]]

第一个图像样本的第一个channel的对应矩阵为A[0,:,:,0]:
[[0 3]
 [6 9]]
将其旋转90度的结果Y[0,:,:,0]:
[[3 9]
 [0 6]]
---------------------------------------------------

二、tf.transpose()

tf.transpose(
    a,
    perm=None,
    name='transpose',
    conjugate=False
)

参数：

a: 表示的是需要变换的张量
perm: a的新的维度序列
name: 操作的名字，可选的
conjugate: 可选的，设置成True，那么就等于tf.conj(tf.transpose(input))

例：

最简单的二维的transpose，就是矩阵的转置

import tensorflow as tf
import numpy as np
     
A = np.array([[1, 2, 3], [4, 5, 6]])
X = tf.transpose(A, [1, 0])
     
with tf.Session() as sess:
   print("original:",A)
   print("tranpose:",sess.run(X))


Output:
----------
original: 
[[1 2 3]
 [4 5 6]]
tranpose: 
[[1 4]
 [2 5]
 [3 6]]
---------

例2：

一个三维的array，shape为[i,j,k],可以看成是i个[j,k]的二维数组，那么i在这个三维数组的高度，j表示的是二维数组的行数，k表示的是二维数组的列数。

import tensorflow as tf
import numpy as np
     
A=np.arange(12).reshape([2,3,2])
X=tf.transpose(A,[0,2,1])
Y=tf.transpose(A,[1,0,2])

with tf.Session() as sess:
   print("original:")
   print(A)
   print("transpose [0,2,1]:")
   print(sess.run(X))
   print("transpose [0,2,1]‘s shape:")
   print(X.get_shape().as_list())
   print("transpose [1,0,2]:")
   print(sess.run(Y))
   print("transpose [1,0,2]'s shape")
   print(Y.get_shape().as_list())


Output:
----------------------------
original:
[[[ 0  1]
  [ 2  3]
  [ 4  5]]

 [[ 6  7]
  [ 8  9]
  [10 11]]]
transpose [0,2,1]:
[[[ 0  2  4]
  [ 1  3  5]]

 [[ 6  8 10]
  [ 7  9 11]]]
transpose [0,2,1]‘s shape:
[2, 2, 3]
transpose [1,0,2]:
[[[ 0  1]
  [ 6  7]]

 [[ 2  3]
  [ 8  9]]

 [[ 4  5]
  [10 11]]]
transpose [1,0,2]'s shape
[3, 2, 2]
------------------------------

原本输入的shape为[2,3,2]，经过transpose(A, 0,2,1])也就是将第二维度和第三维度进行调换，得到的shape为[2,2,3]，同理经过transpose(A, [1,0,2])将第一和第二维度进行调换，得到的shape为[3,2,2]。原本的A[1][1][0]经过transpose([0,2,1])之后变成了X[1][0][1]。同样的原本的A[0][1][1]经过transpose([1,0,2])也就变成了Y[1][0][1]。代码如下所示，

import tensorflow as tf
import numpy as np
     
A=np.arange(12).reshape([2,3,2])
X=tf.transpose(A,[0,2,1])
Y=tf.transpose(A,[1,0,2])
with tf.Session() as sess:
   print("A[1][1][0]:")
   print(A[1][1][0])
   print("transpose [0,2,1]:X[1][0][1]")
   print(sess.run(X)[1][0][1])
   print("A[0][1][1]:")
   print(A[0][1][1])
   print("transpose [1,0,2]:Y[1][0][1]")
   print(sess.run(Y)[1][0][1])


Output:
-----------------------------
A[1][1][0]:
8
transpose [0,2,1]:X[1][0][1]
8
A[0][1][1]:
3
transpose [1,0,2]:Y[1][0][1]
3
-----------------------------

例3：

四维，一般应用在图像上

import tensorflow as tf
import numpy as np
     
A=np.arange(24).reshape([2,3,2,2])
X=tf.transpose(A,[0,2,1,3])
Y=tf.transpose(A,[1,0,3,2])
    
with tf.Session() as sess:
   print("A")
   print(A)
   print("X.shape")
   print(X.get_shape().as_list())
   print("X")
   print(sess.run(X))
   print("Y.shape")
   print(Y.get_shape().as_list())
   print("Y")
   print(sess.run(Y))


Output:
--------------------
A
[[[[ 0  1]
   [ 2  3]]

  [[ 4  5]
   [ 6  7]]

  [[ 8  9]
   [10 11]]]


 [[[12 13]
   [14 15]]

  [[16 17]
   [18 19]]

  [[20 21]
   [22 23]]]]
X.shape
[2, 2, 3, 2]
X
[[[[ 0  1]
   [ 4  5]
   [ 8  9]]

  [[ 2  3]
   [ 6  7]
   [10 11]]]


 [[[12 13]
   [16 17]
   [20 21]]

  [[14 15]
   [18 19]
   [22 23]]]]
Y.shape
[3, 2, 2, 2]
Y
[[[[ 0  2]
   [ 1  3]]

  [[12 14]
   [13 15]]]


 [[[ 4  6]
   [ 5  7]]

  [[16 18]
   [17 19]]]


 [[[ 8 10]
   [ 9 11]]

  [[20 22]
   [21 23]]]]
-----------------