CNN: 이미지를 이해하는 신경망

작은 필터를 사진 위로 미끄러뜨리는 합성곱을 손으로 계산해 PyTorch 결과와 맞춰 보고, 가중치 공유와 풀링이 왜 사진에 잘 맞는지 이해해요. 손글씨 사진을 한두 칸만 밀어도 일반 신경망은 정확도가 97%에서 45%로 무너지는 것, CNN과 데이터 증강이 이를 어떻게 막는지 실험하고, LeNet에서 ResNet, 비전 트랜스포머까지 이미지 모델의 흐름과 전이 학습을 정리해요.

고급강의 5 / 6약 12분

지금까지는 손글씨 사진을 픽셀 64개짜리 목록으로 펼쳐서 신경망에 넣었어요. 그런데 사진은 목록이 아니에요. 바로 옆 픽셀끼리 밀접하게 관련되어 있고, 고양이는 사진 왼쪽에 있든 오른쪽에 있든 고양이예요. 펼쳐 버리면 이런 구조를 버리게 돼요. **합성곱 신경망(CNN)**은 사진의 구조를 그대로 살려서, 훨씬 적은 가중치로 훨씬 잘 봐요. 2012년 딥러닝 혁명을 연 알렉스넷도 CNN이었어요.

펼친 신경망이 사진에 맞지 않는 이유

가로세로 224픽셀 컬러 사진은 숫자가 224×224×3=150,528224 \times 224 \times 3 = 150{,}528개예요. 이걸 펼쳐서 은닉 뉴런 1,000개짜리 층에 넣으면 첫 층의 가중치만 1억 5천만 개예요. 게다가 왼쪽 위의 눈을 알아보는 가중치와 오른쪽 아래의 눈을 알아보는 가중치를 따로따로 배워야 해요. 같은 눈인데도요.

합성곱: 작은 필터를 미끄러뜨리기

합성곱은 작은 필터(커널)를 사진 위로 한 칸씩 미끄러뜨리며, 겹친 부분끼리 곱해서 더하는 계산이에요. 숫자 0 사진에 세로 경계를 찾는 3×3 필터를 직접 대어 볼게요.

import numpy as np
import torch
from torch import nn
import torch.nn.functional as F
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split

X, y = load_digits(return_X_y=True)
img = X[0].reshape(8, 8) / 16                              # 숫자 0 한 장 (밝기 0에서 1)
kernel = np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]])    # 오른쪽이 밝으면 +, 왼쪽이 밝으면 -

out = np.zeros((6, 6))
for i in range(6):
    for j in range(6):
        out[i, j] = (img[i:i + 3, j:j + 3] * kernel).sum()  # 겹친 9칸을 곱해서 더하기
print(np.round(out, 1))

t = F.conv2d(torch.tensor(img, dtype=torch.float32)[None, None], torch.tensor(kernel, dtype=torch.float32)[None, None])
print(np.allclose(t[0, 0].numpy(), out, atol=1e-6))       # True
[[ 2.1  1.7 -0.9 -0.2 -0.4 -1.7]
 [ 2.5  0.6 -1.9  1.1  0.7 -2.1]
 [ 2.2 -0.6 -2.2  1.6  1.5 -1.8]
 [ 1.9 -0.8 -1.9  1.8  1.4 -1.8]
 [ 2.1 -0.4 -1.4  1.8  0.2 -2.1]
 [ 1.9  0.8 -0.6  0.4 -0.9 -1.5]]

결과(특징 지도)를 보면 왼쪽 열은 큰 양수, 오른쪽 열은 큰 음수예요. 숫자 0의 왼쪽 획은 "어둡다가 밝아지는" 경계라 +, 오른쪽 획은 "밝다가 어두워지는" 경계라 -가 나온 거예요. 필터 하나가 사진에서 세로 경계가 어디 있는지를 찾아냈어요. 손으로 한 계산이 PyTorch의 conv2d와 똑같다는 것도 확인했어요.

CNN은 이런 필터의 숫자 9개를 사람이 정하지 않고 데이터에서 배워요. 그리고 필터를 여러 개 두어 세로 경계, 가로 경계, 대각선, 곡선 같은 여러 특징을 동시에 찾아요.

