He et al., Deep Residual Learning for Image Recognition, 2015 (ILSVRC 2015 우승)

1. 배경: 왜 나왔나? (Problem)

VGG 이후로 "층을 깊게 쌓을수록 성능이 좋아진다"는 게 거의 정설이었다. 그런데 실제로 계속 쌓아보니 이상한 일이 생겼다.

• 56층 네트워크가 20층 네트워크보다 test error뿐 아니라 train error도 더 높게 나왔다.
• train error까지 높다는 건 overfitting이 아니라는 뜻이다. 모델이 아예 학습을 제대로 못 하고 있는 것.
• Batch Normalization 등으로 vanishing gradient는 어느 정도 잡은 상태였는데도 이런 현상이 나타났다.

이걸 Degradation Problem이라고 부른다.

논리적으로 보면 말이 안 된다. 20층 모델에 아무것도 안 하는 층(identity) 36개만 붙여도 56층 모델은 최소한 20층만큼은 나와야 한다. 즉, 문제는 표현력이 아니라 "깊은 네트워크가 identity 같은 단순한 함수조차 학습하기 어렵다"는 최적화 문제였다.

• identity: 항등함수

2. 다른 구조와 뭐가 다른가?

비슷한 시기의 Highway Network도 shortcut을 썼지만, 여기엔 학습 가능한 gate가 있어서 파라미터가 늘고 gate가 닫히면 shortcut이 막힐 수 있다. ResNet의 identity shortcut은 파라미터 0개, 항상 열려 있다는 점이 다르다.

Highway Network와 ResNet 모두 입력을 뒤쪽으로 전달하는 shortcut(skip connection)을 사용한다. 차이는 shortcut을 조절하는 방식이다. Highway Network는 $y=T(x)H(x)+(1-T(x))x$처럼 학습 가능한 gate를 곱해 원래 입력 $x$를 얼마나 전달할지 결정한다. Gate 값에 따라 shortcut이 거의 막힐 수도 있다. 반면 ResNet의 identity shortcut은 $y=F(x)+x$처럼 입력을 그대로 더한다. Shortcut 자체에는 학습할 파라미터가 없고, gate에 의해 닫히지도 않는다.

3. 그래서 어떻게 풀었나? (Solve)

핵심: Residual Block + Skip Connection

x ──────────────────┐
│                   │ (identity shortcut)
▼                   │
Conv → BN → ReLU    │
│                   │
Conv → BN           │
│                   │
▼                   │
(+) ◄───────────────┘
│
ReLU
▼
y = F(x) + x

왜 잘 되나?

1. 학습 목표가 쉬워진다 출력 전체를 새로 만드는 대신 입력에서 "얼마나 바꿀지"만 배운다. 필요 없는 층은 가중치를 0 근처로 두면 그냥 통과시킬 수 있다.

2. gradient가 잘 흐른다 $y = F(x) + x$를 미분하면 $$\frac{\partial y}{\partial x} = \frac{\partial F}{\partial x} + 1$$ $+1$ 덕분에 gradient가 아무리 깊어도 사라지지 않고 앞쪽 층까지 전달된다.

세부 설계

• 차원이 안 맞을 때: stride나 채널 수가 바뀌어 x와 F(x)의 shape이 다르면, shortcut에 1x1 conv(projection)를 넣어 맞춘다.
• Basic Block (ResNet-18/34): 3x3 → 3x3
• Bottleneck Block (ResNet-50/101/152): 1x1(채널 축소) → 3x3 → 1x1(채널 복원) 깊게 쌓으면서도 연산량을 줄이기 위한 구조.

결과적으로 152층까지 안정적으로 학습시켰고, ImageNet top-5 error 3.57%로 당시 1위를 차지했다.

4. 코드로는 어떻게 쓰나?

(1) Residual Block 직접 구현 (PyTorch)

import torch.nn as nn

class BasicBlock(nn.Module):
    def __init__(self, in_ch, out_ch, stride=1):
        super().__init__()
        self.conv1 = nn.Conv2d(in_ch, out_ch, 3, stride, 1, bias=False)
        self.bn1   = nn.BatchNorm2d(out_ch)
        self.conv2 = nn.Conv2d(out_ch, out_ch, 3, 1, 1, bias=False)
        self.bn2   = nn.BatchNorm2d(out_ch)
        self.relu  = nn.ReLU(inplace=True)

        # shape이 달라지면 1x1 conv로 shortcut을 맞춰줌
        self.shortcut = nn.Identity()
        if stride != 1 or in_ch != out_ch:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_ch, out_ch, 1, stride, bias=False),
                nn.BatchNorm2d(out_ch),
            )

    def forward(self, x):
        out = self.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        out = out + self.shortcut(x)   # 핵심: F(x) + x
        return self.relu(out)

(2) 사전학습 모델 가져와서 Fine-tuning

직접 구현하기보다 ImageNet으로 학습된 가중치를 가져와 분류기(fc)만 바꿔서 쓰는 경우가 대부분이다.

import torch.nn as nn
from torchvision.models import resnet50, ResNet50_Weights

model = resnet50(weights=ResNet50_Weights.DEFAULT)

# (선택) 백본은 고정하고 분류기만 학습
for p in model.parameters():
    p.requires_grad = False

num_classes = 5
model.fc = nn.Linear(model.fc.in_features, num_classes)  # 새 분류기는 학습됨

데이터가 충분하면 백본 일부(layer4 등)를 풀어서 함께 학습시키면 성능이 더 오른다.

(3) 개념은 어디에나 있다

Skip connection은 이미지 분류를 넘어서 이후 거의 모든 딥러닝 구조의 기본 부품이 됐다.

• Transformer: 각 sublayer마다 x + Attention(x), x + FFN(x)
• U-Net: encoder-decoder 사이 skip connection
• DenseNet: 더하기 대신 이어붙이기(concat)로 확장

한 줄 요약: "깊게 쌓으면 학습이 안 된다" → "차이만 배우게 하고 입력은 그대로 더해주자"

2014, Google (Szegedy et al.) · ILSVRC 2014 분류 부문 우승 (Top-5 error 6.67%)

1. 왜 나왔나? — Problem

2012년 AlexNet 이후 CNN 연구의 흐름은 "네트워크를 더 깊고 넓게 만들면 성능이 오른다" 였다. 하지만 이 방식에는 분명한 한계가 있었다.

• 연산량과 파라미터의 폭발: 층과 채널을 늘리면 연산량이 제곱 단위로 늘어난다. 모델이 커질수록 학습·추론 비용이 감당하기 어려워진다.
• 과적합: 파라미터가 많을수록 데이터가 충분하지 않으면 과적합되기 쉽다. 특히 마지막 Fully Connected 층에 파라미터가 몰려 있었다.
• 필터 크기 선택의 딜레마: 이미지 속 객체의 크기는 제각각이다. 작은 필터(3×3)는 세밀한 특징을, 큰 필터(5×5)는 넓은 문맥을 잘 잡는데, 층마다 어떤 크기를 쓸지 사람이 정해야 했다.
• 기울기 소실: 깊어질수록 앞쪽 층까지 gradient가 잘 전달되지 않는다.

즉, "깊게 쌓고 싶은데 비용은 감당할 수 있게" 라는 문제를 풀어야 했다.

2. 다른 모델과 뭐가 다른가?

VGG가 "단순함"으로 깊이를 얻었다면, GoogLeNet은 "구조 설계"로 깊이와 효율을 동시에 얻었다. VGG보다 깊으면서도 파라미터는 약 1/27이다.

3. 그래서 어떻게 풀었나? — Solve

① Inception 모듈 → 필터 크기 딜레마 해결

한 층에서 필터 크기를 하나만 고르지 않고, 1×1 / 3×3 / 5×5 conv와 3×3 max pooling을 병렬로 수행한 뒤 채널 방향으로 이어 붙인다. 어떤 스케일의 정보가 중요한지는 네트워크가 학습으로 알아서 조합한다. 이 모듈을 9개 쌓아 네트워크 몸통을 만든다.

            ┌─ 1×1 conv ─────────────────┐
            ├─ 1×1 conv → 3×3 conv ──────┤
입력 ───────┤                            ├─ Concat → 출력
            ├─ 1×1 conv → 5×5 conv ──────┤
            └─ 3×3 maxpool → 1×1 conv ───┘

② 1×1 Convolution 병목 → 연산량 폭발 해결

병렬로 여러 필터를 돌리면 연산량이 커지므로, 3×3·5×5 연산 앞에 1×1 conv를 두어 채널 수를 먼저 줄인다.

약 10배 절감된다. 1×1 conv 뒤에도 ReLU가 붙어 비선형성이 추가되는 효과도 있다.

③ Global Average Pooling → 파라미터·과적합 해결

마지막 feature map을 채널별로 평균 내어 1×1×1024 벡터로 만든다. 거대한 FC 층을 없애서 파라미터를 크게 줄이고 과적합도 완화했다.

④ 보조 분류기(Auxiliary Classifier) → 기울기 소실 완화

깊은 신경망은 마지막 층에서 계산한 오차가 앞쪽 층까지 전달되는 과정에서 학습 신호가 약해질 수 있다. 이를 완화하기 위해 중간 층에 작은 분류기를 붙여 추가 loss를 계산한다.

전체 loss = 메인 loss + 0.3 × (보조 loss1 + 보조 loss2)

추론할 때는 떼어낸다. (이후 Batch Normalization이 등장하면서 필요성은 줄었다.)

4. 코드로 어떻게 활용하나?

① Inception 모듈 직접 구현 (PyTorch)

import torch
import torch.nn as nn

class Inception(nn.Module):
    def __init__(self, in_ch, c1, c3_red, c3, c5_red, c5, pool_proj):
        super().__init__()
        # 1×1
        self.b1 = nn.Sequential(nn.Conv2d(in_ch, c1, 1), nn.ReLU(inplace=True))
        # 1×1 병목 → 3×3
        self.b2 = nn.Sequential(
            nn.Conv2d(in_ch, c3_red, 1), nn.ReLU(inplace=True),
            nn.Conv2d(c3_red, c3, 3, padding=1), nn.ReLU(inplace=True))
        # 1×1 병목 → 5×5
        self.b3 = nn.Sequential(
            nn.Conv2d(in_ch, c5_red, 1), nn.ReLU(inplace=True),
            nn.Conv2d(c5_red, c5, 5, padding=2), nn.ReLU(inplace=True))
        # 3×3 maxpool → 1×1
        self.b4 = nn.Sequential(
            nn.MaxPool2d(3, stride=1, padding=1),
            nn.Conv2d(in_ch, pool_proj, 1), nn.ReLU(inplace=True))

    def forward(self, x):
        # 네 갈래의 출력을 채널 방향(dim=1)으로 이어 붙임
        return torch.cat([self.b1(x), self.b2(x), self.b3(x), self.b4(x)], dim=1)

# 논문의 inception(3a) 설정
m = Inception(192, 64, 96, 128, 16, 32, 32)
x = torch.randn(1, 192, 28, 28)
print(m(x).shape)  # torch.Size([1, 256, 28, 28])  ← 64+128+32+32

padding으로 공간 크기(28×28)를 맞춰두었기 때문에 채널 방향으로 concat이 가능하다.

② 사전학습 모델로 전이학습 (실무에서 가장 흔한 방식)

import torch.nn as nn
from torchvision import models
from torchvision.models import GoogLeNet_Weights

weights = GoogLeNet_Weights.DEFAULT
model = models.googlenet(weights=weights)   # ImageNet 사전학습, 보조 분류기는 제거된 상태
preprocess = weights.transforms()           # 학습 때와 같은 전처리

# 백본 고정 (데이터가 적을 때)
for p in model.parameters():
    p.requires_grad = False

# 마지막 분류기만 내 클래스 수에 맞게 교체
model.fc = nn.Linear(model.fc.in_features, 10)  # in_features = 1024

③ 처음부터 학습할 때: 보조 분류기 loss 활용

model = models.googlenet(weights=None, aux_logits=True,
                         num_classes=10, init_weights=True)
criterion = nn.CrossEntropyLoss()

model.train()
out = model(images)  # GoogLeNetOutputs(logits, aux_logits2, aux_logits1)
loss = criterion(out.logits, labels) \
     + 0.3 * (criterion(out.aux_logits1, labels) + criterion(out.aux_logits2, labels))

model.eval()
pred = model(images)  # 추론 시에는 메인 출력만 반환

한 줄 정리

GoogLeNet은 여러 크기의 필터를 병렬로 쓰는 Inception 모듈과 1×1 conv 병목으로, 깊이는 늘리면서 연산량과 파라미터는 줄인 모델이다. 이 병목 설계는 이후 ResNet의 bottleneck block, MobileNet 같은 경량 모델로 이어진다.

2012년 AlexNet이 ImageNet에서 큰 성공을 거두면서, 연구자들은 "CNN을 어떻게 설계해야 성능이 더 좋아질까?"를 고민하기 시작했다.

당시에는 필터 크기, stride, 층 수 등을 이것저것 바꿔보는 식이어서, 어떤 요소가 성능을 결정하는지 명확하지 않았다. 특히 이런 질문이 남아 있었다.

• 네트워크를 깊게 만들면 성능이 좋아지는가?
• 그런데 층을 늘리면 파라미터와 연산량이 폭발하는데, 이걸 어떻게 감당하나?

2014년 옥스퍼드 대학 Visual Geometry Group(Simonyan & Zisserman)은 다른 조건은 최대한 단순하게 고정하고 깊이 하나만 바꿔가며 이 질문에 답하려 했다.

2. 다른 모델과 뭐가 다른가?

• AlexNet 대비: 큰 필터를 버리고 작은 필터를 깊게 쌓았다.
• GoogLeNet 대비: 성능은 약간 낮았지만(ILSVRC 2014 분류 2위), 구조가 훨씬 단순해서 이해·구현·변형이 쉬웠다. 그래서 오히려 더 널리 쓰였다.

3. 어떻게 풀었나? (Solve)

핵심: 3×3 합성곱을 여러 번 쌓는다

3×3 합성곱을 연속으로 쌓으면 큰 필터와 같은 수용 영역(receptive field)을 얻는다.

이렇게 하면 깊이를 늘리면서도 다음 이점을 얻는다.

1. 파라미터 감소: 같은 수용 영역을 더 적은 파라미터로 얻는다.
2. 비선형성 증가: 층마다 ReLU가 들어가므로 표현력이 풍부해진다.

전체 구조

입력 224×224 → 합성곱 블록 5개 → FC 3개 → Softmax

• 각 블록 = 3×3 합성곱(stride 1, padding 1) 여러 개 + 2×2 Max Pooling(stride 2)
• 풀링마다 공간 크기는 절반, 채널은 두 배 (64 → 128 → 256 → 512 → 512)
• 마지막은 FC 4096 → FC 4096 → FC 1000
• VGG16: 합성곱 13층 + FC 3층 / VGG19: 합성곱 16층 + FC 3층

결과와 남은 문제

깊이가 깊어질수록 성능이 좋아진다는 것을 실험으로 보여주었다. 다만 한계도 분명했다.

• 파라미터 대부분이 FC층에 몰려 있어 모델이 무겁다 (첫 FC층만 약 1억 개).
• 19층 이상 쌓으면 기울기 소실로 학습이 어려워진다 → 이후 ResNet이 잔차 연결로 해결.

4. 코드로 어떻게 활용하나? (PyTorch)

4-1. 구조 직접 구현해보기

블록 구조가 규칙적이라 설정 리스트만으로 네트워크를 만들 수 있다.

import torch.nn as nn

