콘볼루션 신경망(CNN)의 구조와 아키텍처

학습 목표

CNN의 일반적인 구조(콘볼루션 → ReLU → 풀링 → … → 펼치기 → 완전연결 → 분류)를 설명할 수 있다
ReLU, 풀링, 완전연결 층이 각각 무엇을 하는지 말할 수 있다
CNN을 통과하며 특성 맵의 크기와 파라미터 수가 어떻게 변하는지 직접 계산할 수 있다
가중치 공유와 이동 불변성이 왜 콘볼루션의 장점인지 설명할 수 있다
LeNet-5의 구조를 층별로 따라갈 수 있고, 객체탐지가 분류에 더하는 출력·레이블·IoU의 쓰임을 설명할 수 있다

CNN의 일반적인 구조

앞 장에서 콘볼루션 연산 하나를 배웠다. 이미지에 커널을 훑어 특성 맵을 만드는 연산이다. 이 연산을 다른 층들과 이어 붙여 이미지를 넣으면 클래스가 나오는 신경망을 만든 것이 콘볼루션 신경망이다.

콘볼루션 신경망 (CNN, Convolutional Neural Network)

콘볼루션 층으로 이미지에서 특성을 뽑아내고(특성 학습), 뽑아낸 특성을 완전연결 층에 넣어 분류하는 인공신경망.

앞부분(Feature Learning)에는 아직 안 본 층이 둘 있다. 콘볼루션 뒤에 붙는 ReLU와 그 뒤의 풀링이다. 뒷부분(Classification)은 2~3장의 완전연결 신경망이다. 차례로 본다.

ReLU 활성화

2장에서 활성화 함수 없이 합만 쌓으면 아무리 깊어도 퍼셉트론 하나와 같다고 했다. 콘볼루션도 같은 자리끼리 곱해 더하는 합이므로 마찬가지다. 콘볼루션 뒤에는 활성화 함수가 붙는다.

ReLU 활성화 (Rectified Linear Unit)

\[f(u) = \max(0,\ u)\]

콘볼루션으로 추출한 특성 맵에서 양의 값만 활성화시키고 음의 값은 0으로 만드는 층. 특성 맵의 각 칸에 독립적으로 적용된다.

콘볼루션 결과가 다음과 같다면

\[\begin{bmatrix} -5 & 3 & 7 \\ 2 & -3 & 9 \\ 1 & 1 & -1 \end{bmatrix} \xrightarrow{\ \text{ReLU}\ } \begin{bmatrix} 0 & 3 & 7 \\ 2 & 0 & 9 \\ 1 & 1 & 0 \end{bmatrix}\]

음수 \(-5, -3, -1\)이 0이 되었다. 앞 장에서 특성 맵의 값이 크다는 것은 그 자리가 커널의 패턴과 일치한다는 뜻이었다. 음수는 패턴과 반대인 자리다. ReLU는 그런 자리를 0으로 지워 두드러지는 특징만 남긴다.

풀링 층 (Pooling Layer)

풀링 (Pooling)

입력 특성 맵의 크기를 줄이는 연산. 작은 창을 겹치지 않게 옮기며 창 안의 값을 하나로 요약한다. 파라미터는 셋이다.

사이즈: 창의 크기. 보통 2 (\(2 \times 2\))
스트라이드: 창이 옮겨 가는 보폭. 보통 2. 사이즈와 같게 두어 창이 겹치지 않게 한다
Max 또는 Average: 창 안의 최댓값을 남기는가, 평균을 남기는가. 보통 Max

\(4 \times 4\) 특성 맵에 사이즈 2, 스트라이드 2의 Max 풀링을 하면 \(2 \times 2\)가 된다. 한 칸씩 확인하자.

poolIn = [[1,2,1,0],[0,1,2,3],[3,0,1,2],[2,4,0,1]]
poolSteps = [0,1,2,3].map(i => { const r = Math.floor(i / 2), c = i % 2; const vals = [poolIn[2*r][2*c], poolIn[2*r][2*c+1], poolIn[2*r+1][2*c], poolIn[2*r+1][2*c+1]]; return { r, c, vals, max: Math.max(...vals) } })
mutable poolStep = 0
mutable poolPlaying = false
viewof poolCtl = Inputs.button([
  ["▸ 다음 스텝", () => { mutable poolPlaying = false; if (poolStep < 3) mutable poolStep = poolStep + 1; return poolStep }],
  ["▶ 재생", () => { mutable poolPlaying = true; return poolStep }],
  ["↺ 처음으로", () => { mutable poolPlaying = false; mutable poolStep = 0; return 0 }]
])
poolPlayer = {
  if (!poolPlaying) return false
  while (poolPlaying && poolStep < 3) { await Promises.delay(1000); mutable poolStep = poolStep + 1; yield true }
  mutable poolPlaying = false; return false
}

