【Paper-Reading Day1】MULTIPLICATIVE FILTER NETWORKS

MULTIPLICATIVE FILTER NETWORKS

1. Paper

1.1 网络结构

就是说相较于之前的非线性激活结构，这里使用elementwise multiplication这种方式实现非线性激活。
$$\begin{array}{rl}{z}^{(1)}& =g\left(x;{\theta }^{(1)}\right)\\ z^{(i+1)}& =\left(W^{(i)}{z}^{(i)}+b^{(i)}\right)\circ g\left(x;{\theta }^{(i+1)}\right),i=1,\dots ,k-1\\ f(x)& =W^{(k)}{z}^{(k)}+b^{(k)}\end{array}$$

1.2 网络实例

1.2.1 MULTIPLICATIVE FOURIER NETWORKS

主要特点是他的输出可以看做一定数量sin函数的线性组合。

证明

证明了一个定理：傅里叶网络的输出是一系列sin函数的线性组合。换句话说，FOURIERNET将其最终函数表示为传统傅里叶基的线性组合，例如"经典"随机傅里叶特征。

证明的主要思想是按照一下公式：

$$\sin (\omega x+\varphi )\circ \sin (\tau x+\psi )=\frac{1}{2}\cos ((\omega -\tau )x+\varphi -\psi )-\frac{1}{2}\cos ((\omega +\tau )x+\varphi +\psi )$$

推论

该推论主要是阐述经过网络的每一层输出的线性组合，其系数是可以进行计算的。

$$\begin{array}{rl}& \bar{\alpha }=\left\{\frac{1}{2^{k-1}}{W}_{i_k,i_{k-1}}^{(k-1)}\dots W_{i_3,i_2}^{(2)}{W}_{i_2,i_1}^{(1)}\right\}\\ & \bar{\omega }=\left\{s_k{\omega }_{i_k}^{(k)}+\dots +s_2{\omega }_{i_2}^{(2)}+{\omega }_{i_1}^{(1)}\right\}\\ & \bar{\varphi }=\left\{s_k{\varphi }_{i_k}^{(k)}+\dots +s_2{\varphi }_{i_2}^{(2)}+{\varphi }_{i_1}^{(1)}+\frac{\pi }{2}\sum _{i=2}^k{s}_k\right\}.\end{array}$$
这里的$s_k$表示的是二进制符号+1与-1

就是可以看到，每一次相乘都会产生两个符号位正负的sin函数组合，这样通过改变乘性网络的深度，可以实现指数级的sin函数数量进行拟合。

1.2.2 GABORNET

相较于傅里叶特征的全局性，小波变换会有更多的局部特征进行表现。

使用的激活函数为

$$g_j\left(x;{\theta }^{(i)}\right)=\exp \left(-\frac{{\gamma }_j^{(i)}}{2}{\Vert x-{\mu }_j^{(i)}\Vert }_2^2\right)\sin \left({\omega }_j^{(i)}x+{\varphi }_j^{(i)}\right)$$
此时这里的优化参数${\theta }^{(i)}$为：

$${\theta }^{(i)}=\left\{{\gamma }_{1:d_i}^{(i)}\in \mathbb{R},{\mu }_{1:d_i}^{(i)}\in {\mathbb{R}}^n,{\omega }_{1:d_i}^{(i)}\in {\mathbb{R}}^n,{\varphi }_{1:d_i}^{(i)}\in \mathbb{R}\right\}$$
同样也对线性组合进行了证明：The output of a Gabor Network is given by a linear combination of Gabor bases

$$f_j(x)=\sum _{t=1}^T{\bar{\alpha }}_t\exp \left(-\frac{1}{2}{\bar{\gamma }}_t{\Vert x-{\bar{\mu }}_t\Vert }^2\right)\sin \left({\bar{\omega }}_{t}x+{\bar{\varphi }}_t\right)+\bar{b},$$
参数的初始化分布：

由于γ有效地充当了高斯的逆协方差项，因此**Gamma( α , β)**随机变量(高斯逆协方差的共轭先验)是该参数的合理选择。

我们也简单地选择每个μ ( i )在允许的输入空间x的范围内均匀分布

我们将每层的α项缩放1 / k，以在最后一层有效地控制这个参数

1.3 网络实验

1.3.1 IMAGE REPRESENTATION & GENERALIZATION

第一个是图像表示的实验，第二个是图像生成的实验。采用PSNR值进行比较判断。

1.3.2 DIFFERENTIAL EQUATIONS

1.3.3 SHAPE REPRESENTATION VIA SIGNED DISTANCE FIELDS

这项任务的主要方法是给一个定向的点云，寻找一个函数实现$f:{\mathbb{R}}^3\to \mathbb{R}$的映射。这样函数的水平集 { x ∣ f ( x ) = 0 } \{x \mid f(x)=0\} {x∣f(x)=0}就是表现物体的形状

使用的损失函数与SIREN使用的损失函数相同：

$L={\sum }_{x\in \Omega }{\lambda }_1\Vert 1-\left|{\nabla }_{x}N(x)\right|\Vert +{\sum }_{x\in {\Omega }_0}{\lambda }_2\Vert N(x)\Vert +{\lambda }_3\left(1-⟨{\nabla }_{x}N(x),n(x)⟩\right)+{\sum }_{x\notin {\Omega }_0}{\lambda }_4\exp (-\alpha |N(x)|)$

