TensorFlow低阶API（二）—— 张量

不念不忘少年蓝@ 2023-08-17 15:47 9阅读 0赞

## 简介 ##

正如名字所示，TensorFlow这一框架定义和运行涉及张量的计算。**张量**是对矢量和矩阵向潜在的更高维度的泛化。TensorFlow在内部将张量表示为基本数据类型的n维数组。

在编写TensorFlow程序时，您操作和传递的主要对象是 **tf.Tensor**。tf.Tensor对象表示一个部分定义的计算，最终会生成一个值。TensorFlow程序首先会构建一个tf.Tensor**对象图**，详细说明如何基于其它可用张量计算每个张量，然后运行运行改图的某些部分以获得期望的结果。

tf.Tensor具有以下属性：

*  数据类型（例如float32、int32或string）
 *  形状

张量中的每个元素都具有相同的数据类型，且该数据类型一定是已知的。形状，即张量的维数和每个维度的大小，可能只有部分已知。如果其输入的形状也完全已知，则大多数操作会生成形状完全已知的张量，但在某些情况下，只能在执行图时获得张量的形状。

有些类型的张量有点特殊，TensorFlow指南的其它部分有所介绍。以下是主要特殊张量：

*  tf.Variable
 *  [tf.constant][]
 *  [tf.placeholder][]
 *  [tf.SparseTensor][]

除了tf.Variable以外，张量的值是不变的，这意味着对于单个执行任务，张量只是一个值。然而，两次评估同一张量可能会返回不同的值。例如，该张量是从磁盘读取数据的结果，或是生成随机数的结果。

## 阶 ##

tf.Tensor对象的阶是它本身的维数。阶的同义词包括：秩、等级或n维。请注意，TensorFlow中的阶与数学中矩阵的阶并不是同一个概念。如下表所示，TensorFlow中的每个阶都对应一个不同的数学实例：

<table style="width:501px;"> 
 <thead> 
  <tr> 
   <th>阶</th> 
   <th>数学实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>0</td> 
   <td>标量（只有大小）</td> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td>矢量（大小和方向）</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>矩阵（数据表）</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>3 阶张量（数据立体）</td> 
  </tr> 
  <tr> 
   <td>n</td> 
   <td>n 阶张量（自行想象）</td> 
  </tr> 
 </tbody> 
</table>

### 0阶 ###

以下摘要演示了创建0阶变量的过程：

1 mammal = tf.Variable("Elephant", tf.string)
    2 ignition = tf.Variable(451, tf.int16)
    3 floating = tf.Variable(3.14159265359, tf.float64)
    4 its_complicated = tf.Variable(12.3 - 4.85j, tf.complex64)

**注意**：字符串在 TensorFlow 中被视为单一项，而不是一连串字符。TensorFlow 可以有标量字符串，字符串矢量，等等。

### 1阶 ###

要创建1阶tf.Tensor对象，您可以传递一个项目列表作为初始值。例如：

1 mystr = tf.Variable(["Hello"], tf.string)
    2 cool_numbers  = tf.Variable([3.14159, 2.71828], tf.float32)
    3 first_primes = tf.Variable([2, 3, 5, 7, 11], tf.int32)
    4 its_very_complicated = tf.Variable([12.3 - 4.85j, 7.5 - 6.23j], tf.complex64)

### 更高阶 ###

2阶tf.Tensor对象至少包含一行和一列：

1 mymat = tf.Variable([[7],[11]], tf.int16)
    2 myxor = tf.Variable([[False, True],[True, False]], tf.bool)
    3 linear_squares = tf.Variable([[4], [9], [16], [25]], tf.int32)
    4 squarish_squares = tf.Variable([ [4, 9], [16, 25] ], tf.int32)
    5 rank_of_squares = tf.rank(squarish_squares)
    6 mymatC = tf.Variable([[7],[11]], tf.int32)

同样，更高阶的张量由一个n维数组组成。例如，在图像处理过程中，会使用许多4阶张量，维度对应批次大小、图像宽度、图像高度和颜色通道。

1 my_image = tf.zeros([10, 299, 299, 3])  # batch x height x width x color

### 获取tf.Tensor对象的阶 ###

