PyTorch Scala 高校计算机硕士研一课程

张量介绍

**张量（Tensor）**是 PyTorch 中将要使用的主要数据结构。如果你使用过 NumPy，你会发现 PyTorch 张量非常熟悉。从本质上讲，张量是多维数组，与 NumPy 的 ndarray 非常相似。

可以把张量看作是常见数学对象的推广：

• 一个标量（单个数字，例如 7）是 0 维张量（或 0 阶张量）。
• 一个向量（一维数字列表或数组，例如 [1, 2, 3]）是 1 维张量（或 1 阶张量）。
• 一个矩阵（二维数字网格，例如 [[1, 2], [3, 4]]）是 2 维张量（或 2 阶张量）。
• 依此类推，可以有 3 维张量（例如数字立方体，常用于 RGB 图像：高 x 宽 x 通道）、4 维张量（常用于图像批次：批大小 x 高 x 宽 x 通道）等。

标量 (7)0维张量向量 [1, 2, 3]1维张量增加维度矩阵 [[1, 2], [3, 4]]2维张量增加维度3维张量(例如：图像 高x宽x通道)增加维度高维张量(例如：批次 批大小x高x宽x通道)…

一种将张量看作标量、向量和矩阵的推广的方式，维度逐渐增加。

在深度学习中，张量用来表示几乎所有数据：

• 输入数据： 图像批次、文本序列或特征表格。
• 模型参数： 神经网络层的权重和偏置。
• 中间激活： 网络内部各层的输出。
• 梯度： 反向传播过程中计算的值，用于更新模型参数。

与标准 Python 列表甚至 NumPy 数组相比，是什么让 PyTorch 张量特别适合深度学习呢？

1. GPU 加速： 张量可以轻松地移动到图形处理器 (GPU) 或其他硬件加速器上进行处理。这为深度学习中常见的计算密集型操作提供了大幅加速。
2. 自动微分： PyTorch 张量通过 Autograd 系统内置了对自动微分的支持（我们将在第 3 章中介绍）。这种机制自动计算梯度，这对通过反向传播训练神经网络来说非常重要。

尽管其原理与 NumPy 数组相似，但这两个特性使得 PyTorch 张量成为高效构建和训练模型的主要工具。在接下来的部分中，我们将介绍如何创建和操作这些重要的数据结构。

创建张量

张量是 PyTorch 中的基本数据结构，代表深度学习模型中使用的多维数组。代码中提供了创建张量的实用方法。PyTorch 提供了一系列灵活的函数来创建张量，无论使用现有数据，还是需要特定形状和初始值。

从现有数据创建张量

创建张量最直接的方法通常是使用现有的 Python 数据结构，比如列表或 NumPy 数组。主要用于此目的的函数是 torch.tensor()。这个函数会根据输入数据自动判断数据类型 (dtype)，但您也可以明确指定。重要的是，torch.tensor() 总是复制输入数据。

我们来看看实际操作。首先，请确保已导入 PyTorch：

import torch.*
import numpy as np

现在，从 Python 列表创建一个张量：

// 从 Scala 列表创建张量
val data_list = Seq(Seq(1, 2), Seq(3, 4))
val tensor_from_list = torch.tensor(data_list)

println("从列表生成的张量:")
println(tensor_from_list)
println(s"数据类型: ${tensor_from_list.dtype}")
println(s"形状: ${tensor_from_list.shape}")

这将输出：

从列表生成的张量:
tensor([[1, 2],
        [3, 4]])
数据类型: torch.int64
形状: torch.Size([2, 2])

请注意 PyTorch 如何根据输入整数判断数据类型为 torch.int64（一个 64 位整数）。

您也可以从 NumPy 数组开始，获得相同的结果：

// 从 NumPy 数组创建张量
val data_numpy = np.array(Seq(Seq(5.0, 6.0), Seq(7.0, 8.0)))
val tensor_from_numpy = torch.tensor(data_numpy)

println("\n从 NumPy 数组生成的张量:")
println(tensor_from_numpy)
println(s"数据类型: ${tensor_from_numpy.dtype}")
println(s"形状: ${tensor_from_numpy.shape}")

输出：

从 NumPy 数组生成的张量:
tensor([[5., 6.],
        [7., 8.]], dtype=torch.float64)
数据类型: torch.float64
形状: torch.Size([2, 2])

这里，数据类型被判断为 torch.float64，因为 NumPy 数组包含浮点数。本章后面将讨论 PyTorch 张量与 NumPy 数组之间的关系，包括更有效的转换方法。

创建具有特定形状和值的张量

很多时候，您需要在没有预先数据的情况下创建特定大小的张量，例如用零、一或随机值进行初始化。PyTorch 为这些情况提供了专门的函数。形状通常作为元组或整数序列传递。

零张量、一张量或未初始化数据张量：

