P5-11.2 합성곱(convolution)과 풀링(pooling)¶

Section ID: P5-11.2 Version: v2026.07.20

P5-11.1에서는 CNN을 이미지의 지역 패턴을 반복해서 읽는 신경망으로 설명했습니다. 이제 다음 질문이 남습니다.

그 지역 패턴을 실제로 계산하는 핵심 연산은 무엇이며, 풀링(pooling)은 왜 자주 함께 등장하는가?

합성곱(convolution)은 작은 필터로 지역 패턴 점수를 계산하는 연산이고, 풀링(pooling)은 그 결과를 더 작고 요약된 형태로 정리하는 연산이다.

연산 이름이 다시 섞이면 개념사전의 합성곱(convolution)과 풀링(pooling) 항목을 함께 다시 보는 편이 좋습니다.

합성곱과 풀링이 닫아야 할 질문¶

• convolution은 무엇을 계산하는가?
• 필터(filter)와 feature map은 무엇을 뜻하는가?
• pooling은 왜 쓰이며, 무엇을 줄이는가?
• 두 연산이 함께 있을 때 CNN의 표현 흐름은 어떻게 읽히는가?

이 절에서는 convolution 수식을 엄밀히 증명하기보다, CNN이 지역 패턴을 점수화하고 그 반응을 요약하는 흐름을 먼저 닫는 데 집중합니다.

대신 이번 절에서 바로 더 넓히지 않을 질문도 분명합니다. CNN 이후의 vision 구조 비교는 보충학습 P5-11.3에서 CNN과 Vision Transformer(ViT) 중심으로 다시 회수합니다. padding, stride, dilation은 이 절에서 필터가 입력을 읽는 방식을 이해하는 데 필요한 만큼만 다룹니다.

지역 반응과 요약 흐름의 판단 기준¶

• convolution을 작은 필터가 지역 패턴 점수를 계산하는 연산으로 설명할 수 있습니다.
• feature map을 필터 반응의 공간적 기록으로 설명할 수 있습니다.
• pooling이 왜 공간 크기를 줄이고 중요한 반응을 요약하는 데 쓰이는지 말할 수 있습니다.
• 실행 가능한 Python 예제로 합성곱과 최대 풀링(max pooling)의 직관을 확인할 수 있습니다.

필터 반응에서 풀링 요약까지¶

1. convolution이 지역 패턴 점수를 어떻게 계산하는지 먼저 봅니다.
2. 그 결과가 feature map이라는 반응 지도로 남는다는 점을 봅니다.
3. pooling이 그 반응을 어떻게 더 작고 요약된 형태로 넘기는지 봅니다.
4. convolution과 pooling이 한 흐름으로 어떻게 이어지는지 정리합니다.
5. 마지막에 padding, stride, dilation이 이 흐름의 읽는 방식을 어떻게 바꾸는지 다시 봅니다.

convolution은 무엇을 하나¶

합성곱(convolution)은 작은 필터(filter)를 이미지 여러 위치에 움직이며, 그 위치가 특정 패턴과 얼마나 잘 맞는지 점수화합니다.

핵심은 필터가 찾고 싶은 작은 패턴을 들고 이미지 각 위치를 훑으며 반응 점수를 만드는 데 있습니다.

• 필터는 찾고 싶은 작은 패턴 템플릿처럼 볼 수 있고
• 이미지의 각 지역 패치와 곱셈/덧셈을 해
• 그 위치의 반응 점수를 만듭니다

즉, convolution은 이미지 전체를 한 번에 판단하지 않고, 작은 패턴 탐지기를 전체 위치에 반복 적용하는 방식입니다.

필터(filter)는 무엇을 뜻하나¶

필터는 보통 작은 숫자 배열입니다. 예를 들어 3x3 필터는 3x3 지역 패치를 볼 수 있습니다.

필터는 edge, 방향, 질감, 작은 모양 같은 패턴에 반응하도록 학습되는 작은 가중치 묶음이다.

CNN이 학습되면 이런 필터 값들도 데이터에 맞게 바뀝니다. 즉, 사람이 직접 모든 필터를 설계하는 것이 아니라, 모델이 어떤 필터가 유용한지를 함께 학습합니다.

