【动手学深度学习PyTorch】数据操作

飞Link

1110人浏览 · 2025-09-29 09:19:25

飞Link · 2025-09-29 09:19:25 发布

数据操作

$n$ 维数组，也称为张量（tensor）。但深度学习框架又比Numpy的ndarray多一些重要功能：

首先，GPU很好地支持加速计算，而NumPy仅支持CPU计算；
其次，张量类支持自动微分。

入门

(首先，我们导入torch。请注意，虽然它被称为PyTorch，但是代码中使用torch而不是pytorch。)

import torch

[张量表示一个由数值组成的数组，这个数组可能有多个维度]。
具有一个轴的张量对应数学上的向量（vector）；
具有两个轴的张量对应数学上的矩阵（matrix）；
具有两个轴以上的张量没有特殊的数学名称。

# 创建一个行向量x
x = torch.arange(12)
x

tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

[可以通过张量的shape属性来访问张量（沿每个轴的长度）的形状]

# 查询张量形状
x.shape

torch.Size([12])

如果只想知道张量中元素的总数，即形状的所有元素乘积，可以检查它的大小（size）。
因为这里在处理的是一个向量，所以它的shape与它的size相同。

# 查询所有元素数量
x.numel()

[要想改变一个张量的形状而不改变元素数量和元素值，可以调用reshape函数。]

# 将张量修改为3行4列的形状
X = x.reshape(3, 4)
X

tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])

# 创建一个全0的张量
torch.zeros((2, 3, 4))

tensor([[[0., 0., 0., 0.],
         [0., 0., 0., 0.],
         [0., 0., 0., 0.]],

        [[0., 0., 0., 0.],
         [0., 0., 0., 0.],
         [0., 0., 0., 0.]]])

# 创建一个全1的张量
torch.ones((2, 3, 4))

tensor([[[1., 1., 1., 1.],
         [1., 1., 1., 1.],
         [1., 1., 1., 1.]],

        [[1., 1., 1., 1.],
         [1., 1., 1., 1.],
         [1., 1., 1., 1.]]])

# 创建一个张量，元素从均值为0、标准差为1的标准高斯分布（正态分布）中随机采样
torch.randn(3, 4)

tensor([[-0.0135,  0.0665,  0.0912,  0.3212],
        [ 1.4653,  0.1843, -1.6995, -0.3036],
        [ 1.7646,  1.0450,  0.2457, -0.7732]])

# 将Python列表转换为张量
torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])

tensor([[2, 1, 4, 3],
        [1, 2, 3, 4],
        [4, 3, 2, 1]])

运算符

[常见的标准算术运算符（+、-、*、/和**）都可以被升级为按元素运算]。
我们可以在同一形状的任意两个张量上调用按元素操作。

x = torch.tensor([1.0, 2, 4, 8])
y = torch.tensor([2, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y  # **运算符是求幂运算

(tensor([ 3.,  4.,  6., 10.]),
 tensor([-1.,  0.,  2.,  6.]),
 tensor([ 2.,  4.,  8., 16.]),
 tensor([0.5000, 1.0000, 2.0000, 4.0000]),
 tensor([ 1.,  4., 16., 64.]))

(“按元素”方式可以应用更多的计算)，包括像求幂这样的一元运算符。

torch.exp(x)

tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])

[我们也可以把多个张量连结（concatenate）在一起]

# 把张量X和张量Y分别按照0轴和1轴连接到一起

X = torch.arange(12, dtype=torch.float32).reshape((3,4))
Y = torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
torch.cat((X, Y), dim=0), torch.cat((X, Y), dim=1)

(tensor([[ 0.,  1.,  2.,  3.],
         [ 4.,  5.,  6.,  7.],
         [ 8.,  9., 10., 11.],
         [ 2.,  1.,  4.,  3.],
         [ 1.,  2.,  3.,  4.],
         [ 4.,  3.,  2.,  1.]]),
 tensor([[ 0.,  1.,  2.,  3.,  2.,  1.,  4.,  3.],
         [ 4.,  5.,  6.,  7.,  1.,  2.,  3.,  4.],
         [ 8.,  9., 10., 11.,  4.,  3.,  2.,  1.]]))

