ResNet은 어떻게 동작하는가

1깊이의 역설 — 층을 쌓을수록 나빠진다?

AlexNet(2012)은 8층, VGG(2014)는 19층, GoogLeNet(2014)은 22층. 깊이가 곧 성능이던 시절, 자연스러운 질문이 나옵니다. “그냥 층을 더 쌓으면 더 좋아지지 않을까?”

ResNet 저자들은 CIFAR-10에서 잔차 연결이 없는 plain 네트워크를 20층과 56층으로 쌓아 비교했습니다. 결과는 반대였습니다 — 56층 네트워크가 20층보다 훈련 오류(training error)조차 더 높았습니다.

이것이 열화 문제(degradation problem)입니다. 핵심은 이 현상이 과적합(overfitting)이 아니라는 점입니다 — 테스트 오류가 아니라 훈련 오류 자체가 높으므로, 모델이 데이터를 “외우지 못하는” 것입니다.

ImageNet에서도 같은 현상이 재현됩니다. 잔차 연결 유무만 다르고 나머지는 동일한 네트워크의 검증 오류(top-1, 10-crop)입니다.

2핵심 아이디어 — 목표 대신 “차이”를 학습한다

어떤 층 묶음이 배워야 할 이상적인 변환을 H(x)라고 합시다. ResNet의 발상은 층이 H(x)를 통째로 배우게 하지 말고, 입력과의 차이(잔차, residual)만 배우게 하자는 것입니다.

두 형태는 수학적으로 동등하지만 배우기 쉬운 정도가 다릅니다. 만약 항등 사상이 최적에 가깝다면 — 깊은 네트워크의 많은 층이 실제로 그렇습니다 — plain 층은 여러 비선형 층으로 H(x) ≈ x를 힘겹게 근사해야 하지만, 잔차 층은 그냥 가중치를 0으로 밀어 F(x) ≈ 0을 만들면 됩니다. 0을 배우는 건 쉽습니다.

구현은 놀랄 만큼 단순합니다. shortcut은 파라미터도, 추가 연산도 거의 없는 단순 덧셈입니다(element-wise addition). 그래서 plain 34층과 ResNet 34층은 파라미터 수와 FLOPs가 사실상 동일합니다 — 성능 차이는 순수하게 최적화가 쉬워진 것에서 옵니다.

3신호 전파 시뮬레이터 — 곱셈의 세계 vs 덧셈의 세계

잔차 연결이 왜 최적화를 쉽게 만드는지는 후속 논문 Identity Mappings in Deep Residual Networks가 수식으로 보여줍니다. shortcut이 순수한 항등이면, 잔차 블록을 재귀적으로 풀었을 때:

plain 네트워크에서 신호와 그래디언트는 층마다 가중치가 곱해지며 전달됩니다. 곱이 1보다 조금만 작아도 지수적으로 소멸하고, 조금만 커도 폭발합니다. 잔차 네트워크는 더하기의 세계라 항상 “1”이라는 안전한 직통 경로가 남습니다. 아래에서 무작위 가중치를 가진 네트워크를 실제로 만들어 확인해 보세요.

4미니 학습 실험 — 같은 깊이, 다른 운명

이론은 충분합니다. 이제 실제로 두 네트워크를 훈련시켜 봅시다. 나선형 2클래스 데이터를 분류하는 완전연결 네트워크(폭 12)를, 층수·파라미터 수가 동일한 plain 버전과 residual 버전으로 만들어 같은 데이터·같은 학습률로 동시에 훈련합니다. 전부 지금 여러분의 브라우저에서 계산됩니다.

5전체 아키텍처 — 블록을 쌓아 네트워크 만들기

ResNet은 하나의 잔차 블록을 모듈처럼 반복해 쌓는 구조입니다. ImageNet용 ResNet은 공통적으로: 7×7 conv(stride 2) → 3×3 max pool → 4개의 스테이지(conv2_x ~ conv5_x) → global average pooling → 1000-way fc. 스테이지가 바뀔 때마다 해상도는 절반, 채널은 2배가 됩니다.

