tf.stack() 详解 —》理解为主

 tensorflow用于矩阵拼接的方法：tf.stack()

个人参考感觉还不错的一个理解（tf.stack() 和 tf.concat()的区别）：https://blog.youkuaiyun.com/Gai_Nothing/article/details/88416782

 

def stack(values, axis=0, name="stack"):
    """Stacks a list of rank-`R` tensors into one rank-`(R+1)` tensor.

  Packs the list of tensors in `values` into a tensor with rank one higher than
  each tensor in `values`, by packing them along the `axis` dimension.
  Given a list of length `N` of tensors of shape `(A, B, C)`;

  if `axis == 0` then the `output` tensor will have the shape `(N, A, B, C)`.
  if `axis == 1` then the `output` tensor will have the shape `(A, N, B, C)`.
  Etc."""

    '''Args:
    values: A list of `Tensor` objects with the same shape and type.
    axis: An `int`. The axis to stack along. Defaults to the first dimension.
      Negative values wrap around, so the valid range is `[-(R+1), R+1)`.
    name: A name for this operation (optional).'''

 个人理解 ~ 测试：

import tensorflow as tf
import numpy as np

sess = tf.Session()
sess.run(tf.global_variables_initializer())

# stack and unstack
stack_data1, stack_data2 = np.arange(1, 31).reshape([2, 3, 5])
print('stack_data1: \n', stack_data1)
print('stack_data1.shape: \n', stack_data1.shape)
print('stack_data2: \n', stack_data2)
print('stack_data2.shape: \n', stack_data2.shape)
# stack_data1:
#  [[ 1  2  3  4  5]
#  [ 6  7  8  9 10]
#  [11 12 13 14 15]]
# stack_data1.shape:
#  (3, 5)
# stack_data2:
#  [[16 17 18 19 20]
#  [21 22 23 24 25]
#  [26 27 28 29 30]]
# stack_data2.shape:
#  (3, 5)

# 理解：
#     举例：当前两个个张量的维度均为：（维1，维2， 维3， 维4）， 此时axis的取值范围为：[-5, 5)
#     所以输入 stacks = [stack_data1, stack_data2], st = tf.stack(stacks, axis=?)
#     此时：
#           stacks的维度为：（2，维1，维2， 维3， 维4 ）   维度为5，所以输出维度也为5， axis取值就在[-5, 5)
#           当axis=0时， st维度为：（2, 维1， 维2， 维3， 维4）
#           当axis=1时， st维度为：（维1， 2，维2， 维3， 维4）
#           当axis=2时， st维度为：（维1， 维2， 2，维3， 维4）
#           当axis=3时， st维度为：（维1， 维2， 维3，2，维4）
#           当axis=4时， st维度为：（维1， 维2， 维3，维4，2）

#           当axis=-5时， st维度为：（2, 维1， 维2， 维3， 维4）
#           当axis=-4时， st维度为：（维1， 2，维2， 维3， 维4）
#           当axis=-3时， st维度为：（维1， 维2， 2，维3， 维4）
#           当axis=-2时， st维度为：（维1， 维2， 维3，2，维4）
#           当axis=-1时， st维度为：（维1， 维2， 维3，维4，2）

print('======================================')
st_0 = tf.stack([stack_data1, stack_data2], axis=0)     # 2 * (3, 5) ==> (2, 3, 5)
st_0 = sess.run(st_0)
print('st_0: \n', st_0)
print('st_0.shape: \n', st_0.shape)
# st_0:
#  [[[ 1  2  3  4  5]
#   [ 6  7  8  9 10]
#   [11 12 13 14 15]]
#
#  [[16 17 18 19 20]
#   [21 22 23 24 25]
#   [26 27 28 29 30]]]
# st_0.shape:
#  (2, 3, 5)

print('======================================')
st_1 = tf.stack([stack_data1, stack_data2], axis=1)     # 2 * (3, 5) ==> (3, 2, 5)
st_1 = sess.run(st_1)
print('st_1: \n', st_1)
print('st_1.shape: \n', st_1.shape)
# st_1:
#  [[[ 1  2  3  4  5]
#   [16 17 18 19 20]]
#
#  [[ 6  7  8  9 10]
#   [21 22 23 24 25]]
#
#  [[11 12 13 14 15]
#   [26 27 28 29 30]]]
# st_1.shape:
#  (3, 2, 5)

print('======================================')
st_2 = tf.stack([stack_data1, stack_data2], axis=2)     # 2 * (3, 5) ==> (3, 5, 2)
st_2 = sess.run(st_2)
print('st_2: \n', st_2)
print('st_2.shape: \n', st_2.shape)
# st_2:
#  [[[ 1 16]
#   [ 2 17]
#   [ 3 18]
#   [ 4 19]
#   [ 5 20]]
#
#  [[ 6 21]
#   [ 7 22]
#   [ 8 23]
#   [ 9 24]
#   [10 25]]
#
#  [[11 26]
#   [12 27]
#   [13 28]
#   [14 29]
#   [15 30]]]
# st_2.shape:
#  (3, 5, 2)

print('======================================')
st_1_ = tf.stack([stack_data1, stack_data2], axis=-1)     # 2 * (3, 5) ==>  (3, 5, 2)   等同于st_2
st_1_ = sess.run(st_1_)
print('st_1_: \n', st_1_)
print('st_1_.shape: \n', st_1_.shape)
# st_1:
#  [[[ 1 16]
#   [ 2 17]
#   [ 3 18]
#   [ 4 19]
#   [ 5 20]]
#
#  [[ 6 21]
#   [ 7 22]
#   [ 8 23]
#   [ 9 24]
#   [10 25]]
#
#  [[11 26]
#   [12 27]
#   [13 28]
#   [14 29]
#   [15 30]]]
# st_1.shape:
#  (3, 5, 2)

print('=================比较st_1, 和 transpose=====================')
print('st_1: \n', st_1)
transpose_test = sess.run(tf.transpose(st_0, [1, 0, 2]))
print('transpose_test: \n', transpose_test)
print('transpose_test == st_1: \n', transpose_test == st_1)

print('=================比较st_2, 和 transpose=====================')
print('st_2: \n', st_2)
transpose_test = sess.run(tf.transpose(st_0, [1, 2, 0]))
print('transpose_test: \n', transpose_test)
print('transpose_test == st_2: \n', transpose_test == st_2)
# 总结：
#     tf.stack() 中 stacks = (2，维1，维2， 维3， 维4 ）
#     当axis=0时， 就相当于tf.transpose(stacks, [0, 1, 2, 3, 4])
#     当axis=1时， 就相当于tf.transpose(stacks, [1, 0, 2, 3, 4])
#     当axis=2时， 就相当于tf.transpose(stacks, [1, 2, 0, 3, 4])
#     当axis=3时， 就相当于tf.transpose(stacks, [1, 2, 3, 0, 4])
#     当axis=0时， 就相当于tf.transpose(stacks, [1, 2, 3, 4, 0])


# 4 维测试：
stack_data1, stack_data2 = np.arange(1, 121).reshape([2, 3, 4, 5]) # (2, 3, 4, 5)
st_ = tf.stack([stack_data1, stack_data2], axis=3)
st_0 = tf.stack([stack_data1, stack_data2], axis=0)
st_ = sess.run(st_)
st_0 = sess.run(st_0)

tr_ = tf.transpose(st_0, [1, 2, 3, 0])
tr_ = sess.run(tr_)

print('st_.shape: ', st_.shape)
print('st_: ', st_)

print('tr_.shape: ', tr_.shape)
print('tr_: ', tr_)

print(st_ == tr_)