{
  const cs = 44, gap = 3, st = poolSteps[poolStep];
  const W = 520, H = 230;
  const svg = d3.create("svg").attr("viewBox", `0 0 ${W} ${H}`).attr("width", "100%").style("max-width", `${W}px`).style("font-family", "Pretendard, sans-serif");
  svg.append("text").attr("x", 20 + 2 * (cs + gap)).attr("y", 18).attr("text-anchor", "middle").attr("font-size", "12").attr("font-weight", "600").attr("fill", "#555").text("입력 특성 맵 (4×4)");
  for (let r = 0; r < 4; r++) for (let c = 0; c < 4; c++) {
    const on = Math.floor(r / 2) === st.r && Math.floor(c / 2) === st.c, isMax = on && poolIn[r][c] === st.max;
    svg.append("rect").attr("x", 20 + c * (cs + gap)).attr("y", 30 + r * (cs + gap)).attr("width", cs).attr("height", cs).attr("rx", 3)
      .attr("fill", isMax ? "#FFCDD2" : on ? "#FFF9C4" : "#C8E6C9").attr("stroke", isMax ? "#C62828" : on ? "#F57F17" : "#4CAF50").attr("stroke-width", on ? 2.5 : 1);
    svg.append("text").attr("x", 20 + c * (cs + gap) + cs / 2).attr("y", 30 + r * (cs + gap) + cs / 2 + 5).attr("text-anchor", "middle").attr("font-size", "15").attr("font-weight", isMax ? "700" : "400").attr("fill", isMax ? "#C62828" : "#333").text(poolIn[r][c]);
  }
  svg.append("text").attr("x", 250).attr("y", 30 + 2 * (cs + gap)).attr("text-anchor", "middle").attr("font-size", "12").attr("fill", "#555").text("2×2 Max →");
  svg.append("text").attr("x", 340 + (cs + gap)).attr("y", 18).attr("text-anchor", "middle").attr("font-size", "12").attr("font-weight", "600").attr("fill", "#555").text("출력 (2×2)");
  for (let r = 0; r < 2; r++) for (let c = 0; c < 2; c++) {
    const idx = r * 2 + c, done = idx <= poolStep, cur = r === st.r && c === st.c;
    svg.append("rect").attr("x", 340 + c * (cs + gap)).attr("y", 30 + (cs + gap) + r * (cs + gap)).attr("width", cs).attr("height", cs).attr("rx", 3)
      .attr("fill", cur ? "#FFCDD2" : done ? "#FFEBEE" : "#fafafa").attr("stroke", cur ? "#C62828" : done ? "#E57373" : "#ccc").attr("stroke-width", cur ? 2.5 : 1);
    if (done) svg.append("text").attr("x", 340 + c * (cs + gap) + cs / 2).attr("y", 30 + (cs + gap) + r * (cs + gap) + cs / 2 + 5).attr("text-anchor", "middle").attr("font-size", "15").attr("fill", cur ? "#C62828" : "#333").attr("font-weight", cur ? "700" : "400").text(poolSteps[idx].max);
  }
  svg.append("text").attr("x", W / 2).attr("y", H - 12).attr("text-anchor", "middle").attr("font-size", "12").attr("fill", "#8C1515").attr("font-weight", "600").text(`스텝 ${poolStep + 1}/4 — 창 안의 값 {${st.vals.join(", ")}} 중 최댓값 ${st.max}`);
  return svg.node();
}

채널이 여러 개일 때

풀링은 채널마다 따로 적용한다. \(14 \times 14 \times 6\) 특성 맵에 \(2 \times 2\) 풀링을 하면 여섯 장 각각이 \(7 \times 7\)이 되어 \(7 \times 7 \times 6\)이다. 크기는 절반이 되고 채널 수는 그대로다.

왜 풀링을 쓰는가

이미지의 크기를 줄여도 그 안의 특성은 크게 변하지 않는다. 건물 사진을 Max 풀링으로 계속 줄여 보자.

{
  const maxpool = m => { const n = m.length / 2; return Array.from({length: n}, (_, r) => Array.from({length: n}, (_, c) => Math.max(m[2*r][2*c], m[2*r][2*c+1], m[2*r+1][2*c], m[2*r+1][2*c+1]))) };
  const levels = [pool_img]; for (let i = 0; i < 3; i++) levels.push(maxpool(levels[levels.length - 1]));
  const wrap = d3.create("div").style("display", "flex").style("gap", "16px").style("justify-content", "center").style("align-items", "flex-end").style("flex-wrap", "wrap").style("font-family", "Pretendard, sans-serif");
  levels.forEach((m, i) => {
    const n = m.length, size = 192;
    const box = wrap.append("div").style("text-align", "center");
    const svg = box.append("svg").attr("viewBox", `0 0 ${n} ${n}`).attr("width", size).attr("height", size).attr("shape-rendering", "crispEdges").style("background", "#000").style("display", "block").style("margin", "0 auto");
    for (let r = 0; r < n; r++) for (let c = 0; c < n; c++) svg.append("rect").attr("x", c).attr("y", r).attr("width", 1).attr("height", 1).attr("fill", `rgb(${m[r][c]},${m[r][c]},${m[r][c]})`);
    box.append("div").style("font-size", "0.85em").style("margin-top", "0.3em").style("font-weight", "600").text(i === 0 ? `원본 ${n}×${n}` : `풀링 ${i}번 → ${n}×${n}`);
    box.append("div").style("font-size", "0.78em").style("color", "#777").text(`${(n * n).toLocaleString()}개 값`);
  });
  return wrap.node();
}

