DeepLab v1

Architecture

Dense CRF (a.k.a Fully-Connected CRF)

• Bilinear interpolation으로는 정교한 segmentation이 불가능하기에 이를 개선

• Dense Conditional Random Field

  1. DeepLab V1을 이용해 segmentation 수행
  2. 계산된 확률, 이미지를 CRF에 입력
  3. 반복 수행
  4. 다른 카테고리에 대해 같은 과정 수행

  

Deeplab V2

Convblock

def conv_block(in_ch, out_ch, k_size, stride, padding, dilation=1, relu=True):
    block = []
    block.append(nn.Conv2d(in_ch, out_ch, k_size, stride, padding, dilation, bias = False))
    block.append(nn.BatchNorm2d(out_ch))
    if relu : 
        block.append(nn.ReLU(inplace=True))
    return nn.Sequential(*block)

Bottleneck

class Bottleneck(nn.Module):
    def __init__(self,in_ch, out_ch, stride=1, dilation =1, downsample = False):
        super().__init__()
        self.block = nn.Sequential(conv_block(in_ch,out_ch//4,1,1,0),
                                  conv_block(out_ch//4, out_ch//4, 3, stride ,dilation, dilation),
                                  conv_block(out_ch//4,out_ch,1,1,0,False))
        self.downsample = nn.Sequential(
            conv_block(in_ch, out_ch, 1, stride, 0, 1, relu = False)) if downsample else None
        
        self.relu = nn.ReLU(inplace = True)
    
    def forward(self, x):
        out = self.block(x)
        identity = x
        if self.downsample is not None :
            identity = self.downsample(x)
        
        out = out + identity
        out = self.relu(out)
        return out

Resblock

class Resblock(nn.Module):
    def __init__(self,in_ch,out_ch, stride, dilation, num_layers):
        super().__init__()
        block = []
        for i in range(num_layers):
            block.append(Bottleneck(in_ch if i is 0 else out_ch,
                                   out_ch,
                                    stride if i is 0 else 1,
                                    dilation, 
                                    True if i is 0 else False
                                   ))
        self.block = nn.Sequential(*block)
    
    def forward(self, x):
        return self.block(x)

ResNet101

class ResNet101(nn.Module):
    def __init__(self, in_channels = 3):
        super().__init__()
        self.block = nn.Sequential(conv_block(in_channels, 64,7,2,3,1,True),
                                  nn.MaxPool2d(3,2,padding=1),
                                  Resblock(64,256,1,1,3),
                                  Resblock(256,512,2,1,4),
                                  Resblock(512,1024,1,2,23),
                                  Resblock(1024,2048,1,4,3)
                                  )
    def forward(self,x):
        return self.block(x)

ASPP

class ASPP(nn.Module):
    def __init__(self,in_ch,out_ch):
        super().__init__()
        self.block1 = nn.Sequential(conv_block(in_ch,in_ch,3,1,padding=6,dilation=6),
                                   conv_block(in_ch,in_ch,1,1,0),
                                   conv_block(in_ch,out_ch,1,1,0))
        self.block2 = nn.Sequential(conv_block(in_ch,in_ch,3,1,padding=12,dilation=12),
                                   conv_block(in_ch,in_ch,1,1,0),
                                   conv_block(in_ch,out_ch,1,1,0))
        self.block3 = nn.Sequential(conv_block(in_ch,in_ch,3,1,padding=18,dilation=18),
                                   conv_block(in_ch,in_ch,1,1,0),
                                   conv_block(in_ch,out_ch,1,1,0))
        self.block4 = nn.Sequential(conv_block(in_ch,in_ch,3,1,padding=24,dilation=24),
                                   conv_block(in_ch,in_ch,1,1,0),
                                   conv_block(in_ch,out_ch,1,1,0))
    
    def forward(self, x):
        out1 = self.block1(x)
        out2 = self.block2(x)
        out3 = self.block3(x)
        out4 = self.block4(x)
        return out1+out2+out3+out4