CNN: 이미지를 이해하는 신경망
작은 필터를 사진 위로 미끄러뜨리는 합성곱을 손으로 계산해 PyTorch 결과와 맞춰 보고, 가중치 공유와 풀링이 왜 사진에 잘 맞는지 이해해요. 손글씨 사진을 한두 칸만 밀어도 일반 신경망은 정확도가 97%에서 45%로 무너지는 것, CNN과 데이터 증강이 이를 어떻게 막는지 실험하고, LeNet에서 ResNet, 비전 트랜스포머까지 이미지 모델의 흐름과 전이 학습을 정리해요.
지금까지는 손글씨 사진을 픽셀 64개짜리 목록으로 펼쳐서 신경망에 넣었어요. 그런데 사진은 목록이 아니에요. 바로 옆 픽셀끼리 밀접하게 관련되어 있고, 고양이는 사진 왼쪽에 있든 오른쪽에 있든 고양이예요. 펼쳐 버리면 이런 구조를 버리게 돼요. **합성곱 신경망(CNN)**은 사진의 구조를 그대로 살려서, 훨씬 적은 가중치로 훨씬 잘 봐요. 2012년 딥러닝 혁명을 연 알렉스넷도 CNN이었어요.
펼친 신경망이 사진에 맞지 않는 이유
가로세로 224픽셀 컬러 사진은 숫자가 개예요. 이걸 펼쳐서 은닉 뉴런 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이 사진에 잘 맞는 세 가지 이유
- 지역 연결: 필터는 한 번에 작은 영역(3×3)만 봐요. 사진의 정보는 가까운 픽셀끼리 모여 있으니까요.
- 가중치 공유: 같은 필터를 사진 전체에 써요. 왼쪽 위의 경계와 오른쪽 아래의 경계를 같은 가중치로 찾으니, 가중치 수가 사진 크기와 상관없이 필터 크기만큼(3×3=9)이에요.
- 위치가 바뀌면 결과도 따라 바뀜: 사진을 한 칸 밀면 특징 지도도 한 칸 밀려요. 어디에 있든 같은 방식으로 찾아내요.
출력 크기 계산
입력 크기 , 필터 크기 , 가장자리를 0으로 덧대는 폭(패딩) , 미끄러지는 간격(스트라이드) 일 때 출력 크기는 이래요.
위 예제는 , , , 이라 이었어요. 패딩을 1로 주면 로 크기가 유지돼요.
풀링: 요약해서 줄이기
최대 풀링은 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칸 |
|---|---|---|---|---|---|
| MLP | 9,610 | 0.967 | 0.449 | 0.116 | 0.147 |
| CNN | 6,090 | 0.967 | 0.571 | 0.276 | 0.280 |
| MLP + 증강 | 9,610 | 0.884 | 0.880 | 0.702 | 0.318 |
| CNN + 증강 | 6,090 | 0.940 | 0.924 | 0.851 | 0.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%). 구조가 사진에 맞으니 같은 데이터에서 더 많이 배우는 거예요. 이렇게 모델 구조에 문제의 성질을 미리 담는 것을 귀납적 편향이라고 해요.
실제 이미지 모델은 밀기뿐 아니라 좌우 뒤집기, 일부 잘라 내기, 밝기와 색 바꾸기, 살짝 돌리기 같은 증강을 거의 언제나 써요. 학습 기술 강의의 "그 밖의 무기" 첫 줄이었죠.
이미지 모델의 계보
| 연도 | 모델 | 무엇을 바꿨나 |
|---|---|---|
| 1998 | LeNet-5 | 합성곱과 풀링으로 손글씨 우편번호를 읽는 CNN의 원형 |
| 2012 | AlexNet | GPU, ReLU, 드롭아웃으로 깊은 CNN을 학습시켜 이미지넷 대회를 압도 |
| 2014 | VGG | 3×3 필터만 깊게 쌓는 단순한 설계 |
| 2015 | ResNet | 층을 건너뛰는 잔차 연결로 152층까지 학습 |
| 2020 | 비전 트랜스포머(ViT) | 사진을 16×16 조각으로 잘라 단어처럼 다루는 어텐션 모델 |
잔차 연결은 특히 중요해요. 층의 출력을 대신 로 만들어서, 층이 "입력에서 무엇을 더 고칠지"만 배우게 해요. 역전파 때 기울기가 덧셈을 타고 그대로 흘러가는 지름길이 생겨서(역전파 강의의 덧셈 규칙), 아주 깊은 신경망도 기울기 소실 없이 학습돼요. 이 아이디어는 다음 강의의 트랜스포머에도 그대로 들어가요.
전이 학습: 남이 배운 눈을 빌려 쓰기
사진 수백만 장으로 학습한 큰 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],[0,0,0],[1,1,1]])으로 바꿔 숫자 0에 대어 보세요. 큰 값이 어디에 나오나요? - CNN의 첫 합성곱 필터 개수를 4, 16, 64로 바꿔 가중치 수와 한 칸 민 사진의 정확도를 비교하세요.
- 증강에 좌우 뒤집기를 추가하면 숫자 분류에는 어떤 문제가 생길까요? (힌트: 2와 5, 6과 9)
- 최대 풀링을 평균 풀링(
nn.AvgPool2d)으로 바꿔 결과를 비교해 보세요.
자주 하는 실수
- 입력 모양을 (개수, 채널, 세로, 가로)로 맞추지 않기. 흑백 사진도 채널 1을 넣어야 해요.
- 풀링 뒤의 크기를 계산하지 않고 분류층 크기 정하기. 모양을 한 번 찍어 보고 정하세요.
- 문제에 맞지 않는 증강 쓰기. 숫자를 뒤집으면 다른 숫자가 되고, 의료 영상을 마구 돌리면 의미가 바뀔 수 있어요.
- 데이터가 적은데 처음부터 큰 CNN 학습하기. 전이 학습부터 해 보세요.
점검 문제
- 가로세로 32인 사진에 5×5 필터를 패딩 0, 스트라이드 1로 쓰면 출력 크기는?
- 3×3 필터 16개를 흑백(채널 1) 사진에 쓰는 합성곱 층의 가중치와 편향은 모두 몇 개인가요?
- 가중치 공유가 주는 두 가지 이득은?
- 실험에서 데이터 증강을 하자 한 칸 민 사진의 정확도가 크게 오른 이유는?
- 잔차 연결이 깊은 신경망 학습을 돕는 이유는?
정답
- 이에요.
- 필터마다 가중치 9개와 편향 1개라 개예요.
- 가중치 수가 사진 크기와 상관없이 작아지고, 사진의 어느 위치에서든 같은 특징을 같은 방식으로 찾을 수 있어요.
- 학습할 때 위치가 조금씩 다른 사진을 보여 줘서, 위치가 달라도 같은 숫자라는 것을 데이터로 배웠기 때문이에요.
- 출력에 입력을 그대로 더해 주는 지름길이 있어서, 역전파 때 기울기가 줄어들지 않고 앞쪽 층까지 전달되기 때문이에요.
다음 강의
사진은 공간 구조가 있는 데이터였어요. 글과 소리는 순서가 있는 데이터예요. 다음 강의에서는 순서를 기억하며 읽는 RNN에서 출발해, 그 한계를 넘어선 어텐션과 트랜스포머의 핵심 아이디어까지 따라가요. LLM으로 가는 마지막 관문이에요.