CNN이 사진에 잘 맞는 세 가지 이유

  1. 지역 연결: 필터는 한 번에 작은 영역(3×3)만 봐요. 사진의 정보는 가까운 픽셀끼리 모여 있으니까요.
  2. 가중치 공유: 같은 필터를 사진 전체에 써요. 왼쪽 위의 경계와 오른쪽 아래의 경계를 같은 가중치로 찾으니, 가중치 수가 사진 크기와 상관없이 필터 크기만큼(3×3=9)이에요.
  3. 위치가 바뀌면 결과도 따라 바뀜: 사진을 한 칸 밀면 특징 지도도 한 칸 밀려요. 어디에 있든 같은 방식으로 찾아내요.

출력 크기 계산

입력 크기 nn, 필터 크기 kk, 가장자리를 0으로 덧대는 폭(패딩) pp, 미끄러지는 간격(스트라이드) ss일 때 출력 크기는 이래요.

출력=⌊n+2p−ks⌋+1\text{출력} = \left\lfloor \frac{n + 2p - k}{s} \right\rfloor + 1

위 예제는 n=8n = 8, k=3k = 3, p=0p = 0, s=1s = 1이라 (8−3)/1+1=6(8 - 3)/1 + 1 = 6이었어요. 패딩을 1로 주면 (8+2−3)+1=8(8 + 2 - 3) + 1 = 8로 크기가 유지돼요.

풀링: 요약해서 줄이기

최대 풀링은 2×2 칸마다 가장 큰 값 하나만 남겨 가로세로를 절반으로 줄여요. "이 근처에 세로 경계가 있다"는 사실만 남기고 정확한 위치는 조금 흐려요. 덕분에 계산이 줄고, 작은 위치 변화에 덜 민감해져요.

CNN 만들기

합성곱 두 번, 풀링 두 번 뒤에 분류층을 붙인 작은 CNN이에요. 비교할 일반 신경망(MLP)도 함께 만들어요.

X_tr, X_te, y_tr, y_te = train_test_split(X / 16, y, test_size=0.25, random_state=0)
Xtr = torch.tensor(X_tr, dtype=torch.float32).reshape(-1, 1, 8, 8)   # (개수, 채널, 세로, 가로)
Xte = torch.tensor(X_te, dtype=torch.float32).reshape(-1, 1, 8, 8)
ytr, yte = torch.tensor(y_tr), torch.tensor(y_te)

class MLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(nn.Flatten(), nn.Linear(64, 128), nn.ReLU(), nn.Linear(128, 10))
    def forward(self, x):
        return self.net(x)

class CNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(1, 16, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),    # 8x8 → 4x4, 필터 16개
            nn.Conv2d(16, 32, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2),   # 4x4 → 2x2, 필터 32개
        )
        self.head = nn.Linear(32 * 2 * 2, 10)
    def forward(self, x):
        return self.head(self.features(x).flatten(1))

층을 지날 때마다 모양이 어떻게 바뀌는지 찍어 보면 이래요.

층출력 모양 (채널, 세로, 가로)
입력(1, 8, 8)
합성곱 16개 + ReLU(16, 8, 8)
최대 풀링(16, 4, 4)
합성곱 32개 + ReLU(32, 4, 4)
최대 풀링(32, 2, 2)
펼쳐서 분류층10

크기는 줄어들고 채널(특징의 종류)은 늘어나요. 앞쪽 층은 경계 같은 단순한 특징을, 뒤쪽 층은 앞의 특징을 조합한 복잡한 특징(곡선, 고리, 숫자의 부분)을 찾아요. 뒤쪽 층의 뉴런 하나는 원래 사진의 더 넓은 영역을 보게 되는데, 이 영역을 수용 영역이라고 해요.

실험: 사진을 한 칸만 밀어도

두 모델을 똑같이 학습시킨 뒤, 시험 사진을 그대로, 오른쪽으로 한 칸, 오른쪽 아래로 한 칸, 오른쪽으로 두 칸 밀어서 평가해 볼게요. 학습할 때 사진을 무작위로 조금씩 미는 데이터 증강을 한 버전도 함께 비교해요.

def shift(x, dx, dy):
    """사진을 오른쪽으로 dx칸, 아래로 dy칸 밀어요 (빈 곳은 0)"""
    out = torch.zeros_like(x)
    h, w = x.shape[-2:]
    out[..., max(dy, 0):h + min(dy, 0), max(dx, 0):w + min(dx, 0)] = x[..., max(-dy, 0):h + min(-dy, 0), max(-dx, 0):w + min(-dx, 0)]
    return out