차원이 바뀌는 경계(각 스테이지의 첫 블록)에서는 shortcut도 차원을 맞춰야 합니다. 논문은 1×1 conv로 차원을 사상하는 projection shortcut(option B)을 차원 증가 시에만 쓰고, 나머지는 전부 파라미터 없는 identity를 사용합니다 — 실험 결과 projection을 늘려도 이득이 미미했고, identity가 병목 구조의 효율에 필수적이기 때문입니다.

Basic 블록 vs Bottleneck 블록

50층 이상에서는 연산량을 아끼기 위해 병목(bottleneck) 블록을 씁니다. 1×1 conv로 채널을 압축(256→64)하고, 그 좁은 공간에서 3×3 conv를 수행한 뒤, 다시 1×1 conv로 복원(64→256)합니다. 비싼 3×3 연산이 좁은 차원에서만 일어나므로, 거의 같은 비용으로 층은 3개, 입출력 채널은 4배가 됩니다.

6ResNet v2 — “깨끗한” 지름길의 완성

원조 ResNet(v1)에도 옥의 티가 있었습니다. 덧셈 뒤에 ReLU가 오기 때문에 shortcut 경로가 완전한 항등이 아니었던 것입니다. 1000층급 초심층에서는 이 작은 방해도 누적되어 문제가 됩니다. 후속 논문은 BN과 ReLU를 conv 앞으로 옮긴 pre-activation 구조를 제안했습니다.

2절에서 해부했던 블록을 v2 구성으로 다시 그리면 차이가 분명합니다. 덧셈 노드 뒤가 텅 비어 있고, 역전파로 바꿔 보면 그래디언트가 어떤 연산도 거치지 않고 shortcut을 타고 그대로 빠져나갑니다.

shortcut을 “더 똑똑하게” 만들려는 시도는 전부 실패했습니다. 110층 ResNet(CIFAR-10)으로 수행한 절제 실험(ablation):

pre-activation의 위력은 극단적 깊이에서 드러납니다. 1001층 ResNet(CIFAR-10)에서 v1은 7.61%에 그쳤지만 v2는 4.92%를 달성하며 훨씬 쉽게 훈련됐습니다. “깊이 자체는 더 이상 적이 아니다 — 최적화를 방해하지만 않는다면”이 증명된 순간입니다.

한 걸음 더 — 왜 경로가 2ⁿ개인가

후속 연구(Veit et al., 2016)는 ResNet을 완전히 다른 각도에서 봤습니다. 잔차 블록을 “층을 쌓은 사슬”이 아니라 “경로가 갈라지는 갈림길”로 보면, n개 블록짜리 ResNet에는 입력에서 출력까지 가는 길이 2ⁿ개 존재합니다.

이유는 단순합니다. 잔차 블록은 y = x + F(x), 즉 신호가 블록마다 두 갈래로 갈라졌다가 덧셈에서 다시 합쳐집니다. 블록 하나를 지날 때마다 “잔차 브랜치 F를 통과할까, shortcut으로 건너뛸까”라는 이지선다가 한 번씩 생기는 셈입니다. 선택이 n번 반복되니 가능한 조합은 2 × 2 × … × 2 = 2ⁿ. plain 네트워크에는 갈림길이 없으므로 경로가 딱 하나뿐입니다.

역전파로 보면 이 “2ⁿ개”가 비유가 아니라 수식 그대로라는 게 분명해집니다. 블록의 야코비안은 ∂(x + F(x))/∂x = I + ∂F/∂x — 즉 두 항의 합이고, n개 블록을 통과한 그래디언트는 이 합들의 곱입니다.

다만 2ⁿ개 경로가 모두 똑같이 기여하지는 않습니다. 경로가 잔차 브랜치를 한 번 더 지날 때마다 전달되는 그래디언트는 지수적으로 작아집니다. 그래서 경로의 개수는 중간 길이에 몰려 있는데도, 실제 학습에 기여하는 경로는 훨씬 짧은 쪽에 몰립니다.