사진: Daniel Büchele, Flickr, CC BY 2.0

네 장을 같은 크기로 그려 비교했다. 값의 개수는 4,096 → 1,024 → 256 → 64로 줄었지만 건물의 윤곽과 밝은 벽, 어두운 지붕은 그대로 남아 있다. 풀링을 쓰는 이유는 세 가지다.

이미지 크기를 줄여도 특성은 크게 변하지 않는다
다음 층에 들어가는 값이 줄어 연산이 효율적이다
작은 위치 차이를 뭉갠다. \(2 \times 2\) 창 안에서 패턴이 한 칸 움직여도 최댓값은 같으므로 출력이 변하지 않는다. 축약 과정을 통해 변동(variance)이 줄어드는 효과다

풀링에는 학습 파라미터가 없다

풀링은 “최댓값을 고른다”는 고정된 규칙일 뿐, 학습되는 가중치가 없다. 파라미터를 셀 때 풀링 층은 0으로 센다.

완전연결 층 (Fully Connected Layer)

CNN의 마지막이다. 콘볼루션과 풀링을 거친 특성 맵은 아직 3차원이다. 이것을 펼쳐서(Flatten) 1차원으로 만들고, 2~3장의 완전연결 신경망에 넣어 분류한다.

마지막 특성 맵이 \(3 \times 3\)이라면

\[\begin{bmatrix} 1 & 0 & 2 \\ 4 & 6 & 1 \\ 3 & 1 & 5 \end{bmatrix} \xrightarrow{\ \text{Flatten}\ } \begin{bmatrix} 1 & 0 & 2 & 4 & 6 & 1 & 3 & 1 & 5 \end{bmatrix}\]

이 벡터가 입력노드 9개가 되어 완전연결 층으로 들어간다. 출력층은 3장 그대로다. 클래스 수만큼 노드를 두고 Softmax로 확률을 만들고, 교차 엔트로피로 손실을 계산한다.

5장에서 이미지를 통째로 펼치면 파라미터가 폭발한다고 했다. 여기서는 콘볼루션과 풀링으로 충분히 작아진 특성 맵을 펼치므로 다르다. 얼마나 다른지는 다음 절에서 센다.

정리: CNN의 일반적인 구조

층 이름이 다 나왔다. 처음 그림을 층 이름으로 다시 읽으면 다음과 같다.

순서	층	하는 일	크기 변화	파라미터
①	콘볼루션	커널로 특성 맵 추출	조금 줄거나 유지, 채널 수 = 커널 개수	커널마다 \(K \times K \times C + 1\)
②	ReLU	음수를 0으로	그대로	0
③	풀링	크기 축소	절반, 채널 유지	0
	①~③ 반복
④	펼치기	3차원 → 1차원	\(H \times W \times C\)개 노드	0
⑤	완전연결	분류	노드 수 → 클래스 수	\(n_{\text{in}} \times n_{\text{out}} + n_{\text{out}}\)
⑥	Softmax	확률	그대로	0

CNN 연산 연습

크기와 파라미터를 따라가 보자. 규칙은 두 개다. 앞 장의 출력 크기 공식 \(\lfloor (N-K+2P)/S \rfloor + 1\)과, 커널 하나의 파라미터 \(K \times K \times C + 1\).

연습 1 — 콘볼루션 세 번

\(39 \times 39 \times 3\) 이미지에 콘볼루션 세 층을 적용한다.

층	커널 크기	스트라이드	패딩	커널 수	출력 크기
입력	—	—	—	—	39 × 39 × 3
Conv1	3	1	0	10	37 × 37 × 10
Conv2	5	2	0	20	17 × 17 × 20
Conv3	5	2	0	40	7 × 7 × 40
Flatten	—	—	—	—	1,960

크기.

Conv1: \(\lfloor (39 - 3)/1 \rfloor + 1 = 37\). 커널 10개 → \(37 \times 37 \times 10\)
Conv2: \(\lfloor (37 - 5)/2 \rfloor + 1 = 17\). 커널 20개 → \(17 \times 17 \times 20\)
Conv3: \(\lfloor (17 - 5)/2 \rfloor + 1 = 7\). 커널 40개 → \(7 \times 7 \times 40\)
펼치기: \(7 \times 7 \times 40 = 1{,}960\)개

커널의 차원. 커널의 채널 수는 들어오는 특성 맵의 채널 수와 같다.

