注意
点击此处下载完整的示例代码
(原型) MaskedTensor 高级语义¶
创建于：2022 年 10 月 28 日 | 最后更新：2022 年 10 月 28 日 | 最后验证：未验证
在学习本教程之前，请务必查看我们的MaskedTensor 概述教程 <https://pytorch.ac.cn/tutorials/prototype/maskedtensor_overview.html>。
本教程的目的是帮助用户理解一些高级语义的工作原理以及它们的由来。我们将重点关注两个特定的方面
*. MaskedTensor 和 NumPy 的 MaskedArray 之间的差异 *. 归约语义
准备工作¶
import torch
from torch.masked import masked_tensor
import numpy as np
import warnings
# Disable prototype warnings and such
warnings.filterwarnings(action='ignore', category=UserWarning)
MaskedTensor 与 NumPy 的 MaskedArray¶
NumPy 的 MaskedArray 与 MaskedTensor 相比，存在一些基本的语义差异。
- *. 它们的工厂函数和基本定义反转了掩码（类似于
torch.nn.MHA）；也就是说，MaskedTensor 使用
True表示“指定”，False表示“未指定”或“有效”/“无效”，而 NumPy 则相反。我们认为我们的掩码定义不仅更直观，而且也更符合 PyTorch 作为一个整体的现有语义。- *. 交集语义。在 NumPy 中，如果两个元素之一被掩码，则结果元素也将被
掩码 – 实际上，它们应用 logical_or 运算符。
data = torch.arange(5.)
mask = torch.tensor([True, True, False, True, False])
npm0 = np.ma.masked_array(data.numpy(), (~mask).numpy())
npm1 = np.ma.masked_array(data.numpy(), (mask).numpy())
print("npm0:\n", npm0)
print("npm1:\n", npm1)
print("npm0 + npm1:\n", npm0 + npm1)
npm0:
[0.0 1.0 -- 3.0 --]
npm1:
[-- -- 2.0 -- 4.0]
npm0 + npm1:
[-- -- -- -- --]
同时，MaskedTensor 不支持掩码不匹配的加法或二元运算符 – 为了理解原因，请查找关于归约的章节。
mt0:
MaskedTensor(
[ 0.0000, 1.0000, --, 3.0000, --]
)
mt1:
MaskedTensor(
[ --, --, 2.0000, --, 4.0000]
)
mt0 + mt1 failed. Error: Input masks must match. If you need support for this, please open an issue on Github.
但是，如果需要此行为，MaskedTensor 通过访问数据和掩码并使用 to_tensor() 将 MaskedTensor 方便地转换为填充了掩码值的张量来支持这些语义。例如
t0:
tensor([0., 1., 0., 3., 0.])
t1:
tensor([0., 0., 2., 0., 4.])
mt2 (t0 + t1):
MaskedTensor(
[ --, --, --, --, --]
)
请注意，掩码是 mt0.get_mask() & mt1.get_mask()，因为 MaskedTensor 的掩码与 NumPy 的掩码相反。
归约语义¶
回顾MaskedTensor 的概述教程，我们讨论了“实现缺失的 torch.nan* ops”。这些是归约的示例 – 从张量中删除一个（或多个）维度，然后聚合结果的运算符。在本节中，我们将使用归约语义来激发我们对上述匹配掩码的严格要求。
从根本上说，:class:`MaskedTensor`s 执行相同的归约操作，同时忽略被掩码（未指定）的值。例如
data = torch.arange(12, dtype=torch.float).reshape(3, 4)
mask = torch.randint(2, (3, 4), dtype=torch.bool)
mt = masked_tensor(data, mask)
print("data:\n", data)
print("mask:\n", mask)
print("mt:\n", mt)
data:
tensor([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]])
mask:
tensor([[False, True, False, False],
[False, True, False, False],
[False, True, False, False]])
mt:
MaskedTensor(
[
[ --, 1.0000, --, --],
[ --, 5.0000, --, --],
[ --, 9.0000, --, --]
]
)
现在，不同的归约（都在 dim=1 上）
print("torch.sum:\n", torch.sum(mt, 1))
print("torch.mean:\n", torch.mean(mt, 1))
print("torch.prod:\n", torch.prod(mt, 1))
print("torch.amin:\n", torch.amin(mt, 1))
print("torch.amax:\n", torch.amax(mt, 1))
torch.sum:
MaskedTensor(
[ 1.0000, 5.0000, 9.0000]
)
torch.mean:
MaskedTensor(
[ 1.0000, 5.0000, 9.0000]
)
torch.prod:
MaskedTensor(
[ 1.0000, 5.0000, 9.0000]
)
torch.amin:
MaskedTensor(
[ 1.0000, 5.0000, 9.0000]
)
torch.amax:
MaskedTensor(
[ 1.0000, 5.0000, 9.0000]
)
值得注意的是，被掩码元素下的值不能保证具有任何特定值，特别是如果行或列完全被掩码（法线化也是如此）。有关掩码语义的更多详细信息，您可以找到此RFC。
现在，我们可以重新审视这个问题：为什么我们强制执行掩码必须与二元运算符匹配的不变性？换句话说，为什么我们不使用与 np.ma.masked_array 相同的语义？考虑以下示例
data0 = torch.arange(10.).reshape(2, 5)
data1 = torch.arange(10.).reshape(2, 5) + 10
mask0 = torch.tensor([[True, True, False, False, False], [False, False, False, True, True]])
mask1 = torch.tensor([[False, False, False, True, True], [True, True, False, False, False]])
npm0 = np.ma.masked_array(data0.numpy(), (mask0).numpy())
npm1 = np.ma.masked_array(data1.numpy(), (mask1).numpy())
print("npm0:", npm0)
print("npm1:", npm1)
npm0: [[-- -- 2.0 3.0 4.0]
[5.0 6.0 7.0 -- --]]
npm1: [[10.0 11.0 12.0 -- --]
[-- -- 17.0 18.0 19.0]]
现在，让我们尝试加法
print("(npm0 + npm1).sum(0):\n", (npm0 + npm1).sum(0))
print("npm0.sum(0) + npm1.sum(0):\n", npm0.sum(0) + npm1.sum(0))
(npm0 + npm1).sum(0):
[-- -- 38.0 -- --]
npm0.sum(0) + npm1.sum(0):
[15.0 17.0 38.0 21.0 23.0]
求和和加法显然应该是结合律的，但使用 NumPy 的语义，它们不是，这肯定会让用户感到困惑。
MaskedTensor，另一方面，将不允许此操作，因为 mask0 != mask1。话虽如此，如果用户愿意，可以通过一些方法来解决这个问题（例如，使用 to_tensor() 填充 MaskedTensor 的未定义元素，如下所示），但用户现在必须更明确地表达他们的意图。
tensor([15., 17., 38., 21., 23.])