[通过逻辑运算符构建二元张量]。
对于每个位置，如果X和Y在该位置相等，则新张量中相应项的值为1。
这意味着逻辑语句X == Y在该位置处为真，否则该位置为0。

X == Y

tensor([[False,  True, False,  True],
        [False, False, False, False],
        [False, False, False, False]])

[对张量中的所有元素进行求和，会产生一个单元素张量。]

# 求张量X所有元素之和
X.sum()

tensor(66.)

广播机制

[即使形状不同，我们仍然可以通过调用广播机制（broadcasting mechanism）来执行按元素操作]。
这种机制的工作方式如下：

通过适当复制元素来扩展一个或两个数组，以便在转换之后，两个张量具有相同的形状；
对生成的数组执行按元素操作。

在大多数情况下，我们将沿着数组中长度为1的轴进行广播，如下例子：

a = torch.arange(3).reshape((3, 1))
b = torch.arange(2).reshape((1, 2))
a, b

(tensor([[0],
         [1],
         [2]]),
 tensor([[0, 1]]))

# 矩阵a将复制列，矩阵b将复制行，然后再按元素相加。
a + b

tensor([[0, 1],
        [1, 2],
        [2, 3]])

索引和切片

[可以用[-1]选择最后一个元素，可以用[1:3]选择第二个和第三个元素]

X[-1], X[1:3]

(tensor([ 8.,  9., 10., 11.]),
 tensor([[ 4.,  5.,  6.,  7.],
         [ 8.,  9., 10., 11.]]))

[通过指定索引来将元素写入矩阵。]

X[1, 2] = 9
X

tensor([[ 0.,  1.,  2.,  3.],
        [ 4.,  5.,  9.,  7.],
        [ 8.,  9., 10., 11.]])

如果我们想[为多个元素赋值相同的值，我们只需要索引所有元素，然后为它们赋值。]

X[0:2, :] = 12
X

tensor([[12., 12., 12., 12.],
        [12., 12., 12., 12.],
        [ 8.,  9., 10., 11.]])

节省内存

[运行一些操作可能会导致为新结果分配内存]。
如果我们用Y = X + Y，我们将取消引用Y指向的张量，而是指向新分配的内存处的张量。
这是因为Python首先计算Y + X，为结果分配新的内存，然后使Y指向内存中的这个新位置。

before = id(Y)
Y = Y + X
id(Y) == before

False

[执行原地操作]
可以使用切片表示法将操作的结果分配给先前分配的数组，例如Y[:] = <expression>。

Z = torch.zeros_like(Y)
print('id(Z):', id(Z))
Z[:] = X + Y
print('id(Z):', id(Z))

id(Z): 140327634811696
id(Z): 140327634811696

[如果在后续计算中没有重复使用X，
我们也可以使用X[:] = X + Y或X += Y来减少操作的内存开销。]

before = id(X)
X += Y
id(X) == before

True

转换为其他Python对象

[numpy与张量互相转换]

A = X.numpy()
B = torch.tensor(A)
type(A), type(B)

(numpy.ndarray, torch.Tensor)

[将大小为1的张量转换为Python标量]

a = torch.tensor([3.5])
a, a.item(), float(a), int(a)

(tensor([3.5000]), 3.5, 3.5, 3)

内容声明
本文基于开源教材《动手学深度学习》（Dive into Deep Learning, 作者：Aston Zhang、Zachary C. Lipton、Mu Li、Alexander J. Smola 等）整理，原始项目地址：https://github.com/d2l-ai/d2l-zh。
在整理过程中对部分内容进行了删改和补充，仅用于个人学习与交流，版权归原作者所有。