注意
点击此处下载完整示例代码
(原型) MaskedTensor 概述¶
创建日期:2022 年 10 月 28 日 | 最后更新:2022 年 10 月 28 日 | 最后验证:未验证
本教程旨在作为使用 MaskedTensor 并讨论其掩码语义的起点。
MaskedTensor 作为 torch.Tensor
的扩展,提供了用户以下能力:
使用任何掩码语义(例如,变长张量、nan* 操作符等)
区分 0 梯度和 NaN 梯度
各种稀疏应用(参见下面的教程)
有关 MaskedTensor 是什么的更详细介绍,请查阅 torch.masked 文档。
使用 MaskedTensor¶
在本节中,我们将讨论如何使用 MaskedTensor,包括如何构造、访问数据和掩码,以及索引和切片。
准备工作¶
我们将首先进行本教程所需的设置
import torch
from torch.masked import masked_tensor, as_masked_tensor
import warnings
# Disable prototype warnings and such
warnings.filterwarnings(action='ignore', category=UserWarning)
构造¶
有几种不同的方法来构造 MaskedTensor
第一种方法是直接调用 MaskedTensor 类
第二种(也是我们推荐的方法)是使用
masked.masked_tensor()
和masked.as_masked_tensor()
工厂函数,它们类似于torch.tensor()
和torch.as_tensor()
在本教程中,我们将假定导入行是:from torch.masked import masked_tensor。
访问数据和掩码¶
MaskedTensor 中的底层字段可以通过以下方式访问:
MaskedTensor.get_data()
函数MaskedTensor.get_mask()
函数。回想一下,True
表示“指定”或“有效”,而False
表示“未指定”或“无效”。
通常,返回的底层数据在未指定的条目中可能无效,因此我们建议用户在需要不包含任何掩码条目的 Tensor 时,使用 MaskedTensor.to_tensor()
(如上所示)来返回一个填充值的 Tensor。
索引和切片¶
MaskedTensor
是 Tensor 的子类,这意味着它继承了与 torch.Tensor
相同的索引和切片语义。下面是一些常见的索引和切片模式示例:
data:
tensor([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]],
[[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]]])
mask:
tensor([[[ True, False, True, False],
[ True, False, True, False],
[ True, False, True, False]],
[[ True, False, True, False],
[ True, False, True, False],
[ True, False, True, False]]])
mt[0]:
MaskedTensor(
[
[ 0.0000, --, 2.0000, --],
[ 4.0000, --, 6.0000, --],
[ 8.0000, --, 10.0000, --]
]
)
mt[:, :, 2:4]:
MaskedTensor(
[
[
[ 2.0000, --],
[ 6.0000, --],
[ 10.0000, --]
],
[
[ 14.0000, --],
[ 18.0000, --],
[ 22.0000, --]
]
]
)
为什么 MaskedTensor 有用?¶
由于 MaskedTensor
将指定值和未指定值作为一等公民处理,而不是作为事后填充(使用填充值、nan 等),它能够解决普通 Tensor 无法解决的几个缺点;事实上,MaskedTensor
在很大程度上正是因此类反复出现的问题而诞生的。
下面,我们将讨论当前 PyTorch 中一些尚未解决的最常见问题,并说明 MaskedTensor
如何解决这些问题。
区分 0 梯度和 NaN 梯度¶
torch.Tensor
遇到的一个问题是无法区分未定义的梯度 (NaN) 和实际为 0 的梯度。由于 PyTorch 没有一种方法来标记值是指定/有效还是未指定/无效,因此它被迫依赖 NaN 或 0(取决于用例),这导致语义不可靠,因为许多操作无法正确处理 NaN 值。更令人困惑的是,有时根据操作顺序的不同,梯度可能会发生变化(例如,取决于 NaN 值在操作链中出现得有多早)。
MaskedTensor
是完美的解决方案!
torch.where¶
在 Issue 10729 中,我们注意到在使用 torch.where()
时,操作顺序可能会产生影响,因为我们难以区分 0 是真实的 0 还是来自未定义梯度的 0。因此,我们保持一致并掩盖结果:
当前结果
x = torch.tensor([-10., -5, 0, 5, 10, 50, 60, 70, 80, 90, 100], requires_grad=True, dtype=torch.float)
y = torch.where(x < 0, torch.exp(x), torch.ones_like(x))
y.sum().backward()
x.grad
tensor([4.5400e-05, 6.7379e-03, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00,
0.0000e+00, 0.0000e+00, 0.0000e+00, nan, nan])
MaskedTensor
结果
x = torch.tensor([-10., -5, 0, 5, 10, 50, 60, 70, 80, 90, 100])
mask = x < 0
mx = masked_tensor(x, mask, requires_grad=True)
my = masked_tensor(torch.ones_like(x), ~mask, requires_grad=True)
y = torch.where(mask, torch.exp(mx), my)
y.sum().backward()
mx.grad
MaskedTensor(
[ 0.0000, 0.0067, --, --, --, --, --, --, --, --, --]
)
这里的梯度仅提供给选定的子集。实际上,这将 where 的梯度更改为掩盖元素,而不是将它们设置为零。
另一个 torch.where¶
Issue 52248 是另一个示例。
当前结果
a = torch.randn((), requires_grad=True)
b = torch.tensor(False)
c = torch.ones(())
print("torch.where(b, a/0, c):\n", torch.where(b, a/0, c))
print("torch.autograd.grad(torch.where(b, a/0, c), a):\n", torch.autograd.grad(torch.where(b, a/0, c), a))
torch.where(b, a/0, c):
tensor(1., grad_fn=<WhereBackward0>)
torch.autograd.grad(torch.where(b, a/0, c), a):
(tensor(nan),)
MaskedTensor
结果
a = masked_tensor(torch.randn(()), torch.tensor(True), requires_grad=True)
b = torch.tensor(False)
c = torch.ones(())
print("torch.where(b, a/0, c):\n", torch.where(b, a/0, c))
print("torch.autograd.grad(torch.where(b, a/0, c), a):\n", torch.autograd.grad(torch.where(b, a/0, c), a))
torch.where(b, a/0, c):
MaskedTensor( 1.0000, True)
torch.autograd.grad(torch.where(b, a/0, c), a):
(MaskedTensor(--, False),)
这个问题类似(甚至链接到下面的下一个问题),它表达了对意外行为的沮丧,因为无法区分“无梯度”和“零梯度”,这反过来又使得使用其他操作时难以推断。
使用掩码时,x/0 产生 NaN 梯度¶
在 Issue 4132 中,用户提出 x.grad 应该是 [0, 1] 而不是 [nan, 1],而 MaskedTensor
通过完全掩盖梯度,使其变得非常清晰。
当前结果
tensor([nan, 1.])
MaskedTensor
结果
MaskedTensor(
[ --, 1.0000]
)
torch.nansum()
和 torch.nanmean()
¶
在 Issue 67180 中,梯度计算不正确(一个长期存在的问题),而 MaskedTensor
则可以正确处理它。
当前结果
a = torch.tensor([1., 2., float('nan')])
b = torch.tensor(1.0, requires_grad=True)
c = a * b
c1 = torch.nansum(c)
bgrad1, = torch.autograd.grad(c1, b, retain_graph=True)
bgrad1
tensor(nan)
MaskedTensor
结果
a = torch.tensor([1., 2., float('nan')])
b = torch.tensor(1.0, requires_grad=True)
mt = masked_tensor(a, ~torch.isnan(a))
c = mt * b
c1 = torch.sum(c)
bgrad1, = torch.autograd.grad(c1, b, retain_graph=True)
bgrad1
MaskedTensor( 3.0000, True)
安全的 Softmax¶
安全 softmax 是 一个经常出现的问题的又一个极佳示例。简而言之,如果有一个完整的批次被“掩盖掉”或完全由填充组成(在 softmax 的情况下,这意味着被设置为 -inf),那么这将导致 NaNs,从而可能导致训练发散。
幸运的是,MaskedTensor
解决了这个问题。考虑以下设置:
data = torch.randn(3, 3)
mask = torch.tensor([[True, False, False], [True, False, True], [False, False, False]])
x = data.masked_fill(~mask, float('-inf'))
mt = masked_tensor(data, mask)
print("x:\n", x)
print("mt:\n", mt)
x:
tensor([[ 0.2345, -inf, -inf],
[-0.1863, -inf, -0.6380],
[ -inf, -inf, -inf]])
mt:
MaskedTensor(
[
[ 0.2345, --, --],
[ -0.1863, --, -0.6380],
[ --, --, --]
]
)
例如,我们想要沿 dim=0 计算 softmax。请注意,第二列是“不安全”的(即完全被掩盖掉),因此当计算 softmax 时,结果将是 0/0 = nan,因为 exp(-inf) = 0。然而,我们真正想要的是梯度被掩盖掉,因为它们是未指定的,对训练无效。
PyTorch 结果
x.softmax(0)
tensor([[0.6037, nan, 0.0000],
[0.3963, nan, 1.0000],
[0.0000, nan, 0.0000]])
MaskedTensor
结果
mt.softmax(0)
MaskedTensor(
[
[ 0.6037, --, --],
[ 0.3963, --, 1.0000],
[ --, --, --]
]
)
实现缺失的 torch.nan* 操作符¶
在 Issue 61474 中,有一个请求是添加额外的操作符来涵盖各种 torch.nan* 应用,例如 torch.nanmax
、torch.nanmin
等。
总的来说,这些问题更自然地适用于掩码语义,因此我们建议使用 MaskedTensor
来代替引入额外的操作符。由于 nanmean 已经落地,我们可以将其作为比较点:
y:
tensor([ 0., 1., 4., 9., 0., 5., 12., 21., 0., 9., 20., 33., 0., 13.,
28., 45.])
z:
tensor([nan, 1., 4., 9., nan, 5., 12., 21., nan, 9., 20., 33., nan, 13.,
28., 45.])
print("y.mean():\n", y.mean())
print("z.nanmean():\n", z.nanmean())
# MaskedTensor successfully ignores the 0's
print("torch.mean(masked_tensor(y, y != 0)):\n", torch.mean(masked_tensor(y, y != 0)))
y.mean():
tensor(12.5000)
z.nanmean():
tensor(16.6667)
torch.mean(masked_tensor(y, y != 0)):
MaskedTensor( 16.6667, True)
在上面的示例中,我们构造了一个 y,并希望在忽略零值的情况下计算该系列的均值。torch.nanmean 可以用来实现这一点,但我们没有其余 torch.nan* 操作的实现。MaskedTensor
通过能够使用基本操作来解决这个问题,而且我们已经支持该问题中列出的其他操作。例如:
torch.argmin(masked_tensor(y, y != 0))
MaskedTensor( 1.0000, True)
确实,忽略 0 时最小参数的索引是索引 1 中的 1。
MaskedTensor
在数据完全被掩盖时也支持 reduction 操作,这等同于上面数据 Tensor 完全是 nan
的情况。nanmean
会返回 nan
(一个模糊的返回值),而 MaskedTensor 会更准确地指示一个被掩盖的结果。
x = torch.empty(16).fill_(float('nan'))
print("x:\n", x)
print("torch.nanmean(x):\n", torch.nanmean(x))
print("torch.nanmean via maskedtensor:\n", torch.mean(masked_tensor(x, ~torch.isnan(x))))
x:
tensor([nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan])
torch.nanmean(x):
tensor(nan)
torch.nanmean via maskedtensor:
MaskedTensor(--, False)
这与安全 softmax 问题类似,即 0/0 = nan,而我们真正想要的是一个未定义的值。
结论¶
在本教程中,我们介绍了 MaskedTensor 是什么,演示了如何使用它们,并通过它们帮助解决的一系列示例和问题来阐明它们的价值。
进一步阅读¶
要继续了解更多,您可以查阅我们的 MaskedTensor 稀疏性教程,了解 MaskedTensor 如何实现稀疏性以及我们目前支持的不同存储格式。
脚本总运行时间: ( 0 分钟 0.029 秒)