feature map은 무엇인가¶

필터 하나를 이미지 전체에 적용하면, 각 위치에서 얼마나 강하게 반응했는지를 담은 새로운 2차원 배열이 나옵니다. 이것을 feature map이라고 부릅니다.

즉:

• 입력 이미지 위에서
• 필터를 위치마다 적용하고
• 그 반응값을 기록한 결과가

feature map입니다.

핵심은 feature map이 특정 필터의 반응이 이미지 어디에서 얼마나 강했는지를 위치별로 기록한 결과라는 점입니다.

feature map은 특정 필터가 이미지의 어디에서 얼마나 강하게 반응했는지를 기록한 지도(map)이다.

독자는 여기서 다음 구분을 같이 잡으면 좋습니다.

pooling은 왜 필요한가¶

convolution 결과를 그대로 계속 쌓기만 하면 공간 크기가 계속 크고 계산량도 많아질 수 있습니다. 또, 모든 세부 위치 정보를 끝까지 그대로 들고 가는 것이 항상 좋은 것도 아닙니다.

pooling은 이런 정보를 더 요약된 형태로 줄이는 역할을 합니다.

예를 들어 max pooling은 작은 구역 안에서 가장 큰 반응만 남깁니다.

pooling은 세부 위치 정보를 조금 줄이는 대신, 중요한 반응을 더 압축해서 다음 층으로 넘기는 방식이다.

왜 max pooling이 직관적인가¶

max pooling은 작은 창 안에서 가장 큰 값 하나를 고릅니다. 이 방식은 독자에게 다음 직관을 줍니다.

• 그 구역에서 가장 강한 패턴 반응이 무엇인지 남긴다
• 작은 위치 변화에는 덜 민감해질 수 있다
• 공간 크기를 줄여 계산을 압축한다

즉, max pooling은 가장 눈에 띄는 신호를 남기는 요약으로 읽으면 좋습니다.

이 차이를 더 짧게 비교하면 다음과 같습니다.

같은 이미지 장면을 두 단계로 나눠 보면 차이가 더 직접 보입니다.

convolution과 pooling은 함께 어떻게 읽히나¶

둘을 아주 단순하게 이어 보면 다음과 같습니다.

flowchart TD
  A["input image"]
  B["convolution<br/>detect local pattern"]
  C["feature map"]
  D["pooling<br/>summarize response"]
  E["smaller feature map"]

  A --> B
  B --> C
  C --> D
  D --> E

이 도식은 찾는다 -> 기록한다 -> 요약한다라는 세 동작을 보여 줍니다.

1. convolution이 먼저 지역 패턴을 찾습니다.
2. feature map이 그 반응을 위치별로 기록합니다.
3. pooling이 그 기록을 더 작고 요약된 형태로 넘깁니다.

이 흐름은 실제 검사 장면과 숫자 배열을 함께 놓고 보면 더 쉽게 읽힙니다. 아래 예시는 실링 가장자리에서 좌우 열분포 차이가 커지는 작은 검사 패치를 단순화한 것입니다.

이 입력 위에 좌우 열 차이에 반응하는 2x2 필터를 얹는다고 생각해 보겠습니다.

필터를 한 칸씩 움직이며 계산하면 다음처럼 feature map이 생깁니다.

같은 변환을 한 단계씩 나누어 보면 다음처럼 읽을 수 있습니다.

입력 패치는 아직 사람이 보는 작은 열분포 장면에 가깝습니다. 왼쪽의 높은 값과 오른쪽의 낮은 값이 함께 놓여 있지만, 이 단계에서는 어디가 경계인가가 점수로 분리되어 있지는 않습니다.

convolution을 지나면 각 위치가 필터와 얼마나 잘 맞는지에 대한 반응 지도로 바뀝니다. 여기서는 좌우 열 차이가 실제로 생기는 가운데 위치에서만 값 4가 반복되어, 입력 장면이 경계 반응의 위치 지도로 바뀐 것입니다.