def train(model, epochs=40, augment=False):
    opt = torch.optim.Adam(model.parameters(), lr=1e-3)
    g = torch.Generator().manual_seed(0)
    for ep in range(epochs):
        model.train()
        perm = torch.randperm(len(Xtr), generator=g)
        for s in range(0, len(Xtr), 64):
            xb, yb = Xtr[perm[s:s + 64]], ytr[perm[s:s + 64]]
            if augment:                                  # 배치마다 -1에서 1칸 사이로 무작위로 밀기
                d = torch.randint(-1, 2, (2,), generator=g).tolist()
                xb = shift(xb, d[0], d[1])
            opt.zero_grad()
            F.cross_entropy(model(xb), yb).backward()
            opt.step()
    return model

def acc(model, x):
    model.eval()
    with torch.no_grad():
        return round((model(x).argmax(1) == yte).float().mean().item(), 3)

for name, make, aug in [("MLP", MLP, False), ("CNN", CNN, False), ("MLP + 증강", MLP, True), ("CNN + 증강", CNN, True)]:
    torch.manual_seed(0)
    m = train(make(), augment=aug)
    n_params = sum(p.numel() for p in m.parameters())
    print(name, n_params, acc(m, Xte), acc(m, shift(Xte, 1, 0)), acc(m, shift(Xte, 1, 1)), acc(m, shift(Xte, 2, 0)))
모델가중치 수그대로오른쪽 1칸대각선 1칸오른쪽 2칸
MLP9,6100.9670.4490.1160.147
CNN6,0900.9670.5710.2760.280
MLP + 증강9,6100.8840.8800.7020.318
CNN + 증강6,0900.9400.9240.8510.651

결과를 차근차근 읽어 볼게요.

  • 원래 사진에서는 둘 다 96.7%로 같아요. 그런데 한 칸만 밀어도 MLP는 44.9%로 무너져요. MLP에게 "왼쪽에서 셋째 칸의 픽셀"과 "넷째 칸의 픽셀"은 완전히 다른 입력이거든요. 사람 눈에는 똑같은 숫자인데요.
  • CNN은 가중치가 3분의 2뿐인데도 더 잘 버텨요(57.1%). 하지만 이 사진은 가로세로 8칸짜리라 한 칸이 사진 폭의 12.5%나 돼서, CNN의 구조만으로는 부족해요.
  • 데이터 증강을 하면 달라져요. 학습할 때 일부러 사진을 조금씩 밀어서 보여 주면, 모델은 "위치가 조금 달라도 같은 숫자"라는 걸 데이터로 배워요. CNN에 증강까지 더하니 한 칸 민 사진에서도 92.4%예요.
  • 같은 증강을 해도 CNN이 MLP보다 훨씬 잘 배워요(대각선 85.1% 대 70.2%). 구조가 사진에 맞으니 같은 데이터에서 더 많이 배우는 거예요. 이렇게 모델 구조에 문제의 성질을 미리 담는 것을 귀납적 편향이라고 해요.

실제 이미지 모델은 밀기뿐 아니라 좌우 뒤집기, 일부 잘라 내기, 밝기와 색 바꾸기, 살짝 돌리기 같은 증강을 거의 언제나 써요. 학습 기술 강의의 "그 밖의 무기" 첫 줄이었죠.

이미지 모델의 계보

연도모델무엇을 바꿨나
1998LeNet-5합성곱과 풀링으로 손글씨 우편번호를 읽는 CNN의 원형
2012AlexNetGPU, ReLU, 드롭아웃으로 깊은 CNN을 학습시켜 이미지넷 대회를 압도
2014VGG3×3 필터만 깊게 쌓는 단순한 설계
2015ResNet층을 건너뛰는 잔차 연결로 152층까지 학습
2020비전 트랜스포머(ViT)사진을 16×16 조각으로 잘라 단어처럼 다루는 어텐션 모델

잔차 연결은 특히 중요해요. 층의 출력을 F(x)F(\mathbf{x}) 대신 x+F(x)\mathbf{x} + F(\mathbf{x})로 만들어서, 층이 "입력에서 무엇을 더 고칠지"만 배우게 해요. 역전파 때 기울기가 덧셈을 타고 그대로 흘러가는 지름길이 생겨서(역전파 강의의 덧셈 규칙), 아주 깊은 신경망도 기울기 소실 없이 학습돼요. 이 아이디어는 다음 강의의 트랜스포머에도 그대로 들어가요.

전이 학습: 남이 배운 눈을 빌려 쓰기