기본값인 블록 54개는 CIFAR-10용 110층 ResNet과 같은 규모입니다. 경로는 2⁵⁴개(약 1.8경 개)나 되고 그중 대부분은 20~30블록짜리 긴 경로인데, 정작 그래디언트의 대부분은 5~17블록(약 10~34층)짜리 짧은 경로에서 옵니다. 110층을 쌓았지만 실질적으로 훈련되는 것은 훨씬 얕은 네트워크들인 셈입니다.

앙상블이란 — 그리고 ResNet이 왜 그렇게 보이는가

앙상블(ensemble)은 여러 모델의 예측을 모아 하나로 쓰는 기법입니다. 투표를 시키거나 평균을 내죠. 랜덤 포레스트(결정 트리 수백 개의 투표)가 대표적입니다. 핵심은 구성원들이 서로 다른 실수를 한다는 점입니다. 실수가 제각각이면 모아 놓았을 때 서로 상쇄되어, 평균이 개별 구성원보다 안정적으로 좋아집니다.

Veit et al.이 실제로 그 실험을 했습니다. 훈련이 끝난 네트워크에서 층을 지워 본 것입니다.

• ResNet에서 잔차 블록 하나를 통째로 삭제 → 오류가 거의 오르지 않습니다. 경로 절반(그 블록을 지나던 경로들)이 사라졌을 뿐, 나머지 절반은 그대로 살아 있기 때문입니다.
• VGG 같은 plain 네트워크에서 층 하나를 삭제 → 성능이 무작위 추측 수준으로 붕괴합니다. 경로가 하나뿐이라 그 길이 끊기면 남는 게 없습니다.
• 여러 블록을 지울수록 오류가 갑자기 무너지지 않고 매끄럽게 올라갑니다. 앙상블에서 구성원 수를 줄일 때 나타나는 전형적인 모습입니다.
• 블록의 순서를 섞어도 성능이 완만하게만 떨어집니다. 순서가 중요한 “사슬”이라면 있을 수 없는 일입니다.

그래서 1000층 ResNet은 “1000층짜리 사슬”이라기보다 가중치를 나눠 쓰는 얕은 네트워크 수없이 많은 것들의 모음에 가깝습니다. 깊이를 늘려도 최적화가 무너지지 않는 이유도 여기서 다시 설명됩니다 — 블록을 하나 더 쌓으면 긴 경로만 늘어나는 게 아니라 짧은 경로도 함께 늘어나기 때문입니다.

7실제 구현 — PyTorch 코드로 확인하기

지금까지 본 모든 것이 실제 코드에서는 몇 줄로 표현됩니다. 아래는 사실상의 표준 구현인 torchvision의 resnet.py 원본 코드입니다. 핵심은 forward()의 단 두 줄입니다.

class BasicBlock(nn.Module):
    expansion: int = 1

    def __init__(self, inplanes, planes, stride=1, downsample=None, ...):
        super().__init__()
        self.conv1 = conv3x3(inplanes, planes, stride)   # 3x3 conv
        self.bn1 = norm_layer(planes)
        self.relu = nn.ReLU(inplace=True)
        self.conv2 = conv3x3(planes, planes)             # 3x3 conv
        self.bn2 = norm_layer(planes)
        self.downsample = downsample
        self.stride = stride

    def forward(self, x):
        identity = x                  # ← 입력을 기억해 둔다 (shortcut)

        out = self.conv1(x)           # ── 잔차 함수 F(x) 시작
        out = self.bn1(out)
        out = self.relu(out)
        out = self.conv2(out)
        out = self.bn2(out)           # ── F(x) 끝

        if self.downsample is not None:
            identity = self.downsample(x)   # 차원이 바뀌면 1x1 conv로 사상 (projection)

        out += identity               # ★ y = F(x) + x  — ResNet의 전부
        out = self.relu(out)          #   (v1: 덧셈 뒤 ReLU)
        return out