max pooling은 이 반응 지도 전체를 그대로 넘기지 않고, 작은 구역 안에서 가장 강한 반응만 남깁니다. 이 단계에서 달라지는 것은 세부 위치보다 강한 경계 반응이 있었다는 요약 신호가 다음 층으로 넘어간다는 점입니다.

이 숫자를 읽을 때 핵심은 다음과 같습니다.

• 0은 필터가 기대한 좌우 차이가 거의 없는 위치입니다.
• 4는 필터가 찾던 열분포 경계가 강하게 잡힌 위치입니다.
• max pooling 뒤의 [[4]]는 세부 위치를 줄이더라도 실링 경계 변화가 강한 구역이 있었다는 요점을 남깁니다.

즉, 작은 검사 패치는 사람이 보는 장면을 붙잡아 주고, 행렬 샘플은 convolution과 pooling이 실제로 어떤 숫자 요약을 만드는지 보여 줍니다.

이 흐름은 CNN이:

• 먼저 패턴을 찾고
• 그 반응을 기록한 뒤
• 더 압축된 형태로 다음 층에 넘긴다는 점

을 보여 줍니다.

즉, convolution은 지역 패턴을 점수화하고, pooling은 그 점수를 다음 층이 읽기 쉬운 형태로 더 작게 넘깁니다.

여기서 다음 절의 ViT 비교로 넘어가기 전에, CNN이 실제로 무엇을 계산 단위로 삼는지 한 번 더 짧게 고정하면 다음처럼 볼 수 있습니다.

flowchart TD
  A["같은 설비 이미지"]
  B["작은 local window가 겹치며 이동"]
  C["각 위치에서 지역 반응 점수 계산"]
  D["강한 반응이 feature map에 기록"]
  E["다음 층이 더 큰 구조를 읽을 기준선"]

  A --> B --> C --> D --> E

이 기준선 도식에서 먼저 붙잡아야 할 점은 다음과 같습니다.

• CNN의 첫 계산 단위는 이미지 전체가 아니라 겹치며 이동하는 작은 local window입니다.
• 각 window에서 먼저 만드는 것은 이 위치가 필터 패턴과 얼마나 잘 맞는가라는 지역 반응 점수입니다.
• 그래서 다음 절에서 ViT의 patch token을 볼 때도, 작은 창을 훑는 방식과 잘라 둔 patch를 읽는 방식을 같은 입력 위에서 비교할 수 있게 됩니다.

CNN을 Part 5나 Transformer 이전의 과거 구조로만 읽으면 이미지용 옛 모델 이름처럼 보이기 쉽습니다. 하지만 Part 5에서 CNN이 맡는 책임은 이미 여기서 닫힙니다. 즉, CNN은 이미지에서 지역 패턴을 어떻게 탐지하고 요약할 것인가에 대한 자체 답을 가진 구조이며, 뒤 Part는 이 답을 대체하는 자리가 아니라 다른 데이터 구조 문제를 다루는 자리로만 이어지면 충분합니다.

padding, stride, dilation은 무엇을 뜻하나¶

이 절의 중심은 convolution과 pooling이지만, 바로 앞에서 이름이 나온 padding, stride, dilation도 최소한의 뜻은 여기서 잡고 가는 편이 좋습니다.

세 용어는 모두 필터가 입력 위를 어떻게 읽는가를 조정합니다.

세 선택의 차이는 다음과 같습니다.

• padding은 가장자리 바깥에 여백을 더하는 선택입니다.
• stride는 필터의 이동 보폭을 정하는 선택입니다.
• dilation은 필터 내부 칸 사이 간격을 벌려 보는 선택입니다.

이 차이를 같은 입력을 읽는 세 방식으로 압축하면 다음과 같습니다.

flowchart TD
  A["같은 입력 이미지"]

  subgraph P["Padding"]
    P1["가장자리에 여백 추가"]
    P2["가장자리 정보를 더 오래 본다"]
  end

  subgraph S["Stride"]
    S1["필터를 더 큰 보폭으로 이동"]
    S2["출력 크기를 더 빨리 줄인다"]
  end

  subgraph D["Dilation"]
    D1["필터 칸 사이 간격을 벌림"]
    D2["큰 커널 없이 더 넓게 본다"]
  end

  A --> P1
  P1 --> P2
  A --> S1
  S1 --> S2
  A --> D1
  D1 --> D2