• torch.zeros(*size, ...): 创建一个填充零的张量。
• torch.ones(*size, ...): 创建一个填充一的张量。
• torch.empty(*size, ...): 创建一个指定大小的张量，但其内容未被设定。其中的值是分配内存时该位置的任意数据。如果您计划在创建后立即填充张量，使用 torch.empty 会快一些，但请注意，初始值是不确定的。

// 定义期望的形状
val shape = Seq(2, 3) // 2 行, 3 列

// 创建具有特定值的张量
val zeros_tensor = torch.zeros(shape)
val ones_tensor = torch.ones(shape)
val empty_tensor = torch.empty(shape) // 值是任意的

println(s"\n零张量 (形状 {shape}):")
println(zeros_tensor)
println(s"\n一张量 (形状 {shape}):")
println(ones_tensor)

println(s"\n空张量 (形状 {shape}):")
println(empty_tensor)

输出（请注意 empty_tensor 的值会有所不同）：

零张量 (形状 (2, 3)):
tensor([[0., 0., 0.],
        [0., 0., 0.]])

一张量 (形状 (2, 3)):
tensor([[1., 1., 1.],
        [1., 1., 1.]])

空张量 (形状 (2, 3)):
tensor([[2.1321e-38, 5.0837e+24, 3.0763e-41],
        [3.0763e-41, 1.2326e-32, 1.8750e+00]])

默认情况下，这些函数创建的数据类型为 dtype=torch.float32 的张量。您可以使用 dtype 参数指定不同的数据类型：

// 创建一个整数类型的一张量
val ones_int_tensor = torch.ones(shape, dtype=torch.int32)
println(s"\n一张量 (dtype=torch.int32):")
println(ones_int_tensor)

输出：

一张量 (dtype=torch.int32):
tensor([[1, 1, 1],
        [1, 1, 1]], dtype=torch.int32)

带随机值的张量：

初始化模型参数通常会从随机值开始。PyTorch 为此提供了函数：

• torch.rand(*size, ...): 创建一个从区间 [0, 1) 均匀采样的张量。
• torch.randn(*size, ...): 创建一个从标准正态分布（均值 0，方差 1）采样的张量。

// 创建带随机值的张量
val rand_tensor = torch.rand(shape) // 均匀分布 [0, 1)
val randn_tensor = torch.randn(shape) // 标准正态分布

println(s"\n随机张量 (均匀分布 [0, 1), 形状 {shape}):")
println(rand_tensor)

println(s"\n随机张量 (标准正态分布, 形状 {shape}):")
println(randn_tensor)

输出（每次运行结果会有所不同）：

随机张量 (均匀分布 [0, 1), 形状 (2, 3)):
tensor([[0.6580, 0.5089, 0.1642],
        [0.3742, 0.5989, 0.7775]])

随机张量 (标准正态分布, 形状 (2, 3)):
tensor([[-0.2651, -0.3249, -1.0134],
        [ 1.1314,  1.1751, -0.1411]])

基于其他张量创建张量

有时，您需要创建一个新张量，使其与现有张量具有相同的属性（如形状和 dtype）。这对于确保操作兼容性很有帮助。PyTorch 为此提供了 _like 变体函数：

• torch.zeros_like(input_tensor, ...)
• torch.ones_like(input_tensor, ...)
• torch.rand_like(input_tensor, ...)
• torch.randn_like(input_tensor, ...)

这些函数接受一个现有张量作为输入，并返回一个新张量，其内容为指定的值（零、一、随机），但会与输入张量的形状和 dtype 匹配，除非明确覆盖。

// 使用现有张量作为模板
val base_tensor = torch.tensor(Seq(Seq(1, 2), Seq(3, 4)), dtype=torch.float32)
println(s"\n基础张量 (形状 {base_tensor.shape}, dtype {base_tensor.dtype}):")
println(base_tensor)

// 创建与基础张量属性匹配的张量
val zeros_like_base = torch.zeros_like(base_tensor)
val rand_like_base = torch.rand_like(base_tensor)

println("\n类似基础张量的零张量:")
println(zeros_like_base)
println(s"形状: ${zeros_like_base.shape}, dtype: ${zeros_like_base.dtype}")

println("\n类似基础张量的随机张量:")
println(rand_like_base)
println(s"形状: ${rand_like_base.shape}, dtype: ${rand_like_base.dtype}")

输出：

基础张量 (形状 torch.Size([2, 2]), dtype torch.float32):
tensor([[1., 2.],
        [3., 4.]])

类似基础张量的零张量:
tensor([[0., 0.],
        [0., 0.]])
形状: torch.Size([2, 2]), dtype: torch.float32

类似基础张量的随机张量:
tensor([[0.1216, 0.5908],
        [0.3264, 0.9272]])
形状: torch.Size([2, 2]), dtype: torch.float32

如您所见，新张量 zeros_like_base 和 rand_like_base 自动从 base_tensor 继承了 shape (torch.Size([2, 2])) 和 dtype (torch.float32)。

这些方法为您生成所需的张量提供了一套全面的方式，它们支撑着深度学习模型中的计算。在接下来的章节中，我们将了解如何操作这些张量并进行重要运算。