张量:比 numpy 多两样东西

torch.Tensor 和 numpy 数组长得几乎一样:同形状、同索引、同运算。

区别只有两样,但这两样决定了后面的一切。

能力

numpy

torch

放到 GPU 上算

❌

✅ .to("cuda")

自动算梯度

❌ 要手推

✅ requires_grad=True

造张量

import torch torch.tensor([1, 2, 3]) # 从列表 torch.tensor([[1., 2.], [3., 4.]]) # 二维 torch.zeros(2, 3) # 全 0 torch.ones(2, 3) # 全 1 torch.full((2, 3), 7) # 全 7 torch.eye(3) # 单位矩阵 torch.arange(0, 10, 2) # 0 2 4 6 8 torch.linspace(0, 1, 5) # 5 个等分点 torch.randn(2, 3) # 标准正态 torch.rand(2, 3) # [0,1) 均匀

和 numpy 互转

import numpy as np a = np.array([1, 2, 3]) t = torch.from_numpy(a) # 共享内存!改一个另一个也变 t = torch.tensor(a) # 复制,独立 t.numpy() # 转回去(CPU 上才行) t.tolist() # 变成 Python 列表

from_numpy 是共享内存

torch.from_numpy(a) 不复制数据,两个变量指向同一块内存。

改 t[0] = 99,a[0] 也变成 99。

要独立副本用 torch.tensor(a) 或 a.copy()。

第一样:能上 GPU

张量的数据存在 memory 上。CPU 内存和显卡显存是两块地方,搬过去才能用显卡算。

每个张量都有一个 device,表示数据存在哪。

x = torch.randn(3, 3) x.device # device(type='cpu') x = x.to("cuda") # 搬到显卡 x.device # device(type='cuda', index=0) x = x.cpu() # 搬回来 torch.zeros(3, device="cuda") # 直接造在显卡上

设备不同不能直接运算

一个在 CPU、一个在 GPU 的两个张量相加会直接报错:

Expected all tensors to be on the same device

这是深度学习最常撞的错。排查方法:把所有张量的 .device 打出来看。

为什么 GPU 快

不是"频率高"。CPU 十几个核,GPU 几千个核。矩阵乘法可以拆成几千个互不依赖的小任务, 正好塞满 GPU。

实测这台机器上(RTX 5060,2000×2000 矩阵乘十次):

设备

耗时

GPU(CUDA)

0.247 秒

同样的计算在 CPU 上要慢一个数量级。

小张量不要上 GPU

数据从内存搬到显存要时间。张量很小的时候,搬运的开销比计算本身还大,上 GPU 反而更慢。

GPU 的优势要在大批量、大矩阵上才体现得出来。

同步:GPU 是异步的

import time t0 = time.perf_counter() y = x @ x # 只是"提交"给了 GPU,没等算完 torch.cuda.synchronize() # 等真正算完 print(time.perf_counter() - t0)

不 synchronize 就计时,测出来的是"提交任务的耗时",不是计算耗时。

第二样:能记梯度

这是 torch 和 numpy 最根本的区别。numpy 只存数,torch 还能记住“这个数是怎么算出来的”。

造张量时加一个参数,PyTorch 就会开始记录它参与过的所有运算。

x = torch.tensor([1., 2., 3.], requires_grad=True) y = (x ** 2).sum() # y = 1 + 4 + 9 = 14 y.backward() # 反向求导 x.grad # tensor([2., 4., 6.]) ← 正好是 2x

y = x² 的导数是 2x,代进去就是 2、4、6。PyTorch 自己算出来的。

这就是深度学习的全部秘密

神经网络要学的参数是几百万个数。手推每个参数的梯度不可能。

requires_grad=True 之后,你只管写前向计算, backward() 自动把梯度算出来。

第 19 课专门讲它是怎么做到的。这一课先记住有这个能力。

张量的属性

上面提到的 device 和 requires_grad 都是属性。把常用的几个一次列全。

属性

含义

shape

各维长度

dtype

元素类型

device

在哪块设备上

requires_grad

是否记录梯度

grad

算出来的梯度(backward() 之后才有)

grad_fn

产生这个张量的运算(计算图节点)

ndim / numel()

维数 / 元素总数

.T

转置(二维)

x = torch.randn(3, 4, requires_grad=True) x.shape # torch.Size([3, 4]) x.dtype # torch.float32 x.device # device(type='cpu') x.numel() # 12 x.grad_fn # None(它是叶子节点)

dtype:默认是 float32

属性里最容易被忽略的是 dtype——它是后面一半报错的来源。

torch.get_default_dtype() # torch.float32 x = torch.tensor([1, 2, 3]) # int64 ← 注意! x = torch.tensor([1., 2., 3.]) # float32 ← 有小数点 x = torch.tensor([1, 2], dtype=torch.float32) x.float() / x.double() / x.long() # 转换

整数张量不能求导

torch.tensor([1, 2, 3]) 是 int64, requires_grad=True 会直接报错:only floating point tensors can require gradients

模型的输入必须转成 float32。

为什么默认 float32 而不是 float64

深度学习的数不需要 64 位精度,而 32 位省一半显存、快一倍。

类型

字节

用途

float16 / bfloat16

2

混合精度训练

float32

4

默认

float64

8

数值计算,深度学习里很少用

int64

8

标签、索引

bool

1

掩码

运算和 numpy 一样

属性和 numpy 不同,但运算几乎一模一样。会 numpy 的话这一节可以扫过去。

a + b, a - b, a * b, a / b # 逐元素 a ** 2, a.sqrt(), a.exp() # 数学函数 a.sum(), a.mean(), a.max() # 聚合 a.sum(dim=0) # 沿第 0 维压掉 a.sum(dim=0, keepdim=True) # 保留那一维(长度变 1) a @ b # 矩阵乘 a.matmul(b) # 同上 a * b # 逐元素!不是矩阵乘

dim 就是 numpy 的 axis

同样的概念,PyTorch 叫 dim,numpy 叫 axis。

dim=k 表示"把第 k 维压掉",规则完全一样。

原地操作带下划线

a.add_(1) # 原地加,a 变了 a.add(1) # 返回新张量,a 不变 a.relu_() # 原地 ReLU

结尾的下划线表示原地修改。省内存,但在自动求导里容易出问题,初学少用。

和 numpy 的差异清单

numpy

torch

axis=0

dim=0

a.reshape(...)

a.reshape(...) / a.view(...)

a.astype(np.float32)

a.float() / a.to(torch.float32)

np.concatenate([a,b], axis=0)

torch.cat([a,b], dim=0)

np.stack([a,b])

torch.stack([a,b])

a[a>0]

a[a>0](一样)

np.random.randn

torch.randn

view 和 reshape 的区别

view 要求内存连续,否则报错;reshape 不满足时会自动复制。

不确定就用 reshape。

下一课

这一课知道了张量能上 GPU、能记梯度。

下一课讲形状:(3,) 和 (3,1) 的区别、广播规则、以及怎么把数据搬到正确的设备上。