이 도식에서 먼저 확인할 결과는, 셋 모두 필터가 무엇을 찾는가를 바꾸기보다 입력을 어떻게 훑을 것인가를 다르게 만든다는 점입니다.

이 절에서는 세 용어를 공식으로 전개하지는 않지만, 뒤의 convolution 설명을 읽을 때는 필터의 내용, 필터의 이동 방식, 필터가 덮는 범위를 조정하는 장치로 먼저 잡아 두면 됩니다. 아래 작은 장면은 그 차이를 바로 보여 줍니다.

먼저 같은 1차원 줄을 읽는다고 상상해 보겠습니다.

1
2

input = [A B C D E]
filter size = 3

이때 세 용어는 각각 다른 질문에 답합니다.

• padding: 양끝에 여백을 둘까?
• stride: 몇 칸씩 움직일까?
• dilation: 필터 칸 사이를 붙여 읽을까, 띄워 읽을까?

즉, 셋 모두 convolution 자체를 바꾸기보다 어떻게 훑을 것인가를 바꾸는 선택입니다.

padding은 왜 필요한가¶

padding이 없으면 필터는 입력 가장자리 바깥으로 나갈 수 없기 때문에, 가장자리 근처 정보는 상대적으로 덜 읽히기 쉽습니다.

예를 들어 3x3 필터를 5x5 이미지에 그대로 움직이면, 필터 중심은 바깥 테두리보다 안쪽에서만 안정적으로 움직입니다. 이때 바깥 가장자리의 작은 선이나 모서리는 덜 반영될 수 있습니다.

padding은 이 바깥에 여백을 한 겹 더 두는 방식입니다.

• 여백이 없으면 가장자리에서 바로 끝납니다.
• 여백이 있으면 가장자리 근처도 한 번 더 읽을 자리가 생깁니다.

즉, padding은 가장자리 근처도 한 번 더 읽을 자리를 만들어, 가장자리 정보를 너무 빨리 잃지 않게 하는 장치입니다.

아주 짧은 줄 예시로 쓰면 다음과 같습니다.

1
2

padding 없음:   [A B C] [B C D] [C D E]
padding 있음: [0 A B] [A B C] [B C D] [C D E] [D E 0]

여기서 핵심은 가장자리도 계산 기회가 생긴다는 점입니다.

stride는 무엇을 바꾸나¶

stride는 필터가 한 번에 몇 칸씩 움직일지를 정합니다.

아주 단순하게 보면:

• stride가 1이면 한 칸씩 움직이며 촘촘히 읽습니다.
• stride가 2면 두 칸씩 건너뛰며 더 성기게 읽습니다.

예를 들어 4칸짜리 줄 위를 2칸 크기 필터가 읽는다고 할 때:

• stride 1이면 [1-2], [2-3], [3-4]처럼 겹치며 읽습니다.
• stride 2면 [1-2], [3-4]처럼 크게 건너뛰며 읽습니다.

즉, stride는 얼마나 촘촘하게 훑을 것인가를 정하는 선택입니다. stride가 커질수록 출력 크기는 더 빨리 줄고, 계산도 더 거칠게 요약됩니다.

이미지에서 이 말을 다시 읽으면 다음과 같습니다.

• stride 1: 거의 모든 위치를 빠짐없이 본다
• stride 2: 한 칸씩 보지 않고 더 성기게 본다

즉, stride를 키우면 출력은 빨리 줄어들지만 세부 위치 차이는 덜 보게 됩니다.

dilation은 왜 따로 이름이 붙나¶

dilation은 필터 칸 사이 간격을 벌려, 필터 크기를 크게 키우지 않고도 더 넓은 범위를 보게 합니다.

예를 들어 3칸 필터를 그대로 붙여 보면 바로 옆 칸끼리 읽습니다. 하지만 dilation을 주면 첫 칸, 한 칸 건너뛴 칸, 또 한 칸 건너뛴 칸처럼 더 멀리 떨어진 위치를 함께 읽을 수 있습니다.

즉, dilation은:

• 파라미터 수를 크게 늘리지 않고
• 더 넓은 receptive field를 보고 싶을 때
• 필터 내부 간격을 벌리는 선택

즉, dilation은 파라미터 수를 크게 늘리지 않고 필터 내부 간격을 벌려 더 넓은 receptive field를 보게 하는 선택입니다.

1차원 줄 예시로 보면 차이는 더 단순합니다.

1
2

dilation 없음: [A B C]
dilation 있음: [A _ C _ E]처럼 떨어진 위치를 함께 읽음

즉, 필터 칸 수는 그대로 두되, 한 번에 보는 범위만 넓히는 방식입니다.

세 용어를 다시 한 줄로 묶으면 다음과 같습니다.

입문 단계에서는 다음 질문으로 다시 확인하면 충분합니다.

• padding: 가장자리도 더 읽게 만들고 싶은가?
• stride: 더 촘촘히 볼까, 더 크게 건너뛸까?
• dilation: 필터 크기를 키우지 않고 더 넓게 보고 싶은가?

작은 숫자 예제로 세 차이를 같이 보면¶

말로만 보면 세 용어가 비슷하게 느껴질 수 있으니, 아주 작은 5x5 입력 위에서 같은 3x3 필터를 읽는 장면으로 다시 묶어 보겠습니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

input
1 0 0 0 1
0 1 0 1 0
0 0 1 0 0
0 1 0 1 0
1 0 0 0 1

filter
1 0 1
0 1 0
1 0 1

이때 독자가 먼저 볼 것은 필터 값 자체보다 어느 위치 묶음을 한 번에 읽는가입니다.

즉, 세 설정은 모두 필터가 무엇을 찾는가보다 필터를 어떤 간격과 범위로 움직일 것인가를 바꾸는 장치입니다.

설정 차이를 먼저 보는 작은 예제¶

이번 작은 예제의 목표는 padding, stride, dilation이 출력 크기와 읽는 위치를 어떻게 바꾸는지 눈으로 확인하는 것입니다. 합성곱 값 전체를 외우는 것이 아니라, 같은 필터라도 스캔 방식이 달라지면 출력 모양과 읽는 패치가 함께 바뀐다는 점을 잡는 데 목적이 있습니다.

코드를 읽기 전에 아래 세 값부터 순서대로 보면 이 절의 구조 차이가 덜 흩어집니다.

입력:

• 5x5 실링 검사 패치
• 3x3 필터
• 서로 다른 padding, stride, dilation 설정

출력:

• 설정별 출력 행렬 shape
• 첫 번째 위치에서 실제로 읽은 patch
• 설정별 convolution 결과

문제 상황:

• padding, stride, dilation은 이름은 비슷해 보여도 필터가 이미지를 읽는 범위를 다르게 만든다

확인할 개념:

• convolution 설정은 결과 shape와 실제 patch 범위를 함께 바꾼다
• 첫 위치 patch와 최종 결과를 같이 보면 각 설정 차이가 더 잘 드러난다

입력(input):

위에 정리한 입력 이미지, 필터, 여러 padding·stride·dilation 설정을 사용합니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

# padding, stride, dilation 설정이 convolution 출력 shape와 첫 patch, 결과값을 어떻게 바꾸는지 비교하는 예제입니다.
import numpy as np

image = np.array([
    [1, 0, 0, 0, 1],
    [0, 1, 0, 1, 0],
    [0, 0, 1, 0, 0],
    [0, 1, 0, 1, 0],
    [1, 0, 0, 0, 1],
], dtype=float)

kernel = np.array([
    [1, 0, 1],
    [0, 1, 0],
    [1, 0, 1],
], dtype=float)