Conv1 커널 1개: \(3 \times 3 \times 3\) (입력 채널 3)
Conv2 커널 1개: \(5 \times 5 \times 10\) (Conv1의 출력 채널 10)
Conv3 커널 1개: \(5 \times 5 \times 20\) (Conv2의 출력 채널 20)

파라미터.

층	커널 1개	커널 수	층 전체
Conv1	\(3 \times 3 \times 3 + 1 = 28\)	10	\(280\)
Conv2	\(5 \times 5 \times 10 + 1 = 251\)	20	\(5{,}020\)
Conv3	\(5 \times 5 \times 20 + 1 = 501\)	40	\(20{,}040\)
특성 학습부 합계			\(25{,}340\)

분류기까지. 펼친 1,960개를 은닉 100 노드에 연결하고, 10개 클래스로 분류한다.

부분	계산	파라미터
Conv1 + Conv2 + Conv3	위 표	\(25{,}340\)
FC1 (1,960 → 100)	\(1{,}960 \times 100 + 100\)	\(196{,}100\)
FC2 (100 → 10)	\(100 \times 10 + 10\)	\(1{,}010\)
전체		\(222{,}450\)

콘볼루션 세 층을 합쳐도 25,340개인데 FC 한 층이 196,100개, 전체의 88%다. 특성 학습부는 파라미터를 아끼지만, 펼친 뒤의 완전연결 층에 파라미터가 몰린다. 이 관찰은 아키텍처 절에서 다시 만난다.

연습 2 — 콘볼루션과 풀링 반복

\(32 \times 32 \times 3\) 이미지에 콘볼루션과 풀링을 번갈아 적용한다.

층	커널 크기	스트라이드	패딩	커널 수	출력 크기
입력	—	—	—	—	32 × 32 × 3
Conv1	5	1	0	6	28 × 28 × 6
Pool1	2	2	—	—	14 × 14 × 6
Conv2	5	1	0	10	10 × 10 × 10
Pool2	2	2	—	—	5 × 5 × 10
Flatten	—	—	—	—	250

Conv1: \(\lfloor (32-5)/1 \rfloor + 1 = 28\), 커널 6개 → \(28 \times 28 \times 6\). 커널 차원 \(5 \times 5 \times 3\)
Pool1: 절반 → \(14 \times 14 \times 6\). 채널 유지
Conv2: \(\lfloor (14-5)/1 \rfloor + 1 = 10\), 커널 10개 → \(10 \times 10 \times 10\). 커널 차원 \(5 \times 5 \times 6\)
Pool2: 절반 → \(5 \times 5 \times 10\)
펼치기: \(250\)개

✍️ 직접 해보기 — 연습 2의 파라미터 수

펼친 250개는 은닉 120 노드, 다시 84 노드, 마지막 10 클래스로 이어진다. 정답을 보기 전에 손으로 먼저 세라.

Conv1: \((5 \times 5 \times 3 + 1) \times 6 = 456\). Pool1: \(0\). Conv2: \((5 \times 5 \times 6 + 1) \times 10 = 1{,}510\). Pool2: \(0\). FC1: \(250 \times 120 + 120 = 30{,}120\). FC2: \(120 \times 84 + 84 = 10{,}164\). FC3: \(84 \times 10 + 10 = 850\). 전체 \(\mathbf{43{,}100}\)개. 이번에도 완전연결 층이 95%다.

종합 연습: 층을 바꾸며 크기 따라가기

입력 크기와 각 층의 설정을 바꾸면 특성 맵의 크기가 층마다 어떻게 변하는지 확인할 수 있다. 연습 1·2의 값을 넣어 위 표와 맞는지 확인해 보자.

viewof cnn_input = Inputs.range([8, 128], {value: 32, step: 1, label: "입력 크기 (N×N)"})
viewof cnn_ch = Inputs.range([1, 3], {value: 3, step: 1, label: "입력 채널 수"})
viewof k1 = Inputs.range([1, 7], {value: 5, step: 2, label: "Conv1 커널 크기"})
viewof f1 = Inputs.range([1, 32], {value: 6, step: 1, label: "Conv1 커널 수"})
viewof pool1_size = Inputs.range([1, 4], {value: 2, step: 1, label: "Pool1 크기"})
viewof k2 = Inputs.range([1, 7], {value: 5, step: 2, label: "Conv2 커널 크기"})
viewof f2 = Inputs.range([1, 64], {value: 16, step: 1, label: "Conv2 커널 수"})
viewof pool2_size = Inputs.range([1, 4], {value: 2, step: 1, label: "Pool2 크기"})

