[PYTHON] Residual Connection이 Vanishing Gradient를 해결하는 3가지 물리적 방법

Vanishing Gradient

 

딥러닝 모델의 층이 깊어질수록 성능이 좋아질 것이라는 초기 예상과 달리, 실제로는 층이 깊어짐에 따라 역전파(Backpropagation) 과정에서 미분값이 0으로 수렴하는 기울기 소실(Vanishing Gradient) 현상이 발생합니다. 이를 혁신적으로 해결하며 현대 딥러닝 아키텍처의 표준이 된 것이 바로 Residual Connection(잔차 연결)입니다. 본 포스팅에서는 단순히 '더하기를 한다'는 수준을 넘어, 수학적·물리적 관점에서 정보의 흐름이 어떻게 보존되는지 분석하고, 이를 파이썬(PyTorch)으로 최적화하여 구현하는 7가지 실무 예제를 상세히 다룹니다.

---

1. 잔차 연결(Residual Connection)의 물리적 메커니즘과 해결 방법

잔차 연결의 핵심은 입력값 $x$를 출력단으로 직접 전달하는 'Shortcut(지름길)'을 만드는 것입니다. 수학적으로 표현하면 다음과 같습니다. $$H(x) = F(x) + x$$ 여기서 $F(x)$는 학습해야 할 잔차(Residual)이며, $x$는 입력입니다. 역전파 시 이 수식을 미분하면 $\frac{\partial H}{\partial x} = \frac{\partial F}{\partial x} + 1$이 됩니다. 이 '+ 1'이라는 물리적 장치가 기울기가 0이 되어도 최소한 1 이상의 정보가 상위 레이어로 흐를 수 있게 보장하는 '기울기 고속도로(Gradient Highway)' 역할을 수행합니다.

기존 방식 vs Residual 방식의 구조적 차이 비교

비교 항목	Plain Network (일반)	Residual Network (잔차)	물리적 해결 기전
역전파 경로	비선형 함수를 모두 통과	Identity Mapping(지름길) 존재	미분 연쇄 법칙의 감쇄 방지
학습 대상	전체 출력 $H(x)$	잔차 정보 $F(x) = H(x) - x$	입력과 출력의 차이만 최적화
기울기 안정성	하위 층으로 갈수록 소실됨	심층부까지 기울기 보존	항등 미분값 1의 존재
최적 깊이	20층 이하 제약	1000층 이상의 초거대 모델	정보 앙상블 효과 극대화

---

2. 실무 개발자를 위한 Python & PyTorch 실전 구현 (7가지 해결 전략)

단순한 ResNet 블록을 넘어, 실무에서 마주하는 차원 불일치 해결, 병목 구조(Bottleneck), 연산 효율성을 고려한 7가지 구현 예제입니다.

Example 1: 표준 Residual Block (BasicBlock) 구현

import torch
import torch.nn as nn

class BasicBlock(nn.Module):
    def __init__(self, in_planes, planes, stride=1):
        super(BasicBlock, self).__init__()
        self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(planes)
        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(planes)

        self.shortcut = nn.Sequential()
        # 스트라이드가 다르거나 입력/출력 채널이 다를 때 차원 맞추기
        if stride != 1 or in_planes != planes:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_planes, planes, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(planes)
            )

    def forward(self, x):
        # 1. Residual 계산
        out = torch.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        # 2. Shortcut 더하기 (물리적 기울기 소실 해결 핵심)
        out += self.shortcut(x)
        out = torch.relu(out)
        return out
    

Example 2: Bottleneck 디자인을 통한 연산 최적화 (ResNet-50 이상)

1x1 Conv를 활용하여 채널 수를 줄였다가 다시 늘려 연산량을 줄이면서 깊은 층을 쌓는 방법입니다.