1.3.4 3D INVERSE RENDERING FOR VIEW SYNTHESIS

2. Code

2.1 mfn.py（网络结构文件）

​ 这个文件主要定义MFN的基本结构与文章中提出的两个网络。

import torch
from torch import nn
import torch.nn.functional as F
import numpy as np


class MFNBase(nn.Module):
    """
    Multiplicative filter network base class.

    Expects the child class to define the 'filters' attribute, which should be 
    a nn.ModuleList of n_layers+1 filters with output equal to hidden_size.
    """

    def __init__(
        self, hidden_size, out_size, n_layers, weight_scale, bias=True, output_act=False
    ):
        super().__init__()

        self.linear = nn.ModuleList(
            [nn.Linear(hidden_size, hidden_size, bias) for _ in range(n_layers)]
        )
        self.output_linear = nn.Linear(hidden_size, out_size)
        self.output_act = output_act

        for lin in self.linear:
            lin.weight.data.uniform_(
                -np.sqrt(weight_scale / hidden_size),
                np.sqrt(weight_scale / hidden_size),
            )

        return

    def forward(self, x):
        #	对每一层先进行非线性激活，本篇文章使用的是Fourier与Gabor，首先对第一层进行滤波器相乘。这里使用的滤波器是一个列表形式的。
        out = self.filters[0](x)
        for i in range(1, len(self.filters)):
            out = self.filters[i](x) * self.linear[i - 1](out)
        out = self.output_linear(out)

        if self.output_act:
            out = torch.sin(out)

        return out


class FourierLayer(nn.Module):
    """
    Sine filter as used in FourierNet.
    """

    def __init__(self, in_features, out_features, weight_scale):
        super().__init__()
        self.linear = nn.Linear(in_features, out_features)
        self.linear.weight.data *= weight_scale  # gamma
        #	给线性层定义偏差，这里其实就是相位
        self.linear.bias.data.uniform_(-np.pi, np.pi)
        return

    def forward(self, x):
        return torch.sin(self.linear(x))

#	疑惑点1：这里的output_act是什么东西。
class FourierNet(MFNBase):
    def __init__(
        self,
        in_size,
        hidden_size,
        out_size,
        n_layers=3,
        input_scale=256.0,
        weight_scale=1.0,
        bias=True,
        output_act=False,
    ):
        super().__init__(
            hidden_size, out_size, n_layers, weight_scale, bias, output_act
        )
        self.filters = nn.ModuleList(
            [
                FourierLayer(in_size, hidden_size, input_scale / np.sqrt(n_layers + 1))
                for _ in range(n_layers + 1)
            ]
        )

class GaborLayer(nn.Module):
    """
    Gabor-like filter as used in GaborNet.
    """

    def __init__(self, in_features, out_features, weight_scale, alpha=1.0, beta=1.0):
        super().__init__()
        self.linear = nn.Linear(in_features, out_features)
        self.mu = nn.Parameter(2 * torch.rand(out_features, in_features) - 1)
        self.gamma = nn.Parameter(
            torch.distributions.gamma.Gamma(alpha, beta).sample((out_features,))
        )
        self.linear.weight.data *= weight_scale * torch.sqrt(self.gamma[:, None])
        self.linear.bias.data.uniform_(-np.pi, np.pi)
        return

    def forward(self, x):
        D = (
            (x ** 2).sum(-1)[..., None]
            + (self.mu ** 2).sum(-1)[None, :]
            - 2 * x @ self.mu.T
        )
        return torch.sin(self.linear(x)) * torch.exp(-0.5 * D * self.gamma[None, :])


class GaborNet(MFNBase):
    def __init__(
        self,
        in_size,
        hidden_size,
        out_size,
        n_layers=3,
        input_scale=256.0,
        weight_scale=1.0,
        alpha=6.0,
        beta=1.0,
        bias=True,
        output_act=False,
    ):
        super().__init__(
            hidden_size, out_size, n_layers, weight_scale, bias, output_act
        )
        self.filters = nn.ModuleList(
            [
                GaborLayer(
                    in_size,
                    hidden_size,
                    input_scale / np.sqrt(n_layers + 1),
                    alpha / (n_layers + 1),
                    beta,
                )
                for _ in range(n_layers + 1)
            ]
        )

2.1.1 nn.ModuleList

参考链接：

1. ModuleList — PyTorch 1.13 documentation
2. 详解PyTorch中的ModuleList和Sequential - 知乎 (zhihu.com)

2.1.2 module.weight.data.uniform_(low, high)

​ 该方法主要是用于对网络中的参数进行均匀初始化，其中两个参数分别为分布的最小值与最大值。

​ 这里是对每一个线性层的参数进行初始化，使其在$[-\sqrt{\frac{weigh{t}_{s}cale}{hidde{n}_{s}ize}},\sqrt{\frac{weigh{t}_{s}cale}{hidde{n}_{s}ize}}]$区间内。

参考连接：

1. python - How do I initialize weights in PyTorch? - Stack Overflow
2. deep-learning-v2-pytorch/weight_initialization_exercise.ipynb at master · udacity/deep-learning-v2-pytorch (github.com)