class Bottleneck(nn.Module):
    expansion: int = 4                # 출력 채널 = planes × 4

    def __init__(self, inplanes, planes, stride=1, downsample=None, ...):
        super().__init__()
        self.conv1 = conv1x1(inplanes, width)            # 1x1: 채널 압축 (256→64)
        self.bn1 = norm_layer(width)
        self.conv2 = conv3x3(width, width, stride, ...)  # 3x3: 좁은 공간에서 연산
        self.bn2 = norm_layer(width)
        self.conv3 = conv1x1(width, planes * self.expansion)  # 1x1: 복원 (64→256)
        self.bn3 = norm_layer(planes * self.expansion)
        ...

    def forward(self, x):
        identity = x
        out = self.relu(self.bn1(self.conv1(x)))
        out = self.relu(self.bn2(self.conv2(out)))
        out = self.bn3(self.conv3(out))
        if self.downsample is not None:
            identity = self.downsample(x)
        out += identity               # ★ 여기서도 핵심은 같은 한 줄
        out = self.relu(out)
        return out

def _make_layer(self, block, planes, blocks, stride=1):
    downsample = None
    # 스테이지 첫 블록: 해상도를 절반으로(stride 2), 채널이 달라지면
    # shortcut에도 1x1 conv(projection)를 달아 차원을 맞춘다
    if stride != 1 or self.inplanes != planes * block.expansion:
        downsample = nn.Sequential(
            conv1x1(self.inplanes, planes * block.expansion, stride),
            norm_layer(planes * block.expansion),
        )

    layers = []
    layers.append(block(self.inplanes, planes, stride, downsample, ...))
    self.inplanes = planes * block.expansion
    for _ in range(1, blocks):        # 나머지 블록은 전부 순수 identity shortcut
        layers.append(block(self.inplanes, planes, ...))
    return nn.Sequential(*layers)

# resnet50 = ResNet(Bottleneck, [3, 4, 6, 3])   ← 스테이지별 블록 수가 모델을 결정
# resnet101 = ResNet(Bottleneck, [3, 4, 23, 3])
# resnet152 = ResNet(Bottleneck, [3, 8, 36, 3])

직접 써보는 건 세 줄이면 됩니다:

import torch, torchvision
model = torchvision.models.resnet50(weights="IMAGENET1K_V2")  # 사전훈련 가중치
model.eval()
logits = model(torch.randn(1, 3, 224, 224))   # → [1, 1000]

8정리 — 그리고 그 이후

• 문제: plain 네트워크는 깊어지면 훈련 오류부터 나빠진다(열화 문제). 과적합이 아니라 최적화 실패다.
• 해법: 층이 목표 H(x) 대신 잔차 F(x) = H(x) − x를 배우게 하고, 출력을 F(x) + x로 만든다. 항등이 최적에 가까우면 가중치를 0으로 밀기만 하면 된다.
• 동작 원리: 순전파는 잔차들의 합, 역전파는 “1 + …” — 어떤 깊이에도 신호·그래디언트의 직통 경로가 보존된다. plain의 곱셈적 전파와의 근본적 차이.
• 규칙: shortcut은 건드리지 마라. 스케일·게이트·conv·dropout 무엇을 끼워도 나빠진다. v2는 ReLU마저 conv 앞으로 옮겨 경로를 완전히 비웠고, 1001층 훈련에 성공했다.
• 유산: 잔차 연결은 이후 사실상 모든 심층 모델 — DenseNet, EfficientNet, 그리고 Transformer(어텐션/FFN 블록마다 x + Sublayer(x)) — 의 기본 부품이 되었다.

이 자료가 참고한 문헌

1. He, Zhang, Ren, Sun. Deep Residual Learning for Image Recognition. CVPR 2016. arXiv:1512.03385
2. He, Zhang, Ren, Sun. Identity Mappings in Deep Residual Networks. ECCV 2016. arXiv:1603.05027
3. Yu, Koltun. Multi-Scale Context Aggregation by Dilated Convolutions. ICLR 2016. arXiv:1511.07122 — ResNet류 백본을 세그멘테이션 등 밀집 예측으로 확장할 때 해상도를 지키는 방법
4. Veit, Wilber, Belongie. Residual Networks Behave Like Ensembles of Relatively Shallow Networks. NeurIPS 2016. arXiv:1605.06431