PyTorch 中的屏蔽和实例规范化

Question

假设我有一个 PyTorch 张量，排列为 [N, C, L] 形状，其中 N 是批量大小，C 是通道数或特征数，L 是长度。在这种情况下，如果希望执行实例规范化，可以执行以下操作：

N = 20
C = 100
L = 40
m = nn.InstanceNorm1d(C, affine=True)
input = torch.randn(N, C, L)
output = m(input) 

这将为每个 N*C = 2000 个数据切片在 L 维维度上执行归一化，减去 2000 个均值，按 2000 个标准差缩放，并按 100 个可学习的权重和偏差参数重新缩放（每个通道一个)。这里不言而喻的假设是所有这些值都存在并且是有意义的。

但我有一种情况，对于切片 N=1，我想排除（例如）L=35 之后的所有数据。对于切片 N=2（比如说），所有数据都是有效的。对于切片 N=3，排除 L=30 之后的所有数据等。这模拟了具有多个特征但长度不同的一维时间序列的数据。

如何在 PyTorch 中对此类数据执行实例规范、获取正确的统计数据并维护可微性/AutoGrad 信息？

更新：在保持 GPU 性能的同时，或者至少不会杀死它。

我不能……

1. ...使用零值的掩码，因为这会破坏计算机均值和方差，从而导致错误结果
2. ...使用 np.nan 或 np.inf 进行掩码，因为 PyTorch 张量不会忽略这些值，而是将它们视为错误。它们很粘，并导致垃圾结果。 PyTorch 目前缺少 np.nanmean 和 np.nanvar 的等效项。
3. ...置换或转置为合适的数据排列；没有这样的方法可以满足我的需要
4. ...使用 pack_padded_sequence；实例规范化不适用于该数据结构，据我所知，无法将数据导入该结构。此外，数据重新排列仍然是必要的，见上文 3。

我是否错过了一种可以满足我需要的方法？或者也许我错过了一种允许上述 3 或 4 工作的数据重新排列方法？

这是循环神经网络一直面临的问题，因此 pack_padded_sequence 功能，但在这里不太适用。

Answer 1

我认为这不能直接使用现有的InstanceNorm1d 来实现，最简单的方法可能是自己从头开始实现。我做了一个应该可以工作的快速实现。为了让它更通用一点，这个模块需要一个布尔掩码（一个与输入大小相同的布尔张量），它指定在通过实例规范时应该考虑哪些元素。

import torch


class MaskedInstanceNorm1d(torch.nn.Module):
    def __init__(self, num_features, eps=1e-6, momentum=0.1, affine=True, track_running_stats=False):
        super().__init__()
        self.num_features = num_features
        self.eps = eps
        self.momentum = momentum
        self.affine = affine
        self.track_running_stats = track_running_stats
        self.gamma = None
        self.beta = None
        if self.affine:
            self.gamma = torch.nn.Parameter(torch.ones((1, self.num_features, 1), requires_grad=True))
            self.beta = torch.nn.Parameter(torch.zeros((1, self.num_features, 1), requires_grad=True))

        self.running_mean = None
        self.running_variance = None
        if self.affine:
            self.running_mean = torch.zeros((1, self.num_features, 1), requires_grad=True)
            self.running_variance = torch.zeros((1, self.num_features, 1), requires_grad=True)

    def forward(self, x, mask):
        mean = torch.zeros((1, self.num_features, 1), requires_grad=False)
        variance = torch.ones((1, self.num_features, 1), requires_grad=False)

        # compute masked mean and variance of batch
        for c in range(self.num_features):
            if mask[:, c, :].any():
                mean[0, c, 0] = x[:, c, :][mask[:, c, :]].mean()
                variance[0, c, 0] = (x[:, c, :][mask[:, c, :]] - mean[0, c, 0]).pow(2).mean()

        # update running mean and variance
        if self.training and self.track_running_stats:
            for c in range(self.num_features):
                if mask[:, c, :].any():
                    self.running_mean[0, c, 0] = (1-self.momentum) * self.running_mean[0, c, 0] \
                                                 + self.momentum * mean[0, c, 0]
                    self.running_variance[0, c, 0] = (1-self.momentum) * self.running_variance[0, c, 0] \
                                                     + self.momentum * variance[0, c, 0]

        # compute output
        x = (x - mean)/(self.eps + variance).sqrt()

        if self.affine:
            x = x * self.gamma + self.beta

        return x