cnn_calc = {
  const n0 = cnn_input;
  const c0 = cnn_ch;

  // Conv1 (stride=1, padding=0)
  const n1 = Math.floor((n0 - k1) / 1) + 1;
  const c1 = f1;
  const valid1 = n1 > 0;

  // Pool1
  const n2 = valid1 ? Math.floor(n1 / pool1_size) : 0;
  const c2 = c1;
  const valid2 = n2 > 0;

  // Conv2 (stride=1, padding=0)
  const n3 = valid2 ? Math.floor((n2 - k2) / 1) + 1 : 0;
  const c3 = f2;
  const valid3 = n3 > 0;

  // Pool2
  const n4 = valid3 ? Math.floor(n3 / pool2_size) : 0;
  const c4 = c3;
  const valid4 = n4 > 0;

  // Flatten
  const flat = valid4 ? n4 * n4 * c4 : 0;

  return {n0, c0, n1, c1, n2, c2, n3, c3, n4, c4, flat,
          valid1, valid2, valid3, valid4};
}

html`<svg viewBox="0 0 820 260" xmlns="http://www.w3.org/2000/svg" style="width:100%;max-width:820px;display:block;margin:0 auto;font-family:sans-serif;">
<defs>
<marker id="ahc" markerWidth="7" markerHeight="5" refX="7" refY="2.5" orient="auto"><path d="M0,0 L7,2.5 L0,5 Z" fill="#888"/></marker>
</defs>
<!-- Input -->
<rect x="5" y="60" width="100" height="70" rx="8" fill="#8C1515" opacity="0.12" stroke="#8C1515" stroke-width="1.5"/>
<text x="55" y="85" text-anchor="middle" font-size="12" font-weight="700" fill="#8C1515">입력</text>
<text x="55" y="105" text-anchor="middle" font-size="11" fill="#333">${cnn_calc.n0}×${cnn_calc.n0}×${cnn_calc.c0}</text>
<text x="55" y="122" text-anchor="middle" font-size="9" fill="#888">${cnn_calc.n0*cnn_calc.n0*cnn_calc.c0} values</text>
<line x1="105" y1="95" x2="128" y2="95" stroke="#888" stroke-width="1" marker-end="url(#ahc)"/>
<!-- Conv1 -->
<rect x="130" y="50" width="100" height="90" rx="8" fill="${cnn_calc.valid1 ? '#1F3F7A' : '#cc0000'}" opacity="0.12" stroke="${cnn_calc.valid1 ? '#1F3F7A' : '#cc0000'}" stroke-width="1.5"/>
<text x="180" y="75" text-anchor="middle" font-size="12" font-weight="700" fill="#1F3F7A">Conv1+ReLU</text>
<text x="180" y="95" text-anchor="middle" font-size="10" fill="#555">${k1}×${k1}, ${f1}개</text>
<text x="180" y="115" text-anchor="middle" font-size="11" fill="${cnn_calc.valid1 ? '#333' : '#cc0000'}">${cnn_calc.valid1 ? cnn_calc.n1+'×'+cnn_calc.n1+'×'+cnn_calc.c1 : '오류!'}</text>
<text x="180" y="132" text-anchor="middle" font-size="9" fill="#888">${cnn_calc.valid1 ? 'kernel: '+k1+'×'+k1+'×'+cnn_calc.c0 : ''}</text>
<line x1="230" y1="95" x2="253" y2="95" stroke="#888" stroke-width="1" marker-end="url(#ahc)"/>
<!-- Pool1 -->
<rect x="255" y="60" width="90" height="70" rx="8" fill="#D4A017" opacity="0.15" stroke="#D4A017" stroke-width="1.5"/>
<text x="300" y="85" text-anchor="middle" font-size="12" font-weight="700" fill="#9A7B00">Pool1</text>
<text x="300" y="100" text-anchor="middle" font-size="10" fill="#555">${pool1_size}×${pool1_size}</text>
<text x="300" y="118" text-anchor="middle" font-size="11" fill="${cnn_calc.valid2 ? '#333' : '#cc0000'}">${cnn_calc.valid2 ? cnn_calc.n2+'×'+cnn_calc.n2+'×'+cnn_calc.c2 : '—'}</text>
<line x1="345" y1="95" x2="368" y2="95" stroke="#888" stroke-width="1" marker-end="url(#ahc)"/>
<!-- Conv2 -->
<rect x="370" y="50" width="100" height="90" rx="8" fill="${cnn_calc.valid3 ? '#1F3F7A' : '#cc0000'}" opacity="0.12" stroke="${cnn_calc.valid3 ? '#1F3F7A' : '#cc0000'}" stroke-width="1.5"/>
<text x="420" y="75" text-anchor="middle" font-size="12" font-weight="700" fill="#1F3F7A">Conv2+ReLU</text>
<text x="420" y="95" text-anchor="middle" font-size="10" fill="#555">${k2}×${k2}, ${f2}개</text>
<text x="420" y="115" text-anchor="middle" font-size="11" fill="${cnn_calc.valid3 ? '#333' : '#cc0000'}">${cnn_calc.valid3 ? cnn_calc.n3+'×'+cnn_calc.n3+'×'+cnn_calc.c3 : '오류!'}</text>
<text x="420" y="132" text-anchor="middle" font-size="9" fill="#888">${cnn_calc.valid3 ? 'kernel: '+k2+'×'+k2+'×'+cnn_calc.c2 : ''}</text>
<line x1="470" y1="95" x2="493" y2="95" stroke="#888" stroke-width="1" marker-end="url(#ahc)"/>
<!-- Pool2 -->
<rect x="495" y="60" width="90" height="70" rx="8" fill="#D4A017" opacity="0.15" stroke="#D4A017" stroke-width="1.5"/>
<text x="540" y="85" text-anchor="middle" font-size="12" font-weight="700" fill="#9A7B00">Pool2</text>
<text x="540" y="100" text-anchor="middle" font-size="10" fill="#555">${pool2_size}×${pool2_size}</text>
<text x="540" y="118" text-anchor="middle" font-size="11" fill="${cnn_calc.valid4 ? '#333' : '#cc0000'}">${cnn_calc.valid4 ? cnn_calc.n4+'×'+cnn_calc.n4+'×'+cnn_calc.c4 : '—'}</text>
<line x1="585" y1="95" x2="608" y2="95" stroke="#888" stroke-width="1" marker-end="url(#ahc)"/>
<!-- Flatten + FC -->
<rect x="610" y="55" width="90" height="80" rx="8" fill="#8C1515" opacity="0.08" stroke="#8C1515" stroke-width="1"/>
<text x="655" y="80" text-anchor="middle" font-size="12" font-weight="700" fill="#8C1515">Flatten</text>
<text x="655" y="100" text-anchor="middle" font-size="13" font-weight="700" fill="${cnn_calc.valid4 ? '#333' : '#cc0000'}">${cnn_calc.valid4 ? cnn_calc.flat.toLocaleString() : '—'}</text>
<text x="655" y="118" text-anchor="middle" font-size="9" fill="#888">${cnn_calc.valid4 ? cnn_calc.n4+'×'+cnn_calc.n4+'×'+cnn_calc.c4 : ''}</text>
<line x1="700" y1="95" x2="723" y2="95" stroke="#888" stroke-width="1" marker-end="url(#ahc)"/>
<!-- Softmax -->
<rect x="725" y="65" width="80" height="60" rx="8" fill="#D4A017" opacity="0.2" stroke="#D4A017" stroke-width="1.5"/>
<text x="765" y="90" text-anchor="middle" font-size="12" font-weight="700" fill="#9A7B00">Softmax</text>
<text x="765" y="108" text-anchor="middle" font-size="9" fill="#555">분류</text>
<!-- Labels -->
<text x="300" y="220" text-anchor="middle" font-size="13" font-weight="700" fill="#1F3F7A">Feature Learning</text>
<line x1="130" y1="205" x2="470" y2="205" stroke="#1F3F7A" stroke-width="2" opacity="0.4"/>
<text x="655" y="220" text-anchor="middle" font-size="13" font-weight="700" fill="#8C1515">Classification</text>
<line x1="610" y1="205" x2="805" y2="205" stroke="#8C1515" stroke-width="2" opacity="0.4"/>
</svg>`