要确定tf.Tensor对象的阶，需要调用 **tf.rank** 方法。例如，以下方法会程序化的确定上一节中所定义的tf.Tensor的阶：

1 r = tf.rank(my_image)
    2 # After the graph runs, r will hold the value 4.

### 引用tf.Tensor切片 ###

由于tf.Tensor是n维单元数组，因此要访问tf.Tensor中的某一单元，需要指定n个索引。

0阶张量（标量）不需要索引，因为其本身就是单一数字。

对于1阶张量（矢量），可以通过传递一个索引访问某个数字：

1 my_scalar = my_vector[2]

**请注意**，如果想从矢量中动态的选择元素，那么在 \[ \] 内传递的索引本身可以是一个标量tf.Tensor。

对于2阶及以上的张量，情况更为有趣。对于2阶tf.Tensor，传递两个数字会如预期般返回一个标量：

1 my_scalar = my_matrix[1, 2]

而传递一个数字则会返回矩阵子矢量，如下所示：

1 my_row_vector = my_matrix[2]
    2 my_column_vector = my_matrix[:, 3]

符号 ： 是python切片语法，意味“不要触碰该维度”。这对更高阶的张量来说很有用，可以帮助访问其子矢量，子矩阵，甚至其它子张量。

## 形状 ##

张量的形状是每个维度中元素的数量。TensorFlow在图的构建中自动推理形状。这些推理的形状可能具有已知阶或未知阶。如果阶已知，则每个维度的大小可能已知或未知。

TensorFlow文件编制中通过三种符号约定来描述张量维度：阶、形状和维数。下表阐述了　　三者如何相互关联：

形状可以通过整形Python列表/元组或者 **tf.TensorShape** 表示。

### 获取tf.Tensor对象的形状 ###

可以通过两种方法获取tf.Tensor的形状。在构建图的时候，询问有关张量形状的已知信息通常很有帮助。可以通过查看shape属性（属于tf.Tensor对象）获取这些信息。该方法会返回一个 **TensorShape** 对象，这样可以方便地表示部分指定的形状（因为在构建图的时候，并不是所有形状都完全已知）。

也可以获取一个将在运行时表示另一个tf.Tensor的完全指定形状的tf.Tensor。为此，可以调动 **tf.shape** 操作。如此以来，您可以构建一个图，通过构建其它取决于输入tf.Tensor的动态形状的张量来控制张量的形状。

例如，以下代码展示了如何创建大小与给定矩阵中的列数相同的零矢量

1 zeros = tf.zeros(my_matrix.shape[1])

### 改变tf.Tensor对象的形状 ###

张量的**元素数量**是其所有形状大小的乘积。标量的元素数量永远是1。由于通常有许多不同的形状具有相同数量的元素，因此如果能改变tf.Tensor的形状并使其元素固定不变通常会很方便。为此，可以使用 **tf.reshape**。

以下示例演示了如何重构张量：

1 rank_three_tensor = tf.ones([3, 4, 5])
     2 matrix = tf.reshape(rank_three_tensor, [6, 10])  # Reshape existing content into
     3                                                  # a 6x10 matrix
     4 matrixB = tf.reshape(matrix, [3, -1])  #  Reshape existing content into a 3x20
     5                                        # matrix. -1 tells reshape to calculate
     6                                        # the size of this dimension.
     7 matrixAlt = tf.reshape(matrixB, [4, 3, -1])  # Reshape existing content into a
     8                                              #4x3x5 tensor
     9 
    10 # Note that the number of elements of the reshaped Tensors has to match the
    11 # original number of elements. Therefore, the following example generates an
    12 # error because no possible value for the last dimension will match the number
    13 # of elements.
    14 yet_another = tf.reshape(matrixAlt, [13, 2, -1])  # ERROR!

## 数据类型 ##

除维度外，张量还具有数据类型。如需数据类型的完整列表，请参阅 **tf.Dtype** 页面。

一个tf.Tensor只能有一种数据类型。但是，可以将任意数据结构序列化为 **string** 并将其存储在tf.Tensor中。

可以将tf.Tensor从一种数据类型转型到另一种（通过 **tf.cast** ）:

1 # Cast a constant integer tensor into floating point.
    2 float_tensor = tf.cast(tf.constant([1, 2, 3]), dtype=tf.float32)

要检查tf.Tensor的数据类型，请使用 **Tensor.dtype** 属性。

用Python对象创建一个tf.Tensor时，可以选择指定数据类型。如果不指定数据类型，TensorFlow会选择一个可以表示您的数据的数据类型。TensorFlow会将Python整数转型为 **tf.int32**，并将Python浮点型转型为 **tf.float32**。此外，TensorFlow使用Numpy在转换至数组时使用的相同规则。

## 评估张量 ##

计算图构建完毕后，您可以运行生成特定tf.Tensor的计算并获取分配给它们的值。这对于程序调试通过非常有帮助，也是TensorFlow的大部分功能正常运行所必需的。

评估张量最简单的方法是使用 **Tensor.eval** 方法。例如：

1 constant = tf.constant([1, 2, 3])
    2 tensor = constant * constant
    3 print(tensor.eval())

**eval** 方法仅在默认tf.Session处于活跃状态时才起作用。例如：

1 sess = tf.Session()
    2 
    3 constant = tf.constant([1, 2, 3])
    4 tensor = constant * constant
    5 print(tensor.eval(session = sess))

**Tensor.eval** 会返回一个与张量相同的Numpy数组。

有时没法在没有背景信息的情况下评估tf.Tensor，因为它的值可能取决于无法获取的动态信息。例如，在没有为placehloder提供之的情况下，无法评估依赖于placeholder的张量：

1 p = tf.placeholder(tf.float32)
    2 t = p + 1.0
    3 t.eval()  # This will fail, since the placeholder did not get a value.
    4 t.eval(feed_dict={p:2.0})  # This will succeed because we're feeding a value
    5                            # to the placeholder.

请注意，可以提供任何tf.Tensor，而不仅仅是占位符。

其它模型构造可能会使评估tf.Tensor变得较为复杂。TensorFlow无法直接评估在函数内部或控制流结构内部定义的tf.Tensor。如果tf.Tensor取决于队列中的值，那么只有在某个项加入队列后才能评估tf.Tensor；否则。评估将被搁置。在处理队列时，请先调用 **tf.train.start\_queue\_runners**，在评估任何tf.Tensor。

## 输出张量 ##

出于调试目的，您可能需要输出tf.Tensor的值。虽然 [tfdbg][] 提供高级调试支持，但TensorFlow也有一个操作可以直接输出tf.Tensor的值。

请注意，输出tf.Tensor时很少使用以下模式：

1 t = <<some tensorflow operation>>
    2 print(t)  # This will print the symbolic tensor when the graph is being built.
    3           # This tensor does not have a value in this context.

上述代码会输出tf.Tensor对象（表示延迟计算），而不是其值。TensorFlow提供了 **tf.Print** 操作，该操作会返回其第一个张量参数（保持不变），同时输出第二个参数传递的tf.Tensor集合。

要正确使用tf.Print，必须使用其返回值。例如：

1 t = <<some tensorflow operation>>
    2 tf.Print(t, [t])  # This does nothing
    3 t = tf.Print(t, [t])  # Here we are using the value returned by tf.Print
    4 result = t + 1  # Now when result is evaluated the value of `t` will be printed.

在评估result时，会评估所有影响result的元素。由于result依靠t，而评估t会导致输出其输入（t的旧值），所以系统会输出t。

参考链接：[https://tensorflow.google.cn/guide/tensors\#rank][https_tensorflow.google.cn_guide_tensors_rank]

转载于:https://www.cnblogs.com/lfri/p/10359052.html

[tf.constant]: https://tensorflow.google.cn/api_docs/python/tf/constant
[tf.placeholder]: https://tensorflow.google.cn/api_docs/python/tf/placeholder
[tf.SparseTensor]: https://tensorflow.google.cn/api_docs/python/tf/SparseTensor
[tfdbg]: https://tensorflow.google.cn/guide/debugger
[https_tensorflow.google.cn_guide_tensors_rank]: https://tensorflow.google.cn/guide/tensors#rank