FCNVMB

网络结构

FCNVMB在代码层面更接近UNet结构，因此FCNVMB是UNet架构下的FWI。

在编码解码过程有如下三种操作：

1. 红色箭头：特征重整和，不会发生尺码改变
2. 紫色箭头：下采样，对特征进一步提取细化，尺寸缩小一半
3. 黄色箭头：反卷积，导致尺寸扩大一倍
4. skip connection：在编码过程中，首先利用上一次上采样$t$的输出作为近端输入，再利用$t$的对称的特征图，扩充过后作远端输入，将两个输入拼接，即可完成，如下是该过程实现代码

    def forward(self, inputs1, inputs2):
        '''

        :param inputs1:      Layer of the selected coding area via skip connection
        :param inputs2:      Current network layer based on network flows
        :return:
        '''
        outputs2 = self.up(inputs2)
        offset1 = (outputs2.size()[2] - inputs1.size()[2])
        offset2 = (outputs2.size()[3] - inputs1.size()[3])
        padding = [offset2 // 2, (offset2 + 1) // 2, offset1 // 2, (offset1 + 1) // 2]

        # Skip and concatenate
        outputs1 = F.pad(inputs1, padding)
        return self.conv(torch.cat([outputs1, outputs2], 1))

这里的卷积层网络分为三个部分：

1. nn.Conv2d二维卷积层
2. nn.BatchNorm2d二维批归一化层
3. nn.ReLU激活函数

        if is_batchnorm:
            self.conv1 = nn.Sequential(nn.Conv2d(in_size, out_size, 3, 1, 1),
                                       nn.BatchNorm2d(out_size),
                                       nn.ReLU(inplace=True), )
            self.conv2 = nn.Sequential(nn.Conv2d(out_size, out_size, 3, 1, 1),
                                       nn.BatchNorm2d(out_size),
                                       nn.ReLU(inplace=True), )
        else:
            self.conv1 = nn.Sequential(nn.Conv2d(in_size, out_size, 3, 1, 1),
                                       nn.ReLU(inplace=True), )
            self.conv2 = nn.Sequential(nn.Conv2d(out_size, out_size, 3, 1, 1),
                                       nn.ReLU(inplace=True), )

解码器

首先将输入的$(29,400,301)$地震数据卷积为$(64,200,151)$，再特征重整和，最后下采样，重复此操作，直到变成$(1024,50,38)$，代码如下：

        self.down1 = unetDown(self.in_channels, filters[0], self.is_batchnorm)
        self.down2 = unetDown(filters[0], filters[1], self.is_batchnorm)
        self.down3 = unetDown(filters[1], filters[2], self.is_batchnorm)
        self.down4 = unetDown(filters[2], filters[3], self.is_batchnorm)

class unetDown(nn.Module):
    def __init__(self, in_size, out_size, is_batchnorm):
        '''
        Downsampling Unit
        [Affiliated with FCNVMB]

        :param in_size:         Number of channels of input
        :param out_size:        Number of channels of output
        :param is_batchnorm:    Whether to use BN
        '''
        super(unetDown, self).__init__()
        self.conv = unetConv2(in_size, out_size, is_batchnorm)
        self.down = nn.MaxPool2d(2, 2, ceil_mode=True)

    def forward(self, inputs):
        '''

        :param inputs:          Input Image
        :return:
        '''
        outputs = self.conv(inputs)
        outputs = self.down(outputs)
        return outputs

解码器

解码器则是先将上次输出先进行上采样，再利用上采样结果作为近端输入，结合远端输入实现skip connection操作，如此循环重复

class unetUp(nn.Module):
    def __init__(self, in_size, out_size, is_deconv):
        '''
        Upsampling Unit
        [Affiliated with FCNVMB]

        :param in_size:      Number of channels of input
        :param out_size:     Number of channels of output
        :param is_deconv:    Whether to use deconvolution
        '''
        super(unetUp, self).__init__()
        self.conv = unetConv2(in_size, out_size, True)
        # Transposed convolution
        if is_deconv:
            self.up = nn.ConvTranspose2d(in_size, out_size, kernel_size=2, stride=2)
        else:
            self.up = nn.UpsamplingBilinear2d(scale_factor=2)

    def forward(self, inputs1, inputs2):
        '''

        :param inputs1:      Layer of the selected coding area via skip connection
        :param inputs2:      Current network layer based on network flows
        :return:
        '''
        outputs2 = self.up(inputs2)
        offset1 = (outputs2.size()[2] - inputs1.size()[2])
        offset2 = (outputs2.size()[3] - inputs1.size()[3])
        padding = [offset2 // 2, (offset2 + 1) // 2, offset1 // 2, (offset1 + 1) // 2]

        # Skip and concatenate
        outputs1 = F.pad(inputs1, padding)
        return self.conv(torch.cat([outputs1, outputs2], 1))

        self.up4 = unetUp(filters[4], filters[3], self.is_deconv)
        self.up3 = unetUp(filters[3], filters[2], self.is_deconv)
        self.up2 = unetUp(filters[2], filters[1], self.is_deconv)
        self.up1 = unetUp(filters[1], filters[0], self.is_deconv)
        self.final = nn.Conv2d(filters[0], self.n_classes, 1)

预训练

可以先使用模拟数据进行预训练，最后再使用真实数据训练得到最终的Re-trained model

与InversionNet的异同点

相同点:

1. 无论是FCNVMB还是InversionNet, 它们都是单一的端到端深度网络
   并没有利用更多的物理含义.
2. 都采用了编码器-解码器的架构.
3. 都是利用叠前多炮数据的不同炮集直接投入训练, 并未处理.

不同点:

1. InversionNet在编码的过程中最终将图像压缩为完全的一维向量, 抛弃了空间关联性; 而FCNVMB在压缩后仍保留了25 * 19的空间尺寸关联. 但是对应的代价是FCMVMB的模型内存占有量很大, 难以进行大batch体量的训练; 而InversionNet可以非常灵活进行训练.
2. FCNVMB面向SEG数据, InversionNet面向部分OpenFWI的数据. 因为OpenFWI数据的特点, InversionNet有非常明显的高度降维部分.
3. FCNVMB使用了迁移学习的训练手段, 后者InversionNet是单一的训练思想.
4. FCNVMB采用了包含skip connection的UNet的架构, 而InversionNet是单一的CNN架构.