def conv2d(image, kernel, padding=0, stride=1, dilation=1):
    padded = np.pad(image, padding, mode="constant", constant_values=0)
    kernel_h, kernel_w = kernel.shape
    effective_h = kernel_h + (kernel_h - 1) * (dilation - 1)
    effective_w = kernel_w + (kernel_w - 1) * (dilation - 1)
    out_h = ((padded.shape[0] - effective_h) // stride) + 1
    out_w = ((padded.shape[1] - effective_w) // stride) + 1
    output = np.zeros((out_h, out_w))

    first_patch = None
    for out_i in range(out_h):
        for out_j in range(out_w):
            row = out_i * stride
            col = out_j * stride
            sampled = padded[
                row:row + effective_h:dilation,
                col:col + effective_w:dilation,
            ]
            if first_patch is None:
                first_patch = sampled.copy()
            output[out_i, out_j] = np.sum(sampled * kernel)

    return output, first_patch

settings = [
    ("base", 0, 1, 1),
    ("padding=1", 1, 1, 1),
    ("stride=2", 0, 2, 1),
    ("dilation=2", 0, 1, 2),
]

for name, padding, stride, dilation in settings:
    result, first_patch = conv2d(
        image=image,
        kernel=kernel,
        padding=padding,
        stride=stride,
        dilation=dilation,
    )
    print(f"[{name}]")
    print("shape =", result.shape)
    print("first_patch =")
    print(first_patch)
    print("result =")
    print(result)

출력에서는 result의 shape, 첫 patch, 그리고 최종 result 값이 어떻게 연결되는지 순서대로 보면 됩니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

[base]
shape = (3, 3)
first_patch =
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
result =
[[3. 0. 3.]
 [0. 5. 0.]
 [3. 0. 3.]]
[padding=1]
shape = (5, 5)
first_patch =
[[0. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
result =
[[2. 0. 2. 0. 2.]
 [0. 3. 0. 3. 0.]
 [2. 0. 5. 0. 2.]
 [0. 3. 0. 3. 0.]
 [2. 0. 2. 0. 2.]]
[stride=2]
shape = (2, 2)
first_patch =
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
result =
[[3. 3.]
 [3. 3.]]
[dilation=2]
shape = (1, 1)
first_patch =
[[1. 0. 1.]
 [0. 1. 0.]
 [1. 0. 1.]]
result =
[[5.]]

이 결과에서 먼저 읽을 점은 다음과 같습니다.

• padding=1은 출력이 5x5로 유지되며 가장자리도 계산 대상에 남깁니다.
• stride=2는 필터가 두 칸씩 건너뛰므로 출력이 2x2로 빠르게 줄어듭니다.
• dilation=2는 3x3 필터가 실제로는 더 넓은 5x5 범위를 띄엄띄엄 읽게 만듭니다.

즉, 세 용어는 모두 convolution을 다른 연산으로 바꾸는 것이 아니라, 같은 convolution이 어떤 범위와 간격으로 입력을 읽을지를 바꾸는 선택입니다.

사례 및 예시¶

대표 사례. edge detection 직관¶

흰 배경 위에 검은 선이 지나가는 이미지를 생각해 보겠습니다. 사람은 이런 장면을 볼 때 선이 어디에 있나를 먼저 눈으로 찾습니다. 하지만 컴퓨터가 원본 픽셀 숫자만 그대로 보면, 어느 값 변화가 선이고 어느 값 변화가 단순 잡음인지 바로 구분하기 어렵습니다. 예를 들어 선이 한 픽셀 옆으로 조금만 이동해도, 원본 숫자 배열만 보면 완전히 다른 값처럼 보일 수 있습니다. 필터는 바로 이런 밝기 변화가 큰 위치에서 강하게 반응하도록 만들 수 있습니다. 그러면 feature map에는 선이나 경계가 있는 자리가 더 큰 값으로 나타나고, 모델은 어디에 구조가 있는가를 숫자로 읽기 시작합니다. 그래서 이 사례에서 확인해야 할 결과는 원본 픽셀값 전체를 보는 대신, 경계가 있는 위치가 convolution 반응에서 실제로 먼저 크게 살아나고 그 반응이 다음 단계 판단의 출발점이 되는가입니다.

같은 관점은 설비 장면 이미지나 의료 이미지·산업 비전에도 그대로 이어집니다. 다만 이 절에서 붙잡을 핵심은 도메인 이름이 아니라, convolution이 어디서 먼저 큰 국소 반응을 만들고 pooling이 그 반응을 어떻게 다음 단계까지 남기는가입니다.

세 사례를 같이 놓고 보면 convolution과 pooling을 연산 이름 두 개보다 어디서 반응을 만들고 무엇을 남길 것인가를 나누는 한 흐름으로 읽어야 하는 이유가 더 분명해집니다.

세 사례를 한 줄로 다시 묶으면 다음과 같습니다.

연습 및 예제¶

이번 예제의 목표는 포장 실링(seal) 표면을 스캔하는 자동 검사 장면에서, convolution이 어디에 이상 경계가 생겼는가를 먼저 점수화하고 pooling이 그 이상 신호를 다음 단계에도 남기는가를 어떻게 보여 주는지 확인하는 것입니다.

코드를 읽기 전에, 이번 예제에서 실제로 봐야 할 값은 세 가지입니다.

입력:

• 정상 실링 열분포를 단순화한 5x5 스캔 행렬
• 실링 일부가 약해져 경계가 갑자기 흔들린 5x5 스캔 행렬
• 좌우 변화에 반응하는 2x2 필터

출력:

• 정상/약한 실링의 convolution 결과
• 정상/약한 실링의 max pooling 결과
• 가장 큰 이상 반응이 남는 위치와 크기

문제 상황:

• 생산 라인의 자동 검사에서는 이미지 전체 평균보다 작은 경계 이상 하나가 재검사나 라인 점검의 출발점이 될 수 있다

확인할 개념:

• convolution은 위치별 지역 반응을 만들어 어디가 이상한가를 먼저 드러낸다
• max pooling은 지역 반응을 압축하더라도 가장 큰 이상 신호를 남긴다
• 정상 장면과 이상 장면을 나란히 비교해야 무엇이 달라졌는가가 더 잘 보인다

코드를 보기 전에, 정상 실링과 약한 실링에서 어떤 값이 먼저 갈라질지 예상해 보면 좋습니다.

입력(input):

위에 정리한 정상 실링(normal_seal)과 약한 실링(weak_seal) 스캔 행렬을 사용합니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

# 정상 실링과 약한 실링에서 convolution 지역 반응과 max pooling 뒤에 남는 가장 큰 이상 신호를 비교하는 예제입니다.
normal_seal = [
    [2, 2, 2, 2, 2],
    [2, 3, 3, 3, 2],
    [2, 3, 4, 3, 2],
    [2, 3, 3, 3, 2],
    [2, 2, 2, 2, 2],
]

weak_seal = [
    [2, 2, 2, 2, 2],
    [2, 3, 3, 3, 2],
    [2, 3, 6, 2, 1],
    [2, 3, 4, 2, 1],
    [2, 2, 2, 2, 2],
]

kernel = [
    [1, -1],
    [1, -1],
]


def convolve_2x2(image, kernel):
    out = []
    for i in range(len(image) - 1):
        row = []
        for j in range(len(image[0]) - 1):
            score = 0
            for di in range(2):
                for dj in range(2):
                    score += image[i + di][j + dj] * kernel[di][dj]
            row.append(float(score))
        out.append(row)
    return out


def max_pool_2x2(feature_map):
    pooled = []
    for i in range(0, len(feature_map) - 1, 2):
        row = []
        for j in range(0, len(feature_map[0]) - 1, 2):
            block = [
                feature_map[i][j],
                feature_map[i][j + 1],
                feature_map[i + 1][j],
                feature_map[i + 1][j + 1],
            ]
            row.append(float(max(block)))
        pooled.append(row)
    return pooled


normal_conv = convolve_2x2(normal_seal, kernel)
weak_conv = convolve_2x2(weak_seal, kernel)
normal_pool = max_pool_2x2(normal_conv)
weak_pool = max_pool_2x2(weak_conv)

print("normal_conv =", normal_conv)
print("normal_pool =", normal_pool)
print("weak_conv =", weak_conv)
print("weak_pool =", weak_pool)
print("weak seal max response =", max(max(row) for row in weak_conv))

출력에서는 정상 실링과 약한 실링의 반응 차이, 그리고 pooling 뒤에도 가장 큰 이상 신호가 남는지를 순서대로 보면 됩니다.

1
2
3
4
5

normal_conv = [[-1.0, 0.0, 0.0, 1.0], [-2.0, -1.0, 1.0, 2.0], [-2.0, -1.0, 1.0, 2.0], [-1.0, 0.0, 0.0, 1.0]]
normal_pool = [[0.0, 2.0], [0.0, 2.0]]
weak_conv = [[-1.0, 0.0, 0.0, 1.0], [-2.0, -3.0, 4.0, 2.0], [-2.0, -4.0, 6.0, 2.0], [-1.0, -1.0, 2.0, 1.0]]
weak_pool = [[0.0, 4.0], [-1.0, 6.0]]
weak seal max response = 6.0

출력 숫자를 읽을 때도 어디서 반응을 만들었는가와 그 반응 중 무엇이 살아남았는가를 분리해서 봐야 합니다.

• convolution은 각 위치 패치를 읽어 이상 경계 점수를 만듭니다
• 그 점수들이 모인 결과가 feature map이고, weak_conv에서 특정 위치가 갑자기 커진 것이 핵심입니다
• pooling은 정보를 줄이지만, 재검사에 중요한 큰 반응은 그대로 남길 수 있습니다

즉, 이 예제는 이미지 전체가 대체로 비슷해 보여도, 실링 가장자리 일부에서 경계 반응이 급격히 커지면 재검사해야 한다는 운영 장면을 보여 줍니다. convolution과 pooling을 함께 보는 이유는 단순히 계산 순서를 외우기 위해서가 아니라, 어떤 국소 이상이 다음 단계까지 살아남는가를 이해하기 위해서입니다.

CNN 교육에서 convolution과 pooling은 거의 항상 함께 소개됩니다. 이유는 이 둘이 CNN의 핵심 계산 흐름을 가장 압축적으로 보여 주기 때문입니다.

역사적으로도 LeNet, AlexNet 같은 구조를 통해 convolution 기반 지역 패턴 탐지와 pooling 기반 요약이 이미지 인식의 기본 직관으로 널리 퍼졌습니다. 이후 구조는 더 다양해졌지만, 입문 단계에서는 여전히 가장 중요한 기본 축입니다.

여기서 한 번 멈추고, 언제 연산 이름 자체보다 어떻게 훑고 무엇을 남기는가를 먼저 읽어야 하는가를 짧게 고정해 두면 다음 순차 데이터 장으로 넘어가기 전에 CNN 계산 감각이 덜 흩어집니다.

체크리스트¶

• 합성곱(convolution)과 풀링(pooling)이 각각 무엇을 계산하는지 설명할 수 있는가?
• 지역 패턴 읽기와 요약이 왜 함께 등장하는지 말할 수 있는가?
• convolution은 작은 필터로 지역 패턴 점수를 계산하는 연산이라는 점을 설명할 수 있는가?
• feature map은 필터 반응이 공간적으로 기록된 결과라는 점을 말할 수 있는가?
• pooling을 크기 줄이기 정도로만 말하지 않고, 강한 반응을 요약해 다음 층으로 넘기는 역할로 설명할 수 있는가?
• CNN은 지역 패턴 탐지와 요약을 반복하며 표현을 쌓아 간다는 점을 설명할 수 있는가?
• 연산 이름은 알지만 이미지 위를 어떻게 훑고 무엇을 남기는지가 흐릴 때, convolution·pooling 관점을 먼저 떠올릴 수 있는가?
• padding, stride, dilation이 모두 필터를 어떻게 훑을 것인가를 바꾸는 선택이라는 점을 말할 수 있는가?

출처와 참고 자료¶

• Yann LeCun et al., Gradient-Based Learning Applied to Document Recognition, Proceedings of the IEEE, 1998, 확인 날짜: 2026-07-19. https://doi.org/10.1109/5.726791
• Ian Goodfellow, Yoshua Bengio, Aaron Courville, Deep Learning, MIT Press, 2016, 확인 날짜: 2026-06-29. https://www.deeplearningbook.org/
• Alex Krizhevsky, Ilya Sutskever, Geoffrey E. Hinton, ImageNet Classification with Deep Convolutional Neural Networks, NeurIPS 2012, 확인 날짜: 2026-07-19. https://papers.nips.cc/paper/2012/hash/c399862d3b9d6b76c8436e924a68c45b-Abstract.html