# 숫자 = 3×3 합성곱의 출력 채널, 'M' = Max Pooling
VGG16_CFG = [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M',
             512, 512, 512, 'M', 512, 512, 512, 'M']

def make_features(cfg):
    layers, in_ch = [], 3
    for v in cfg:
        if v == 'M':
            layers.append(nn.MaxPool2d(kernel_size=2, stride=2))
        else:
            layers += [nn.Conv2d(in_ch, v, kernel_size=3, padding=1),
                       nn.ReLU(inplace=True)]
            in_ch = v
    return nn.Sequential(*layers)

class VGG16(nn.Module):
    def __init__(self, num_classes=1000):
        super().__init__()
        self.features = make_features(VGG16_CFG)
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(512 * 7 * 7, 4096), nn.ReLU(True), nn.Dropout(0.5),
            nn.Linear(4096, 4096), nn.ReLU(True), nn.Dropout(0.5),
            nn.Linear(4096, num_classes),
        )

    def forward(self, x):
        return self.classifier(self.features(x))

4-2. 전이학습 (가장 흔한 활용)

실무에서는 직접 학습하기보다 ImageNet으로 사전학습된 모델을 가져와 내 데이터에 맞게 마지막 층만 바꾼다.

import torch.nn as nn
from torchvision import models

model = models.vgg16(weights=models.VGG16_Weights.IMAGENET1K_V1)

# 특징 추출부는 고정
for p in model.features.parameters():
    p.requires_grad = False

# 마지막 FC층을 내 클래스 수에 맞게 교체 (예: 5개 클래스)
model.classifier[6] = nn.Linear(4096, 5)

4-3. 특징 추출기로 활용 (Perceptual Loss 등)

VGG의 중간층 출력은 이미지의 질감·형태를 잘 담고 있어서, 스타일 트랜스퍼나 초해상도 모델에서 "두 이미지가 사람 눈에 얼마나 비슷한가"를 측정하는 데 쓰인다.

import torch.nn as nn
from torchvision import models

vgg = models.vgg16(weights=models.VGG16_Weights.IMAGENET1K_V1).features[:16].eval()
for p in vgg.parameters():
    p.requires_grad = False

def perceptual_loss(pred, target):
    # 픽셀 값 대신 VGG 특징 맵끼리 비교
    return nn.functional.mse_loss(vgg(pred), vgg(target))

정리

• Problem: CNN에서 깊이가 성능에 어떤 영향을 주는지 불분명했다.
• 차이점: 큰 필터 대신 3×3 필터만 쓰고, 구조를 단순·규칙적으로 만들었다.
• Solve: 작은 필터를 깊게 쌓아 파라미터는 줄이고 비선형성은 늘렸다.
• 활용: 지금은 분류 모델 자체보다 전이학습 백본, 특징 추출기로 주로 쓰인다.

Krizhevsky, Sutskever, Hinton. ImageNet Classification with Deep Convolutional Neural Networks. NeurIPS 2012.

1. 왜 나왔나? (Problem)

2012년 이전의 이미지 분류는 사람이 특징을 설계하는 방식이었다. SIFT, HOG 같은 특징 추출기로 이미지를 벡터로 바꾸고, 그 위에 SVM 같은 분류기를 얹었다. 이 방식은 두 가지 벽에 부딪혀 있었다.

• 성능 정체: 특징을 사람이 만들다 보니 복잡한 이미지에서 한계가 뚜렷했다. ImageNet 대회 top-5 오류율은 25% 근처에서 맴돌았다.
• 신경망은 "이론상 좋지만 실제로는 안 되는" 기술: CNN은 LeNet(1998)부터 있었지만 손글씨 숫자 같은 작은 문제에서만 통했다. 네트워크를 깊고 크게 만들면
  • 학습이 너무 느리고 (sigmoid/tanh의 기울기 포화, CPU 연산 한계)
  • 데이터 대비 파라미터가 많아 과적합이 심했다.

즉 풀어야 할 문제는 이것이었다. "120만 장, 1000개 클래스짜리 대규모 데이터에서, 거대한 CNN을 현실적인 시간 안에, 과적합 없이 학습시킬 수 있는가?"

2. 다른 방법과 뭐가 다른가?

비교 대상	그쪽 방식	AlexNet
전통 방식 (SIFT + SVM)	특징을 사람이 설계	특징을 데이터로부터 학습 (end-to-end)
LeNet-5 (1998)	작은 입력(32×32), 층 얕음, 파라미터 약 6만, CPU, tanh	224×224 컬러, Conv 5 + FC 3, 파라미터 약 6,000만, GPU, ReLU
좌측은 LeNet-5, 우측은 AlexNet입니다.
이미지 출처: daeun-computer-uneasy.tistory.com

핵심 차이는 "새로운 층을 발명했다"가 아니라, 규모를 키웠을 때 생기는 문제들을 실전적으로 해결해서 깊은 CNN이 실제로 동작함을 증명했다는 점이다.

3. 그래서 어떻게 풀었나? (Solve)

구조: Conv 5층 + FC 3층

문제별 해결책

학습이 느리다 → ReLU + GPU

• max(0, x)는 양수 구간에서 기울기가 1로 유지돼 포화가 없다. 논문 실험에서 tanh 대비 같은 오류율 도달이 약 6배 빨랐다.
• GTX 580(3GB) 한 장에 모델이 안 들어가서 네트워크를 절반씩 두 GPU에 나눠 학습했다. 특정 층에서만 GPU끼리 통신한다. (구조도가 위아래 두 갈래인 이유)

과적합이 심하다 → Dropout + Data Augmentation

• Dropout (p=0.5): FC6, FC7에서 뉴런을 무작위로 끈다. 파라미터가 몰린 FC층의 과적합을 직접 겨냥했다.
• Data Augmentation: 256×256에서 무작위 224×224 크롭 + 좌우 반전, PCA 기반 색상 변형으로 데이터를 사실상 크게 늘렸다.

일반화 성능을 조금 더 → Overlapping Pooling, LRN

• 3×3 풀링을 stride 2로 겹쳐서 적용.
• LRN으로 인접 채널 간 정규화. (단, 이후 효과가 미미하다고 밝혀져 BatchNorm에 자리를 내줌)

LRN(Local Response Normalization)이란? LRN은 AlexNet에서 사용한 정규화 기법이다. 같은 공간 위치에 있는 인접 채널들의 활성값을 이용해 각 값을 조정한다. 주변 채널의 활성값이 클수록 더 큰 값으로 나누기 때문에, 해당 채널의 출력이 작아진다. 여기서 값을 ‘누른다’는 것은 0으로 만든다는 뜻이 아니라 크기를 줄인다는 뜻이다. 큰 활성값도 LRN을 거치면 작아질 수 있으며, 채널 사이의 반응을 상대적으로 비교하는 효과가 있다. AlexNet에서는 일부 합성곱 층의 ReLU 뒤, Max Pooling 앞에 LRN을 적용했다. 오늘날에는 LRN보다 Batch Normalization 같은 정규화 방법이 주로 사용된다.

Overlapping Pooling이란? 풀링 창을 이동할 때 인접한 창이 서로 겹치도록 하는 방식이다. 풀링 창의 크기보다 이동 간격(stride)이 작으면 겹침이 생긴다. 예를 들어 AlexNet은 3×3 Max Pooling에 stride 2를 사용했다. 첫 번째 창이 가로 방향의 13번째 값을 보면, 다음 창은 35번째 값을 본다. 3번째 값이 두 창에 모두 포함되는 것이다. 반대로 2×2 창을 stride 2로 이동하면 창끼리 겹치지 않는다. AlexNet 논문에서는 overlapping pooling을 사용했을 때 오류율이 소폭 낮아졌다고 보고했다.

학습 설정: SGD + momentum 0.9, weight decay 0.0005, batch 128, lr 0.01에서 시작해 정체 시 1/10, 약 90 epoch, 5~6일.

결과

ILSVRC 2012 top-5 오류율 15.3%. 2위는 26.2%. 이 격차로 컴퓨터 비전의 주류가 하루아침에 딥러닝으로 넘어갔다.

4. 코드로는 어떻게 쓰나?

실무에서 AlexNet을 처음부터 학습시킬 일은 거의 없다. 주로 구조를 직접 구현하며 CNN을 이해하는 용도나, 사전학습 모델로 전이학습을 연습하는 용도로 쓴다.

참고: torchvision의 AlexNet은 원 논문이 아니라 단일 GPU 버전이다. Conv1 채널이 64개이고, LRN이 없다.

(1) 직접 구현 (PyTorch)

import torch
import torch.nn as nn

