TensorFlow低阶API（二）—— 张量

2022-02-24 简介

顾名思义，这个框架定义并运行涉及张量的计算。张量是向量和矩阵向潜在更高维度的推广。在内部将张量表示为原始数据类型的 n 维数组。

在编写程序时，您操作和传递的主要对象是 tf.一个tf。 表示最终产生一个值的部分定义的计算。该程序首先构建一个 tf.对象图详细说明了如何根据其他可用张量计算每个张量，然后运行图的某些部分以获得所需的结果。

tf.具有以下属性：

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

某些类型的张量有点特殊，在指南的其他地方都有介绍。以下是主要的特殊张量：

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

等级

tf.一个对象的顺序是它自己的维度。 order 的同义词包括：rank、rank 或 n-。注意，矩阵的阶与数学中的矩阵阶不是同一个概念。如下表所示，每个顺序对应一个不同的数学实例：

一阶数学示例

标量（仅大小）

1

矢量（大小和方向）

2

矩阵（数据表）

3

Tier 3 张量（数据立体声）

n

n 阶张量（想象你自己）

订单 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)

注意：字符串在 中被视为单个项目，而不是字符序列。可以有标量字符串、字符串向量等等。

第 1 层

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

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.对象至少包含一行和一列：

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.对象

确定 tf.对象，调用 tf.rank 方法。例如，以下方法将以编程方式确定 tf.如上一节所定义：

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

引用 tf.slice

自 tf.是一个 n 维元胞数组，要访问 tf. 中的一个元胞，需要指定 n 个索引。

秩为 0 的张量（标量）不需要索引，因为它本身就是一个数字。

对于等级 1 的张量（向量），可以通过传递索引来访问数字：

1 my_scalar = my_vector[2]

注意，如果你想从向量中动态选择元素，传入[]的索引本身可以是一个标量tf。

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

1 my_scalar = my_matrix[1, 2]

传递一个数字返回一个矩阵子向量如下：

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

: 是切片语法，意思是“不要碰这个维度”。这对于高阶张量帮助访问其子向量、子矩阵甚至其他子张量很有用。

形状

张量的形状是每个维度中元素的数量。自动推理图形构造中的形状。这些推论的形状可能是已知或未知的顺序。如果顺序已知，则每个维度的大小可能未知，也可能未知。

文档中使用三种符号约定来描述张量维度：等级、形状和维度。下表说明了三者之间的关系：

订单形状尺寸示例

[]

0-D

0维张量。标量。

1

[D0]

一维

形状 [5] 的一维张量。

2

[D0, D1]

二维

形状为 [3, 4] 的二维张量。

3

[D0, D1, D2]

3-D

形状为 [1, 4, 3] 的 3 维张量。

n

[D0, D1, … Dn-1]

n维

形状为 [D0, D1, … Dn-1] 的张量。

形状可以用整数列表/元组或 tf 表示。

获取 tf.对象

tf 的形状。可以通过两种方式获得。在构建图形时，询问有关张量形状的已知信息通常会有所帮助。可以通过查看（tf.对象的）形状属性来获得此信息。该方法返回一个对象，方便表示部分指定的形状（因为在构建图形时并非所有形状都完全已知）。

也可以获取 tf.完全指定的形状，将代表另一个 tf.在运行时。为此，可以调用 tf.shape 操作。这样，您可以通过构建依赖于输入 tf 的动态形状的其他张量来构建控制张量形状的图。

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

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

改变 tf.对象

张量的元素数是其所有形状大小的乘积。标量的元素个数始终为 1。由于经常有许多不同的形状具有相同的元素数，因此能够方便地更改 tf.并保持其元素固定。为此，tf.可以使用。

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

 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.只能有一种数据类型。但是，可以将任意数据结构序列化并存储在 tf 中。

Tf。可以从一种数据类型转换为另一种数据类型（通过 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. 的数据类型，请使用 .dtype 属性。

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

评估张量

计算图建立后，你可以运行生成特定tf.s的计算，并获取分配给它们的值。这对于程序调试非常有帮助，也是大部分功能正常工作所必需的。

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

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

eval 方法仅在默认 tf.活跃。例如：

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

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

有时无法评估 tf.没有背景信息，因为它的价值可能取决于不可用的动态信息。例如，一个依赖于的张量如果不提供就无法评估：

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.可以提供，而不仅仅是占位符。

其他模型结构可能会使评估 tf.一个tf。在函数内部或控制流结构内部定义的不能直接评估。如果 tf.取决于队列中的一个值，然后是 tf.只能在将项目添加到队列后进行评估；否则。评估将被搁置。处理队列时，调用 tf.train。首先，在评估任何 tf..之前。

输出张量

出于调试目的，您可能希望输出 tf.在 tfdbg 提供高级调试支持的同时，也有直接输出 tf 值的操作。

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

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.对象（代表惰性计算），而不是它的值。提供了 tf.Print 操作，它返回它的第一个张量参数（保持不变），同时输出第二个参数传递的 tf.set。

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

1 t = <>
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.

评估时，会评估所有受影响的元素。系统输出 t，因为它依赖于 t 并且评估 t 会导致输出其输入（t 的旧值）。

参考链接：

分类：

技术要点：

相关文章：