class Bottleneck(nn.Module):
    expansion = 4
    def __init__(self, in_planes, planes, stride=1):
        super(Bottleneck, self).__init__()
        self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=1, bias=False)
        self.bn1 = nn.BatchNorm2d(planes)
        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(planes)
        self.conv3 = nn.Conv2d(planes, self.expansion * planes, kernel_size=1, bias=False)
        self.bn3 = nn.BatchNorm2d(self.expansion * planes)

        self.shortcut = nn.Sequential()
        if stride != 1 or in_planes != self.expansion * planes:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_planes, self.expansion * planes, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(self.expansion * planes)
            )

    def forward(self, x):
        out = torch.relu(self.bn1(self.conv1(x)))
        out = torch.relu(self.bn2(self.conv2(out)))
        out = self.bn3(self.conv3(out))
        out += self.shortcut(x)
        return torch.relu(out)
    

Example 3: Pre-Activation Residual Unit (ResNet-V2)

ReLU를 더하기 전에 적용하여 기울기 흐름을 더욱 깨끗하게 유지하는 개선된 방법입니다.

class PreActBlock(nn.Module):
    def __init__(self, in_planes, planes, stride=1):
        super(PreActBlock, self).__init__()
        self.bn1 = nn.BatchNorm2d(in_planes)
        self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(planes)
        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False)

    def forward(self, x):
        # Activation을 먼저 수행하여 Shortcut 경로의 비선형성 방해 제거
        out = torch.relu(self.bn1(x))
        shortcut = x if hasattr(self, 'no_projection') else self.conv1(out) # 단순 예시
        out = self.conv1(out)
        out = self.conv2(torch.relu(self.bn2(out)))
        return out + x # Shortcut 경로가 더 깨끗함
    

Example 4: Projection Shortcut 해결 (채널 불일치 시 가중치 연결)

# 차원이 맞지 않을 때 1x1 Conv로 선형 사영(Linear Projection) 수행
shortcut = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=2)(x)

Example 5: Dense Connection과의 차이 해결 및 응용

더하기가 아닌 결합(Concatenation)을 사용하지만 원리는 유사한 DenseNet 방식의 브릿지 구현입니다.

def dense_forward(x, layers):
    for layer in layers:
        new_features = layer(x)
        x = torch.cat([x, new_features], 1) # 더하기가 아닌 채널 확장을 통한 보존
    return x

Example 6: Zero-Init BatchNorm 전략 (학습 초기 안정성)

# 마지막 BN의 가중치를 0으로 초기화하여 초기 학습 시 Shortcut(x)만 흐르게 함
# 이는 초기 학습의 안정성을 통계적으로 유의미하게 향상시킴
nn.init.constant_(block.bn2.weight, 0) 

Example 7: Transformer 내의 Residual Connection (LayerNorm 위치 해결)

class TransformerBlock(nn.Module):
    def forward(self, x):
        # 1. Self-Attention + Residual
        attn_out = self.self_attn(self.norm1(x))
        x = x + attn_out
        # 2. FFN + Residual
        ffn_out = self.ffn(self.norm2(x))
        x = x + ffn_out
        return x

---

3. 결론:Residual Connection의 가치

Residual Connection은 단순한 연산 기법을 넘어, 딥러닝이 '심층(Deep)'이라는 이름에 걸맞은 성능을 내게 한 일등공신입니다. 물리적으로는 기울기의 소실을 막는 가법적 결합(Additive Coupling)을 제공하며, 시스템적으로는 수많은 얕은 네트워크들의 앙상블(Ensemble) 효과를 창출합니다. 실무적으로는 레이어의 깊이에 따라 BasicBlock과 Bottleneck을 적절히 선택하고, 초기 학습 안정성을 위해 Zero-initialization 전략을 병행하는 것이 최적의 성능을 내는 방법입니다.

---

참고 문헌 및 출처

• He, K., Zhang, X., Ren, S., & Sun, J. (2016). "Deep Residual Learning for Image Recognition." CVPR.
• He, K., Zhang, X., Ren, S., & Sun, J. (2016). "Identity Mappings in Deep Residual Networks." ECCV.
• PyTorch Vision Models Repository (ResNet Implementation).