ResNet은 마이크로소프트에서 개발한 알고리즘으로 "Deep Residual Learning for Image Recognition"이라는 논문에서 발표되었다. ResNet 핵심은 깊어진 신경망을 효과적으로 학습하기 위한 방법으로 레지듀얼(residual) 개념을 고안한 것이다.

---

ResNet

일반적으로 신경망 깊이가 깊어질수록 성능이 좋아지다가 일정한 단계에 다다르면 오히려 성능이 나빠진다는 단점이 있다.

ResNet은 이러한 문제를 해결하기 위해 레지듀얼 블록(residual block)을 도입했다. 레지듀얼 블록은 기울기가 잘 전파될 수 있도록 일종의 숏컷(shortcut, skip connection)을 만들어 기울기 소멸 문제를 방지했다.
👉🏻 블록(block)이란 계층의 묶음이다. 합성곱층을 하나의 블록으로 묶은 것이다.

아래의 그림에서 같은 색으로 묶인 계층들을 하나의 레지듀얼 블록이라고 하며 레지듀얼 블록을 여러 개 쌓은 것을 ResNet이라고 한다.

계층의 깊이가 깊어질수록 파라미터가 무제한으로 커지기 때문에 이를 해결하기 위해 병목 블록(bottleneck block)이라는 것을 두었다.

▶︎ 병목 블록을 사용하는 ResNet50을 살펴보자!
ResNet50에서는 3x3 합성곱층 앞뒤로 1x1 합성곱층이 붙어 있는데, 1x1 합성곱층의 채널 수를 조절하면서 차원을 줄였다 늘리는 것이 가능하기 때문에 파라미터 수를 줄일 수 있다.

ResNet 용어 정리

• 아이덴티티 매핑(identity mapping)이란 입력 x가 어떤 함수를 통과하더라도 다시 x라는 형태로 출력되도록 한다.

• 다운샘플(downsample)이란 특성뱁 크기를 줄이기 위한 것으로 풀링과 같은 역할을 한다. 다른 레지듀얼 블럭간의 형태를 맞추지 않으면 아이덴티티 매핑을 할 수 없기 때문에 아이덴티티에 대해 다운샘플이 필요하다.

  만약 입력과 출력의 형태를 같도록 맞추어 주기 위해서는 스트라이드 2를 가진 1x1 합성곱 계층을 하나 연결해주면 된다.

  ▶︎ 입력과 출력의 차원이 같은 것을 아이텐디디 블록이라고 하며, 입력 및 출력 차원이 동일하지 않고 입력의 차원을 출력에 맞추어 변경해야 하는 것을 합성곱 블록이라고 한다.

Code로 살펴보기

Block

👉🏻 ResNet의 전체 네트워크 구성을 위해 그것을 구성하는 기본 블록과 병목 블록에 대한 코드를 살펴보자
1) 기본 블록

# 기본 블록
# ResNet18, ResNet34에서 사용됨
class BasicBlock(nn.Module):    
    expansion = 1
    
    def __init__(self, in_channels, out_channels, stride = 1, downsample = False):
        super().__init__()                
        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size = 3, 
                               stride = stride, padding = 1, bias = False)
        self.bn1 = nn.BatchNorm2d(out_channels)        
        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size = 3, 
                               stride = 1, padding = 1, bias = False)
        self.bn2 = nn.BatchNorm2d(out_channels)        
        self.relu = nn.ReLU(inplace = True)
        
        if downsample:					# 다운샘플이 적용됨 -> 입력 데이터의 크기와 네트워크를 통과한 후 출력 데이터의 크기가 다를 경우에 사용한다.
            conv = nn.Conv2d(in_channels, out_channels, kernel_size = 1, 
                             stride = stride, bias = False)
            bn = nn.BatchNorm2d(out_channels)
            downsample = nn.Sequential(conv, bn)
        else:
            downsample = None        
        self.downsample = downsample
        
    def forward(self, x):       
        i = x       
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)        
        x = self.conv2(x)
        x = self.bn2(x)
        
        if self.downsample is not None:
            i = self.downsample(i)
                        
        x += i						# identity mapping (skip connection)
        x = self.relu(x)
        
        return x

2) 병목 블록

• 1x1합성곱층, 3x3합성곱층, 1x1합성곱층으로 구성된다.
• 계층을 더 깊게 쌓으면서 계산에 대한 비용을 줄일 수 있다.
• 활성화 함수가 기존보다 더 많이 포함되기 깨문에 더 많은 비선형성을 처리할 수 있다.(다양한 입력 데이터에 대한 처리가 가능하다.)

# 병목 블록
# ResNet50,ResNet101,ResNet152에서 적용됨 
class Bottleneck(nn.Module):    
    expansion = 4
    
    def __init__(self, in_channels, out_channels, stride = 1, downsample = False):
        super().__init__()    
        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size = 1, stride = 1, bias = False) # 1x1합성곱층
        self.bn1 = nn.BatchNorm2d(out_channels)        
        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size = 3, stride = stride, padding = 1, bias = False) # 3x3합성곱층
        self.bn2 = nn.BatchNorm2d(out_channels)        
        self.conv3 = nn.Conv2d(out_channels, self.expansion * out_channels, kernel_size = 1,
                               stride = 1, bias = False) 
