周报(6.17-6.23)

最新推荐文章于 2024-07-14 21:15:27 发布

XLyu233

最新推荐文章于 2024-07-14 21:15:27 发布

阅读量785

点赞数 6

文章标签：学习

本文链接：https://blog.csdn.net/XLyu233/article/details/139899271

版权

周报(6.17-6.23)

本周工作：

学习地震反演概念及数据结构
复现InversionNet网络代码
在复现代码过程中，发现自己对反卷积认识不太清晰，所以进行了强化学习，形成博客一篇。

FWI数据结构

FWI数据集包含许多数据单元对，每对数据可以视作同一地点的探测与真实结果。数据单元对包含地震数据和速度模型，地震数据包含同一地理位置有间隔的施加振动源后获取的传感器数据，施加几次地震源就有几幅地震数据剖面图。速度模型是地震波在不同地层中的速度的可视化展示。

在这里插入图片描述

读取SEG盐数据时，我发现单个数据文件包含一个数据单元对，地震数据共有29炮的剖面图，有301道数据，400个时间单位数据

在这里插入图片描述

OpenFWI的一个数据文件则包含500个数据对，地震数据有5炮，每炮有70道数据，包含1000个时间单位数据

在这里插入图片描述

复现InversionNet网络代码

InversionNet整体结构如下：

在这里插入图片描述

而我准备使用openfwi的数据进行训练，openfwi的数据形状与网络输入部分不完全相同，因此我参考资料对网络结构进行调整。首先，图中每个卷积/反卷积运算都包含三层网络结构：卷积/反卷积层-批量归一化-LeakyReLU激活器。

卷积块代码如下所示：

# 卷积块
class ConvBlock(nn.Module):
    def __init__(self, in_channel,out_channel,kernel_size=3, stride=1, padding=0, negative_slope=0.2):
        super().__init__()
        conv = nn.Conv2d(in_channel,out_channel,kernel_size=kernel_size,stride=stride,padding=padding)
        bn = nn.BatchNorm2d(out_channel)
        active = nn.LeakyReLU(negative_slope, inplace=True)
        self.layers = nn.Sequential(conv, bn, active)
    def forward(self, inputs):
        outputs = self.layers(inputs)
        return outputs

反卷积块代码如下所示：

class DeconvBlock(nn.Module):
    def __init__(self, in_channel,out_channel,kernel_size=3, stride=1, padding=0, output_padding=0, negative_slope=0.2):
        super().__init__()
        conv = nn.ConvTranspose2d(in_channel,out_channel,kernel_size=kernel_size,stride=stride,padding=padding,output_padding=output_padding)
        bn = nn.BatchNorm2d(out_channel)
        active = nn.LeakyReLU(negative_slope, inplace=True)
        self.layers = nn.Sequential(conv, bn, active)
    def forward(self, inputs):
        outputs = self.layers(inputs)
        return outputs

上图的上半部分是编码器结构，由于数据在时间维度的尺度过大，原图首先经过了5次卷积，保证时间维度和空间维度大小相似后再同时进行卷积，形成512个单一的特征。下半部分是解码器结构，通过512个特征还原为80*80的速度模型，再通过剪裁获得与openfwi相同的70*70的速度模型。由此还原出的InversionNet网络结构如下，我在每一层后面标注了输出的形状。