사진 수백만 장으로 학습한 큰 CNN은 앞쪽 층에 경계, 질감, 모양을 알아보는 범용 눈을 갖고 있어요. 내 문제(예: 우리 공장 불량품 사진 500장)를 풀 때 처음부터 배울 필요 없이, 이 모델을 가져와서 마지막 분류층만 내 문제에 맞게 바꿔 학습시키면 적은 데이터로도 좋은 성능이 나와요. 이것이 전이 학습이에요.

# 실제로는 이런 식으로 써요 (처음 실행할 때 학습된 가중치를 내려받아요)
# import torchvision
# model = torchvision.models.resnet18(weights="IMAGENET1K_V1")
# for p in model.parameters():
#     p.requires_grad = False                       # 배운 눈은 그대로 두고
# model.fc = nn.Linear(model.fc.in_features, 3)     # 마지막 층만 내 문제(3종류)에 맞게 바꿔요

현업의 이미지 문제는 대부분 이렇게 시작해요. 학습 방식 강의에서 말한 "미리 배운 큰 모델을 조금만 더 가르치기"의 대표적인 예예요.

분류를 넘어서

일무엇을 하나대표 모델
객체 탐지사진 속 물체마다 상자와 이름YOLO 계열
분할픽셀마다 무엇인지 칠하기U-Net
생성잡음에서 사진 만들어 내기확산 모델(U-Net이나 트랜스포머 사용)

이미지 생성 AI의 확산 모델도 안에 CNN이나 트랜스포머를 써요. 오늘 배운 합성곱이 그림을 그리는 AI의 부품이기도 해요.

실습

  1. 손 계산 예제의 필터를 가로 경계용([[-1,-1,-1],[0,0,0],[1,1,1]])으로 바꿔 숫자 0에 대어 보세요. 큰 값이 어디에 나오나요?
  2. CNN의 첫 합성곱 필터 개수를 4, 16, 64로 바꿔 가중치 수와 한 칸 민 사진의 정확도를 비교하세요.
  3. 증강에 좌우 뒤집기를 추가하면 숫자 분류에는 어떤 문제가 생길까요? (힌트: 2와 5, 6과 9)
  4. 최대 풀링을 평균 풀링(nn.AvgPool2d)으로 바꿔 결과를 비교해 보세요.

자주 하는 실수

  • 입력 모양을 (개수, 채널, 세로, 가로)로 맞추지 않기. 흑백 사진도 채널 1을 넣어야 해요.
  • 풀링 뒤의 크기를 계산하지 않고 분류층 크기 정하기. 모양을 한 번 찍어 보고 정하세요.
  • 문제에 맞지 않는 증강 쓰기. 숫자를 뒤집으면 다른 숫자가 되고, 의료 영상을 마구 돌리면 의미가 바뀔 수 있어요.
  • 데이터가 적은데 처음부터 큰 CNN 학습하기. 전이 학습부터 해 보세요.

점검 문제

  1. 가로세로 32인 사진에 5×5 필터를 패딩 0, 스트라이드 1로 쓰면 출력 크기는?
  2. 3×3 필터 16개를 흑백(채널 1) 사진에 쓰는 합성곱 층의 가중치와 편향은 모두 몇 개인가요?
  3. 가중치 공유가 주는 두 가지 이득은?
  4. 실험에서 데이터 증강을 하자 한 칸 민 사진의 정확도가 크게 오른 이유는?
  5. 잔차 연결이 깊은 신경망 학습을 돕는 이유는?

정답

  1. (32−5)/1+1=28(32 - 5)/1 + 1 = 28이에요.
  2. 필터마다 가중치 9개와 편향 1개라 16×10=16016 \times 10 = 160개예요.
  3. 가중치 수가 사진 크기와 상관없이 작아지고, 사진의 어느 위치에서든 같은 특징을 같은 방식으로 찾을 수 있어요.
  4. 학습할 때 위치가 조금씩 다른 사진을 보여 줘서, 위치가 달라도 같은 숫자라는 것을 데이터로 배웠기 때문이에요.
  5. 출력에 입력을 그대로 더해 주는 지름길이 있어서, 역전파 때 기울기가 줄어들지 않고 앞쪽 층까지 전달되기 때문이에요.

다음 강의

사진은 공간 구조가 있는 데이터였어요. 글과 소리는 순서가 있는 데이터예요. 다음 강의에서는 순서를 기억하며 읽는 RNN에서 출발해, 그 한계를 넘어선 어텐션과 트랜스포머의 핵심 아이디어까지 따라가요. LLM으로 가는 마지막 관문이에요.