콘볼루션 연산의 특징

크기와 파라미터를 다 셌으니, 콘볼루션이 완전연결과 무엇이 다른지 두 가지로 정리한다.

가중치 공유 (Weight Sharing)

같은 가중치(커널)를 이미지의 여러 부분에 적용하는 것. 커널이 이미지를 훑는 동안 커널 안의 값은 바뀌지 않는다.

\(5 \times 5\) 이미지에 \(3 \times 3\) 커널을 적용하면 출력은 9개다. 25개 입력에서 9개 출력을 만드는 데 필요한 파라미터를 비교한다.

방식	25 입력 → 9 출력	파라미터
완전연결	출력 노드 9개가 각각 입력 25개와 연결, 편향 9개	\((25 + 1) \times 9 = 234\)
콘볼루션	커널 9개 값 + 편향 1개를 9곳에 공유	\(9 + 1 = 10\)

같은 일을 23배 적은 파라미터로 한다. 이미지가 커질수록 차이는 더 벌어진다.

이동 불변성 (Shift Invariance)

이미지 속 글자 X가 왼쪽에 있든 오른쪽에 있든, 조금 기울어져 있든, 사람은 같은 X로 안다. 우리가 이미지를 인식할 때 중요한 것은 특성의 존재 여부이고, 특성이 어느 위치에 있는지는 크게 중요하지 않다.

이동 불변성 (Shift Invariance)

특성이 이미지의 어느 위치에 있어도 같은 방식으로 포착되는 성질. 커널이 유용한 특성을 표현하고 있다면, 그 특성이 이미지의 어느 부분에 있어도 같은 커널이 잡아낸다. 가중치 공유의 결과다.