class AlexNet(nn.Module):
    def __init__(self, num_classes=1000):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 96, kernel_size=11, stride=4, padding=2),
            nn.ReLU(inplace=True),
            nn.LocalResponseNorm(size=5),
            nn.MaxPool2d(kernel_size=3, stride=2),     # overlapping pooling

            nn.Conv2d(96, 256, kernel_size=5, padding=2),
            nn.ReLU(inplace=True),
            nn.LocalResponseNorm(size=5),
            nn.MaxPool2d(kernel_size=3, stride=2),

            nn.Conv2d(256, 384, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(384, 384, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(384, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
        )
        self.classifier = nn.Sequential(
            nn.Dropout(0.5),
            nn.Linear(256 * 6 * 6, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            nn.Linear(4096, num_classes),
        )

    def forward(self, x):
        x = self.features(x)
        x = torch.flatten(x, 1)
        return self.classifier(x)

model = AlexNet()
print(model(torch.randn(1, 3, 224, 224)).shape)  # torch.Size([1, 1000])

(2) 사전학습 모델로 추론

from torchvision.models import alexnet, AlexNet_Weights
from PIL import Image

weights = AlexNet_Weights.IMAGENET1K_V1
model = alexnet(weights=weights).eval()
preprocess = weights.transforms()   # 리사이즈·크롭·정규화를 한 번에

img = preprocess(Image.open("dog.jpg")).unsqueeze(0)
with torch.no_grad():
    pred = model(img).softmax(dim=1)

idx = pred.argmax().item()
print(weights.meta["categories"][idx], pred[0, idx].item())

(3) 전이학습: 내 데이터(예: 5개 클래스)에 맞추기

model = alexnet(weights=AlexNet_Weights.IMAGENET1K_V1)

# 특징 추출부는 고정
for p in model.features.parameters():
    p.requires_grad = False

# 마지막 FC층만 내 클래스 수로 교체
model.classifier[6] = nn.Linear(4096, 5)

optimizer = torch.optim.SGD(
    filter(lambda p: p.requires_grad, model.parameters()),
    lr=1e-3, momentum=0.9, weight_decay=5e-4,   # 논문 설정과 같은 계열
)

센서 측정, 이미지, 비디오, 텍스트, 이벤트 등을 통해 졍형화되어 있지 않은 데이터를 받는다. 데이터 과학은 이러한 데이터들의 폭발적인 양의 원시(가공되지 않은) 데이터를 활용 가능하도록 정형화된 형태로 변환해야 한다. 정형 데이터 중 가장 일반적인 형태는 열이 있는 테이블 형태이다.

정형데이터의 종류

수치형 데이터

• 연속형 데이터: 풍속이나 지속 시간
• 이산 데이터: 사건의 발생 빈도

  범주형 데이터

  도시명(대전, 부산, 서울)과 같이 범위가 정해진 값들을 같은 경우
• 이진 데이터: 범주형 중에서도 참/거짓, 0과 1, 예/아니요 같은 두 값 중 하나를 갖는 특수한 경우
• 순서형 데이터: 평점(1, 2, 3, 4, 5)이 대표적

왜 정형화된 데이터로 바꿀까?

데이터를 분석하고 예측을 모델링할 때, 시각화, 해석, 통계 모델 결정 등에 데이터 종류가 중요한 역할을 하기 때문이다.

테이블 데이터

가장 대표적으로 사용되는 객체의 형태로 엑셀이나 데이터베의 테이블과 같은 테이블 데이터이다. 기본적으로 레코드를 나타내는 행과 피쳐(변수)를 나타내는 열로 이루어진 이차원 행렬을 의미한다.

지표 변수가 결과 변수가 되기도 한다.

테이블 형식이 아닌 데이터 구조

• 시계열 데이터: 동일한 변수 안에 연속적인 측정값을 가진다.
• 공간 데이터: 객체를 표현할 때는, 어떤 객체(주택)와 그것의 공간 좌표가 데이터의 중심이 된다. 반면 필드 정보는 공간을 나타내는 작은 단위들과 적당한 측정 기준값(픽셀의 밝기)에 중점을 둔다
• 그래프(혹은 네트워크) 데이터: 물리적 관계, 사회적 관계, 그리고 다소 추상적인 관계들을 표현하기 위해 사용

위치 추정

데이터를 살펴보는 가장 기초적인 단계는 각 피처(변수)의 '대푯값'을 구하는 것이다. 대부분의 값이 어디에 위치하는지(중심경향성)을 나타내는 추정값

• 평균(mean): 모든 값의 총합을 개수로 나눈 값
• 가중평균(weighted mean): 가중치를 곱한 값의 총합을 가중치의 총합으로 나눈 값
• 중간값(median): 데이터에서 가장 가운데 위치한 값, 로버스트한 위치 추정 방버
• 백분위수(percentile): 전체 데이터의 $P%$를 아래에 두는 값(크기순으로 나열한 데이터를 100등분하여 특정 위치의 값을 나타내는 통계적 수치)
• 가중 중간값(weighted median)**: 데이터를 정렬한 후, 각 가중치 값을 위에서부터 더할 때, 총합의 중간이 위치하는 데이터 값
• 절사평균(trimmed mean): 정해진 개수의 극단값을 제외한 나머지 값들의 평균
• 로버스트(robust): 극단값들에 민감하지 않다는 것을 의미
• 특잇값(outlier): 대부분의 값과 매우 다른 데이터 값(유의어: 극단값)

지수 가중 평균: 데이터의 이동 평균을 구할 때, 오래된 데이터가 미치는 영향을 지수적으로 감쇠(exponential decay) 하도록 만들어 주는 방법

변이 추정

데이터 값이 얼마나 밀집해 있는지 혹은 퍼져 있는지를 나타내는 산포도를 나타낸다.

• 편차(deviation): 관측값과 위치 추정값 사이의 차이(유의어: 오차, 잔차)
• 분산(variance): 평균과의 편차를 제곱한 값들의 합을 n-1로 나눈 값, n은 데이터 개수(유의어: 평균제곱오차)
• 표준편차(standard deviation): 분산의 제곱근
• 평균절대편차(mean absolute deviation): 평균과의 편차의 절댓갑의 평균(유의어: L1 노름, 맨해튼 노름, 평균절대오차)
• 중간값의 중위절대편차(MAD): 중간값과의 편차의 절댓갑의 중간값
• 순서 통계량(order statistics): 최소에서 최대까지 정렬된 데이터 값에 따른 계량형

출처

데이터 과학을 위한 통계(p.19-38)

오토인코더를 처음 접하면 목표부터 이상하게 느껴진다. 입력한 이미지를 그대로 출력하도록 학습한다니, return x 한 줄이면 끝나는 것 아닐까?

하지만 입력이 좁은 통로를 지나야 한다면 이야기가 달라진다. 784개 픽셀을 더 적은 수의 값으로 표현하고 다시 복원하려면, 어떤 특징을 남길지 학습해야 한다.

이번 글에서는 MNIST 손글씨 이미지로 세 가지 모델을 살펴본다.

아래 수치와 그림은 실습 노트북에 저장된 실행 결과다. 모델 초기화, 난수, 실행 환경에 따라 재실행 결과는 달라질 수 있다. 본문에는 핵심 코드를 싣고, 긴 비교·시각화 코드는 마지막 부록에 모았다.

1. 실습 준비: 28×28 이미지를 784차원 벡터로

MNIST 이미지는 28×28 크기의 흑백 이미지다. ToTensor()로 픽셀을 0~1 범위의 텐서로 바꾸고, 완전연결층에 넣기 전에 784차원으로 펼친다.

필요한 패키지는 다음과 같이 설치한다.

pip install torch torchvision matplotlib

다음은 원본 실습의 환경 설정이다. Apple Silicon의 MPS를 사용할 수 있으면 활용하고, 그렇지 않으면 CPU에서 실행한다.

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
import matplotlib.pyplot as plt

# 모델 초기화와 노이즈 생성 등에 사용할 공통 시드입니다.
SEED = 42
torch.manual_seed(SEED)

device = "mps" if torch.backends.mps.is_available() else "cpu"

train_set = datasets.MNIST("./data", train=True, download=True,
                           transform=transforms.ToTensor())
train_loader = DataLoader(train_set, batch_size=256, shuffle=True)

DataLoader는 학습 데이터를 256장씩 묶어 제공한다. 한 번에 처리하는 양과 업데이트 횟수를 조절하기 위한 선택이다.

torch.flatten(images, start_dim=1)은 배치 차원을 유지하면서 이미지 차원만 합친다.

[배치 크기, 1, 28, 28] → [배치 크기, 784]

2. AE: 복원을 배우게 하는 병목

AE는 인코더와 디코더로 구성된다.

• 인코더: 입력 x를 잠재 벡터 z로 변환한다.
• 디코더: 잠재 벡터 z로 복원 이미지 x̂를 만든다.

이번 모델의 구조는 다음과 같다.

입력 784 → 은닉층 128 → 잠재 벡터 32 → 은닉층 128 → 출력 784

잠재 벡터는 이미지를 복원하는 데 사용할 요약 표현이다. 병목은 정보를 그대로 전달하기 어렵게 만들지만, 사람이 원하는 의미적 특징을 자동으로 보장하지는 않는다.

class AutoEncoder(nn.Module):
    #잠재표현 층을 몇 차원으로 줄건지 latent_dim으로 받음.
    def __init__(self, latent_dim):
        super().__init__()
        #encoder
        self.encoder = nn.Sequential(
            nn.Linear(784, 128), 
            nn.ReLU(),
            nn.Linear(128, latent_dim)
        )
        #decoder
        self.decoder = nn.Sequential(
            nn.Linear(latent_dim, 128), 
            nn.ReLU(),
            nn.Linear(128, 784), 
            nn.Sigmoid()
        )
    #forward = 순전파
    def forward(self, x):
        z = self.encoder(x)
        return self.decoder(z)

마지막 Sigmoid는 출력 픽셀을 0~1 범위로 제한한다. forward()에서는 입력을 인코딩한 뒤 바로 디코딩한다.

숫자 레이블 대신 입력 자체를 목표로 사용한다

학습할 때 숫자 클래스 레이블은 사용하지 않는다. 대신 복원 결과와 입력 이미지 사이의 MSE, 즉 픽셀별 평균 제곱 오차를 줄인다.

여기서 “레이블을 쓰지 않는다”는 “학습 목표가 없다”는 뜻이 아니다. 입력 이미지 자체가 복원의 목표다. MSE는 이번 실습에서 선택한 복원 손실이며, 픽셀이 연속값이라는 이유로 반드시 MSE만 써야 하는 것은 아니다.

model = AutoEncoder(latent_dim=32).to(device)
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

for epoch in range(5):
    total = 0
    for images, _ in train_loader:
        #start_dim=1: 1번 차원부터 합치기를 시작합니다. (보통 0번 차원은 배치 크기(Batch Size)이므로 유지합니다.)
        x = torch.flatten(images, start_dim=1).to(device)

        output = model(x)
        loss = criterion(output, x)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        total += loss.item()
    print(f"epoch {epoch+1}: {total/len(train_loader):.4f}")

저장된 학습 로그는 다음과 같다. 이 값은 각 epoch의 배치별 평균 손실을 다시 평균한 학습 지표다.

epoch 1: 0.0645
epoch 2: 0.0304
epoch 3: 0.0210
epoch 4: 0.0172
epoch 5: 0.0151

손실은 감소했다. 실제 복원 이미지도 확인해보자.

위: 원본 이미지 · 아래: 잠재 차원 32인 AE의 복원 결과. 학습 데이터에서 뽑은 예시다.

잠재 차원을 784로 늘리면 완벽하게 복사할까?

현재 모델에서는 잠재 차원만 늘려도 다음 구조가 된다.

784 → 128 → 784 → 128 → 784

여전히 128차원 층이 남아 있다. 따라서 잠재 차원이 입력과 같아졌다는 이유만으로 병목이 없어졌다고 말할 수 없다.

중간 층까지 넓히고 구조와 활성화 함수가 허용하면 항등 함수를 표현할 수 있지만, 학습이 실제로 그 해에 도달하는지는 별개의 문제다. 또 처음 보는 입력까지 그대로 반환하는 항등 함수와 훈련 데이터만 외우는 과적합도 구분해야 한다.

핵심은 복원을 잘하는 것과 다른 작업에도 유용한 표현을 배우는 것은 서로 다른 평가 대상이라는 점이다.

3. 잠재 차원을 줄이면 무엇을 잃을까?

잠재 차원을 2, 4, 8, 16, 32, 64로 바꾸어 비교했다. 모든 모델을 5 epoch 학습하고, 같은 순서의 학습 배치를 사용했다. 평가는 테스트 이미지 10,000장 전체의 픽셀당 평균 MSE로 계산했다.

# 모든 잠재 차원을 동일한 테스트 데이터로 평가합니다.
test_set = datasets.MNIST("./data", train=False, download=True,
                          transform=transforms.ToTensor())
test_loader = DataLoader(test_set, batch_size=1000, shuffle=False)
latent_dims = [2, 4, 8, 16, 32, 64]


def evaluate_mse(model, loader):
    model.eval()
    squared_error = 0.0
    pixel_count = 0
    with torch.no_grad():
        for images, _ in loader:
            x = torch.flatten(images, start_dim=1).to(device)
            recon = model(x)
            squared_error += F.mse_loss(
                recon, x, reduction="sum"
            ).item()
            pixel_count += x.numel()
    return squared_error / pixel_count


results = {}

for d in latent_dims:
    model = AutoEncoder(latent_dim=d).to(device)
    criterion = nn.MSELoss()
    optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
    # 모델 크기별 초기화 난수 소비량과 무관하게 같은 배치 순서를 사용합니다.
    comparison_loader = DataLoader(
        train_set, batch_size=256, shuffle=True,
        generator=torch.Generator().manual_seed(SEED)
    )

    for epoch in range(5):
        model.train()
        for images, _ in comparison_loader:
            x = torch.flatten(images, start_dim=1).to(device)
            loss = criterion(model(x), x)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

    test_mse = evaluate_mse(model, test_loader)
    results[d] = {"model": model, "test_mse": test_mse}
    print(f"latent {d:>2}: test MSE {test_mse:.4f}")

이번 실행에서는 차원이 커질수록 테스트 MSE가 낮아졌다. 32에서 64로 늘렸을 때도 개선은 있었지만, 그 차이는 0.0010이었다.

같은 테스트 이미지 8장을 잠재 차원별로 복원한 결과.

처음에는 숫자를 알아보려면 64차원 정도는 필요하지 않을까 예상했다. 하지만 그림에서는 2차원에서도 1이나 0처럼 읽을 수 있는 예시가 있고, 8~16차원에서는 더 많은 숫자의 형태가 드러난다. 차원을 더 늘리면 획과 필체도 원본에 가까워지는 모습이 보인다.

다만 두 질문은 나누어 봐야 한다.

1. 어떤 숫자인지 사람이 알아볼 수 있는가?
2. 원본의 획 두께, 기울기, 필체까지 보존하는가?

MSE는 픽셀 오차를 측정하므로 사람의 판독 가능성과 반드시 일치하지 않는다. 또한 차원을 늘리면 파라미터 수와 학습 양상도 달라진다. 한 번의 초기화와 5 epoch 결과만으로 특정 차원을 MNIST의 “실질적인 정보량”이라고 해석할 수는 없다.

4. 2차원 잠재 공간을 직접 들여다보기

잠재 차원이 2라면 이미지 하나를 평면의 점 하나로 표시할 수 있다. 테스트 이미지를 인코더에 넣어 z1, z2를 얻고, 해석을 위해 숫자 레이블로 색을 칠했다.

test_set = datasets.MNIST("./data", train=False, download=True,
                          transform=transforms.ToTensor())
test_loader = DataLoader(test_set, batch_size=1000)

model2 = results[2]["model"]
model2.eval()

zs, ys = [], []
with torch.no_grad():
    for images, labels in test_loader:
        x = torch.flatten(images, start_dim=1).to(device)
        zs.append(model2.encoder(x).cpu())
        ys.append(labels)

z = torch.cat(zs); y = torch.cat(ys)

plt.figure(figsize=(8, 7))
sc = plt.scatter(z[:, 0], z[:, 1], c=y, cmap="tab10", s=3, alpha=0.6)
plt.colorbar(sc, ticks=range(10))
plt.xlabel("z1"); plt.ylabel("z2")
plt.show()

2차원 AE의 잠재 벡터. 색은 학습에 사용하지 않은 숫자 레이블이다.

같은 숫자의 이미지들이 일부 가까이 모이지만 서로 다른 숫자가 겹치는 영역도 있다. 복원을 위해 배운 형태적 특징이 숫자 구분과 연결되는 부분이 있다는 정도로 해석할 수 있다. 이 결과만으로 모델이 숫자의 의미를 이해했다고 단정하지는 않는다.

관측된 점이 없는 곳을 디코딩하면?

잠재 공간에서 한 숫자가 우세한 위치, 레이블이 섞인 위치, 관측점에서 떨어진 위치를 골라 디코더에 넣어보았다.

왼쪽의 X 좌표를 디코딩한 결과가 오른쪽에 표시되어 있다.

그림의 표시값은 다음과 같이 읽는다.

• dominant share: 가까운 30개 점에서 가장 많은 숫자의 비율이다. 디코더의 분류 확률이 아니다.
• mixed labels: 주변 점들의 숫자 레이블이 섞인 후보 위치다.
• nearby gap: 관측된 테스트 잠재 벡터에서 떨어진 후보 위치다. 학습 데이터까지 전혀 없었던 곳이라는 뜻은 아니다.

원본 실습에서는 빈 공간 후보에서도 9와 1처럼 보이는 출력이 관찰되었다. 즉, “AE의 빈 공간에서는 숫자가 나오지 않는다”는 설명은 적절하지 않다.

남는 질문은 따로 있다. 새 이미지를 생성하려면 좌표를 어디서, 어떤 확률로 뽑아야 할까? 일반 AE의 복원 목표만으로는 그 분포가 정해지지 않는다. 이 질문은 뒤에서 VAE로 이어진다.

5. DAE: 손상된 입력에서 원본을 추정하기

이번에는 입력에 노이즈를 더해보자. 일반 AE와 DAE의 차이는 모델 구조보다 입력과 목표의 관계에 있다.

핵심 코드는 간단하다.

def add_noise(x, factor=0.3):
    return torch.clamp(x + factor * torch.randn_like(x), 0., 1.)

loss = criterion(dae(add_noise(x)), x)

입력에만 노이즈가 있고, 손실 함수의 목표는 여전히 깨끗한 원본이다. 모델은 손상된 입력을 그대로 복사하는 대신 원본을 추정해야 한다.

같은 노이즈 입력으로 AE와 DAE 비교하기

두 모델은 잠재 차원 16, 같은 초기 가중치, 같은 배치 순서, 같은 학습 횟수인 50 epoch를 사용했다. 평가 시에는 두 모델 모두 동일한 노이즈 테스트 이미지를 입력받았다.

세 값 모두 테스트 이미지 10,000장 전체의 픽셀당 평균 제곱 오차다.

위에서부터 원본, 노이즈 입력, 일반 AE 출력, DAE 출력.

이번 결과에서 일반 AE는 노이즈 입력 자체보다 MSE가 높았다. 깨끗한 입력으로 복원을 학습했다고 해서 손상된 입력에서도 잘 복원하는 것은 아니라는 사례다.

반면 DAE는 노이즈를 줄이고 숫자 형태를 더 잘 복원했다. 다만 획과 필체까지 완벽하게 보존하지는 않았다. 노이즈를 얼마나 없앴는지와 원본의 특징을 얼마나 남겼는지를 함께 확인해야 한다.

이 비교는 현재 노이즈 종류와 세기에 대한 결과다. 모든 손상에 같은 성능을 보인다는 뜻은 아니다.

6. VAE: 새 좌표를 뽑을 분포까지 정하기

AE에서는 입력을 잠재 벡터 하나로 바꾸었다. 이번 VAE에서는 입력마다 잠재 벡터의 평균과 로그 분산을 계산한다.

입력 이미지 → 인코더 → mu, logvar → 잠재 벡터 z 샘플링 → 디코더 → 복원

이미지별 잠재 분포를 이용해 원본을 복원하면서, 그 분포가 기준 분포인 표준정규분포에서 너무 멀어지지 않도록 학습한다.

$$ q_\phi(z\mid x)=\mathcal{N}\left(\mu_\phi(x),\operatorname{diag}(\sigma_\phi^2(x))\right),\qquad p(z)=\mathcal{N}(0,I) $$

분포는 숫자 클래스마다 하나씩 만들어지는 것이 아니라 입력 이미지마다 만들어진다. 생성할 때는 입력 이미지 없이 기준 분포에서 z를 뽑아 디코더에 넣는다.

Reparameterization trick

인코더가 출력한 logvar는 로그 분산이다. 이를 표준편차로 바꾼 뒤 표준정규분포 난수와 결합한다.

$$ \sigma=\exp\left(\frac{1}{2}\operatorname{logvar}\right),\qquad \epsilon\sim\mathcal{N}(0,I),\qquad z=\mu+\sigma\odot\epsilon $$

난수는 eps에서 뽑고, mu와 std에는 미분 가능한 연산을 적용한다. 이 경로를 통해 복원 손실의 기울기가 인코더까지 전달된다.

class VAE(nn.Module):
    def __init__(self, latent_dim=2):
        super().__init__()
        self.fc = nn.Sequential(nn.Linear(784, 128), nn.ReLU())
        # 이미지마다 잠재 좌표의 중심 mu를 계산
        # latent_dim=2라면 [mu1, mu2]처럼 숫자 2개를 출력
        self.fc_mu = nn.Linear(128, latent_dim)
        # 로그 연산을 하는 층이 아니라, 출력값을 로그 분산으로 사용하는 층
        # 아래 표준편차 계산과 KL 손실에서 이 의미로 사용함
        self.fc_logvar = nn.Linear(128, latent_dim)
        self.decoder = nn.Sequential(
            nn.Linear(latent_dim, 128), nn.ReLU(),
            nn.Linear(128, 784), nn.Sigmoid()
        )

    def encode(self, x):
        h = self.fc(x)
        return self.fc_mu(h), self.fc_logvar(h)

    def reparameterize(self, mu, logvar):
        # 로그 분산을 표준편차로 변환: std = exp(logvar / 2)
        std = torch.exp(0.5 * logvar)
        # 평균 0, 표준편차 1인 정규분포 난수
        # 각 좌표에서 중심으로부터 표준편차의 몇 배만큼 이동할지 정함
        eps = torch.randn_like(std)
        # 중심 + 이동량으로 잠재 좌표 계산
        return mu + eps * std

    def forward(self, x):
        mu, logvar = self.encode(x)
        z = self.reparameterize(mu, logvar)
        return self.decoder(z), mu, logvar

복원 손실과 KL 항

이번 실습의 손실은 복원 오차와 KL 항을 더한 것이다.

$$ \mathcal{L}=\mathcal{L}{\mathrm{reconstruction}}+D{\mathrm{KL}}\left(q_\phi(z\mid x)\Vert p(z)\right) $$

복원 항은 원본을 잘 되살리도록 하고, KL 항은 이미지별 분포의 평균과 분산이 기준 분포에 가까워지도록 작용한다.

# reconstruction: 원본과 복원 이미지의 픽셀별 제곱 오차 합
# KL: 이미지별 잠재 분포가 기준 분포에서 벗어난 정도
# 로그에서는 두 항과 합계를 각각 이미지 수로 나눕니다.
# reconstruction은 픽셀 평균 MSE가 아니라 이미지당 픽셀 오차 합입니다.
def vae_loss(recon, x, mu, logvar, return_components=False):
    recon_loss = F.mse_loss(recon, x, reduction="sum")
    kl = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
    total = recon_loss + kl
    if return_components:
        return total, recon_loss, kl
    return total

여기서 복원 항은 reduction="sum"을 사용한다. 로그를 출력할 때는 이미지 수로 나누므로, 앞에서 사용한 픽셀당 평균 MSE와 단위가 다르다. 복원 항과 KL 항의 합산 방식은 두 목표의 상대적인 크기에도 영향을 준다.

KL 항을 빼면 어떻게 될까? 모델은 복원 오차만 줄이면 되므로 표준편차를 작게 만들어 난수의 영향을 줄이는 방향으로 학습될 수 있다. 또한 이미지별 분포를 기준 분포에 맞출 이유가 사라져, 생성 시 표준정규분포에서 뽑은 좌표가 좋은 출력을 만든다고 기대하기 어려워진다.

그렇다고 KL 항이 모든 빈 공간을 채우거나 이미지를 반드시 선명하게 만드는 것은 아니다. 복원 목표와 분포 제약 사이에 절충이 생긴다.

2차원 VAE 학습하기

vae = VAE(latent_dim=2).to(device)
optimizer = torch.optim.Adam(vae.parameters(), lr=1e-3)

for epoch in range(20):
    vae.train()
    recon_total, kl_total, sample_count = 0.0, 0.0, 0
    for images, _ in train_loader:
        x = images.view(images.size(0), -1).to(device)
        recon, mu, logvar = vae(x)
        loss, recon_term, kl_term = vae_loss(
            recon, x, mu, logvar, return_components=True
        )
        optimizer.zero_grad(); loss.backward(); optimizer.step()
        recon_total += recon_term.item()
        kl_total += kl_term.item()
        sample_count += x.size(0)
    if (epoch+1) % 5 == 0:
        print(f"epoch {epoch+1} | per image: "
              f"reconstruction {recon_total/sample_count:.4f} | "
              f"KL {kl_total/sample_count:.4f} | "
              f"total {(recon_total+kl_total)/sample_count:.4f}")

학습 중 복원 항은 감소하고 KL 항은 증가했다. 합계는 감소했으므로 두 항을 함께 최적화하는 과정에서 나타난 변화로 읽을 수 있다. 각 항이 매번 동시에 감소해야 하는 것은 아니다.

7. 입력 이미지 없이 생성하기

학습이 끝나면 인코더를 거치지 않고 표준정규분포에서 잠재 벡터를 뽑는다.

# 입력 이미지와 인코더 없이, 기준 분포 N(0, I)에서 생성합니다.
vae.eval()
with torch.no_grad():
    z_new = torch.randn(16, vae.fc_mu.out_features, device=device)
    generated = vae.decoder(z_new).cpu().view(16, 28, 28)

fig, axes = plt.subplots(4, 4, figsize=(6, 6))
for i, ax in enumerate(axes.flat):
    ax.imshow(generated[i], cmap="gray", vmin=0, vmax=1)
    ax.axis("off")
fig.suptitle("VAE: samples from N(0, I)")
plt.tight_layout()
plt.show()

2차원 VAE의 기준 분포에서 잠재 벡터 16개를 뽑아 생성한 이미지.

이 결과는 주어진 원본의 복원이 아니다. 새로운 잠재 좌표를 디코더에 넣은 생성 결과다. 숫자 형태가 나타나지만 모든 결과가 선명하거나 명확한 것은 아니다.

잠재 차원을 16으로 늘리면?

같은 데이터, 배치 크기, 학습률, 손실 함수로 16차원 VAE를 별도로 20 epoch 학습했다.

왼쪽: 잠재 차원 2 · 오른쪽: 잠재 차원 16. 각 모델의 잠재 공간은 서로 다르다.

이 예시에서는 오른쪽에 경계가 더 뚜렷한 숫자가 여러 개 보인다. 하지만 같은 칸에 같은 숫자가 나와야 하는 비교는 아니다. 두 모델의 잠재 좌표는 서로 대응하는 의미를 갖지 않는다.

20 epoch의 학습 로그도 비교하면 다음과 같다.

16차원 모델에서 복원 항은 작고 KL 항은 컸다. 차원이 늘면 파라미터 수와 KL을 합산하는 차원 수도 달라지고, 이번 두 모델의 초기화와 학습 순서도 같지 않다. 따라서 차원을 늘리면 반드시 생성 품질이 좋아진다는 결론 대신, 현재 설정에서의 탐색적 비교로 받아들이는 것이 적절하다.

잠재 좌표를 조금씩 이동해보기

왼쪽: AE의 관측 잠재 범위 · 오른쪽: VAE의 각 축 -2.5~2.5 범위. 균일 간격의 좌표 격자다.

가로로 이동하면 z1, 세로로 이동하면 z2가 변한다. 이웃한 좌표에서 획과 숫자 형태가 어떻게 바뀌는지 볼 수 있다.

이 그림은 균일한 간격으로 좌표를 훑은 결과이며, 정규분포에서 무작위로 뽑은 결과가 아니다. AE와 VAE의 탐색 범위, 좌표 의미, 학습 횟수도 다르므로 이 그림 하나로 생성 성능의 우열을 판단하기는 어렵다.

8. 정리: 어떤 제약을 주느냐가 학습을 바꾼다

처음 질문은 “입력을 그대로 출력할 거라면 왜 학습할까?”였다. 실험을 따라가며 중요한 것은 어떤 경로로 복원하게 만드는지라는 점을 확인했다.

이 과정에서 구분해야 할 것도 남았다.

• 낮은 복원 손실만으로 잠재 표현의 유용성을 판단할 수 없다.
• 노이즈 제거 성능과 원본의 세부 특징 보존은 함께 확인해야 한다.
• 몇 개의 그럴듯한 생성 이미지와 안정적인 생성 성능은 다르다.

이번 비교는 저장된 단일 실행 결과를 바탕으로 한다. 테스트 결과를 반복해서 보며 차원이나 학습 횟수를 선택하려면 별도의 검증 세트를 두어야 한다.

오토인코더의 흥미로운 점은 “복원”이라는 비슷한 목표에서도 병목, 손상된 입력, 확률분포라는 조건을 어떻게 주느냐에 따라 배우는 표현과 활용 방식이 달라진다는 것이다.

부록: 비교 실험과 시각화 코드

아래 코드는 본문에서 정의한 변수와 모델을 이어서 사용한다. DAE 학습과 16차원 VAE 학습은 환경에 따라 시간이 걸릴 수 있다.

model.eval()
with torch.no_grad():
    images, _ = next(iter(train_loader))
    x = torch.flatten(images, start_dim=1).to(device)
    recon = model(x).cpu().view(-1, 28, 28)

fig, axes = plt.subplots(2, 8, figsize=(12, 3))
for i in range(8):
    # 원본
    axes[0, i].imshow(images[i].squeeze(), cmap="gray"); axes[0, i].axis("off")
    # 복원  
    axes[1, i].imshow(recon[i], cmap="gray"); axes[1, i].axis("off")
plt.show()

# 섞지 않은 테스트 데이터의 첫 8장을 모든 모델에 똑같이 사용합니다.
images, _ = next(iter(test_loader))
images = images[:8]
x = torch.flatten(images, start_dim=1).to(device)

fig, axes = plt.subplots(len(latent_dims) + 1, 8, figsize=(12, 11))
for i in range(8):
    axes[0, i].imshow(images[i].squeeze(), cmap="gray", vmin=0, vmax=1)
    axes[0, i].axis("off")
axes[0, 0].set_title("original", loc="left")

for row, d in enumerate(latent_dims, start=1):
    model_d = results[d]["model"]
    model_d.eval()
    with torch.no_grad():
        recon = model_d(x).cpu().view(-1, 28, 28)
    for i in range(8):
        axes[row, i].imshow(recon[i], cmap="gray", vmin=0, vmax=1)
        axes[row, i].axis("off")
    axes[row, 0].set_title(f"latent {d}", loc="left")
plt.tight_layout()
plt.show()

model2 = results[2]["model"]
model2.eval()


def select_latent_points(z, y, neighbors=30):
    # CPU에서 현재 산점도의 이웃을 조사합니다. 레이블은 위치 해석에만 씁니다.
    coords = z.detach().cpu().float()
    labels = y.detach().cpu().long()
    k = min(neighbors, len(coords))
    candidates = coords[torch.linspace(0, len(coords) - 1,
                                       min(600, len(coords))).long()]
    distances, indices = torch.cdist(candidates, coords, compute_mode="donot_use_mm_for_euclid_dist").topk(k, largest=False)
    proportions = F.one_hot(labels[indices], num_classes=10).float().mean(1)
    purity, dominant = proportions.max(1)
    entropy = -(proportions * proportions.clamp_min(1e-12).log()).sum(1)
    radius = distances[:, -1]
    dense = radius <= torch.quantile(radius, 0.6)
    typical_radius = radius.median().clamp_min(1e-6)
    separation = (coords.max(0).values - coords.min(0).values).norm() * 0.12

    def pick_spaced(order, pool, count=2):
        chosen = []
        for index in order.tolist():
            if not chosen or torch.cdist(pool[index:index+1], pool[chosen]).min() >= separation:
                chosen.append(index)
            if len(chosen) == count:
                break
        # 분포가 좁아도 같은 후보를 중복 선택하지 않습니다.
        for index in order.tolist():
            if len(chosen) == count:
                break
            if index not in chosen:
                chosen.append(index)
        return chosen

    # 밀집한 후보에서 서로 다른 숫자가 우세한 위치를 고릅니다.
    dense_indices = torch.where(dense)[0]
    pure_order = dense_indices[torch.argsort(purity[dense_indices], descending=True)]
    first = pure_order[0].item()
    other_classes = pure_order[dominant[pure_order] != dominant[first]]
    second = other_classes[0].item() if len(other_classes) else pure_order[1].item()
    pure_indices = [first, second]

    # 밀집한 후보 중 주변 레이블이 많이 섞인 위치를 고릅니다.
    mixed_order = dense_indices[torch.argsort(entropy[dense_indices], descending=True)]
    mixed_order = mixed_order[(mixed_order != first) & (mixed_order != second)]
    high_entropy = mixed_order[entropy[mixed_order] >= 0.5 * entropy[mixed_order].max()]
    if len(high_entropy) >= 2:
        mixed_order = high_entropy
    mixed_indices = pick_spaced(mixed_order, candidates)

    # 관측 범위보다 조금 넓은 격자에서 실제 점과 적당히 떨어진 위치를 찾습니다.
    lower, upper = coords.min(0).values, coords.max(0).values
    padding = (upper - lower).clamp_min(1e-6) * 0.05
    gx = torch.linspace(lower[0] - padding[0], upper[0] + padding[0], 35)
    gy = torch.linspace(lower[1] - padding[1], upper[1] + padding[1], 35)
    xx, yy = torch.meshgrid(gx, gy, indexing="ij")
    grid = torch.stack([xx.flatten(), yy.flatten()], dim=1)
    nearest = torch.cat([
        torch.cdist(chunk, coords, compute_mode="donot_use_mm_for_euclid_dist").min(1).values
        for chunk in grid.split(128)
    ])
    # 가장 가까운 실제 점까지의 거리가 대표적인 이웃 반경의 1.5배에 가까운 후보를 고릅니다.
    gap_order = torch.argsort((nearest - 1.5 * typical_radius).abs())
    gap_indices = pick_spaced(gap_order, grid)

    points = torch.cat([candidates[pure_indices], candidates[mixed_indices], grid[gap_indices]])
    names = [f"dominant {dominant[j].item()}" for j in pure_indices]
    names += ["mixed labels" if entropy[j] > 0.1 else "low mixing" for j in mixed_indices]
    names += ["nearby gap", "nearby gap"]
    notes = [f"dominant share: {purity[j]:.0%}" for j in pure_indices + mixed_indices]
    notes += [f"nearest sample: {nearest[j]:.2f}" for j in gap_indices]
    return points, names, notes


points, point_names, point_notes = select_latent_points(z, y)
with torch.no_grad():
    images = model2.decoder(points.to(device)).cpu().view(-1, 28, 28).numpy()

fig = plt.figure(figsize=(14, 8))
gs = fig.add_gridspec(3, 4, width_ratios=[1, 1, 0.85, 0.85])
ax = fig.add_subplot(gs[:, :2])
sc = ax.scatter(z[:, 0], z[:, 1], c=y, cmap="tab10", s=3, alpha=0.6,
                vmin=-0.5, vmax=9.5)
fig.colorbar(sc, ax=ax, ticks=range(10), fraction=0.04)
for i, p in enumerate(points):
    ax.scatter(*p.tolist(), s=160, marker="X", c="white", edgecolors="black", zorder=5)
    ax.annotate(str(i), p.tolist(), xytext=(6, 6), textcoords="offset points",
                bbox=dict(boxstyle="round,pad=0.2", fc="white", alpha=0.8))
ax.set(xlabel="z1", ylabel="z2", title="Points selected from the current latent space")
for i in range(6):
    row, col = divmod(i, 2)
    im_ax = fig.add_subplot(gs[row, col + 2])
    im_ax.imshow(images[i], cmap="gray", vmin=0, vmax=1)
    px, py = points[i].tolist()
    im_ax.set_title(f"{i}: {point_names[i]} ({px:.1f}, {py:.1f})\n{point_notes[i]}", fontsize=9)
    im_ax.axis("off")
plt.tight_layout()
plt.show()

# 입력에만 노이즈를 더하고, 복원 목표는 원본으로 둡니다.
def add_noise(x, factor=0.3):
    return torch.clamp(x + factor * torch.randn_like(x), 0., 1.)


def evaluate_denoising(ae, dae, loader, factor, seed):
    ae.eval()
    dae.eval()
    # 평가할 때마다 같은 난수열로 각 이미지에 동일한 노이즈를 더합니다.
    noise_generator = torch.Generator().manual_seed(seed)
    totals = {"noisy input": 0.0, "AE": 0.0, "DAE": 0.0}
    pixels = 0
    with torch.no_grad():
        for images, _ in loader:
            clean_cpu = torch.flatten(images, start_dim=1)
            noise = torch.randn(clean_cpu.shape, generator=noise_generator)
            noisy = (clean_cpu + factor * noise).clamp(0, 1).to(device)
            clean = clean_cpu.to(device)
            outputs = {"noisy input": noisy, "AE": ae(noisy), "DAE": dae(noisy)}
            for name, output in outputs.items():
                totals[name] += F.mse_loss(output, clean, reduction="sum").item()
            pixels += clean.numel()
    return {name: total / pixels for name, total in totals.items()}


latent_dim = 16
epochs = 50
noise_factor = 0.3
torch.manual_seed(SEED)
ae_baseline = AutoEncoder(latent_dim=latent_dim).to(device)
dae = AutoEncoder(latent_dim=latent_dim).to(device)
# 동일한 초기 가중치에서 시작해 입력에 노이즈를 더하는 효과를 비교합니다.
dae.load_state_dict(ae_baseline.state_dict())
ae_optimizer = torch.optim.Adam(ae_baseline.parameters(), lr=1e-3)
dae_optimizer = torch.optim.Adam(dae.parameters(), lr=1e-3)
criterion = nn.MSELoss()
paired_loader = DataLoader(
    train_set, batch_size=256, shuffle=True,
    generator=torch.Generator().manual_seed(SEED)
)
test_loader_eval = DataLoader(test_set, batch_size=1000, shuffle=False)
train_hist, test_hist = [], []
ae_train_hist, ae_test_hist = [], []

for epoch in range(epochs):
    ae_baseline.train()
    dae.train()
    ae_total, dae_total, train_pixels = 0.0, 0.0, 0
    for images, _ in paired_loader:
        x = torch.flatten(images, start_dim=1).to(device)
        # 일반 AE: 원본 → 원본
        ae_loss = criterion(ae_baseline(x), x)
        ae_optimizer.zero_grad()
        ae_loss.backward()
        ae_optimizer.step()
        # DAE: 노이즈 입력 → 원본. 같은 미니배치로 같은 횟수만큼 업데이트합니다.
        dae_loss = criterion(dae(add_noise(x, noise_factor)), x)
        dae_optimizer.zero_grad()
        dae_loss.backward()
        dae_optimizer.step()
        ae_total += ae_loss.item() * x.numel()
        dae_total += dae_loss.item() * x.numel()
        train_pixels += x.numel()

    metrics = evaluate_denoising(ae_baseline, dae, test_loader_eval, noise_factor, SEED + 1)
    ae_train_hist.append(ae_total / train_pixels)
    train_hist.append(dae_total / train_pixels)
    ae_test_hist.append(metrics["AE"])
    test_hist.append(metrics["DAE"])
    if (epoch + 1) % 10 == 0 or epoch + 1 == epochs:
        print(f"epoch {epoch+1}: fixed noisy test MSE | "
              f"input {metrics['noisy input']:.4f} | "
              f"AE {metrics['AE']:.4f} | DAE {metrics['DAE']:.4f}")

# 평가와 동일한 테스트 이미지와 노이즈에서 첫 8장을 표시합니다.
images, _ = next(iter(test_loader_eval))
clean_cpu = torch.flatten(images, start_dim=1)
noise_generator = torch.Generator().manual_seed(SEED + 1)
noise = torch.randn(clean_cpu.shape, generator=noise_generator)
noisy_cpu = (clean_cpu + noise_factor * noise).clamp(0, 1)
x = clean_cpu[:8].to(device)
noisy = noisy_cpu[:8].to(device)

ae_baseline.eval()
dae.eval()
with torch.no_grad():
    ae_out = ae_baseline(noisy).cpu().view(-1, 28, 28)
    out = dae(noisy).cpu().view(-1, 28, 28)

rows = [images[:8].squeeze(1), noisy.cpu().view(-1, 28, 28), ae_out, out]
names = ["original", "noisy input", "AE reconstruction", "DAE reconstruction"]
fig, axes = plt.subplots(4, 8, figsize=(12, 7))
for row, (batch, name) in enumerate(zip(rows, names)):
    for i in range(8):
        axes[row, i].imshow(batch[i], cmap="gray", vmin=0, vmax=1)
        axes[row, i].axis("off")
    axes[row, 0].set_title(name, loc="left", fontsize=9)
plt.tight_layout()
plt.show()

# 표시한 8장만이 아니라 테스트 세트 전체의 평균 MSE입니다.
comparison_mse = evaluate_denoising(
    ae_baseline, dae, test_loader_eval, noise_factor, SEED + 1
)
print(f"Test samples: {len(test_set)} | latent dim: {latent_dim} | epochs: {epochs}")
for name, mse in comparison_mse.items():
    print(f"{name:>11}: MSE {mse:.4f}")

# 기존 vae(2차원)는 유지하고 16차원 모델을 별도로 학습합니다.
torch.manual_seed(SEED)
vae16 = VAE(latent_dim=16).to(device)
optimizer16 = torch.optim.Adam(vae16.parameters(), lr=1e-3)
comparison_epochs = 20  # 위 2차원 VAE와 같은 학습 횟수
vae16_loader = DataLoader(
    train_set, batch_size=train_loader.batch_size, shuffle=True,
    generator=torch.Generator().manual_seed(SEED)
)

for epoch in range(comparison_epochs):
    vae16.train()
    recon_total16, kl_total16, sample_count16 = 0.0, 0.0, 0
    for images, _ in vae16_loader:
        x = torch.flatten(images, start_dim=1).to(device)
        recon, mu16, logvar16 = vae16(x)
        loss16, recon_term16, kl_term16 = vae_loss(
            recon, x, mu16, logvar16, return_components=True
        )
        optimizer16.zero_grad()
        loss16.backward()
        optimizer16.step()
        recon_total16 += recon_term16.item()
        kl_total16 += kl_term16.item()
        sample_count16 += x.size(0)
    if (epoch + 1) % 5 == 0 or epoch + 1 == comparison_epochs:
        print(f"latent 16 | epoch {epoch+1} | per image: "
              f"reconstruction {recon_total16/sample_count16:.4f} | "
              f"KL {kl_total16/sample_count16:.4f} | "
              f"total {(recon_total16+kl_total16)/sample_count16:.4f}")

# 고정된 난수로 생성 예시를 비교합니다. 각 모델의 z는 서로 다른 공간입니다.
sample_generator = torch.Generator().manual_seed(SEED + 2)
z16_compare = torch.randn(16, 16, generator=sample_generator)
z2_compare = z16_compare[:, :2]
vae.eval()
vae16.eval()
with torch.no_grad():
    samples2 = vae.decoder(z2_compare.to(device)).cpu().view(16, 28, 28)
    samples16 = vae16.decoder(z16_compare.to(device)).cpu().view(16, 28, 28)

fig, axes = plt.subplots(4, 8, figsize=(12, 6))
for i in range(16):
    row, col = divmod(i, 4)
    for offset, samples in [(0, samples2), (4, samples16)]:
        ax = axes[row, col + offset]
        ax.imshow(samples[i], cmap="gray", vmin=0, vmax=1)
        ax.axis("off")
fig.suptitle("VAE generation: latent 2 (left) / latent 16 (right)")
plt.tight_layout()
plt.show()

vae.eval()
zs, ys = [], []
with torch.no_grad():
    for imgs_b, labels in test_loader:

        xb = imgs_b.view(imgs_b.size(0), -1).to(device)
        mu, _ = vae.encode(xb)
        zs.append(mu.cpu()); ys.append(labels)
z_vae = torch.cat(zs); y_vae = torch.cat(ys)

print("std:", z_vae.std(dim=0).tolist())

# 1) 좌표를 먼저 정한다 — 숫자별 군집 중심
targets = [0, 1, 3, 7, 8, 9]
points, labels_txt = [], []
for d in targets:
    c = z_vae[y_vae == d].mean(dim=0)
    points.append([c[0].item(), c[1].item()])
    labels_txt.append(f"center of {d}")

# 2) 그 좌표로 이미지를 만든다
with torch.no_grad():
    pts = torch.tensor(points, dtype=torch.float32).to(device)
    gen = vae.decoder(pts).cpu().view(-1, 28, 28).numpy()

# 3) 그린다
fig = plt.figure(figsize=(13, 7))
ax = fig.add_axes([0.05, 0.08, 0.55, 0.85])

sc = ax.scatter(z_vae[:, 0], z_vae[:, 1], c=y_vae, cmap="tab10", s=3, alpha=0.6)
fig.colorbar(sc, ax=ax, ticks=range(10), fraction=0.04)

for i, p in enumerate(points):
    ax.scatter(p[0], p[1], s=200, marker="X",
               c="white", edgecolors="black", linewidths=1.5, zorder=5)
    ax.annotate(labels_txt[i], p, xytext=(6, 6), textcoords="offset points",
                fontsize=9, bbox=dict(boxstyle="round,pad=0.3", fc="white", alpha=0.8))

ax.set_xlabel("z1"); ax.set_ylabel("z2"); ax.set_title("VAE latent space")

for i in range(6):
    row, col = divmod(i, 2)
    im_ax = fig.add_axes([0.68 + col * 0.15, 0.68 - row * 0.28, 0.13, 0.22])
    im_ax.imshow(gen[i], cmap="gray")
    im_ax.set_title(f"{labels_txt[i]} ({points[i][0]:.1f},{points[i][1]:.1f})",
                    fontsize=8)
    im_ax.axis("off")

plt.show()

import numpy as np


def latent_grid(model_decoder, x_range, y_range, n=15, device=device):
    grid_x = np.linspace(*x_range, n)
    grid_y = np.linspace(*y_range, n)
    canvas = np.zeros((28*n, 28*n))
    with torch.no_grad():
        for i, yi in enumerate(grid_y[::-1]):
            pts = torch.tensor([[xj, yi] for xj in grid_x],
                               dtype=torch.float32, device=device)
            imgs = model_decoder(pts).cpu().view(-1, 28, 28).numpy()
            for j in range(n):
                canvas[i*28:(i+1)*28, j*28:(j+1)*28] = imgs[j]
    return canvas


ae2 = results[2]["model"]
ae2.eval()
vae.eval()
# 다른 셀의 z를 재사용하지 않고 현재 AE로 테스트 잠재 좌표를 계산합니다.
ae_grid_codes = []
with torch.no_grad():
    for images, _ in test_loader:
        x = torch.flatten(images, start_dim=1).to(device)
        ae_grid_codes.append(ae2.encoder(x).cpu())
ae_grid_codes = torch.cat(ae_grid_codes)
ae_lower = ae_grid_codes.min(dim=0).values
ae_upper = ae_grid_codes.max(dim=0).values
ae_x_range = (ae_lower[0].item(), ae_upper[0].item())
ae_y_range = (ae_lower[1].item(), ae_upper[1].item())

# VAE는 관측된 mu 범위가 아니라 기준 분포 N(0,I)의 중심 주변을 탐색합니다.
vae_x_range = (-2.5, 2.5)
vae_y_range = (-2.5, 2.5)
grid_n = 15
ae_canvas = latent_grid(ae2.decoder, ae_x_range, ae_y_range, n=grid_n)
vae_canvas = latent_grid(vae.decoder, vae_x_range, vae_y_range, n=grid_n)

fig, axes = plt.subplots(1, 2, figsize=(16, 8))
panels = [
    (ae_canvas, "AE: observed test range", ae_x_range, ae_y_range),
    (vae_canvas, "VAE: prior N(0, I), +/-2.5 per axis", vae_x_range, vae_y_range),
]
tick_indices = np.array([0, grid_n // 2, grid_n - 1])
# 각 타일의 중심에 실제 디코딩한 좌표를 표시합니다.
tick_positions = tick_indices * 28 + 13.5
for ax, (canvas, title, x_range, y_range) in zip(axes, panels):
    ax.imshow(canvas, cmap="gray", vmin=0, vmax=1, interpolation="nearest")
    ax.set_xticks(tick_positions, [f"{v:.2f}" for v in np.linspace(*x_range, grid_n)[tick_indices]])
    ax.set_yticks(tick_positions, [f"{v:.2f}" for v in np.linspace(*y_range, grid_n)[::-1][tick_indices]])
    ax.set_xlabel("z1")
    ax.set_ylabel("z2")
    ax.set_title(title, fontsize=12)
fig.suptitle("Uniform coordinate grid — not random sampling", fontsize=14)
plt.tight_layout()
plt.show()

학습 목표

이 글을 읽고 나면 다음을 할 수 있다.

1. loss.backward()로 계산된 Gradient가 parameter update에 어떻게 쓰이는지 설명할 수 있다.
2. batch_size에 따라 Batch GD, SGD, Mini-batch GD를 코드로 구분할 수 있다.
3. Momentum, AdaGrad, RMSProp, Adadelta, Adam의 핵심 update를 직접 구현할 수 있다.
4. 같은 training loop에서 PyTorch Optimizer를 바꿔 가며 비교할 수 있다.

목차

1. 공통 실습 코드
2. Gradient Descent — Gradient로 parameter 직접 업데이트하기
3. Batch GD / SGD / Mini-batch — batch_size로 확인하기
4. 기본 Gradient Descent의 문제 — 코드로 재현하기
5. Momentum — 이전 방향을 저장하기
6. AdaGrad — parameter별 누적 보폭 만들기
7. RMSProp / Adadelta — 오래된 Gradient를 잊기
8. Adam — 방향과 크기를 함께 저장하기
9. torch.optim으로 같은 실험 실행하기
10. Trade-off와 전체 흐름 정리

1. 공통 실습 코드

먼저 모든 Optimizer에서 함께 사용할 간단한 선형 회귀 데이터를 만든다.

정답 관계는 대략 $y=3x+2$이며, 모델은 이 관계의 weight와 bias를 학습한다.

import torch
from torch import nn
from torch.utils.data import DataLoader, TensorDataset

torch.manual_seed(42)

# y = 3x + 2에 작은 noise를 추가한 데이터
X = torch.linspace(-2, 2, 256).unsqueeze(1)
y = 3 * X + 2 + 0.2 * torch.randn_like(X)

dataset = TensorDataset(X, y)


def make_model():
    torch.manual_seed(42)
    return nn.Linear(1, 1)


criterion = nn.MSELoss()

모델의 예측식은 다음과 같다.

$$ \hat{y}=wx+b $$

학습해야 할 parameter는 model.weight와 model.bias다.

model = make_model()

for name, parameter in model.named_parameters():
    print(name, parameter.shape)

# weight torch.Size([1, 1])
# bias   torch.Size([1])

이제 같은 모델과 데이터에서 update 코드만 바꾸며 Optimizer의 차이를 확인해 보자.

2. Gradient Descent — Gradient로 parameter 직접 업데이트하기

Gradient Descent의 update 식은 다음과 같다.

$$ \theta_{t+1} = \theta_t-\eta\nabla_\theta J(\theta_t) $$

이 식은 PyTorch 코드로 거의 그대로 옮길 수 있다.

model = make_model()

pred = model(X)
loss = criterion(pred, y)

# 각 parameter의 gradient를 계산해 .grad에 저장한다.
loss.backward()

learning_rate = 0.1

with torch.no_grad():
    for parameter in model.parameters():
        parameter -= learning_rate * parameter.grad

# 다음 step의 gradient가 누적되지 않도록 비운다.
model.zero_grad()

핵심은 세 줄이다.

loss.backward()                              # gradient 계산
parameter -= learning_rate * parameter.grad # gradient 반대 방향으로 이동
model.zero_grad()                            # 이전 gradient 제거

parameter.grad에는 무엇이 들어 있을까?

loss.backward()를 호출하면 각 parameter를 Loss에 대해 편미분한 값이 .grad에 저장된다.

model = make_model()
loss = criterion(model(X), y)
loss.backward()

print(model.weight.grad)  # ∂J / ∂w
print(model.bias.grad)    # ∂J / ∂b

두 값을 하나의 벡터로 모으면 Gradient가 된다.

$$ \nabla J(w,b) = \begin{bmatrix} \frac{\partial J}{\partial w}\ \frac{\partial J}{\partial b} \end{bmatrix} $$

Gradient는 현재 위치에서 목적함수 $J$가 가장 빠르게 증가하는 방향이다.

Loss를 줄이려면 반대 방향으로 이동해야 하므로 update 코드에 -가 들어간다.

parameter -= learning_rate * parameter.grad

왜 매 step마다 Gradient를 다시 계산할까?

parameter가 바뀌면 모델의 예측값과 Loss가 달라지고, 새로운 위치에서의 Gradient도 달라진다.

그래서 학습 코드는 다음 과정을 반복한다.

for step in range(100):
    pred = model(X)               # 현재 parameter로 예측
    loss = criterion(pred, y)     # 현재 위치의 Loss

    loss.backward()               # 현재 위치의 Gradient

    with torch.no_grad():
        for parameter in model.parameters():
            parameter -= 0.1 * parameter.grad

    model.zero_grad()             # 다음 step을 위해 초기화

3. Batch GD / SGD / Mini-batch — batch_size로 확인하기

Batch GD, SGD, Mini-batch의 update 원리는 같다. 코드에서 가장 눈에 띄는 차이는 DataLoader의 batch_size다.

# Batch Gradient Descent: 전체 데이터로 1번 update
batch_loader = DataLoader(
    dataset,
    batch_size=len(dataset),
    shuffle=True,
)

# Stochastic Gradient Descent: 데이터 1개마다 update
sgd_loader = DataLoader(
    dataset,
    batch_size=1,
    shuffle=True,
)

# Mini-batch Gradient Descent: 32개마다 update
mini_batch_loader = DataLoader(
    dataset,
    batch_size=32,
    shuffle=True,
)

한 epoch의 update 횟수도 바로 확인할 수 있다.

print(len(batch_loader))       # 1
print(len(sgd_loader))         # 256
print(len(mini_batch_loader))  # 8

training loop은 세 경우 모두 같다.

def train_one_epoch(model, loader, optimizer):
    model.train()

    for x_batch, y_batch in loader:
        optimizer.zero_grad()

        pred = model(x_batch)
        loss = criterion(pred, y_batch)

        loss.backward()
        optimizer.step()

차이는 한 번의 optimizer.step()이 어떤 데이터를 보고 계산된 Gradient를 사용하는가다.

Mini-batch Gradient는 어떻게 만들어질까?

batch에 데이터가 $B$개 있다면 각 sample의 Gradient를 평균낸 값이 사용된다.

$$ g_B=\frac{1}{B}\sum_{i=1}^{B}g_i $$

PyTorch에서는 loss를 평균내는 nn.MSELoss()의 기본 설정과 backward()가 이 계산을 처리한다.

x_batch, y_batch = next(iter(mini_batch_loader))

pred = model(x_batch)
loss = criterion(pred, y_batch)  # batch의 평균 MSE
loss.backward()                  # 평균 Loss에 대한 Gradient

Mini-batch는 여러 sample을 평균내 순수한 SGD보다 안정적이며, 행렬 연산을 통해 GPU를 효율적으로 사용할 수 있다.

반면 batch가 너무 크면 메모리 사용량이 증가하고 한 epoch의 update 횟수가 감소한다. 너무 작으면 Gradient noise가 커진다.

Batch Size 역시 계산 효율성과 Gradient 안정성 사이의 trade-off다.

4. 기본 Gradient Descent의 문제 — 코드로 재현하기

4.1 Learning Rate가 너무 작거나 큰 경우

간단한 함수에서 Learning Rate만 바꿔 보자.

$$ J(w)=(w-3)^2 $$

이 함수의 minimum은 $w=3$이다.

def run_gradient_descent(lr, steps=10):
    w = torch.tensor(0.0, requires_grad=True)
    history = []

    for step in range(steps):
        loss = (w - 3) ** 2
        loss.backward()

        with torch.no_grad():
            w -= lr * w.grad

        history.append({
            "step": step,
            "w": w.item(),
            "loss": loss.item(),
        })

        w.grad.zero_()

    return history


slow = run_gradient_descent(lr=0.05)      # 조금씩 이동
oscillating = run_gradient_descent(lr=0.8) # minimum 양쪽을 오가며 수렴
diverging = run_gradient_descent(lr=1.1)   # 진폭이 커지며 발산

Gradient가 방향을 알려줘도 실제 이동량은 lr이 결정한다.

update = learning_rate * gradient

• lr이 너무 작으면 학습이 느리다.
• lr이 너무 크면 minimum을 지나쳐 진동하거나 발산할 수 있다.

4.2 Gradient가 0이면 항상 minimum일까?

Saddle Point는 한 방향에서는 minimum, 다른 방향에서는 maximum처럼 보이는 지점이다.

$$ f(x,y)=x^2-y^2 $$

원점에서 Gradient를 코드로 계산하면 두 성분이 모두 0이다.

point = torch.tensor([0.0, 0.0], requires_grad=True)
x, y = point[0], point[1]

value = x**2 - y**2
value.backward()

print(point.grad)  # tensor([0., 0.])

하지만 $x$ 방향으로는 값이 증가하고 $y$ 방향으로는 감소하므로 원점은 minimum이 아니다.

4.3 모든 parameter에 같은 Learning Rate를 적용한다

기본 SGD의 코드를 보면 모든 parameter에 동일한 lr을 곱한다.

for parameter in model.parameters():
    parameter -= lr * parameter.grad

그러나 각 parameter의 Gradient 크기와 update 빈도는 다를 수 있다. 이후 AdaGrad, RMSProp, Adam은 parameter마다 다른 실제 보폭을 만들기 위해 별도의 상태값을 저장한다.

5. Momentum — 이전 방향을 저장하기

Mini-batch SGD는 batch마다 Gradient가 달라져 좁고 긴 Loss Surface에서 지그재그로 움직일 수 있다.

기본 SGD는 현재 Gradient만 사용한다.

parameter -= lr * parameter.grad

Momentum은 이전까지의 이동 방향을 velocity에 저장한다.

$$ v_t=\beta v_{t-1}+g_t $$

$$ \theta_{t+1}=\theta_t-\eta v_t $$

이를 직접 구현하면 다음과 같다.

model = make_model()
parameters = list(model.parameters())

# parameter마다 같은 모양의 velocity를 하나씩 만든다.
velocity = {
    parameter: torch.zeros_like(parameter)
    for parameter in parameters
}


@torch.no_grad()
def momentum_step(parameters, velocity, lr=0.01, beta=0.9):
    for parameter in parameters:
        velocity[parameter].mul_(beta).add_(parameter.grad)
        parameter.add_(velocity[parameter], alpha=-lr)

training loop에서는 직접 만든 momentum_step()을 optimizer.step() 자리에 호출한다.

for x_batch, y_batch in mini_batch_loader:
    model.zero_grad()

    loss = criterion(model(x_batch), y_batch)
    loss.backward()

    momentum_step(parameters, velocity, lr=0.01, beta=0.9)

코드의 핵심은 이 부분이다.

velocity[parameter].mul_(beta).add_(parameter.grad)

• Gradient가 같은 방향으로 반복되면 velocity에 누적된다.
• Gradient가 반대 방향으로 바뀌면 이전 값과 일부 상쇄된다.

Momentum은 일관된 방향의 이동은 강화하고, 반복되는 진동은 줄인다.

다만 beta가 너무 크면 관성이 강해져 minimum을 지나치는 overshooting이 발생할 수 있다.

PyTorch에서는 같은 동작을 다음처럼 사용한다.

optimizer = torch.optim.SGD(
    model.parameters(),
    lr=0.01,
    momentum=0.9,
)

6. AdaGrad — parameter별 누적 보폭 만들기

AdaGrad의 출발점은 간단하다.

자주 크게 움직인 parameter는 천천히, 드물게 움직인 parameter는 상대적으로 크게 움직이자.

이를 위해 parameter마다 과거 Gradient 제곱의 누적값을 저장한다.

$$ G_t=G_{t-1}+g_t^2 $$

$$ \theta_{t+1} = \theta_t-\frac{\eta}{\sqrt{G_t}+\epsilon}g_t $$

model = make_model()
parameters = list(model.parameters())

squared_grad_sum = {
    parameter: torch.zeros_like(parameter)
    for parameter in parameters
}


@torch.no_grad()
def adagrad_step(parameters, squared_grad_sum, lr=0.01, eps=1e-10):
    for parameter in parameters:
        grad = parameter.grad

        # G_t = G_{t-1} + g_t²
        squared_grad_sum[parameter].addcmul_(grad, grad)

        # parameter마다 서로 다른 실제 보폭
        denominator = squared_grad_sum[parameter].sqrt().add_(eps)
        parameter.addcdiv_(grad, denominator, value=-lr)

핵심은 denominator가 parameter별로 다르다는 점이다.

denominator = squared_grad_sum[parameter].sqrt() + eps
effective_lr = lr / denominator

Gradient가 계속 컸던 parameter는 squared_grad_sum이 커지고 실제 Learning Rate는 작아진다.

문제는 이 값이 계속 더해지기만 한다는 것이다.

squared_grad_sum[parameter] += grad * grad

Gradient 제곱은 음수가 아니므로 누적값은 줄어들지 않는다. 학습이 길어지면 실제 Learning Rate가 거의 0에 가까워질 수 있다.

AdaGrad는 과거를 너무 오래 기억하기 때문에 학습이 지나치게 빨리 느려질 수 있다.

PyTorch에서는 다음과 같이 사용한다.

optimizer = torch.optim.Adagrad(
    model.parameters(),
    lr=0.01,
)

7. RMSProp / Adadelta — 오래된 Gradient를 잊기

AdaGrad가 과거 Gradient를 모두 더하는 것이 문제라면, 오래된 정보의 영향력을 줄이면 된다.

RMSProp

RMSProp은 단순 누적합 대신 Gradient 제곱의 지수 이동 평균을 저장한다.

$$ v_t=\beta v_{t-1}+(1-\beta)g_t^2 $$

model = make_model()
parameters = list(model.parameters())

square_avg = {
    parameter: torch.zeros_like(parameter)
    for parameter in parameters
}


@torch.no_grad()
def rmsprop_step(parameters, square_avg, lr=0.001, beta=0.9, eps=1e-8):
    for parameter in parameters:
        grad = parameter.grad

        # v_t = beta * v_{t-1} + (1 - beta) * g_t²
        square_avg[parameter].mul_(beta).addcmul_(
            grad,
            grad,
            value=1 - beta,
        )

        denominator = square_avg[parameter].sqrt().add_(eps)
        parameter.addcdiv_(grad, denominator, value=-lr)

AdaGrad와 비교하면 한 줄의 차이가 핵심이다.

# AdaGrad: 과거 값을 그대로 유지하며 계속 더한다.
accumulator += grad**2

# RMSProp: 과거 값은 beta만큼만 남긴다.
square_avg = beta * square_avg + (1 - beta) * grad**2

예를 들어 beta=0.9라면 오래된 Gradient의 영향은 시간이 지나며 다음처럼 작아진다.

$$ 1\rightarrow0.9\rightarrow0.9^2\rightarrow0.9^3\rightarrow\cdots $$

RMSProp은 최근 Gradient의 크기를 더 중요하게 보면서 parameter별 보폭을 조절한다.

PyTorch 코드는 다음과 같다.

optimizer = torch.optim.RMSprop(
    model.parameters(),
    lr=0.001,
    alpha=0.9,
)

Adadelta

Adadelta도 Gradient 제곱의 지수 이동 평균을 사용한다. 여기에 최근 parameter update의 제곱 평균도 함께 저장한다.

model = make_model()
parameters = list(model.parameters())

square_avg = {
    parameter: torch.zeros_like(parameter)
    for parameter in parameters
}
acc_delta = {
    parameter: torch.zeros_like(parameter)
    for parameter in parameters
}


@torch.no_grad()
def adadelta_step(parameters, square_avg, acc_delta, rho=0.9, eps=1e-6):
    for parameter in parameters:
        grad = parameter.grad

        # 최근 Gradient²의 이동 평균
        square_avg[parameter].mul_(rho).addcmul_(
            grad,
            grad,
            value=1 - rho,
        )

        # 최근 update²와 Gradient²를 이용해 update 크기 결정
        std = square_avg[parameter].add(eps).sqrt()
        delta = acc_delta[parameter].add(eps).sqrt().div(std).mul(grad)

        parameter.sub_(delta)

        # 방금 적용한 update²의 이동 평균
        acc_delta[parameter].mul_(rho).addcmul_(
            delta,
            delta,
            value=1 - rho,
        )

RMSProp이 square_avg 하나를 중심으로 보폭을 조절한다면, Adadelta는 square_avg와 acc_delta를 함께 사용한다.

optimizer = torch.optim.Adadelta(
    model.parameters(),
    rho=0.9,
)

8. Adam — 방향과 크기를 함께 저장하기

지금까지 코드에서 저장한 상태값을 다시 보자.

# Momentum
velocity       # Gradient 방향을 누적

# RMSProp
square_avg     # Gradient²의 이동 평균

Adam은 두 아이디어를 함께 사용한다.

first_moment   # Gradient의 지수 이동 평균
second_moment  # Gradient²의 지수 이동 평균

First Moment

$$ m_t=\beta_1m_{t-1}+(1-\beta_1)g_t $$

Momentum과 비슷하게 Gradient의 방향을 안정화한다.

Second Moment

$$ v_t=\beta_2v_{t-1}+(1-\beta_2)g_t^2 $$

RMSProp과 비슷하게 parameter별 보폭을 조절한다.

Bias Correction까지 직접 구현하기

두 moment는 0으로 초기화되므로 학습 초반에는 0에 가깝게 편향된다.

$$ \hat{m}_t=\frac{m_t}{1-\beta_1^t},\qquad \hat{v}_t=\frac{v_t}{1-\beta_2^t} $$

보정한 값을 사용하는 전체 update 코드는 다음과 같다.

model = make_model()
parameters = list(model.parameters())

first_moment = {
    parameter: torch.zeros_like(parameter)
    for parameter in parameters
}
second_moment = {
    parameter: torch.zeros_like(parameter)
    for parameter in parameters
}


@torch.no_grad()
def adam_step(
    parameters,
    first_moment,
    second_moment,
    step,
    lr=0.001,
    beta1=0.9,
    beta2=0.999,
    eps=1e-8,
):
    for parameter in parameters:
        grad = parameter.grad

        # 1차 모멘트: Gradient의 이동 평균
        first_moment[parameter].mul_(beta1).add_(
            grad,
            alpha=1 - beta1,
        )

        # 2차 모멘트: Gradient²의 이동 평균
        second_moment[parameter].mul_(beta2).addcmul_(
            grad,
            grad,
            value=1 - beta2,
        )

        # 0으로 초기화되어 생기는 초반 편향 보정
        m_hat = first_moment[parameter] / (1 - beta1**step)
        v_hat = second_moment[parameter] / (1 - beta2**step)

        parameter.addcdiv_(
            m_hat,
            v_hat.sqrt().add_(eps),
            value=-lr,
        )

training loop에서는 step을 1부터 증가시킨다.

step = 0

for x_batch, y_batch in mini_batch_loader:
    model.zero_grad()

    loss = criterion(model(x_batch), y_batch)
    loss.backward()

    step += 1
    adam_step(
        parameters,
        first_moment,
        second_moment,
        step,
    )

코드와 역할을 연결하면 다음과 같다.

PyTorch에서는 다음 한 줄로 같은 핵심 로직을 사용한다.

optimizer = torch.optim.Adam(
    model.parameters(),
    lr=0.001,
    betas=(0.9, 0.999),
)

Adam은 Gradient의 방향과 크기를 모두 추적하고, parameter마다 adaptive한 update를 수행한다.

9. torch.optim으로 같은 실험 실행하기

직접 구현한 update 식은 서로 다르지만 PyTorch의 training loop는 거의 같다.

def train(model, loader, optimizer, epochs=100):
    losses = []

    for epoch in range(epochs):
        model.train()
        epoch_loss = 0.0

        for x_batch, y_batch in loader:
            optimizer.zero_grad()

            pred = model(x_batch)
            loss = criterion(pred, y_batch)

            loss.backward()
            optimizer.step()

            epoch_loss += loss.item() * len(x_batch)

        losses.append(epoch_loss / len(loader.dataset))

    return losses

Optimizer 생성 부분만 함수로 분리해 바꿔 가며 실행할 수 있다.

def make_optimizer(name, model):
    if name == "sgd":
        return torch.optim.SGD(model.parameters(), lr=0.01)

    if name == "momentum":
        return torch.optim.SGD(
            model.parameters(),
            lr=0.01,
            momentum=0.9,
        )

    if name == "adagrad":
        return torch.optim.Adagrad(model.parameters(), lr=0.01)

    if name == "rmsprop":
        return torch.optim.RMSprop(
            model.parameters(),
            lr=0.001,
            alpha=0.9,
        )

    if name == "adadelta":
        return torch.optim.Adadelta(
            model.parameters(),
            rho=0.9,
        )

    if name == "adam":
        return torch.optim.Adam(
            model.parameters(),
            lr=0.001,
            betas=(0.9, 0.999),
        )

    raise ValueError(f"Unknown optimizer: {name}")

같은 초기 parameter와 같은 Mini-batch 조건에서 비교한다.

results = {}

for name in [
    "sgd",
    "momentum",
    "adagrad",
    "rmsprop",
    "adadelta",
    "adam",
]:
    model = make_model()
    loader = DataLoader(
        dataset,
        batch_size=32,
        shuffle=True,
        generator=torch.Generator().manual_seed(42),
    )
    optimizer = make_optimizer(name, model)

    losses = train(model, loader, optimizer, epochs=100)

    results[name] = {
        "final_loss": losses[-1],
        "weight": model.weight.item(),
        "bias": model.bias.item(),
    }

for name, result in results.items():
    print(name, result)

이 실험에서 중요한 것은 순위를 한 번 정하는 것이 아니다. Optimizer마다 Learning Rate의 적절한 범위가 다르므로 값 하나만으로 공정한 우열을 결정할 수 없다.

대신 다음을 확인하는 코드로 사용하면 좋다.

• 초기 Loss가 얼마나 빠르게 감소하는가?
• Loss가 크게 진동하는가?
• 같은 epoch 이후 $w\approx3$, $b\approx2$에 얼마나 가까운가?
• Learning Rate를 바꾸면 결과가 얼마나 민감하게 변하는가?

Optimizer가 실제로 저장하는 상태 확인하기

optimizer.state를 보면 각 알고리즘이 무엇을 기억하는지 확인할 수 있다. 최소 한 번 optimizer.step()을 실행한 뒤 확인해야 한다.

parameter = next(model.parameters())
state = optimizer.state[parameter]

print(state.keys())

대표적인 state는 다음과 같다.

결국 같은 optimizer.step() 안에서 Optimizer마다 서로 다른 state를 읽고 갱신한다.

10. Trade-off와 전체 흐름 정리

Adam의 코드가 가장 많은 정보를 사용한다고 해서 모든 문제에서 항상 가장 좋은 것은 아니다.

Optimizer의 발전을 코드의 state 변화로 연결하면 다음과 같다.

Gradient Descent / SGD
└─ parameter.grad만 사용
   │
   │ Mini-batch Gradient가 noisy하고 진동한다.
   ▼
Momentum
└─ velocity 추가
   │
   │ 모든 parameter에 같은 Learning Rate를 사용한다.
   ▼
AdaGrad
└─ squared_grad_sum 추가
   │
   │ 과거 Gradient²가 끝없이 누적된다.
   ▼
RMSProp / Adadelta
└─ square_avg, acc_delta로 오래된 정보의 영향 감소
   │
   │ 방향 정보도 함께 사용하면 어떨까?
   ▼
Adam
├─ first_moment: Gradient 방향의 이동 평균
└─ second_moment: Gradient²의 이동 평균

코드에서 다시 보면 차이는 더욱 선명하다.

# SGD
parameter -= lr * grad

# Momentum
velocity = beta * velocity + grad
parameter -= lr * velocity

# AdaGrad
grad_sum += grad**2
parameter -= lr * grad / (sqrt(grad_sum) + eps)

# RMSProp
square_avg = beta * square_avg + (1 - beta) * grad**2
parameter -= lr * grad / (sqrt(square_avg) + eps)

# Adam
first_moment = beta1 * first_moment + (1 - beta1) * grad
second_moment = beta2 * second_moment + (1 - beta2) * grad**2
parameter -= lr * m_hat / (sqrt(v_hat) + eps)

Optimizer의 발전은 단순히 더 빠르게 내려가기 위한 경쟁이 아니다.
학습 과정에서 만나는 문제에 따라 어떤 정보를 추가로 저장하고 update에 반영할지 발전시켜 온 과정이다.

Reference

• Sebastian Ruder, An overview of gradient descent optimization algorithms, arXiv:1609.04747.
• PyTorch Optimizer documentation

학습지표

Decision Tree의 높은 variance를 줄이기 위해 Bagging은 데이터에 randomness를 주고, Random Forest는 feature 후보에도 randomness를 추가하며, Extra Trees는 분할 threshold까지 randomness를 추가한다.

1편에서는 Decision Tree의 높은 variance를 Bagging이 Bootstrap과 Aggregation으로 완화하는 과정을 살펴봤다.

하지만 Bootstrap만으로 모든 Tree가 충분히 달라지는 것은 아니다. 이번 글에서는 Bagging 뒤에도 남는 Tree 간 오류 상관에서 출발해 Random Forest와 Extra Trees의 차이를 정리한다.

1. Bagging 뒤에도 남는 문제: Tree들이 너무 비슷하다

Bootstrap 표본이 다르더라도 모든 Tree는 보통 전체 Feature에서 가장 좋은 분할을 찾는다. 하나의 Feature가 매우 강력하다면 대부분의 Tree가 루트나 상위 노드에서 같은 Feature를 선택할 수 있다.

Bootstrap A → Fare로 첫 분할
Bootstrap B → Fare로 첫 분할
Bootstrap C → Fare로 첫 분할
Bootstrap D → Fare로 첫 분할

학습 표본은 조금씩 달라도 Tree 구조와 오류가 비슷해질 수 있다. 모델 수만 늘리는 것으로 평균 효과가 계속 커지지 않는 이유다.

같은 variance σ²을 가진 모델 B개의 모든 쌍이 같은 상관계수 ρ를 가진다고 단순화하면, 평균 예측의 variance는 다음처럼 쓸 수 있다.

$$ \operatorname{Var}(\bar f) =\sigma^2\left(\rho+\frac{1-\rho}{B}\right) $$

• ρ=0이면 평균 variance가 σ²/B까지 감소한다.
• ρ가 크면 모델 수를 늘려도 감소 폭이 제한된다.
• B→∞여도 식은 ρσ²에 가까워진다.

이 식은 단순한 가정 아래의 직관이지만 중요한 메시지를 준다.

앙상블에서는 모델 수뿐 아니라 구성원 오류가 얼마나 다르게 움직이는지도 중요하다.

Random Forest는 이 상관을 낮추기 위해 Feature 선택에도 무작위성을 넣는다.

2. Random Forest: 노드마다 다른 Feature 후보를 본다

scikit-learn의 전형적인 Random Forest는 다음 세 요소를 결합한다.

Bootstrap sample
  +
노드별 Feature 후보 무작위화
  +
Tree 예측의 평균

핵심은 max_features다. Tree를 만들 때 Feature 묶음을 한 번만 뽑아 끝까지 고정하는 방식이 아니다. 각 노드에서 분할을 찾을 때마다 Feature 후보 집합을 새로 선택한다.

루트 노드:      [Age, Fare, Sex] 중 최적 분할 선택
왼쪽 자식 노드: [Pclass, Fare, SibSp] 중 최적 분할 선택
오른쪽 자식:    [Age, Parch, Pclass] 중 최적 분할 선택

강력한 Feature가 후보에서 빠진 노드에서는 다른 Feature가 분할 기회를 얻는다. 그 결과 Tree 구조와 오류 패턴이 더 다양해질 수 있다.

2.1 Random Forest의 목적은 단순히 “더 랜덤하게”가 아니다

Feature 후보 수에는 trade-off가 있다.

• 후보가 많으면 개별 Tree는 좋은 분할을 찾기 쉽지만 Tree들이 비슷해질 수 있다.
• 후보가 적으면 Tree 다양성은 커질 수 있지만 중요한 Feature를 자주 놓칠 수 있다.

Breiman의 Random Forest 논문은 이를 개별 Tree의 strength와 Tree 사이의 correlation 사이의 균형으로 설명한다.

좋은 Random Forest를 만드는 방향
= 충분한 개별 Tree의 예측력
+ 지나치게 높지 않은 Tree 간 오류 상관

따라서 max_features는 “작을수록 좋다”는 파라미터가 아니다. 데이터에 맞게 검증해야 하는 조절 장치다.

2.2 Bagged Trees와 Random Forest의 차이

Bagged Trees
Bootstrap sample
  → 보통 모든 Feature에서 최적 분할 탐색
  → Tree 생성
  → 예측 집계

Random Forest
Bootstrap sample
  → 매 노드에서 Feature 일부를 무작위 선택
  → 선택된 후보 안에서 최적 분할 탐색
  → Tree 생성
  → 예측 집계

단, scikit-learn의 범용 BaggingClassifier도 max_features와 bootstrap_features를 통해 Feature sampling을 지원한다. 차이는 Random Forest가 Tree의 각 노드에서 Feature 후보를 다시 선택한다는 점이다.

2.3 “독립적인 Tree”라는 표현을 조심해야 한다

Random Forest의 Tree들은 앞 Tree의 결과를 다음 Tree가 이어받지 않으므로 별도·병렬 학습이 가능하다. 그러나 예측 오류가 통계적으로 독립이라는 뜻은 아니다.

오히려 Random Forest가 해결하려는 문제가 바로 Tree 오류의 상관이다. 따라서 다음 표현이 더 정확하다.

Tree들은 순차 의존 없이 학습할 수 있으며, Feature Randomness는 Tree들이 덜 비슷하게 움직이도록 설계된 장치다.

3. Extra Trees: 분할 임계값까지 무작위화한다

Extra Trees(Extremely Randomized Trees)는 Random Forest보다 분할 과정에 더 강한 무작위성을 넣는다.

Random Forest
→ Feature 일부를 무작위 선택
→ 각 후보 Feature에서 좋은 Threshold 탐색
→ 후보 안에서 최적 분할 선택

Extra Trees
→ Feature 일부를 무작위 선택
→ 각 후보 Feature의 Threshold를 무작위 생성
→ 무작위로 생성된 분할 중 가장 좋은 것 선택

예를 들어 Age가 후보 Feature라면 Random Forest는 가능한 분할점들을 비교해 불순도를 가장 많이 줄이는 값을 찾는다. Extra Trees는 Age < 31.7과 같은 임계값을 무작위로 생성하고, 다른 후보 Feature에서 생성한 무작위 분할과 비교한다.

중요한 점은 Extra Trees가 아무 분할이나 그대로 채택하는 것은 아니라는 것이다.

후보 Feature마다 무작위 Threshold를 만들지만, 그 무작위 후보들 중에서는 가장 좋은 분할을 선택한다.

3.1 더 강한 무작위성의 trade-off

Extra Trees의 무작위화는 Tree 오류의 상관과 ensemble variance를 더 낮출 수 있다. 모든 가능한 Threshold를 탐색하지 않아 학습이 빨라질 수도 있다.

반면 유용한 최적 분할을 놓치면 bias가 커질 수 있다.

무작위성 증가
  → Tree 다양성 증가 가능
  → 오류 상관과 variance 감소 가능
  → 개별 Tree의 최적 분할을 놓쳐 bias 증가 가능

이 방향은 일반적인 경향이지 성능 보장이나 고정 순위가 아니다.

3.2 scikit-learn의 중요한 기본값 차이

scikit-learn에서 두 모델의 기본값은 다음과 다르다.

• RandomForestClassifier: bootstrap=True
• ExtraTreesClassifier: bootstrap=False

따라서 Extra Trees는 기본적으로 각 Tree가 전체 학습 표본을 사용한다. Tree 차이는 주로 노드별 Feature 후보와 Threshold 무작위성에서 나온다.

이 때문에 Extra Trees까지 엄밀한 의미의 “Bootstrap Bagging”으로 부르면 정확하지 않다. Bagging, Random Forest, Extra Trees를 함께 묶어 말하고 싶다면 다음 표현이 안전하다.

순차 의존 없이 여러 randomized Tree를 만들고 평균하는 ensemble

또는 scikit-learn 문서의 표현처럼 perturb-and-combine 방식의 randomized tree ensemble이라고 부를 수 있다.

4. Random Forest와 Extra Trees 비교

표의 bias–variance 행은 방향성이다. 다음처럼 확정적인 화살표 순위를 붙이면 과도한 단순화가 된다.

Bagging variance ↓
Random Forest variance ↓↓
Extra Trees variance ↓↓↓

실제 결과는 표본 수, 신호 강도, Feature 수, 잡음, Tree 깊이, max_features 등에 따라 달라진다.

5. scikit-learn으로 비교하기

5.1 공통 데이터

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

X, y = load_iris(return_X_y=True)

X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.2,
    stratify=y,
    random_state=42,
)

5.2 RandomForestClassifier

from sklearn.ensemble import RandomForestClassifier

random_forest = RandomForestClassifier(
    n_estimators=300,
    max_features="sqrt",
    bootstrap=True,
    oob_score=True,
    n_jobs=-1,
    random_state=42,
)

random_forest.fit(X_train, y_train)

print("RF test accuracy:", random_forest.score(X_test, y_test))
print("RF OOB accuracy:", random_forest.oob_score_)

max_features="sqrt"는 각 노드의 분할을 찾을 때 대략 전체 Feature 수의 제곱근만큼을 후보로 고려한다는 뜻이다. 후보 집합은 노드마다 다시 무작위로 선택된다.

scikit-learn은 유효한 분할을 찾기 위해 필요한 경우 실질적으로 max_features보다 더 많은 Feature를 검사할 수 있다고 문서에 명시한다. 따라서 “어떤 상황에서도 정확히 그 개수만 본다”라고 표현하지 않는 편이 안전하다.

5.3 ExtraTreesClassifier

from sklearn.ensemble import ExtraTreesClassifier

extra_trees = ExtraTreesClassifier(
    n_estimators=300,
    max_features="sqrt",
    bootstrap=False,
    n_jobs=-1,
    random_state=42,
)

extra_trees.fit(X_train, y_train)

print("Extra Trees test accuracy:", extra_trees.score(X_test, y_test))

bootstrap=False는 scikit-learn의 기본 동작을 명시한 것이다. 모든 Tree가 전체 학습 표본을 사용하더라도 Feature와 Threshold 무작위성 때문에 서로 다른 Tree가 만들어질 수 있다.

OOB 점수가 필요하다면 Bootstrap을 명시적으로 켠다.

extra_trees_oob = ExtraTreesClassifier(
    n_estimators=300,
    max_features="sqrt",
    bootstrap=True,
    oob_score=True,
    n_jobs=-1,
    random_state=42,
)

5.4 같은 평가 조건에서 비교하기

한 번의 train/test split보다 같은 Cross Validation 조건에서 평균과 fold별 변동성을 함께 보는 편이 낫다.

from sklearn.model_selection import StratifiedKFold, cross_val_score

cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

for name, model in {
    "Random Forest": random_forest,
    "Extra Trees": extra_trees,
}.items():
    scores = cross_val_score(model, X, y, cv=cv, scoring="accuracy")
    print(f"{name:14s}: {scores.mean():.3f} ± {scores.std():.3f}")

여기서 표준편차는 해당 fold 구성에서 측정한 성능 점수의 변동성이다. bias–variance 분해에서 말하는 모델 variance와 같은 값은 아니다.

6. 선택할 때 주의할 점

• 먼저 조정할 값은 n_estimators, max_features, max_depth, min_samples_leaf다.
• max_features가 작을수록 variance가 단조롭게 줄거나 성능이 좋아진다는 법칙은 없다.
• “Clean이면 RF, Noisy면 Extra Trees”는 비교 가설일 뿐 모델 선택 규칙이 아니다.
• Feature Randomness는 Tree 오류 상관을 낮출 수 있지만 개별 Tree의 예측력도 낮출 수 있다.
• Tree 수를 늘리면 예측은 안정되는 경향이 있지만 개선은 포화되고 계산 비용은 증가한다.
• Extra Trees는 bootstrap=False가 기본이므로 전형적인 Bootstrap Bagging과 같지 않다.
• scikit-learn의 Random Forest 분류는 Tree별 class probability를 평균해 최종 class를 정한다.

이론은 비교할 가설을 제공하고, 실제 선택은 동일한 평가 조건의 Cross Validation 결과가 결정한다.

7. 이번 글의 핵심

Random Forest

노드별 Feature 후보 무작위화로 Tree들이 덜 비슷하게 움직이도록 만들고 평균의 효과를 키우려 한다.

Extra Trees

Feature뿐 아니라 분할 Threshold까지 무작위화해 더 강한 bias–variance trade-off를 만든다.

모델 선택

Random Forest와 Extra Trees의 우열은 데이터에 따라 달라지므로 같은 Cross Validation 조건에서 성능과 비용을 비교한다.

Bagging, Random Forest, Extra Trees는 Tree들을 순차 의존 없이 만들고 예측을 평균하는 방식이다. 다음 글에서는 이들과 다른 질문을 던지는 Boosting을 살펴본다.

현재 모델이 아직 틀리는 방향을 다음 Tree가 어떻게 보완할까?

참고 자료

• Leo Breiman, “Random Forests” (2001)
• Geurts, Ernst & Wehenkel, “Extremely randomized trees” (2006)
• scikit-learn: Ensembles user guide
• scikit-learn: RandomForestClassifier
• scikit-learn: ExtraTreesClassifier

학습지표

Decision Tree의 높은 variance를 줄이기 위해 Bagging은 데이터에 randomness를 주고, Random Forest는 feature 후보에도 randomness를 추가하며, Extra Trees는 분할 threshold까지 randomness를 추가한다.

Decision Tree는 비선형 관계와 변수 사이의 상호작용을 자연스럽게 표현한다. 전처리가 비교적 적고, 사람이 규칙을 따라갈 수 있다는 장점도 있다.

그러나 한 가지 약점이 크다. 학습 표본이 조금만 달라져도 Tree 구조와 예측이 크게 달라질 수 있다.

이번 글에서는 이 문제에서 출발해 다음 질문에 답한다.

1. Decision Tree는 왜 흔들리는가?
2. Bagging은 왜 Tree를 여러 개 만드는가?
3. Bootstrap과 Aggregation은 각각 무슨 역할을 하는가?
4. OOB는 어디서 생기고 무엇을 평가하는가?

1. Decision Tree는 왜 불안정할까?

1.1 상위 분할 하나가 전체 구조를 바꾼다

Decision Tree는 각 노드에서 데이터를 가장 잘 나누는 질문을 탐욕적(Greedy Algorithm)으로 선택한다.

petal width < 0.8인가?

최적 후보들의 점수가 비슷하다면 학습 데이터 몇 개만 추가되거나 빠져도 선택되는 분할이 달라질 수 있다. 상위 노드의 분할이 바뀌면 자식 노드가 받는 데이터도 달라지므로 이후 가지 구조가 연쇄적으로 변한다.

원본 데이터 D      → Tree A → Decision Boundary A
조금 바뀐 데이터 D' → Tree B → Decision Boundary B

이 성질을 통계적인 언어로는 variance가 높다고 표현한다.

여기서 variance는 데이터 열의 분산이 아니다.

같은 모집단에서 학습 표본을 다시 뽑아 모델을 재학습한다면 예측이 얼마나 달라지는가?

깊은 Tree는 복잡한 패턴을 잡아 bias가 낮을 수 있지만, 표본의 우연한 변화와 잡음까지 따라가기 쉬워 variance가 커질 수 있다.

복잡하고 깊은 Tree: bias가 낮을 수 있지만 variance가 커질 수 있음
단순하고 얕은 Tree: variance는 작아질 수 있지만 bias가 커질 수 있음

이는 절대적인 법칙이라기보다 모델 복잡도를 조절할 때 나타나는 대표적인 trade-off다.

1.2 Tree 하나를 단순하게 만들면 되지 않을까?

max_depth, min_samples_leaf 같은 제약으로 Tree를 단순하게 만들면 흔들림을 줄일 수 있다. 그러나 지나치게 제한하면 중요한 비선형 관계까지 놓쳐 underfitting이 생길 수 있다.

Bagging은 다른 질문을 던진다.

개별 Tree의 표현력을 크게 포기하지 않으면서 여러 Tree의 흔들림을 결합 과정에서 상쇄할 수는 없을까?

이 질문에 대한 답이 Bootstrap Aggregating, 줄여서 Bagging이다.

2. Bagging: 서로 다르게 흔들리게 한 뒤 평균낸다

Bagging은 같은 종류의 기본 모델을 서로 다른 Bootstrap 표본에 학습하고 예측을 결합한다.

원본 학습 데이터
  ├─ Bootstrap 표본 1 → Tree 1 ─┐
  ├─ Bootstrap 표본 2 → Tree 2 ─┼→ 평균 또는 투표
  └─ Bootstrap 표본 3 → Tree 3 ─┘

Tree들은 앞 Tree의 결과를 다음 Tree가 이어받지 않는다. 따라서 순차 의존 없이 별도로 학습할 수 있고 병렬화하기 쉽다.

이를 “Tree들이 통계적으로 독립적이다”라고 표현하면 정확하지 않다. 같은 원본 데이터와 Feature를 공유하므로 예측 오류는 서로 상관될 수 있다. 이 상관 문제는 다음 글의 Random Forest가 다룬다.

2.1 같은 Tree를 복사하는 것만으로는 부족하다

같은 데이터, 같은 알고리즘, 같은 설정으로 Tree를 100개 만들면 동일하거나 매우 비슷한 Tree가 만들어질 수 있다.

같은 학습 데이터
  ├─ Tree 1 ─┐
  ├─ Tree 2 ─┤ 비슷한 예측
  └─ Tree 3 ─┘

같은 실수를 하는 모델 100개를 모아도 평균의 효과는 제한된다. Bagging은 먼저 학습 표본을 바꿔 각 모델에 서로 다른 학습 경험을 제공한다.

3. Bootstrap Sampling: 서로 다른 학습 표본 만들기

Bootstrap은 원본 학습 데이터에서 복원 추출(with replacement)하는 방법이다.

원본 데이터가 다음과 같다고 하자.

[A, B, C, D, E]

크기가 5인 Bootstrap 표본은 다음처럼 만들어질 수 있다.

표본 1: [A, A, C, D, E]
표본 2: [B, B, C, C, E]
표본 3: [A, B, D, D, D]

한 번 뽑은 관측치를 다시 뽑을 수 있으므로 중복이 생긴다. 반대로 어떤 관측치는 한 번도 선택되지 않을 수 있다.

max_samples=0.8의 정확한 의미

학습 데이터가 1,000개이고 다음과 같이 설정했다고 하자.

max_samples=0.8
bootstrap=True

각 모델은 원본의 80%에 해당하는 800번을 복원 추출한다. 서로 다른 관측치 800개가 반드시 포함된다는 뜻은 아니다. 중복 때문에 실제 고유 관측치 수는 800개보다 적다.

Bootstrap의 목적은 개별 Tree 하나를 반드시 더 정확하게 만드는 것이 아니다.

Tree들을 서로 다르게 흔들리게 만들어, 결합할 때 오차가 일부 상쇄될 조건을 만드는 것이다.

4. Aggregation: 흔들림을 안정성으로 바꾸기

Bootstrap 표본 D_1, D_2, ..., D_B로 모델 f_1, f_2, ..., f_B를 학습했다고 하자.

회귀에서는 예측값을 평균한다.

$$ \hat f_{\text{bag}}(x)=\frac{1}{B}\sum_{b=1}^{B}f_b(x) $$ $$ (B) = Tree 개수 $$ $$ (f_b(x)) = b번째 Tree가 입력 (x)에 대해 낸 예측값 $$ $$ (\sum_{b=1}^{B} f_b(x)) = 모든 Tree 예측을 다 더함 $$ (\frac{1}{B}) = Tree 개수로 나눔 $$ (\hat f_{\text{bag}}(x)) = Bagging의 최종 예측 $$

예를 들어 실제값이 50이고 다섯 Tree의 예측이 다음과 같다면:

Tree 1 → 43
Tree 2 → 58
Tree 3 → 48
Tree 4 → 55
Tree 5 → 46
평균   → 50

개별 Tree의 오차 방향이 완전히 같지 않다면 평균 과정에서 일부 오차가 상쇄된다. 그래서 Bagging을 대표적인 variance reduction 기법이라고 부른다.

분류의 결합 방식은 설명 층위를 구분할 필요가 있다.

• Breiman의 원래 Bagging 설명: 가장 많은 표를 받은 클래스를 선택하는 plurality vote
• scikit-learn BaggingClassifier: 기본 모델이 predict_proba()를 제공하면 클래스 확률을 평균하고, 제공하지 않으면 voting 사용

즉 “분류는 무조건 hard voting”이라고 외우기보다 사용하는 구현의 결합 방식을 확인해야 한다.

5. OOB: Bootstrap에서 자연스럽게 생기는 내부 추정치

원본 데이터가 N개이고 크기가 N인 Bootstrap 표본을 만든다고 하자. 특정 관측치 하나가 한 번도 선택되지 않을 확률은 다음과 같다.

$$ \left(1-\frac{1}{N}\right)^N \xrightarrow[N\to\infty]{} \frac{1}{e}\approx0.368 $$

따라서 표준적인 Bootstrap 표본 하나에는 평균적으로 다음과 같은 구성이 나타난다.

한 번 이상 등장한 고유 관측치: 약 63.2%
한 번도 등장하지 않은 관측치: 약 36.8%

한 Tree의 Bootstrap 표본에 포함되지 않은 관측치를 그 Tree의 Out-of-Bag(OOB) 표본이라고 한다.

5.1 OOB 평가는 어떻게 만들어질까?

각 학습 관측치에 대해 그 관측치를 보지 않고 학습한 Tree들의 예측만 모은다.

관측치 x_i
  ↓
x_i를 학습에 사용하지 않은 Tree만 선택
  ↓
그 Tree들의 예측을 집계
  ↓
y_i와 비교 → OOB 성능 추정치

OOB는 별도의 모델 재학습 없이 얻을 수 있는 편리한 신호다. 그러나 역할을 과장하면 안 된다.

• 36.8%는 N개에서 N번 복원 추출할 때의 근사값이다.
• max_samples가 달라지면 OOB 비율도 달라진다.
• OOB는 원래 학습 풀 내부에서 만든 추정치다.
• 최종 독립 테스트 세트인 final holdout과 같지 않다.
• 모든 상황에서 Cross Validation을 대체한다는 규칙도 아니다.

OOB는 “공짜 테스트 세트”보다 Bootstrap 과정에서 얻는 내부 보조 성능 추정치라고 부르는 편이 정확하다.

6. scikit-learn으로 Bagging과 OOB 확인하기

6.1 데이터 준비

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

X, y = load_iris(return_X_y=True)

X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.2,
    stratify=y,
    random_state=42,
)

6.2 단일 Decision Tree

from sklearn.tree import DecisionTreeClassifier

tree = DecisionTreeClassifier(random_state=42)
tree.fit(X_train, y_train)

print("Decision Tree test accuracy:", tree.score(X_test, y_test))

한 번의 정확도만으로 모델의 안정성을 판단할 수는 없다. 여러 데이터 분할에서 예측이나 성능이 얼마나 달라지는지도 확인해야 한다.

6.3 BaggingClassifier

from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier

bagging = BaggingClassifier(
    estimator=DecisionTreeClassifier(random_state=42),
    n_estimators=100,
    max_samples=1.0,
    bootstrap=True,
    oob_score=True,
    n_jobs=-1,
    random_state=42,
)

bagging.fit(X_train, y_train)

print("Bagging test accuracy:", bagging.score(X_test, y_test))
print("Bagging OOB accuracy:", bagging.oob_score_)

scikit-learn 1.2 이전 코드에서는 estimator 대신 base_estimator가 보일 수 있다. 현재 API에서는 estimator를 사용한다.

Iris처럼 작고 쉬운 데이터에서는 두 모델의 한 번의 test accuracy가 같을 수도 있다. 이 결과 하나로 “Bagging이 항상 더 좋다”거나 “효과가 없다”고 결론 내리면 안 된다.

7. 이번 글의 핵심

Decision Tree

학습 표본이 조금 달라질 때 예측이 크게 바뀔 수 있는 고분산 모델이다.

Bagging

불안정한 모델을 버리는 대신 서로 다른 Bootstrap 표본에서 다르게 흔들리게 만들고, 예측을 집계해 흔들림을 줄인다.

OOB

각 모델이 학습 중 보지 않은 표본의 예측만 모아 만든 학습 풀 내부의 보조 성능 추정치다.

Bagging은 Tree뿐 아니라 여러 기본 추정기에 적용할 수 있다. 다만 표본 변화에 민감한 고분산 모델에서 특히 유용해 Decision Tree와 자주 결합한다. Tree 수를 늘리면 예측은 안정되는 경향이 있지만 개선은 포화되고 계산 비용은 증가한다.

그러나 Bootstrap을 사용해도 강력한 Feature 때문에 Tree들이 계속 비슷한 분할을 선택할 수 있다. Tree들의 오류가 비슷하면 평균 효과도 제한된다.

다음 글에서는 이 문제를 해결하기 위해 노드별 Feature 후보를 무작위화하는 Random Forest와 분할 임계값까지 무작위화하는 Extra Trees를 비교한다.

참고 자료

• Leo Breiman, “Bagging predictors” (1996)
• scikit-learn: BaggingClassifier
• scikit-learn: OOB Errors for Random Forests
• scikit-learn: Cross-validation guide