# 1x1합성곱층
# self.expansion * out_channels : 다음 계층의 입력 채널 수와 일치하도록하기 위함
        self.bn3 = nn.BatchNorm2d(self.expansion * out_channels)  
        	   
        self.relu = nn.ReLU(inplace = True)
        
        if downsample:
            conv = nn.Conv2d(in_channels, self.expansion * out_channels, kernel_size = 1, 
                             stride = stride, bias = False)
            bn = nn.BatchNorm2d(self.expansion * out_channels)
            downsample = nn.Sequential(conv, bn)
        else:
            downsample = None            
        self.downsample = downsample
        
    def forward(self, x):        
        i = x        
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)        
        x = self.conv2(x)
        x = self.bn2(x)
        x = self.relu(x)        
        x = self.conv3(x)
        x = self.bn3(x)
                
        if self.downsample is not None:
            i = self.downsample(i)
            
        x += i
        x = self.relu(x)
    
        return x

Model

1) 직접 layer만들기

• class 정의

class ResNet(nn.Module):
    def __init__(self, config, output_dim, zero_init_residual=False):
        super().__init__()
                
        block, n_blocks, channels = config # - ①
        self.in_channels = channels[0]            
        assert len(n_blocks) == len(channels) == 4
        
        self.conv1 = nn.Conv2d(3, self.in_channels, kernel_size = 7, stride = 2, padding = 3, bias = False)
        self.bn1 = nn.BatchNorm2d(self.in_channels)
        self.relu = nn.ReLU(inplace = True)
        self.maxpool = nn.MaxPool2d(kernel_size = 3, stride = 2, padding = 1)
        
        self.layer1 = self.get_resnet_layer(block,  n_blocks[0], channels[0]) # - ②
        self.layer2 = self.get_resnet_layer(block, n_blocks[1], channels[1], stride = 2)
        self.layer3 = self.get_resnet_layer(block, n_blocks[2], channels[2], stride = 2)
        self.layer4 = self.get_resnet_layer(block, n_blocks[3], channels[3], stride = 2)
        
        self.avgpool = nn.AdaptiveAvgPool2d((1,1))
        self.fc = nn.Linear(self.in_channels, output_dim)

        if zero_init_residual: # - ③
            for m in self.modules():
                if isinstance(m, Bottleneck):
                    nn.init.constant_(m.bn3.weight, 0)
                elif isinstance(m, BasicBlock):
                    nn.init.constant_(m.bn2.weight, 0)
        
    def get_resnet_layer(self, block, n_blocks, channels, stride = 1):   # - ④
        layers = []        
        if self.in_channels != block.expansion * channels:
            downsample = True
        else:
            downsample = False
        
        layers.append(block(self.in_channels, channels, stride, downsample))
        
        for i in range(1, n_blocks):
            layers.append(block(block.expansion * channels, channels))

        self.in_channels = block.expansion * channels            
        return nn.Sequential(*layers)
        
    def forward(self, x):        
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x)
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)        
        x = self.avgpool(x)
        h = x.view(x.shape[0], -1)
        x = self.fc(h)        
        return x, h

① config 환경 설정(어떤 resnet을 사용할지에 따라 값이 달라진다.)
② 완전 연결 층으로 get_resnet_layer함수를 이용해 layer를 생성한다.
③ 각 레지듀얼 분기에 있는 마지막 Batch Normalization을 0으로 초기화해서 다음 레지듀얼 분기를 0에서 시각잘 수 있도록한다.
-> 필수는 아니나 0으로 초기화를 할 경우 모델의 성능이 0.2 ~ 0.3% 정도 향상된다.
④ 아래의 코드를 통해 구현하고자 하는 ResNet을 정의한다.

ResNetConfig = namedtuple('ResNetConfig', ['block', 'n_blocks', 'channels'])

• block : 기본 블럭(BasicBlock)인지 병목 블럭(Bottleneck)인지를 결정한다.
• n_blocks : 블럭의 수를 결정한다.
• channels : 채널의 수를 결정한다.

# 기본 블럭을 사용한 ResNet
resnet18_config = ResNetConfig(block = BasicBlock,
                               n_blocks = [2,2,2,2],
                               channels = [64, 128, 256, 512])

resnet34_config = ResNetConfig(block = BasicBlock,
                               n_blocks = [3,4,6,3],
                               channels = [64, 128, 256, 512])
                               
# 병목 블럭을 사용한 ResNet
resnet50_config = ResNetConfig(block = Bottleneck,
                               n_blocks = [3, 4, 6, 3],
                               channels = [64, 128, 256, 512])

resnet101_config = ResNetConfig(block = Bottleneck,
                                n_blocks = [3, 4, 23, 3],
                                channels = [64, 128, 256, 512])

resnet152_config = ResNetConfig(block = Bottleneck,
                                n_blocks = [3, 8, 36, 3],
                                channels = [64, 128, 256, 512])

2) 사전 훈련된 모델 사용하기

pretrained_model = models.resnet50(pretrained = True)

---

출처

• 딥러닝 파이토치 교과서