Tensor Flow也提供了许多用于多张量的形状进行变换拆合的方法，主要分为维度变换和拆分合并两个方面，其中维度变换主要是对一个张量的形状进行改变，而拆分合并主要用于将一个张量按要求拆分成多个张量，或者将多个张量按某种方式合并成一个张量。下面分别从维度变换和拆分合并两个方面简单介绍一下张量在形状上的变换操作。
一、维度变换
维度变换主要包括：形状改变、维度扩张、维度缩减以及维度交换，TensorFlow中提供的维度变换相关函数主要有： tf.reshape，tf.expand_dims，tf.squeeze以及tf.transpose。其中：
-
tf.reshape用来对张量的进行形状改变。 -
tf.expand_dims用于对张量进行维度扩张。 -
tf.squeeze用于对张量进行维度缩减。 -
tf.transpose用于张量内部维度间的维度交换。
下面我们用代码实例的方式，演示集中方法的具体作用，在上述功能之前，我们需要先引入Numpy和TensorFlow的包，代码如下：
import numpy as np
import tensorflow as tf
print(np.__version__)
print(tf.__version__)
结果如下：
1.23.5
2.11.0
tf.reshape
tf.reshape可以改变张量的形状，但是其本质上不会改变底层张量元素的存储顺序和结构，所以该操作性能较高。代码如下：
#创建一个三维的形状为[3,3,3]的张量
a = tf.random.uniform(shape=[3, 3, 3], minval=0, maxval=10, dtype=tf.int32)
tf.print("a.shape:", a.shape)
print("a:")
tf.print(a)
print("----------------------------------")
#利用reshape生成一个[3,9]的二维张量
b = tf.reshape(a, [3, 9])
print("resize之后的b:")
tf.print(b)
print("----------------------------------")
#利用reshape生成一个[9,3]的二维张量
c = tf.reshape(b, [9, 3])
print("resize之后的c:")
tf.print(c)
print("----------------------------------")
#利用reshape生成一个[9,3,1]的三维张量
d = tf.reshape(c, [9, 3, 1])
print("resize之后的d:")
tf.print(d)
print("----------------------------------")
#原始张量不变
print("resize之后的a:")
tf.print(a)
print("----------------------------------")
结果如下：
a.shape: TensorShape([3, 3, 3])
a:
[[[3 5 2]
[2 1 0]
[2 8 9]]
[[3 4 5]
[7 1 3]
[1 6 3]]
[[5 1 1]
[5 5 5]
[6 0 8]]]
----------------------------------
resize之后的b:
[[3 5 2 ... 2 8 9]
[3 4 5 ... 1 6 3]
[5 1 1 ... 6 0 8]]
----------------------------------
resize之后的c:
[[3 5 2]
[2 1 0]
[2 8 9]
...
[5 1 1]
[5 5 5]
[6 0 8]]
----------------------------------
resize之后的d:
[[[3]
[5]
[2]]
[[2]
[1]
[0]]
[[2]
[8]
[9]]
...
[[5]
[1]
[1]]
[[5]
[5]
[5]]
[[6]
[0]
[8]]]
----------------------------------
resize之后的a:
[[[3 5 2]
[2 1 0]
[2 8 9]]
[[3 4 5]
[7 1 3]
[1 6 3]]
[[5 1 1]
[5 5 5]
[6 0 8]]]
----------------------------------
通过上述示例我们可以发现，tf.reshape不仅可以实现同维度间张量的形状变换，还能实现不同维度间张量的形状变换。
tf.expand_dims 和 tf.squeeze
tf.expand_dims主要用于在原张量的基础上，向第几个维度插入一个新维度，从而实现张量的维度扩张，而tf.squeeze用于自动识别张量中长度为1的维度，并将该维度消除，以实现对原张量的维度缩减的目的。实例代码如下：
#创建一个三维的形状为[3,3,3]的张量
a = tf.random.uniform(shape=[3, 3, 3], minval=0, maxval=10, dtype=tf.int32)
print("a.ndim:", a.ndim)
print("a.shape:", a.shape)
print("a:")
tf.print(a)
print("----------------------------------")
#在第axis = 1维插入一个新的维度
b = tf.expand_dims(a, axis=1)
print("b.ndim:", b.ndim)
print("b.shape:", b.shape)
tf.print(b)
print("----------------------------------")
#将某个维度上长度为1的维度进行消除
c = tf.squeeze(b)
print("c.ndim:", c.ndim)
print("c.shape:", c.shape)
tf.print(c)
print("----------------------------------")
结果如下：
a.ndim: 3
a.shape: (3, 3, 3)
a:
[[[7 8 7]
[7 3 3]
[4 0 6]]
[[8 4 5]
[6 9 1]
[4 4 9]]
[[3 4 5]
[1 1 2]
[6 1 9]]]
----------------------------------
b.ndim: 4
b.shape: (3, 1, 3, 3)
[[[[7 8 7]
[7 3 3]
[4 0 6]]]
[[[8 4 5]
[6 9 1]
[4 4 9]]]
[[[3 4 5]
[1 1 2]
[6 1 9]]]]
----------------------------------
c.ndim: 3
c.shape: (3, 3, 3)
[[[7 8 7]
[7 3 3]
[4 0 6]]
[[8 4 5]
[6 9 1]
[4 4 9]]
[[3 4 5]
[1 1 2]
[6 1 9]]]
----------------------------------
tf.transpose
与tf.reshape不同tf.transpose可以交换张量的维度进而改变张量元素的存储顺序。示例代码如下：
a = tf.random.uniform(shape=[2,3,4], minval=0, maxval=10, dtype=tf.int32)
print("a.shape:", a.shape)
print("a:")
tf.print(a)
print("----------------------------------")
# 转换成将形状转换成[4,2,3],
# 原张量中4对应于第2维，2对应于第0维，3对应于第1维，故perm=[2,0,1]
# 相比较原始张量的perm=[0,1,2],perm=[2,0,1]相当于先对第0维和第2维进行了维度交换，
# 然后对维度1和0进行交换
b = tf.transpose(a, perm=[2, 0, 1])
print("b.shape:", b.shape)
print("b:")
tf.print(b)
print("----------------------------------")
# 不对维度进行交换
c = tf.transpose(a, perm=[0, 1, 2])
print("c.shape:", c.shape)
print("c:")
tf.print(c)
print("----------------------------------")
结果如下：
a.shape: (2, 3, 4)
a:
[[[0 0 5 3]
[2 5 3 8]
[3 9 6 1]]
[[5 7 3 0]
[2 5 0 2]
[4 3 8 0]]]
----------------------------------
b.shape: (4, 2, 3)
b:
[[[0 2 3]
[5 2 4]]
[[0 5 9]
[7 5 3]]
[[5 3 6]
[3 0 8]]
[[3 8 1]
[0 2 0]]]
----------------------------------
c.shape: (2, 3, 4)
c:
[[[0 0 5 3]
[2 5 3 8]
[3 9 6 1]]
[[5 7 3 0]
[2 5 0 2]
[4 3 8 0]]]
----------------------------------
以上关于TensorFlow中张量的形状变换进行了简单的示例，下面我们继续了解一下TensorFlow中张量的拆分合并。
二、拆分合并
针对张量的拆分，TensorFlow提供了tf.split方法来实现，而针对多个张量和合并，TensorFlow也提供了类似于Numpy和Pandas的tf.concat及tf.stack等方法。
首先我们先对张量的拆分进行简单的示例，tf.split主要用于将某个张量按照某个维度平均拆分成若干份，从而得到多个拆分后的张量。代码如下：
a = tf.random.uniform(shape=[2,3,4], minval=0, maxval=10, dtype=tf.int32)
print("a.shape:", a.shape)
print("a:")
tf.print(a)
print("----------------------------------")
#基于维度0，将a张量平均拆分成两个
splits = tf.split(a, 2, axis = 0)
print("基于维度0，将a张量平均拆分成2个，拆分后的每个张量如下:")
for split in splits:
tf.print(split)
print("==================")
print("----------------------------------")
print("基于维度1，将a张量平均拆分成3个，拆分后的每个张量如下:")
splits = tf.split(a, 3, axis = 1)
for split in splits:
tf.print(split)
print("==================")
print("----------------------------------")
print("基于维度2，将a张量平均拆分成2个，拆分后的每个张量如下:")
splits = tf.split(a, 2, axis = 2)
for split in splits:
tf.print(split)
print("==================")
print("----------------------------------")
结果如下：
a.shape: (2, 3, 4)
a:
[[[8 3 4 2]
[4 7 2 8]
[9 9 9 1]]
[[3 9 1 6]
[4 7 5 9]
[8 5 6 8]]]
----------------------------------
基于维度0，将a张量平均拆分成2个，拆分后的每个张量如下:
[[[8 3 4 2]
[4 7 2 8]
[9 9 9 1]]]
==================
[[[3 9 1 6]
[4 7 5 9]
[8 5 6 8]]]
==================
----------------------------------
基于维度1，将a张量平均拆分成3个，拆分后的每个张量如下:
[[[8 3 4 2]]
[[3 9 1 6]]]
==================
[[[4 7 2 8]]
[[4 7 5 9]]]
==================
[[[9 9 9 1]]
[[8 5 6 8]]]
==================
----------------------------------
基于维度2，将a张量平均拆分成2个，拆分后的每个张量如下:
[[[8 3]
[4 7]
[9 9]]
[[3 9]
[4 7]
[8 5]]]
==================
[[[4 2]
[2 8]
[9 1]]
[[1 6]
[5 9]
[6 8]]]
==================
----------------------------------
上面我们讲完了张量的拆分，下面我们介绍一下张量的合并。TensorFlow提供了两种方法来实现张量和合并，分别是tf.concat和tf.stack，其中tf.concat是从某个维度上对两个张量进行连接，形成新的结果张量，结果张量的维度和原张量的维度是一致的，不会增加结果张量的维度。而tf.stack是堆叠，会增加结果张量维度。我们先来看一下tf.concat的合并效果，代码如下：
a = tf.constant([[1, 2, 3], [4, 5, 6]])
b = tf.constant([[7, 8, 9], [10, 11,12]])
print("原始张量a:")
tf.print(a)
print("----------------------------------")
print("原始张量b:")
tf.print(b)
print("----------------------------------")
# 按照维度0对张量a和张量b进行合并
c = tf.concat([a, b], axis = 0)
print("按照维度0合并后的张量：")
print("c.shape:", c.shape)
print("c: ")
tf.print(c)
print("----------------------------------")
# 按照维度1对张量a和张量b进行合并
d = tf.concat([a, b], axis = 1)
print("按照维度1合并后的张量：")
print("d.shape:", d.shape)
print("d: ")
tf.print(d)
print("----------------------------------")
结果如下：
原始张量a:
[[1 2 3]
[4 5 6]]
----------------------------------
原始张量b:
[[7 8 9]
[10 11 12]]
----------------------------------
按照维度0合并后的张量：
c.shape: (4, 3)
c:
[[1 2 3]
[4 5 6]
[7 8 9]
[10 11 12]]
----------------------------------
按照维度1合并后的张量：
d.shape: (2, 6)
d:
[[1 2 3 7 8 9]
[4 5 6 10 11 12]]
----------------------------------
我们再看一下tf.stack的合并效果，代码如下：
a = tf.constant([[1, 2, 3, 4], [5, 6, 7, 8]])
b = tf.constant([[9, 10, 11, 12], [13, 14, 15, 16]])
print("原始张量a:")
print("a.shape:", a.shape)
tf.print(a)
print("----------------------------------")
print("原始张量b:")
print("b.shape:", b.shape)
tf.print(b)
print("----------------------------------")
# 按照维度0对张量a和张量b进行合并
c = tf.stack([a, b], axis = 0)
print("按照维度0合并后的张量：")
print("c.shape:", c.shape)
print("c: ")
tf.print(c)
print("----------------------------------")
# 按照维度1对张量a和张量b进行合并
d = tf.stack([a, b], axis = 1)
print("按照维度1合并后的张量：")
print("d.shape:", d.shape)
print("d: ")
tf.print(d)
print("----------------------------------")
结果如下：
原始张量a:
a.shape: (2, 4)
[[1 2 3 4]
[5 6 7 8]]
----------------------------------
原始张量b:
b.shape: (2, 4)
[[9 10 11 12]
[13 14 15 16]]
----------------------------------
按照维度0合并后的张量：
c.shape: (2, 2, 4)
c:
[[[1 2 3 4]
[5 6 7 8]]
[[9 10 11 12]
[13 14 15 16]]]
----------------------------------
按照维度1合并后的张量：
d.shape: (2, 2, 4)
d:
[[[1 2 3 4]
[9 10 11 12]]
[[5 6 7 8]
[13 14 15 16]]]
----------------------------------
关于TensorFlow中张量的变换拆合就简单介绍到这里，其实TensorFlow中的张量操作很大程度上参考了Numpy中对ndarray的操作，因此上手起来还是比较容易的。
