为什么深度自适应输入标准化 (DAIN) 跨行标准化时间序列数据？答案

【问题标题】：Why Deep Adaptive Input Normalization (DAIN) normalizes time series data accross rows?为什么深度自适应输入标准化 (DAIN) 跨行标准化时间序列数据？
【发布时间】：2021-03-04 06:53:48
【问题描述】：

DAIN paper 描述了网络如何通过自身学习规范化时间序列数据，here 是作者实现它的方式。该代码使我认为规范化是跨行而不是跨列发生的。谁能解释为什么以这种方式实施？因为我一直认为只有跨列标准化时间序列才能保留每个特征的真实信息。

这是规范化的部分：

```python
class DAIN_Layer(nn.Module):
    def __init__(self, mode='adaptive_avg', mean_lr=0.00001, gate_lr=0.001, scale_lr=0.00001, input_dim=144):
        super(DAIN_Layer, self).__init__()
        print("Mode = ", mode)

        self.mode = mode
        self.mean_lr = mean_lr
        self.gate_lr = gate_lr
        self.scale_lr = scale_lr

        # Parameters for adaptive average
        self.mean_layer = nn.Linear(input_dim, input_dim, bias=False)
        self.mean_layer.weight.data = torch.FloatTensor(data=np.eye(input_dim, input_dim))

        # Parameters for adaptive std
        self.scaling_layer = nn.Linear(input_dim, input_dim, bias=False)
        self.scaling_layer.weight.data = torch.FloatTensor(data=np.eye(input_dim, input_dim))

        # Parameters for adaptive scaling
        self.gating_layer = nn.Linear(input_dim, input_dim)

        self.eps = 1e-8

    def forward(self, x):
        # Expecting  (n_samples, dim,  n_feature_vectors)

        # Nothing to normalize
        if self.mode == None:
            pass

        # Do simple average normalization
        elif self.mode == 'avg':
            avg = torch.mean(x, 2)
            avg = avg.resize(avg.size(0), avg.size(1), 1)
            x = x - avg

        # Perform only the first step (adaptive averaging)
        elif self.mode == 'adaptive_avg':
            avg = torch.mean(x, 2)
            adaptive_avg = self.mean_layer(avg)
            adaptive_avg = adaptive_avg.resize(adaptive_avg.size(0), adaptive_avg.size(1), 1)
            x = x - adaptive_avg

        # Perform the first + second step (adaptive averaging + adaptive scaling )
        elif self.mode == 'adaptive_scale':

            # Step 1:
            avg = torch.mean(x, 2)
            adaptive_avg = self.mean_layer(avg)
            adaptive_avg = adaptive_avg.resize(adaptive_avg.size(0), adaptive_avg.size(1), 1)
            x = x - adaptive_avg

            # Step 2:
            std = torch.mean(x ** 2, 2)
            std = torch.sqrt(std + self.eps)
            adaptive_std = self.scaling_layer(std)
            adaptive_std[adaptive_std <= self.eps] = 1

            adaptive_std = adaptive_std.resize(adaptive_std.size(0), adaptive_std.size(1), 1)
            x = x / (adaptive_std)

        elif self.mode == 'full':

            # Step 1:
            avg = torch.mean(x, 2)
            adaptive_avg = self.mean_layer(avg)
            adaptive_avg = adaptive_avg.resize(adaptive_avg.size(0), adaptive_avg.size(1), 1)
            x = x - adaptive_avg

            # # Step 2:
            std = torch.mean(x ** 2, 2)
            std = torch.sqrt(std + self.eps)
            adaptive_std = self.scaling_layer(std)
            adaptive_std[adaptive_std <= self.eps] = 1

            adaptive_std = adaptive_std.resize(adaptive_std.size(0), adaptive_std.size(1), 1)
            x = x / adaptive_std

            # Step 3: 
            avg = torch.mean(x, 2)
            gate = F.sigmoid(self.gating_layer(avg))
            gate = gate.resize(gate.size(0), gate.size(1), 1)
            x = x * gate

        else:
            assert False

        return x
```

【问题讨论】：

我投票结束这个问题，因为它不是关于 help center 中定义的编程，而是关于 ML 理论和方法。
问题是关于深度学习技术，应该没问题。您能否更详细地解释一下为什么这个问题被关闭了？
请参阅machine-learningtag info中的介绍和注意。
注意说，“如果你想用这个标签来解决不直接与实施相关的问题，那么考虑在计算机科学、交叉验证、数据科学或人工智能上发帖。否则你可能无关”。我的问题直接与实施有关，我将指向该实施的链接放在问题中。这个问题实际上是关于机器学习和深度学习的。请重新打开问题。
如果“一个仅跨列标准化时间序列以保留每个功能的真实信息”或其他方式，为什么不是实现问题，而是方法问题（实现是关于如何做到这一点）。另外，相关代码必须存在于问题本身中，而不是外部存储库中 - 请重新阅读 How to ask（甚至不清楚究竟在哪里相关部分的链接代码是 - 请看看为什么a wall of code is not helpful)。

标签： deep-learning time-series data-science normalization preprocessor

【解决方案1】：

我也不确定，但它们确实在前向函数中转置：MLP 类的 x = x.transpose(1, 2)。因此，在我看来，它们会随着时间的推移对每个特征进行归一化。

【讨论】：