5장에서 완전연결 신경망은 같은 무늬가 다른 위치에 오면 알아보지 못했다. 콘볼루션은 커널이 모든 위치를 지나가므로 위치가 달라도 같은 값을 낸다. 풀링이 여기에 더해져, 창 안의 작은 이동은 출력에 나타나지도 않게 된다. 5장이 요구한 “위치가 달라도 같은 특성을 같은 방법으로 찾는 연산”이 콘볼루션과 풀링의 조합이다.

CNN 아키텍처의 발전

딥러닝 아키텍처 (Architecture)

딥러닝 신경망을 구성하는 특정한 패턴. 층을 어떤 종류, 어떤 순서, 어떤 크기로 쌓는가를 정한 설계다. 컴퓨터 비전의 CNN은 1998년 LeNet-5에서 출발했다. 이후의 모델들은 같은 구조를 더 크고 깊게 쌓은 것이다.

LeNet-5 (1998)

콘볼루션 → 풀링 → 콘볼루션 → 풀링 → 펼치기 → 완전연결. 손글씨 숫자 인식에 쓰인 최초의 CNN이다. 연습 2의 신경망이 이 구조다.

특성 맵은 층을 지날수록 작아지고(32 → 28 → 14 → 10 → 5) 두꺼워진다(3 → 6 → 10). 콘볼루션이 특성을 뽑고 풀링이 크기를 줄이는 일을 두 번 반복한 뒤, \(5 \times 5 \times 10\)을 250개로 펼쳐 완전연결 층에 넣는다. 파라미터는 특성 추출부 1,966개, 분류부 41,134개다. 연습 1·2에서 본 대로 완전연결 층에 파라미터가 몰린다.

객체탐지

객체탐지는 컴퓨터 비전에서 가장 성공적이고 가장 널리 쓰이는 응용이다. 지금까지의 CNN은 이미지 한 장을 받아 그것이 무엇인지를 클래스 하나로 답했다. 제조 라인의 검사 카메라에는 그것으로 부족하다. 불량이 있는지가 아니라 어느 부품에 있는지를 알아야 골라낼 수 있다. 자율주행의 카메라도 보행자가 있는지가 아니라 어디에 있는지를 알아야 멈춘다. 무엇이 어디에 있는지를 찾는 것이 객체탐지다.

객체탐지 (Object Detection)

이미지 안의 물체마다 위치(바운딩 박스)와 종류(클래스)를 함께 찾는 작업.

이미지 한 장에 물체가 여럿일 수 있으므로 탐지는 물체마다 답을 하나씩 낸다. 그 답에 무엇이 들어가야 하는지부터 정한다.

추가되는 출력

분류 CNN의 출력은 클래스 확률 \(K\)개였다. 탐지는 물체마다 둘을 더 낸다. 물체가 어디에 있는지를 나타내는 바운딩 박스와, 그 박스 안 사물이 무엇인지를 나타내는 클래스다.

바운딩 박스 (Bounding Box)

물체를 둘러싸는 최소 크기의 직사각형. 두 가지로 적는다.

모서리 표기 \((x_1, y_1, x_2, y_2)\): 왼쪽 위 모서리와 오른쪽 아래 모서리
중심 표기 \((x_c, y_c, w, h)\): 중심 좌표와 너비·높이

\[x_c = \frac{x_1 + x_2}{2}, \quad y_c = \frac{y_1 + y_2}{2}, \quad w = x_2 - x_1, \quad h = y_2 - y_1\]

위치는 이렇게 숫자 넷으로 적힌다. 클래스는 분류와 같이 확률 \(K\)개다. 여기에 하나가 더 필요하다. 신경망은 물체가 있을 만한 자리마다 박스를 내놓는데, 그 자리에 정말 물체가 있는지를 따로 말해야 한다.

신뢰도 (Confidence)

예측한 박스 안에 물체가 있을 확률. 출력 묶음 하나는 {바운딩 박스, 클래스, 신뢰도}다.

분류의 출력은 이미지마다 \(K\)개로 정해져 있다. 탐지의 출력은 이 묶음이 물체 수만큼 나오므로 이미지마다 개수가 다르다. 물체가 없으면 0개다. 출력의 형태가 정해졌으니 학습에 쓸 정답도 같은 형태여야 한다.

레이블링

레이블 (Label)

학습 데이터의 이미지마다 사람이 적어 둔 정답. 탐지의 레이블은 물체마다 바운딩 박스와 클래스다.

분류의 레이블은 이미지마다 클래스 번호 하나였다. 탐지의 레이블은 출력과 같은 형태로 만든다. 사람이 이미지 위에 물체마다 사각형을 그리고 클래스를 붙인다. 레이블 파일에는 물체 하나가 한 줄이고, 한 줄은 클래스와 박스 네 숫자다.

레이블과 출력이 같은 형태이므로 학습은 둘을 비교하는 일이 된다. 클래스는 3장의 교차 엔트로피로 비교한다. 박스는 어떻게 비교하는가.

IoU