class InversionNet(nn.Module):
    def __init__(self):
        super().__init__()
        layers = []
        # input: 1000, 70
        self.convblock1 = ConvBlock(5, 32, kernel_size=(7,1), stride=(2,1), padding=(3,0))
        # output: 500, 70
        
        self.convblock2_1 = ConvBlock(32,64,kernel_size=(3, 1), stride=(2,1), padding=(1,0))
        # output: 250, 70
        self.convblock2_2 = ConvBlock(64,64,kernel_size=(3, 1), padding=(1,0))
        # output: 250, 70
    
        self.convblock3_1 = ConvBlock(64,out_channel=64,kernel_size=(3, 1), stride=(2,1), padding=(1,0))
        # output: 125, 70
        self.convblock3_2 = ConvBlock(64,64,kernel_size=(3, 1), padding=(1,0))
        # output: 125, 70

        self.convblock4_1 = ConvBlock(64, 128, kernel_size=(3,1), stride=(2,1),padding=(1,0))
        # output: 63, 70
        self.convblock4_2 = ConvBlock(128, 128, kernel_size=(3,1),padding=(1,0))
        # output: 63, 70
        
        self.convblock5_1 = ConvBlock(128, 128, kernel_size=(3,3), stride=2, padding=(1,0))# stride: 2,1->2,2 no padding
        # output: 32, 35
        self.convblock5_2 = ConvBlock(128, 128, kernel_size=(3,3), padding=1)
        # output: 32, 35
        
        self.convblock6_1 = ConvBlock(128, 256, kernel_size=(3,3), stride=2,padding=1)
        # output: 16, 18
        self.convblock6_2 = ConvBlock(256, 256, kernel_size=(3,3),padding=1)
        # output: 16, 18
        
        self.convblock7_1 = ConvBlock(256, 256, kernel_size=(3,3), stride=2, padding=1)
        # output: 8, 9
        self.convblock7_2 = ConvBlock(256, 256, kernel_size=(3,3), padding=1)
        # output: 8, 9
        
        self.convblockEnd = ConvBlock(256, 512, kernel_size=(8,9))
        # output: 1, 1 but 512 feature
        
        self.deconvblock1_1 = DeconvBlock(512,512, kernel_size=(5,5))
        # output: 5, 5
        self.deconvblock1_2 = ConvBlock(512,512,kernel_size=(3,3),padding=1)
        # output: 5, 5
        
        self.deconvblock2_1 = DeconvBlock(512,256, kernel_size=(4,4), stride=(2,2), padding=1)
        # output: 10, 10
        self.deconvblock2_2 = ConvBlock(256,256,kernel_size=(3,3),padding=1)
        # output: 10, 10
        
        self.deconvblock3_1 = DeconvBlock(256,128, kernel_size=(4,4), stride=(2,2), padding=1)
        # output: 20, 20
        self.deconvblock3_2 = ConvBlock(128,128,kernel_size=(3,3),padding=1)
        # output: 20, 20
        
        
        self.deconvblock4_1 = DeconvBlock(128,64, kernel_size=(4,4), stride=(2,2), padding=1)
        # output: 40, 40
        self.deconvblock4_2 = ConvBlock(64,64,kernel_size=(3,3),padding=1)
        # output: 40, 40
        
                
        self.deconvblock5_1 = DeconvBlock(64,32, kernel_size=(4,4), stride=(2,2), padding=1)
        # output: 80, 80
        self.deconvblock5_2 = ConvBlock(32,32,kernel_size=(3,3),padding=1)
        # output: 80, 80
        
        self.deconvblockEnd = ConvBlock(32, 1, kernel_size=(3,3),padding=1)
        # output: 80, 80 with 1 feature
        
    def forward(self, inputs):
        outputs = self.convblock1(inputs)
        outputs = self.convblock2_1(outputs)
        outputs = self.convblock2_2(outputs)
        outputs = self.convblock3_1(outputs)
        outputs = self.convblock3_2(outputs)
        outputs = self.convblock4_1(outputs)
        outputs = self.convblock4_2(outputs)
        outputs = self.convblock5_1(outputs)
        outputs = self.convblock5_2(outputs)
        outputs = self.convblock6_1(outputs)
        outputs = self.convblock6_2(outputs)
        outputs = self.convblock7_1(outputs)
        outputs = self.convblock7_2(outputs)
        outputs = self.convblockEnd(outputs)
        
        outputs = self.deconvblock1_1(outputs)
        outputs = self.deconvblock1_2(outputs)
        outputs = self.deconvblock2_1(outputs)
        outputs = self.deconvblock2_2(outputs)
        outputs = self.deconvblock3_1(outputs)
        outputs = self.deconvblock3_2(outputs)
        outputs = self.deconvblock4_1(outputs)
        outputs = self.deconvblock4_2(outputs)
        outputs = self.deconvblock5_1(outputs)
        outputs = self.deconvblock5_2(outputs)
        outputs = nn.functional.pad(outputs,[-5, -5, -5, -5], mode="constant", value=0)
        outputs = self.deconvblockEnd(outputs)
        return outputs

经测试，网络结构正常可用。

在这里插入图片描述

出现问题：

在还原过程中，遇到了一些问题，如网络报了conv2d() received an invalid combination of arguments的错误，经查是因为测试时使用了Numpy的ndarray数据结构，而不是pytorch的Tensor结构。这些问题都进行了解决。
LeakyReLU用于回归任务和卷积神经网络隐藏层，tanh用于二分类任务和模型隐藏层。但学习资料和网络资料的代码中编码器到512个特征的卷积(convblockEnd)中使用的激活函数是tanh而不是LeakyReLU，需要进一步了解为什么要这么做。

下一步工作：

解决出现的问题，详细了解网络中其他组件的作用等。
给网络加入CRF方法。
使用openfwi数据集进行训练测试的同时结合论文进一步理解网络。
继续学习地震反演原理，深度学习原理

XLyu233

关注

6
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
周报(6.17-6.23)

上图的上半部分是编码器结构，由于数据在时间维度的尺度过大，原图首先经过了5次卷积，保证时间维度和空间维度大小相似后再同时进行卷积，形成512个单一的特征。FWI数据集包含许多数据单元对，每对数据可以视作同一地点的探测与真实结果。数据单元对包含地震数据和速度模型，地震数据包含同一地理位置有间隔的施加振动源后获取的传感器数据，施加几次地震源就有几幅地震数据剖面图。读取SEG盐数据时，我发现单个数据文件包含一个数据单元对，地震数据共有29炮的剖面图，有301道数据，400个时间单位数据。
复制链接

扫一扫