예측 박스가 정답 박스와 얼마나 가까운지를 숫자 하나로 재야 한다. 두 박스가 겹치는 비율로 잰다.

IoU (Intersection over Union)

두 박스의 교집합 넓이를 합집합 넓이로 나눈 값.

\[\text{IoU} = \frac{A \cap B}{A \cup B} = \frac{A \cap B}{A + B - A \cap B}\]

완전히 일치하면 1, 전혀 겹치지 않으면 0이다.

읽는 법: 분자는 두 박스가 함께 덮은 부분이고, 분모는 둘 중 하나라도 덮은 부분이다. 겹침이 같아도 박스가 크면 분모가 커져 IoU는 작아진다.

그림의 칸을 세어 계산한다. 정답 박스가 초록, 예측 박스가 파랑이다.

정답 박스 12칸, 예측 박스 12칸, 겹침 4칸이다. 합집합은 \(12 + 12 - 4 = 20\)칸이고, IoU는 \(4 / 20 = 0.20\)이다.

✍️ 직접 해보기

정답 박스가 가로 4칸, 세로 4칸이고, 예측 박스가 같은 크기로 오른쪽 아래로 2칸씩 밀려 있다. IoU는? 정답을 보기 전에 손으로 먼저 계산하라.

겹침 \(2 \times 2 = 4\)칸, 합집합 \(16 + 16 - 4 = 28\)칸, IoU \(= 4 / 28 = \mathbf{0.14}\).

IoU는 두 곳에서 쓰인다. 학습에서는 박스의 오차로, 출력에서는 박스를 정리하고 판정하는 기준으로 쓰인다. 차례로 본다.

학습에서의 IoU

학습은 3장과 같다. 출력과 레이블의 차이로 손실을 만들고, 손실을 줄이는 방향으로 가중치를 갱신한다. 클래스 부분의 손실은 교차 엔트로피다. 박스 부분의 손실은 예측 박스와 정답 박스의 IoU에서 나온다. IoU가 1이면 오차가 0이고 겹침이 줄수록 오차가 커지므로, 손실을 줄이는 갱신은 예측 박스를 정답 박스 쪽으로 옮긴다. 에폭이 지날수록 IoU가 올라간다.

출력에서의 IoU

학습이 끝난 신경망에 이미지를 넣으면 물체 하나에 비슷한 박스가 여러 개 나온다. 물체 근처의 자리마다 박스를 내놓기 때문이다. 이 박스들이 같은 물체를 가리키는지를 IoU로 판단해 하나만 남긴다.

NMS (Non-Maximum Suppression, 비최대 억제)

겹치는 예측 박스 중 신뢰도가 가장 높은 것만 남기고 나머지를 제거하는 절차.

남은 박스 중 신뢰도가 가장 높은 박스를 채택한다
채택한 박스와 IoU가 0.5 이상인 박스를 모두 제거한다
남은 박스가 없을 때까지 1~2를 반복한다

B1을 채택하고 B1과 겹치는 B2, B3을 제거한다. B4를 채택하고 B4와 겹치는 B5를 제거한다. 출력은 B1, B4다.

남은 박스가 맞았는지의 판정에도 IoU를 쓴다. 예측 박스와 정답 박스의 IoU가 0.5 이상이고 클래스가 같으면 맞은 예측이다. 이 기준으로 세는 정밀도와 재현율, 그리고 탐지 모델의 학습은 심화 자료 9장에서 다룬다.

핵심 요약

개념	핵심 내용
CNN 구조	콘볼루션 → ReLU → 풀링 반복 → 펼치기 → 완전연결 → Softmax
ReLU	\(\max(0, u)\). 음수를 0으로 지워 두드러지는 특징만 남긴다
풀링	사이즈 2·스트라이드 2·Max. 크기 절반, 채널 유지, 파라미터 0
완전연결 층	작아진 특성 맵을 펼쳐 분류. Softmax + 교차 엔트로피
크기·파라미터 계산	\(\lfloor (N-K+2P)/S \rfloor + 1\), 커널 \(K \times K \times C + 1\), 풀링 0, FC \(n_{\text{in}} n_{\text{out}} + n_{\text{out}}\)
가중치 공유	같은 커널을 모든 위치에. 25→9에서 234개 vs 10개
이동 불변성	특성이 어디 있어도 같은 커널이 잡아낸다. 풀링이 작은 이동을 더 무시
LeNet-5	콘볼루션·풀링 두 번 → 펼치기 → 완전연결. 연습 2의 구조. 파라미터 95%가 FC
객체탐지	분류 출력에 바운딩 박스·클래스·신뢰도를 더 낸다. 레이블은 물체마다 박스와 클래스. 박스의 오차는 IoU = 교집합/합집합. 학습에서는 박스 손실, 출력에서는 NMS와 판정 기준 0.5

다음 장 예고: 학습한 CNN의 정확도를 높이는 전략(데이터 증강, 사전 학습 모델)과 시맨틱 분할을 다룬다.