콘텐츠로 이동
Search

RF-DETR:Tutorial:04-DeepLearningBasics

lastmod 2026-11-18created 2026-11-1818 edits

딥러닝 기초와 분류 손실은 RF-DETR 튜토리얼의 4장이다. 2 · 3장에서 박스를 재고 탐지기를 채점하는 법을 배웠으니, 탐지기를 만들기 전에 뒤 장들이 설명 없이 쓰는 딥러닝 부품을 한 번 정리한다. 선형 층과 활성 함수(ReLU · GELU · SiLU), 역전파 손계산과 autograd, SGD → Adam → AdamW, 정규화 층(배치 · 층 정규화), 잔차 연결, 합성곱은 짧게 훑고, 분류 손실(시그모이드 · 로짓, 베르누이 최대우도에서 유도한 BCE 와 그 기울기 \(p - y\), 수치 안정 형태, 부드러운 목표, 소프트맥스 + 배경 클래스와 클래스별 시그모이드의 차이, 포컬 손실, 사전 확률 편향 초기화)은 유도를 한 줄도 빼지 않고 따라간다. 7 · 9 · 11장에 나오는 탐지기의 손실이 모두 이 장의 식을 조금씩 바꾼 것이기 때문이다. 장 끝에서는 도형 세상에서 양성이 0.6% 뿐인 분류 문제를 세 가지 설정으로 학습해 비교한다.

이 장을 읽는 법

신경망 · 미분 · 역전파 · 합성곱을 처음부터 길게 설명한 글은 World Model 튜토리얼의 4장 “딥러닝과 PyTorch 기초” 에 있다. 이 장은 그 글을 읽지 않아도 따라올 수 있게 꼭 필요한 만큼 다시 설명하되, 같은 내용은 짧게 줄이고 탐지기에 필요한 분류 손실에 분량을 쓴다. 이미 딥러닝에 익숙하다면 “분류 ① 시그모이드와 로짓” 부터 읽어도 된다.

신경망은 매개변수를 가진 함수다

신경망(neural network)은 입력 \(x\) 를 받아 출력을 내는 함수 \(f_\theta(x)\) 이다. 아래 첨자 \(\theta\)(세타)는 함수 안에 들어 있는 조절 가능한 숫자들, 곧 매개변수(parameter)를 한데 묶어 부르는 이름이다. 탐지기라면 \(x\) 는 그림이고 출력은 “박스들과 클래스 점수들” 이다. RF-DETR (nano) 의 \(\theta\) 는 숫자 약 3,050만 개다(논문 표 2). 학습이란 출력이 정답에 가까워지도록 \(\theta\) 를 조금씩 고치는 일이고, 이 장의 앞 절반은 그 “고치는 방법” 을 다룬다.

선형 층과 모양 계산

신경망의 가장 작은 부품은 선형 층(linear layer, fully connected layer)이다. 숫자 \(n\) 개짜리 벡터 \(x\) 를 받아 숫자 \(m\) 개짜리 벡터 \(h\) 를 낸다.

\(h = Wx + b, \qquad x \in \mathbb{R}^{n},\quad W \in \mathbb{R}^{m \times n},\quad b \in \mathbb{R}^{m},\quad h \in \mathbb{R}^{m}\)

\(W\) 는 가중치 행렬(\(m\) 행 \(n\) 열), \(b\) 는 편향 벡터다. \(h\) 의 \(i\) 번째 숫자는 “\(W\) 의 \(i\) 번째 행과 \(x\) 를 같은 자리끼리 곱해 더하고, \(b_i\) 를 더한 값” 이다. 매개변수는 \(W\) 의 \(m \times n\) 개와 \(b\) 의 \(m\) 개, 모두 \(mn + m\) 개다.

손계산 — 숫자 3개를 받아 2개를 내는 선형 층
\(W = \begin{pmatrix} 1 & 0 & -1 \\ 2 & 1 & 0 \end{pmatrix},\quad x = \begin{pmatrix} 1 \\ 2 \\ 3 \end{pmatrix},\quad b = \begin{pmatrix} 0.5 \\ -1 \end{pmatrix}\)
\(n = 3\), \(m = 2\) 이므로 \(W\) 는 2행 3열이다. 매개변수는 \(2 \times 3 + 2 = 8\) 개.
\(h_1 = 1 \cdot 1 + 0 \cdot 2 + (-1) \cdot 3 + 0.5 = -1.5\)
\(W\) 의 첫 행 \((1, 0, -1)\) 과 \(x\) 를 곱해 더하고 \(b_1 = 0.5\) 를 더했다.
\(h_2 = 2 \cdot 1 + 1 \cdot 2 + 0 \cdot 3 + (-1) = 3\)
둘째 행 \((2, 1, 0)\) 과 \(x\) 를 곱해 더하고 \(b_2 = -1\) 을 더했다.
\(h = (-1.5,\ 3)\)
모양으로 적으면 \((3,) \to (2,)\) 이다.

PyTorch 의 nn.Linear(n, m) 은 입력의 마지막 축에만 이 계산을 하고 앞의 축들은 그대로 둔다. 그래서 입력이 (B, n) 이면 출력은 (B, m), 입력이 (B, N, n) 이면 출력은 (B, N, m) 이다. 예를 들어 RF-DETR 의 분류 머리는 nn.Linear(256, 클래스 수) 하나다(10장). 그림 B 장마다 300개의 예측 자리가 있고 자리마다 256차원 벡터가 있으므로, 클래스가 80개라면 모양은 (B, 300, 256) → (B, 300, 80) 이고 매개변수는 \(256 \times 80 + 80 = 20{,}560\) 개다. 이 (B, 300, 80) 칸 하나하나가 이 장 뒤쪽의 주인공이다.

활성 함수: ReLU · GELU · SiLU

선형 층만 여러 번 쌓으면 아무리 쌓아도 결국 선형 층 하나와 같다. \(W_2(W_1 x + b_1) + b_2 = (W_2 W_1)x + (W_2 b_1 + b_2)\) 이기 때문이다. 그래서 층 사이에 직선이 아닌 함수, 곧 활성 함수(activation function)를 숫자마다 따로 적용해 끼워 넣는다. 이 튜토리얼에서 만날 활성 함수는 셋이다.

이름

식

\(x = -1\) 일 때

\(x = 1\) 일 때

RF-DETR 에서 쓰이는 곳

ReLU(rectified linear unit)

\(\max(0, x)\)

\(0\)

\(1\)

디코더의 FFN (5장, 10장)

GELU(Gaussian error linear unit)

\(x \cdot \Phi(x)\)

\(-0.1587\)

\(0.8413\)

ViT(DINOv2) 백본의 FFN (6장)

SiLU(sigmoid linear unit, Swish)

\(x \cdot \sigma(x)\)

\(-0.2689\)

\(0.7311\)

프로젝터의 C2f 블록 (9장)

\(\Phi(x)\)(파이)는 표준 정규 분포의 누적 분포 함수, 곧 “평균 0 · 표준편차 1 인 종 모양 분포에서 뽑은 수가 \(x\) 이하일 확률” 이다(\(\Phi(0) = 0.5\), \(\Phi(1) = 0.8413\)). \(\sigma(x) = 1/(1 + e^{-x})\) 는 뒤에서 자세히 다룰 시그모이드다(\(\sigma(1) = 0.7311\)). 두 함수 모두 0 에서 1 로 부드럽게 올라가는 곡선이므로, GELU 와 SiLU 는 “\(x\) 를 얼마나 통과시킬지를 \(x\) 자신이 정하는” 부드러운 ReLU 라고 볼 수 있다.

def relu(x: torch.Tensor) -> torch.Tensor:
    """ReLU(x) = max(0, x). 음수는 0 으로, 양수는 그대로."""
    return torch.clamp(x, min=0.0)

def gelu(x: torch.Tensor) -> torch.Tensor:
    """GELU(x) = x · Φ(x). Φ 는 표준 정규 분포의 누적 분포 함수: Φ(x) = (1 + erf(x / √2)) / 2."""
    return x * 0.5 * (1.0 + torch.erf(x / math.sqrt(2.0)))

def silu(x: torch.Tensor) -> torch.Tensor:
    """SiLU(x) = x · σ(x). σ 는 시그모이드. Swish 라고도 부른다."""
    return x * torch.sigmoid(x)
  • 그림: 그림 4-1 세 활성 함수(왼쪽)와 그 도함수(오른쪽). 실선 ReLU, 파선 GELU, 일점쇄선 SiLU.

그림 4-1 에서 읽을 것은 세 가지다.

  • 큰 양수에서는 셋이 거의 같다. \(x = 3\) 에서 ReLU 3, GELU 2.9960, SiLU 2.8577 이다.
  • 0 근처에서 다르다. ReLU 는 0 에서 꺾이고, 음수 쪽 도함수가 정확히 0 이다. 입력이 음수인 동안에는 그 자리로 기울기가 전혀 흐르지 않는다. GELU 와 SiLU 는 꺾이지 않고 매끄럽게 이어지며, 음수 쪽에서 살짝 아래로 내려갔다가(최솟값은 GELU 가 \(x = -0.7518\) 에서 \(-0.1700\), SiLU 가 \(x = -1.2785\) 에서 \(-0.2785\)) 0 으로 돌아온다.
  • 도함수가 1 을 조금 넘는 구간이 있다(오른쪽 그림). GELU · SiLU 가 음수 쪽에서 내려갔다 올라오느라 생기는 모양이고, 문제될 것은 없다.

어느 것이 더 좋은지는 구조와 데이터에 따라 달라서, 이 튜토리얼은 “원래 모델이 쓰는 것을 그대로 쓴다” 는 태도를 따른다.

이 장의 코드는 파일 하나(code/ch04_basics.py)이고, 한 번 실행하면 [1] 부터 [10] 까지의 결과가 차례로 출력된다. 아래부터는 그 출력을 해당하는 절에서 조각조각 보여 준다. 전체 실행은 8GB 노트북 GPU 를 다른 작업과 함께 쓰는 상태에서 5분 40초 걸렸고(대부분 장 끝의 [9] 실험), --quick 을 붙인 축소판은 약 20초다.

$ python ch04_basics.py
[1] 활성 함수: ReLU · GELU · SiLU
  x        -3.0000   -1.0000    0.0000    1.0000    3.0000
  ReLU      0.0000    0.0000    0.0000    1.0000    3.0000   | check: 내장과의 최대 차이 0.0e+00
  GELU     -0.0040   -0.1587    0.0000    0.8413    2.9960   | check: 내장과의 최대 차이 1.8e-07
  SiLU     -0.1423   -0.2689    0.0000    0.7311    2.8577   | check: 내장과의 최대 차이 2.4e-07
  GELU 의 최솟값 -0.1700 (x = -0.7518)
  SiLU 의 최솟값 -0.2785 (x = -1.2785)

직접 구현한 세 함수가 PyTorch 내장(F.relu, F.gelu, F.silu)과 반올림 오차(\(10^{-7}\), float32) 안에서 같고, 표와 위에서 말한 최솟값이 그대로 나온다.

MLP: 층을 쌓은 것

“선형 층 → 활성 함수 → 선형 층 → …” 으로 쌓은 신경망을 MLP(multi-layer perceptron, 다층 퍼셉트론)라고 부른다. 활성 함수를 \(\phi\)(파이)라고 쓰면 2층 MLP 는 다음과 같다.

\(f_\theta(x) = W_2\,\phi(W_1 x + b_1) + b_2, \qquad \theta = \{W_1, b_1, W_2, b_2\}\)

가운데 \(\phi(W_1 x + b_1)\) 은 밖에서 보이지 않는 중간 값이라 은닉 벡터라고 부른다. 뒤 장에서 MLP 는 두 가지 이름으로 나온다. Transformer 블록 안의 FFN(5장: 선형 층 둘 사이에 활성 함수 하나)과, 256차원 벡터에서 박스 좌표 4개를 뽑는 박스 머리(7장: 3층 MLP)이다.

손실과 경사 하강법

손실 함수와 기울기

신경망의 출력이 정답에서 얼마나 먼지를 숫자 하나로 잰 것이 손실 함수(loss function) \(L\) 이다. 작을수록 좋다. 데이터가 정해져 있으면 손실은 매개변수 \(\theta\) 만의 함수 \(L(\theta)\) 가 되고, 학습은 “\(L(\theta)\) 를 작게 만드는 \(\theta\) 찾기” 가 된다.

찾는 방법은 단순하다. 매개변수 하나하나에 대해 “이 숫자를 아주 조금 키우면 손실이 얼마나 변하는가” 를 구한다. 이것이 편미분 \(\frac{\partial L}{\partial \theta_i}\) 이고, 모든 매개변수의 편미분을 모은 벡터를 기울기 \(\nabla_\theta L\)(나블라)이라고 부른다. 기울기는 손실이 가장 빨리 커지는 방향을 가리키므로, 그 반대로 조금 움직이면 손실이 줄어든다.

\(\theta \leftarrow \theta - \eta\, \nabla_\theta L(\theta)\)

이것이 경사 하강법(gradient descent)이다. \(\eta\)(에타)는 한 번에 얼마나 움직일지 정하는 학습률(learning rate)이다. 너무 크면 골짜기를 건너뛰어 손실이 오히려 커지고, 너무 작으면 학습이 끝나지 않는다. RF-DETR 의 기본 학습률은 \(10^{-4}\) 이고, 사전 학습된 백본을 망가뜨리지 않으려고 일부러 작게 잡은 값이다(11장). 왜 기울기 반대 방향이 손실을 줄이는지, 학습률이 얼마를 넘으면 발산하는지의 유도는 World Model 튜토리얼 4장의 “경사 하강법” 절에 있다.

연쇄 법칙과 역전파 손계산

매개변수가 수천만 개인 신경망의 기울기를 어떻게 구할까? 도구는 고등학교에서 배운 합성 함수의 미분, 곧 연쇄 법칙(chain rule) 하나다. \(L\) 이 \(q\) 의 함수이고 \(q\) 가 \(r\) 의 함수이면

\(\frac{\partial L}{\partial r} = \frac{\partial L}{\partial q} \cdot \frac{\partial q}{\partial r}\)

이다. 말로 하면 “\(r\) 이 \(L\) 에 미치는 영향 = (\(q\) 가 \(L\) 에 미치는 영향) × (\(r\) 이 \(q\) 에 미치는 영향)” 이다. 신경망은 계산이 줄줄이 이어진 것이므로, 손실에서 출발해 거꾸로 한 칸씩 가면서 (뒤에서 받은 기울기) × (이 칸의 국소 미분) 을 넘겨주면 모든 매개변수의 기울기가 나온다. 입력에서 손실까지 값을 계산하는 것을 순전파(forward pass), 손실에서 거꾸로 기울기를 계산하는 것을 역전파(backpropagation)라고 부른다.

숫자가 하나씩만 흐르는 2층 신경망으로 직접 해 본다.

부분

식

값

입력 · 정답

\(x\), \(y\)

\(x = 2\), \(y = 1\)

1층

\(u = w_1 x + b_1\), \(h = \max(0, u)\)

\(w_1 = 0.5\), \(b_1 = 0.1\)

2층

\(\hat{y} = w_2 h + b_2\)

\(w_2 = -1.5\), \(b_2 = 0.2\)

손실

\(L = (\hat{y} - y)^2\)

\(\hat{y}\)(와이 햇)은 신경망의 예측, \(u\) 는 활성 함수에 들어가기 전의 값, \(h\) 는 은닉 값이다.

원문 그림 4-2 는 이 신경망의 계산 그래프다. 다섯 값 \(x \to u \to h \to \hat{y} \to L\) 이 왼쪽에서 오른쪽으로 이어지고, 화살표마다 \(\times w_1 + b_1\), ReLU, \(\times w_2 + b_2\), \((\hat{y} - y)^2\) 의 계산이 붙어 있다. 위쪽에는 순전파로 구한 값(\(x = 2\), \(u = 1.1\), \(h = 1.1\), \(\hat{y} = -1.45\), \(L = 6.0025\))이, 아래쪽에는 역전파로 구한 기울기(\(\partial L/\partial L = 1\), \(\partial L/\partial \hat{y} = -4.9\), \(\partial L/\partial h = 7.35\), \(\partial L/\partial u = 7.35\))가 적혀 있다. 화살표 아래에는 그 화살표에 들어 있는 매개변수의 기울기(\(\partial L/\partial w_1 = 14.7\), \(\partial L/\partial b_1 = 7.35\), \(\partial L/\partial w_2 = -5.39\), \(\partial L/\partial b_2 = -4.9\))가 있다. 순전파 값은 왼쪽에서 오른쪽으로, 역전파 기울기는 오른쪽에서 왼쪽으로 흐른다.

순전파 — 입력에서 손실까지
\(u = w_1 x + b_1 = 0.5 \cdot 2 + 0.1 = 1.1\)
1층의 선형 계산.
\(h = \max(0, u) = \max(0, 1.1) = 1.1\)
ReLU. \(u\) 가 양수이므로 그대로 통과한다.
\(\hat{y} = w_2 h + b_2 = -1.5 \cdot 1.1 + 0.2 = -1.45\)
2층의 선형 계산.
\(L = (\hat{y} - y)^2 = (-1.45 - 1)^2 = (-2.45)^2 = 6.0025\)
정답 1 에서 2.45 나 떨어져 있다.
역전파 — 손실에서 거꾸로, (받은 기울기) × (국소 미분)
\(\frac{\partial L}{\partial \hat{y}} = 2(\hat{y} - y) = 2 \cdot (-2.45) = -4.9\)
\(L = (\hat{y} - y)^2\) 을 \(\hat{y}\) 로 미분. 음수이므로 “\(\hat{y}\) 를 키우면 손실이 준다” 는 뜻이다.
\(\frac{\partial L}{\partial w_2} = \frac{\partial L}{\partial \hat{y}} \cdot \frac{\partial \hat{y}}{\partial w_2} = -4.9 \cdot h = -4.9 \cdot 1.1 = -5.39, \qquad \frac{\partial L}{\partial b_2} = -4.9 \cdot 1 = -4.9\)
\(\hat{y} = w_2 h + b_2\) 에서 \(\frac{\partial \hat{y}}{\partial w_2} = h\), \(\frac{\partial \hat{y}}{\partial b_2} = 1\). 2층의 매개변수 기울기가 나왔다.
\(\frac{\partial L}{\partial h} = \frac{\partial L}{\partial \hat{y}} \cdot \frac{\partial \hat{y}}{\partial h} = -4.9 \cdot w_2 = -4.9 \cdot (-1.5) = 7.35\)
같은 식에서 \(\frac{\partial \hat{y}}{\partial h} = w_2\). 이 값을 1층으로 넘겨준다.
\(\frac{\partial L}{\partial u} = \frac{\partial L}{\partial h} \cdot \frac{\partial h}{\partial u} = 7.35 \cdot 1 = 7.35\)
ReLU 의 미분은 \(u \gt 0\) 이면 1, \(u \lt 0\) 이면 0 이다. 여기서는 \(u = 1.1 \gt 0\) 이므로 1. 만약 \(u\) 가 음수였다면 여기서 기울기가 0 이 되어 1층은 아무것도 배우지 못한다.
\(\frac{\partial L}{\partial w_1} = \frac{\partial L}{\partial u} \cdot x = 7.35 \cdot 2 = 14.7, \qquad \frac{\partial L}{\partial b_1} = 7.35 \cdot 1 = 7.35\)
\(u = w_1 x + b_1\) 에서 \(\frac{\partial u}{\partial w_1} = x\), \(\frac{\partial u}{\partial b_1} = 1\). 네 매개변수의 기울기를 모두 구했다.

학습률 \(\eta = 0.01\) 로 경사 하강법을 한 번 적용하면 \(w_1 = 0.5 - 0.01 \cdot 14.7 = 0.353\), \(b_1 = 0.1 - 0.0735 = 0.0265\), \(w_2 = -1.5 + 0.0539 = -1.4461\), \(b_2 = 0.2 + 0.049 = 0.249\) 가 되고, 새 매개변수로 순전파를 다시 하면 손실이 \(6.0025 \to 3.2771\) 로 줄어든다.

autograd 와 대조하기

PyTorch 는 순전파를 하는 동안 어떤 계산을 했는지 기록해 두었다가, .backward() 한 줄로 위의 역전파를 대신 해 준다(autograd). 그래서 우리는 순전파만 적으면 된다. 위 손계산을 코드로 옮긴 것과 autograd 를 나란히 놓는다.

x, y = 2.0, 1.0  # 입력과 정답
w1, b1, w2, b2 = 0.5, 0.1, -1.5, 0.2  # 매개변수 네 개

# 순전파: 값을 왼쪽에서 오른쪽으로
u = w1 * x + b1  # 1층의 선형 계산
h = max(u, 0.0)  # ReLU
y_hat = w2 * h + b2  # 2층
loss = (y_hat - y) ** 2

# 역전파: 손실에서 거꾸로, (받은 기울기) × (국소 미분)
d_yhat = 2 * (y_hat - y)  # ∂L/∂ŷ
d_w2 = d_yhat * h  # ŷ = w2·h + b2 → ∂ŷ/∂w2 = h
d_b2 = d_yhat * 1.0  # ∂ŷ/∂b2 = 1
d_h = d_yhat * w2  # ∂ŷ/∂h = w2
d_u = d_h * (1.0 if u > 0 else 0.0)  # ReLU 의 미분: u > 0 이면 1, 아니면 0
d_w1 = d_u * x  # u = w1·x + b1 → ∂u/∂w1 = x
d_b1 = d_u * 1.0
params = torch.tensor([w1, b1, w2, b2], dtype=torch.float64, requires_grad=True)
tw1, tb1, tw2, tb2 = params.unbind()
t_loss = (tw2 * torch.relu(tw1 * x + tb1) + tb2 - y) ** 2  # 순전파만 적는다
t_loss.backward()  # 역전파는 autograd 가 한다
[2] 역전파 손계산 ↔ autograd (2층, 스칼라)
  순전파: u=1.1000 h=1.1000 ŷ=-1.4500 L=6.0025
  손계산: dL/dw1=14.7000 dL/db1=7.3500 dL/dw2=-5.3900 dL/db2=-4.9000
  autograd: dL/dw1=14.7000 dL/db1=7.3500 dL/dw2=-5.3900 dL/db2=-4.9000
  check: 손계산과 autograd 의 최대 차이 0.0e+00
  경사 하강 한 스텝(η=0.01): w1=0.3530 b1=0.0265 w2=-1.4461 b2=0.2490 → L=3.2771 (전 6.0025)

손계산과 autograd 가 소수점 아래 끝까지 같다. 역전파는 새로운 수학이 아니라 연쇄 법칙을 뒤에서부터 차례로 적용한 것이다. 은닉 값이 벡터인 2층 신경망의 손계산은 World Model 튜토리얼 4장의 “역전파: 2층 신경망을 손으로 계산하기” 에 있다.

미니배치와 옵티마이저

미니배치 · 스텝 · 에폭

손실은 보통 데이터 전체에 대한 평균이다. 하지만 매개변수를 한 번 고칠 때마다 수만 장의 그림을 모두 보는 것은 낭비다. 그래서 데이터에서 그림 \(B\) 장을 무작위로 뽑아(미니배치(mini-batch)) 그 평균 손실의 기울기로 한 번 갱신한다. 용어 셋을 정해 둔다.

  • 배치 크기 \(B\): 한 번에 넣는 그림 수.
  • 스텝(step): 매개변수를 한 번 갱신하는 것.
  • 에폭(epoch): 학습 데이터 전체를 한 바퀴 도는 것.

이 장 끝의 실험은 그림 2,000장을 32장씩 묶으므로 한 에폭이 \(\lfloor 2000 / 32 \rfloor = 62\) 스텝이다(\(\lfloor\cdot\rfloor\) 는 소수점 아래를 버린다는 뜻. 남는 16장은 그 에폭에서 쓰지 않는다). 미니배치의 기울기는 전체 데이터 기울기의 “잡음 섞인 추정값” 이고, 배치가 작을수록 잡음이 크다. 미니배치 기울기로 하는 경사 하강법을 SGD(stochastic gradient descent, 확률적 경사 하강법)라고 부른다.

SGD 에서 Adam 으로

SGD 는 모든 매개변수에 같은 학습률을 쓴다. 그런데 신경망에서는 매개변수마다 기울기의 크기가 수천 배씩 다르다. Adam(adaptive moment estimation; Kingma & Ba, 2015)은 매개변수마다 “요즘 기울기가 평균적으로 어느 방향인지” 와 “요즘 기울기가 얼마나 큰지” 를 따로 기억해 두고, 큰 기울기는 작게, 작은 기울기는 크게 고쳐서 움직인다. \(n\) 번째 스텝의 기울기를 \(g_n\) 이라고 하면,

\(\begin{aligned} m_n &= \beta_1 m_{n-1} + (1 - \beta_1)\, g_n && \text{(기울기의 지수 이동 평균: 방향)} \\ v_n &= \beta_2 v_{n-1} + (1 - \beta_2)\, g_n^2 && \text{(기울기 제곱의 지수 이동 평균: 크기)} \\ \hat{m}_n &= \frac{m_n}{1 - \beta_1^{\,n}}, \quad \hat{v}_n = \frac{v_n}{1 - \beta_2^{\,n}} && \text{(0 에서 시작한 탓에 작게 나온 것을 보정)} \\ \theta_n &= \theta_{n-1} - \eta\, \frac{\hat{m}_n}{\sqrt{\hat{v}_n} + \epsilon} && \text{(갱신)} \end{aligned}\)

\(m_0 = v_0 = 0\) 에서 시작하고, 기본값은 \(\beta_1 = 0.9\), \(\beta_2 = 0.999\)(베타), \(\epsilon = 10^{-8}\)(엡실론: 0 으로 나누는 것을 막는 작은 수)이다. 모든 계산은 매개변수마다 따로 한다. 핵심은 마지막 줄의 나눗셈이다. 첫 스텝(\(n = 1\))을 손으로 계산해 보면 무슨 일이 일어나는지 보인다.

Adam 의 첫 스텝은 기울기의 크기와 무관하다
\(m_1 = (1 - \beta_1)\, g_1, \qquad v_1 = (1 - \beta_2)\, g_1^2\)
\(m_0 = v_0 = 0\) 이므로 앞의 항이 사라진다.
\(\hat{m}_1 = \frac{(1 - \beta_1)\, g_1}{1 - \beta_1} = g_1, \qquad \hat{v}_1 = \frac{(1 - \beta_2)\, g_1^2}{1 - \beta_2} = g_1^2\)
보정 항이 \((1 - \beta)\) 를 정확히 지워 준다.
\(\theta_1 = \theta_0 - \eta\, \frac{g_1}{\sqrt{g_1^2} + \epsilon} \approx \theta_0 - \eta \cdot \frac{g_1}{|g_1|} = \theta_0 \mp \eta\)
\(\sqrt{g_1^2} = |g_1|\) 이고 \(\epsilon\) 은 아주 작으므로 무시했다. 기울기가 10 이든 0.001 이든, 양수이면 정확히 \(\eta\) 만큼 줄고 음수이면 \(\eta\) 만큼 는다.

Adam 은 기울기의 크기를 지우고 방향(과 그 일관성)만 남긴다. 그래서 손실에 상수를 곱해도 갱신량이 거의 변하지 않고, 층마다 기울기 크기가 제각각인 Transformer 를 학습시키기 쉽다. 모멘텀과 편향 보정의 자세한 설명은 World Model 튜토리얼 4장의 “미니배치 · SGD · Adam” 에 있다.

AdamW: 가중치 감쇠를 기울기와 분리하기

가중치 감쇠(weight decay)는 가중치가 쓸데없이 커지지 않게 스텝마다 조금씩 0 쪽으로 당기는 것이다. 세기는 \(\lambda\)(람다)로 정한다. 넣는 방법이 두 가지 있고, SGD 에서는 둘이 같지만 Adam 에서는 달라진다.

방법

무엇을 하나

식

L2 벌점 (Adam + L2)

손실에 \(\frac{\lambda}{2}\theta^2\) 을 더한다 → 기울기에 \(\lambda\theta\) 가 더해진다

\(g_n \leftarrow g_n + \lambda\,\theta_{n-1}\) 로 바꾼 뒤 위의 Adam 을 그대로

분리된 감쇠 (AdamW: Adam with decoupled weight decay)

기울기는 건드리지 않고, 가중치를 따로 줄인다

\(\theta_n = \theta_{n-1} - \eta\lambda\,\theta_{n-1} - \eta\, \dfrac{\hat{m}_n}{\sqrt{\hat{v}_n} + \epsilon}\)

첫째 방법에서는 감쇠 항 \(\lambda\theta\) 가 기울기에 섞여 들어가 \(m\), \(v\) 를 거치고 \(\sqrt{\hat{v}}\) 로 나뉜다. Adam 은 기울기의 크기를 지우는 방법이므로 감쇠의 크기도 함께 지워진다. 둘째 방법(Loshchilov & Hutter, 2019)은 감쇠를 그 나눗셈 밖에 둔다. “기울기와 분리한다(decoupled)” 는 말은 이것을 가리킨다. 가중치 \(\theta = 1\), \(\eta = 0.01\), \(\lambda = 0.1\) 로 첫 스텝을 계산해 본다.

손계산 — 기울기 10 인 가중치와 0.001 인 가중치의 첫 스텝
\(\text{감쇠 없음:}\quad \theta_1 = 1 - \eta \cdot \frac{g_1}{|g_1|} = 1 - 0.01 = 0.99\)
위에서 본 대로 첫 스텝은 기울기의 부호만 남는다. 두 가중치 모두 0.99.
\(\text{Adam + L2:}\quad g_1 \leftarrow g_1 + \lambda\theta = \begin{cases} 10 + 0.1 = 10.1 \\ 0.001 + 0.1 = 0.101 \end{cases} \;\Rightarrow\; \theta_1 = 1 - 0.01 \cdot \frac{g_1}{|g_1|} = 0.99\)
기울기에 \(\lambda\theta = 0.1\) 이 더해졌지만 부호는 여전히 양수이고, 크기는 나눗셈에서 지워진다. 감쇠를 넣었는데도 결과가 감쇠 없을 때와 같다.
\(\text{AdamW:}\quad \theta_1 = 1 - \underbrace{0.01 \cdot 0.1 \cdot 1}_{\eta\lambda\theta\, =\, 0.001} - \underbrace{0.01}_{\text{Adam 갱신}} = 0.989\)
두 가중치 모두 기울기 크기와 무관하게 \(\eta\lambda = 0.1\%\) 만큼 줄어든다. 감쇠가 의도한 대로 “가중치 크기에 비례해” 작동한다.

첫 스텝 뒤에도 사정은 같다. Adam + L2 에서는 감쇠가 손실 기울기와 한데 섞여 \(\sqrt{\hat{v}}\) 로 나뉘므로, 손실 기울기가 큰 가중치일수록 감쇠가 상대적으로 약해진다. AdamW 는 모든 가중치를 스텝마다 똑같이 \((1 - \eta\lambda)\) 배로 줄인다. Transformer 계열 모델은 거의 모두 AdamW 로 학습하고, RF-DETR 도 AdamW(가중치 감쇠 \(10^{-4}\))를 쓴다.

def adam_step(theta, grad, state, lr=0.01, beta1=0.9, beta2=0.999, eps=1e-8, weight_decay=0.0, decoupled=True):
    """Adam 한 스텝. theta · grad 는 모양이 같은 텐서, state 는 {"m", "v", "n"} 사전.

    weight_decay = λ 를 넣는 방법이 둘이다.
      decoupled=False (Adam + L2): 기울기에 λ·θ 를 더한다 → 감쇠 항도 √v̂ 로 나뉜다.
      decoupled=True  (AdamW)    : 기울기는 그대로 두고, θ 를 따로 (1 − η·λ) 배로 줄인다.
    """
    if weight_decay and not decoupled:
        grad = grad + weight_decay * theta  # L2 벌점 (λ/2)·θ² 의 기울기 λ·θ 를 손실 기울기에 섞는다
    if weight_decay and decoupled:
        theta = theta - lr * weight_decay * theta  # 기울기와 분리된 감쇠: θ ← (1 − η·λ)·θ
    state["n"] += 1
    state["m"] = beta1 * state["m"] + (1 - beta1) * grad  # 1차 모멘트: 기울기의 지수 이동 평균
    state["v"] = beta2 * state["v"] + (1 - beta2) * grad**2  # 2차 모멘트: 기울기 제곱의 지수 이동 평균
    m_hat = state["m"] / (1 - beta1 ** state["n"])  # 0 에서 시작한 탓에 작게 나온 것을 보정
    v_hat = state["v"] / (1 - beta2 ** state["n"])
    return theta - lr * m_hat / (v_hat.sqrt() + eps)
[3] Adam · Adam+L2 · AdamW 한 스텝 (θ=1, η=0.01, λ=0.1)
  Adam (감쇠 없음): 기울기 10 인 가중치 → 0.990000, 기울기 0.001 인 가중치 → 0.990000
  Adam + L2      : 기울기 10 인 가중치 → 0.990000, 기울기 0.001 인 가중치 → 0.990000
  AdamW          : 기울기 10 인 가중치 → 0.989000, 기울기 0.001 인 가중치 → 0.989000
  check: 직접 구현한 Adam+L2 20 스텝 vs torch.optim 최대 차이 1.1e-16
  check: 직접 구현한 AdamW 20 스텝 vs torch.optim 최대 차이 1.1e-16

손계산과 같은 숫자가 나왔고, 직접 구현한 스텝을 20번 이어 적용한 결과가 torch.optim.Adam(weight_decay=…) · torch.optim.AdamW 와 \(10^{-16}\) 수준까지 같다.

분류 ① 시그모이드와 로짓

탐지기는 예측 자리마다 “여기에 고양이가 있는가?”, “여기에 자동차가 있는가?” 같은 예 / 아니오 질문에 답해야 한다. 신경망의 마지막 선형 층이 내는 값은 \(-\infty\) 에서 \(+\infty\) 까지 아무 실수나 될 수 있으므로, 이것을 0 과 1 사이의 확률로 바꾸는 함수가 필요하다.

시그모이드의 정의와 두 가지 성질

그 함수가 시그모이드(sigmoid, logistic function) \(\sigma\)(시그마)이다. 확률로 바뀌기 전의 실수 \(z\) 를 로짓(logit)이라고 부른다.

\(p = \sigma(z) = \frac{1}{1 + e^{-z}}\)

\(z\) 가 아주 크면 \(e^{-z} \to 0\) 이라 \(p \to 1\), \(z\) 가 아주 작으면(큰 음수) \(e^{-z} \to \infty\) 라 \(p \to 0\), \(z = 0\) 이면 \(p = \frac{1}{1 + 1} = 0.5\) 이다. 몇 개 값을 계산해 두면 뒤에서 편하다: \(\sigma(2) = \frac{1}{1 + e^{-2}} = \frac{1}{1 + 0.1353} = 0.8808\), \(\sigma(-2) = \frac{1}{1 + e^{2}} = \frac{1}{1 + 7.3891} = 0.1192\). 그래프는 뒤의 그림 4-4 왼쪽에 있다.

성질 1 — \(\sigma(-z) = 1 - \sigma(z)\)
\(\sigma(-z) = \frac{1}{1 + e^{z}}\)
정의에서 \(z\) 자리에 \(-z\) 를 넣었다.
\(= \frac{e^{-z}}{e^{-z}(1 + e^{z})} = \frac{e^{-z}}{e^{-z} + 1}\)
분자와 분모에 \(e^{-z}\) 를 곱했다. \(e^{-z} \cdot e^{z} = 1\).
\(= \frac{(1 + e^{-z}) - 1}{1 + e^{-z}} = 1 - \frac{1}{1 + e^{-z}}\)
분자 \(e^{-z}\) 를 \((1 + e^{-z}) - 1\) 로 쓰고 둘로 나누었다.
\(\sigma(-z) = 1 - \sigma(z)\)
“예” 일 확률이 \(\sigma(z)\) 이면 “아니오” 일 확률은 \(\sigma(-z)\) 이다. 숫자로: \(\sigma(2) + \sigma(-2) = 0.8808 + 0.1192 = 1\).
성질 2 — \(\sigma'(z) = \sigma(z)\,(1 - \sigma(z))\)
\(\sigma(z) = (1 + e^{-z})^{-1}\)
분수를 거듭제곱 꼴로 썼다.
\(\sigma'(z) = -(1 + e^{-z})^{-2} \cdot \frac{d}{dz}(1 + e^{-z}) = -(1 + e^{-z})^{-2} \cdot (-e^{-z})\)
연쇄 법칙. 바깥 \(q^{-1}\) 의 미분은 \(-q^{-2}\), 안쪽 \(1 + e^{-z}\) 의 미분은 \(-e^{-z}\).
\(= \frac{e^{-z}}{(1 + e^{-z})^2} = \frac{1}{1 + e^{-z}} \cdot \frac{e^{-z}}{1 + e^{-z}}\)
음수 둘이 만나 양수가 되었고, 분수를 둘로 쪼갰다.
\(\sigma'(z) = \sigma(z)\,(1 - \sigma(z))\)
앞 조각은 \(\sigma(z)\), 뒤 조각은 성질 1 의 유도에서 본 \(\frac{e^{-z}}{1 + e^{-z}} = 1 - \sigma(z)\) 이다. 숫자로: \(\sigma'(2) = 0.8808 \times 0.1192 = 0.1050\), \(\sigma'(0) = 0.5 \times 0.5 = 0.25\)(최댓값).

성질 2 는 “\(p\) 를 \(z\) 로 미분하면 \(p(1 - p)\)” 라고 외워 두면 된다. \(p\) 가 0 이나 1 에 가까우면 이 값이 0 에 가까워진다. 시그모이드가 한쪽으로 확신하고 있을 때는 로짓을 움직여도 확률이 거의 변하지 않는다.

로짓은 로그 오즈다

거꾸로, 확률 \(p\) 를 주면 로짓 \(z\) 는 얼마일까? 시그모이드를 \(z\) 에 대해 푼다.

시그모이드의 역함수
\(p = \frac{1}{1 + e^{-z}} \;\Longrightarrow\; 1 + e^{-z} = \frac{1}{p}\)
양변의 역수를 취했다.
\(e^{-z} = \frac{1}{p} - 1 = \frac{1 - p}{p}\)
1 을 넘기고 통분했다.
\(z = -\log\frac{1 - p}{p} = \log\frac{p}{1 - p}\)
양변에 로그(자연로그)를 취하고 부호를 옮겼다. \(-\log\frac{a}{b} = \log\frac{b}{a}\).

\(\frac{p}{1 - p}\) 는 “일어날 확률 ÷ 안 일어날 확률” 이고, 이것을 오즈(odds, 승산)라고 부른다. 확률 0.8 이면 오즈는 \(0.8 / 0.2 = 4\)(“4 대 1”)이다. 로짓은 오즈에 로그를 씌운 로그 오즈(log-odds)이다. 표로 감을 잡는다.

확률 \(p\)

0.01

0.1192

0.5

0.8808

0.99

오즈 \(p/(1-p)\)

\(1/99\)

\(0.1353\)

\(1\)

\(7.389\)

\(99\)

로짓 \(z\)

\(-4.5951\)

\(-2\)

\(0\)

\(2\)

\(4.5951\)

\(p = 0.01\) 일 때 \(z = \log\frac{0.01}{0.99} = -\log 99 = -4.5951\) 이라는 숫자는 “사전 확률 편향 초기화” 에서 다시 나온다. 또 이 역함수는 8장에서 박스 좌표를 다룰 때 “역시그모이드” 라는 이름으로 다시 쓰인다.

분류 ② 이진 교차 엔트로피

신경망이 낸 확률 \(p\) 가 정답 \(y\)(\(y = 1\) 은 “예”, \(y = 0\) 은 “아니오”)와 얼마나 맞는지를 재는 손실이 필요하다. 탐지에서는 \(y = 1\) 인 칸을 양성(positive), \(y = 0\) 인 칸을 음성(negative)이라고 부른다. 이 손실은 아무렇게나 정한 것이 아니라 확률 모형에서 따라 나온다.

베르누이 최대우도에서 BCE 로

“예” 가 확률 \(p\) 로, “아니오” 가 확률 \(1 - p\) 로 나오는 분포를 베르누이 분포라고 한다(찌그러진 동전 던지기). 신경망이 \(p\) 를 내놓았을 때 실제 정답 \(y\) 가 나올 확률을 가능도(likelihood)라고 부르고, 가능도가 가장 커지도록 매개변수를 정하는 것이 최대우도 추정(maximum likelihood estimation, MLE)이다. “정답에 높은 확률을 준 모델이 좋은 모델” 이라는 뜻이다.

베르누이 가능도의 음의 로그 = 이진 교차 엔트로피
\(P(y \mid p) = \begin{cases} p & (y = 1) \\ 1 - p & (y = 0) \end{cases}\)
베르누이 분포의 정의. 신경망이 \(p\) 를 냈을 때 정답 \(y\) 가 나올 확률이다.
\(P(y \mid p) = p^{\,y}\,(1 - p)^{1 - y}\)
두 경우를 한 줄로 적는 요령이다. \(y = 1\) 이면 \(p^1 (1-p)^0 = p\), \(y = 0\) 이면 \(p^0 (1-p)^1 = 1 - p\) 로 위와 같다.
\(\prod_{i=1}^{N} p_i^{\,y_i}\,(1 - p_i)^{1 - y_i}\)
칸이 \(N\) 개 있고 서로 독립이라고 보면, 모든 정답이 한꺼번에 나올 확률은 칸마다의 확률을 곱한 것이다(\(\prod\) 는 곱 기호). 이것이 가능도이고, 크게 만들고 싶은 값이다.
\(\log \prod_{i=1}^{N} p_i^{\,y_i}\,(1 - p_i)^{1 - y_i} = \sum_{i=1}^{N} \big[\, y_i \log p_i + (1 - y_i) \log (1 - p_i) \,\big]\)
로그를 씌웠다. 로그는 곱을 합으로(\(\log ab = \log a + \log b\)), 거듭제곱을 곱으로(\(\log a^y = y \log a\)) 바꾼다. 로그는 커지기만 하는 함수라서 가능도를 최대로 하는 것과 로그 가능도를 최대로 하는 것은 같다. 1보다 작은 수를 수만 번 곱하면 컴퓨터에서 0 이 되어 버리는 문제도 피한다.
\(L_{\operatorname{BCE}} = -\sum_{i=1}^{N} \big[\, y_i \log p_i + (1 - y_i) \log (1 - p_i) \,\big]\)
부호를 뒤집었다. “로그 가능도를 최대로” 가 “음의 로그 가능도를 최소로” 가 되어 손실 함수의 꼴이 된다.

이것이 이진 교차 엔트로피(binary cross-entropy, BCE)이다. 칸 하나만 보면

\(\operatorname{BCE}(p, y) = -\,y \log p - (1 - y)\log(1 - p) = \begin{cases} -\log p & (y = 1) \\ -\log(1 - p) & (y = 0) \end{cases}\)

이다. 정답 쪽에 준 확률의 \(-\log\) 이다. 정답에 확률 1 을 주면 손실 \(-\log 1 = 0\), 확률을 0 에 가깝게 주면 손실이 끝없이 커진다.

손계산 — 로짓 \(z = 2\) 인 칸의 BCE
\(p = \sigma(2) = 0.8808\)
앞에서 계산한 값.
\(y = 1:\quad \operatorname{BCE} = -\log 0.8808 = 0.1269\)
정답이 “예” 인데 0.88 이라고 했으니 꽤 맞혔다. 손실이 작다.
\(y = 0:\quad \operatorname{BCE} = -\log(1 - 0.8808) = -\log 0.1192 = 2.1269\)
정답이 “아니오” 인데 0.88 이라고 했으니 크게 틀렸다. 손실이 약 17배 크다.

로짓에 대한 기울기

역전파는 손실을 로짓 \(z\) 로 미분한 값에서 출발해 신경망 안쪽으로 들어간다. 그 값이 놀랄 만큼 단순하다.

\(\dfrac{\partial\, \operatorname{BCE}}{\partial z} = p - y\)
\(\frac{\partial\, \operatorname{BCE}}{\partial p} = -\frac{y}{p} + \frac{1 - y}{1 - p}\)
\(\operatorname{BCE} = -y\log p - (1 - y)\log(1 - p)\) 를 \(p\) 로 미분. \(\frac{d}{dp}\log p = \frac{1}{p}\), \(\frac{d}{dp}\log(1 - p) = -\frac{1}{1 - p}\).
\(\frac{\partial p}{\partial z} = p\,(1 - p)\)
시그모이드의 성질 2.
\(\frac{\partial\, \operatorname{BCE}}{\partial z} = \left(-\frac{y}{p} + \frac{1 - y}{1 - p}\right) p\,(1 - p) = -y\,(1 - p) + (1 - y)\,p\)
연쇄 법칙으로 둘을 곱했다. 첫 항에서 \(p\) 가, 둘째 항에서 \((1 - p)\) 가 약분된다.
\(\frac{\partial\, \operatorname{BCE}}{\partial z} = -y + yp + p - yp = p - y\)
전개하면 \(yp\) 가 서로 지워진다. 기울기는 “예측 확률 − 정답” 이다.

위 손계산에 넣어 보면 \(y = 1\) 일 때 \(0.8808 - 1 = -0.1192\)(로짓을 조금 키워라), \(y = 0\) 일 때 \(0.8808 - 0 = 0.8808\)(로짓을 크게 줄여라)이다. 많이 틀릴수록 기울기가 크고, 크기는 1 을 넘지 않는다. 시그모이드의 미분 \(p(1 - p)\) 가 손실의 미분에 있는 \(\frac{1}{p}\), \(\frac{1}{1 - p}\) 와 정확히 약분된 덕분이고, 시그모이드와 BCE 를 짝으로 쓰는 이유다.

수치 안정 형태: 로짓에서 바로 계산하기

식대로 “먼저 \(p = \sigma(z)\) 를 만들고 \(\log\) 를 취하면” 컴퓨터에서 문제가 생긴다. 32비트 실수(float32)는 1 근처에서 약 \(6 \times 10^{-8}\) 보다 작은 차이를 표현하지 못한다. \(z = 40\) 이면 \(\sigma(40) = 1 - 4 \times 10^{-18}\) 인데 이것이 정확히 1 로 반올림되고, \(y = 0\) 일 때의 손실 \(-\log(1 - p) = -\log 0 = \infty\) 가 된다. 참값은 40 인데도 그렇다. 손실에 \(\infty\) 가 하나라도 섞이면 기울기가 전부 못 쓰게 된다. 그래서 \(p\) 를 거치지 않고 로짓에서 바로 계산하는 꼴로 식을 바꿔 둔다.

\(\operatorname{BCE} = \max(z, 0) - z\,y + \log\!\big(1 + e^{-|z|}\big)\)
\(\log p = \log\frac{1}{1 + e^{-z}} = -\log(1 + e^{-z})\)
\(\log\frac{1}{a} = -\log a\).
\(\log(1 - p) = \log\frac{e^{-z}}{1 + e^{-z}} = -z - \log(1 + e^{-z})\)
성질 1 의 유도에서 \(1 - \sigma(z) = \frac{e^{-z}}{1 + e^{-z}}\) 였다. \(\log\frac{a}{b} = \log a - \log b\) 이고 \(\log e^{-z} = -z\).
\(\operatorname{BCE} = y\log(1 + e^{-z}) + (1 - y)\big[z + \log(1 + e^{-z})\big]\)
두 식을 \(\operatorname{BCE} = -y\log p - (1 - y)\log(1 - p)\) 에 넣었다.
\(= (1 - y)\,z + \log(1 + e^{-z}) = z - z\,y + \log(1 + e^{-z})\)
\(\log(1 + e^{-z})\) 의 계수는 \(y + (1 - y) = 1\). 여기까지가 \(z \ge 0\) 일 때 쓰는 꼴이다. \(e^{-z} \le 1\) 이라 넘칠 일이 없다.
\(\log(1 + e^{-z}) = \log\!\big(e^{-z}(e^{z} + 1)\big) = -z + \log(1 + e^{z})\)
\(z \lt 0\) 이면 \(e^{-z}\) 가 엄청나게 커져 넘친다(\(e^{110}\) 은 float32 의 최댓값 약 \(3.4 \times 10^{38}\) 을 넘는다). 그래서 \(e^{-z}\) 를 밖으로 꺼낸다.
\(\operatorname{BCE} = z - z\,y - z + \log(1 + e^{z}) = -z\,y + \log(1 + e^{z}) \qquad (z \lt 0)\)
앞 줄을 대입했다. 이제 \(e^{z} \lt 1\) 이라 안전하다.
\(\operatorname{BCE}(z, y) = \max(z, 0) - z\,y + \log\!\big(1 + e^{-|z|}\big)\)
두 경우를 합쳤다. \(z \ge 0\) 이면 \(\max(z, 0) = z\), \(|z| = z\) 로 넷째 줄과 같고, \(z \lt 0\) 이면 \(\max(z, 0) = 0\), \(-|z| = z\) 로 여섯째 줄과 같다. \(e\) 의 지수가 늘 0 이하다.

\(z = 2\), \(y = 1\) 로 확인하면 \(\max(2, 0) - 2 \cdot 1 + \log(1 + e^{-2}) = 2 - 2 + \log 1.1353 = 0.1269\) 로 앞의 손계산과 같다. PyTorch 의 F.binary_cross_entropy_with_logits 가 이 계산을 하고, 그래서 탐지기 코드는 시그모이드를 거친 확률이 아니라 로짓을 그대로 손실 함수에 넣는다.

def sigmoid(z: torch.Tensor) -> torch.Tensor:
    """σ(z) = 1 / (1 + e^(−z)). 로짓(실수 전체)을 확률(0 – 1)로."""
    return 1.0 / (1.0 + torch.exp(-z))

def bce_naive(z: torch.Tensor, t: torch.Tensor) -> torch.Tensor:
    """정의 그대로: 먼저 p = σ(z) 를 만들고 −t·log p − (1 − t)·log(1 − p). |z| 가 크면 log(0) 이 나온다."""
    p = sigmoid(z)
    return -t * torch.log(p) - (1 - t) * torch.log(1 - p)

def bce_with_logits(z: torch.Tensor, t: torch.Tensor) -> torch.Tensor:
    """로짓에서 바로 계산하는 BCE: max(z, 0) − z·t + log(1 + e^(−|z|)). 원소마다의 손실을 돌려준다.

    z: 로짓, t: 목표(0 또는 1, 또는 0 – 1 사이의 부드러운 목표). 모양은 같아야 하고 무엇이든 된다.
    e 의 지수가 늘 0 이하(−|z|)이므로 넘치지 않고, log1p 는 1 + (아주 작은 수) 의 로그를 정확히 계산한다.
    max(z, 0) 은 (z + |z|) / 2 로 적었다. 값은 같고, 꺾이는 점 z = 0 에서도 autograd 가 옳은 기울기(p − t)를 준다.
    """
    return 0.5 * (z + z.abs()) - z * t + torch.log1p(torch.exp(-z.abs()))
torch.manual_seed(args.seed)
logits = (torch.randn(1000, dtype=torch.float64) * 5).requires_grad_(True)
targets = torch.randint(0, 2, (1000,)).double()
mine = bce_with_logits(logits, targets)
ref = F.binary_cross_entropy_with_logits(logits, targets, reduction="none")
print(f"  check: bce_with_logits vs F.binary_cross_entropy_with_logits 최대 차이 {(mine - ref).abs().max().item():.1e}")
mine.sum().backward()  # autograd 가 구한 ∂L/∂z
by_formula = torch.sigmoid(logits.detach()) - targets  # 손으로 유도한 p − y
print(f"  check: 기울기 ∂L/∂z vs (p − y) 최대 차이 {(logits.grad - by_formula).abs().max().item():.1e}")
[4] 시그모이드 · BCE · 소프트맥스
  z          -4.5951   -2.0000    0.0000    2.0000    4.5951
  σ(z)        0.0100    0.1192    0.5000    0.8808    0.9900
  σ(z)+σ(−z)   1.0000    1.0000    1.0000    1.0000    1.0000
  log(p/(1−p))  -4.5951   -2.0000    0.0000    2.0000    4.5951  ← 로짓이 되돌아온다
  z=2, y=1: p=0.8808  BCE(정의)=0.1269  BCE(로짓에서 바로)=0.1269
  z=2, y=0: p=0.8808  BCE(정의)=2.1269  BCE(로짓에서 바로)=2.1269
  check: bce_with_logits vs F.binary_cross_entropy_with_logits 최대 차이 8.7e-16
  check: 기울기 ∂L/∂z vs (p − y) 최대 차이 2.2e-16
  float32, z=40, y=0: 정의 그대로 = inf, 로짓에서 바로 = 40.0000
  float32, z=-110, y=1: 정의 그대로 = inf, 로짓에서 바로 = 110.0000

출력에서 확인할 것:

  • \(\sigma(z) + \sigma(-z) = 1\), 그리고 \(\log\frac{p}{1 - p}\) 가 원래 로짓을 되돌려 준다(성질 1, 로그 오즈).
  • 직접 구현한 bce_with_logits 가 PyTorch 내장과 \(10^{-15}\) 수준까지 같고, autograd 가 구한 기울기가 손으로 유도한 \(p - y\) 와 같다.
  • float32 에서 정의 그대로 계산하면 \(z = 40\), \(y = 0\) 과 \(z = -110\), \(y = 1\) 에서 inf 가 나오지만, 로짓에서 바로 계산하면 참값 40 과 110 이 나온다.

부드러운 목표

지금까지 정답 \(y\) 는 0 아니면 1 이었다. 그런데 BCE 의 식은 목표가 0 과 1 사이의 값이어도 그대로 계산된다. 이런 목표를 부드러운 목표(soft target)라고 부르고, 이 장에서는 \(t\) 로 쓴다(\(0 \le t \le 1\)).

\(\operatorname{BCE}(p, t) = -\,t \log p - (1 - t)\log(1 - p)\)

“이 칸은 70% 쯤 양성” 이라는 목표를 준다는 뜻이다. 이때 신경망이 손실을 가장 작게 만드는 \(p\) 는 얼마일까?

부드러운 목표 \(t\) 의 BCE 는 \(p = t\) 에서 가장 작다
\(\frac{\partial\, \operatorname{BCE}}{\partial p} = -\frac{t}{p} + \frac{1 - t}{1 - p}\)
\(p\) 로 미분. 앞의 기울기 유도와 같은 계산이고 \(y\) 자리에 \(t\) 가 있을 뿐이다.
\(= \frac{-t\,(1 - p) + (1 - t)\,p}{p\,(1 - p)} = \frac{p - t}{p\,(1 - p)}\)
통분했다. 분자는 \(-t + tp + p - tp = p - t\).
\(\frac{p - t}{p\,(1 - p)} = 0 \;\Longleftrightarrow\; p = t\)
\(0 \lt p \lt 1\) 에서 분모는 늘 양수이므로, 미분이 0 이 되는 곳은 \(p = t\) 하나뿐이다. \(p \lt t\) 이면 미분이 음수(손실이 줄어드는 중), \(p \gt t\) 이면 양수(늘어나는 중)이므로 이 점은 최솟점이다.
\(\min_p \operatorname{BCE}(p, t) = -\,t \log t - (1 - t)\log(1 - t) \quad (p = t \text{ 일 때})\)
\(p = t\) 를 넣은 값이다. \(t = 0.7\) 이면 \(-0.7\log 0.7 - 0.3\log 0.3 = 0.2497 + 0.3612 = 0.6109\). \(t\) 가 0 이나 1 이 아니면 최솟값이 0 이 아니다.

세 가지를 기억해 둔다.

  • 최솟점은 \(p = t\). 부드러운 목표로 학습한 신경망은 확률을 1 로 밀어 올리지 않고 \(t\) 에 맞춘다.
  • 최솟값은 0 이 아니다. 손실이 0 으로 내려가지 않는다고 학습이 덜 된 것이 아니다.
  • 로짓에 대한 기울기는 여전히 \(p - t\). 둘째 줄에 \(\frac{\partial p}{\partial z} = p(1 - p)\) 를 곱하면 바로 나온다. 수치 안정 형태도 \(y\) 를 \(t\) 로 바꾸기만 하면 된다.

# 부드러운 목표 t 일 때 손실이 가장 작아지는 확률 p 를 촘촘한 격자에서 찾는다
grid = torch.linspace(0.001, 0.999, 999, dtype=torch.float64)  # p = 0.001, 0.002, …, 0.999
for t in [0.2, 0.7, 1.0]:
    loss = -t * torch.log(grid) - (1 - t) * torch.log(1 - grid)
    best = grid[loss.argmin()].item()
    print(f"  부드러운 목표 t={t}: 손실이 최소인 p={best:.3f}, 그때의 손실 {loss.min().item():.4f}")
  부드러운 목표 t=0.2: 손실이 최소인 p=0.200, 그때의 손실 0.5004
  부드러운 목표 t=0.7: 손실이 최소인 p=0.700, 그때의 손실 0.6109
  부드러운 목표 t=1.0: 손실이 최소인 p=0.999, 그때의 손실 0.0010
  check: z=0(p=0.5), t=0.7 에서 ∂L/∂z = -0.2000 (p − t = −0.2)

촘촘한 격자에서 찾은 최솟점이 \(t = 0.2\) 일 때 \(p = 0.200\), \(t = 0.7\) 일 때 \(p = 0.700\) 으로 유도와 같다(\(t = 1\) 은 최솟점이 \(p = 1\) 인데 격자가 0.999 까지만 있어 0.999 가 나왔다).

9장의 복선: 목표를 “박스가 얼마나 잘 맞았는가” 로

9장의 IoU 인지 BCE 손실(IA-BCE)은 양성 칸의 목표를 1 이 아니라 예측 박스와 정답 박스의 IoU 로 만든 값 \(t\) 로 둔다. 방금 본 대로 그렇게 학습한 신경망의 점수는 \(t\) 를 따라가므로, “박스가 잘 맞은 예측일수록 점수가 높다” 는 성질이 생긴다. 3장에서 본 것처럼 AP 는 점수 순서에 민감하므로 이 성질이 곧 성능으로 이어진다. RF-DETR 도 이 손실을 기본으로 쓴다(11장).

분류 ③ 소프트맥스와 클래스별 시그모이드

시그모이드는 예 / 아니오 질문 하나에 답한다. 클래스가 \(K\) 개(도형 세상은 원 · 사각형 · 삼각형의 3개, COCO 는 80개)일 때는 길이 두 갈래다. “\(K\) 개 가운데 하나를 고르는 문제” 로 보거나, “클래스마다 예 / 아니오를 따로 묻는 문제 \(K\) 개” 로 보는 것이다.

소프트맥스와 교차 엔트로피

하나를 고르는 쪽의 도구가 소프트맥스(softmax)이다. 로짓 \(K\) 개 \(z_1, \dots, z_K\) 를 받아 합이 1 인 확률 \(K\) 개로 바꾼다.

\(p_k = \frac{e^{z_k}}{\sum_{j=1}^{K} e^{z_j}} \qquad (k = 1, \dots, K)\)

\(e^{z}\) 로 모두 양수로 만든 다음 전체 합으로 나눈 것이다. 로짓이 가장 큰 클래스가 가장 큰 확률을 받는다. 정답 클래스가 \(y\) 번일 때의 손실은 BCE 와 같은 생각(정답에 준 확률의 \(-\log\))으로 정하고, 교차 엔트로피(cross-entropy, CE)라고 부른다.

\(L_{\text{CE}} = -\log p_y\)

손계산 — 로짓 \((2, 1, 0)\), 정답은 첫째 클래스
\(e^{2} = 7.3891,\quad e^{1} = 2.7183,\quad e^{0} = 1 \qquad\Rightarrow\qquad \text{합} = 11.1073\)
로짓마다 \(e\) 의 거듭제곱을 구해 더했다.
\(p = \left(\frac{7.3891}{11.1073},\ \frac{2.7183}{11.1073},\ \frac{1}{11.1073}\right) = (0.6652,\ 0.2447,\ 0.0900)\)
합으로 나누었다. 세 확률을 더하면 1(반올림 탓에 0.9999).
\(L_{\text{CE}} = -\log 0.6652 = 0.4076\)
정답 클래스(첫째)에 준 확률의 \(-\log\).

같은 로짓에 시그모이드를 따로따로 씌우면 \((\sigma(2), \sigma(1), \sigma(0)) = (0.8808,\ 0.7311,\ 0.5)\) 이고 합은 2.1119 이다. 서로 눈치를 보지 않으므로 합이 1 일 이유가 없다. 소프트맥스에서는 한 클래스의 확률을 올리면 다른 클래스의 확률이 반드시 내려간다(클래스끼리 경쟁). 시그모이드에서는 칸마다 독립이다.

클래스가 둘인 소프트맥스는 시그모이드다
\(p_1 = \frac{e^{z_1}}{e^{z_1} + e^{z_2}}\)
\(K = 2\) 인 소프트맥스.
\(= \frac{1}{1 + e^{z_2 - z_1}} = \frac{1}{1 + e^{-(z_1 - z_2)}} = \sigma(z_1 - z_2)\)
분자와 분모를 \(e^{z_1}\) 로 나누었다. 두 로짓의 차이를 로짓으로 하는 시그모이드다. 시그모이드는 “예 / 아니오 두 클래스짜리 소프트맥스” 인 셈이다.

def softmax_cross_entropy(z: torch.Tensor, label: torch.Tensor) -> torch.Tensor:
    """소프트맥스 교차 엔트로피. z: (N, K) 로짓, label: (N,) 정답 클래스 번호 → (N,) 손실.

    log p_k = z_k − log Σ_j e^(z_j). 가장 큰 로짓을 먼저 빼 두면 e 의 지수가 0 이하가 되어 넘치지 않는다.
    """
    z = z - z.max(dim=1, keepdim=True).values
    log_p = z - torch.log(torch.exp(z).sum(dim=1, keepdim=True))  # (N, K)
    return -log_p.gather(1, label[:, None]).squeeze(1)  # 정답 클래스의 −log p 만 고른다
  소프트맥스: z=(2, 1, 0) → p=(0.6652, 0.2447, 0.0900) 합 1.0000, 정답 0번 CE=0.4076
  시그모이드 따로: σ(z)=(0.8808, 0.7311, 0.5000) 합 2.1119
  check: softmax_cross_entropy vs F.cross_entropy 최대 차이 1.8e-15
  check: 2클래스 소프트맥스 p_0=0.845535 = σ(z_0 − z_1)=0.845535

소프트맥스 교차 엔트로피를 로짓으로 미분하면 BCE 와 똑같이 “확률 − 정답”(정답 클래스 자리에서만 1 을 뺀 것)이 된다. 그 유도는 World Model 튜토리얼 4장의 “분류: 소프트맥스와 교차 엔트로피” 에 있다. 이 튜토리얼에서 소프트맥스는 분류 손실보다 5장의 어텐션 가중치를 만드는 데 훨씬 자주 쓰인다.

배경 클래스를 둘 것인가

탐지기는 분류기와 한 가지가 다르다. 예측 자리 대부분에는 아무 객체도 없다. “없음” 을 어떻게 표현하느냐에 따라 두 방식이 갈린다.

  • 소프트맥스 + 배경 클래스. “객체 없음” 을 \(K + 1\) 번째 클래스로 추가한다. 이 가짜 클래스를 배경 클래스(background class, no-object class ∅)라고 부른다. DETR 원본(7장)이 이 방식이다.
  • 클래스별 시그모이드. 출력은 \(K\) 개뿐이고 클래스마다 독립인 예 / 아니오 질문이다. “없음” 은 따로 출력이 없고, \(K\) 개 확률이 모두 낮은 것이 곧 “없음” 이다. Deformable DETR(8장) 이후의 DETR 계열과 LW-DETR · RF-DETR 가 이 방식이다.

소프트맥스 + 배경 클래스

클래스별 시그모이드

예측 자리 하나의 출력 수

\(K + 1\)

\(K\)

확률의 합

늘 1 (클래스끼리 경쟁)

제약 없음 (칸마다 독립)

“객체 없음” 의 표현

배경 클래스의 확률이 가장 큼

모든 클래스의 확률이 낮음

정답(양성 자리)

정답 클래스 번호 하나

정답 클래스 칸만 1, 나머지 \(K - 1\) 칸은 0

정답(음성 자리)

배경 클래스 번호

\(K\) 칸 모두 0

손실

교차 엔트로피

칸마다의 BCE 계열(포컬 손실, IA-BCE)

불균형 대처

배경 클래스 항의 가중치를 줄임

포컬 손실의 조절 인자, 사전 확률 편향 초기화

쓰는 모델

DETR (2020)

Deformable DETR (2020), LW-DETR, RF-DETR

원 논문과 공개 코드에서 확인한 사실은 다음과 같다.

  • DETR 논문은 예측 자리마다 소프트맥스로 클래스를 예측하고 “객체 없음” 을 나타내는 특별한 클래스 ∅ 를 둔다고 적는다. 그리고 클래스 불균형 때문에 정답이 ∅ 인 자리의 로그 확률 항을 10분의 1 로 줄여 더한다(3.1절).
  • Deformable DETR 논문은 학습 설정이 DETR 을 따르되 박스 분류에 포컬 손실(손실 가중치 2)을 쓰고 객체 질의를 100개에서 300개로 늘렸다고 적는다(5절의 구현 설명).
  • RF-DETR 의 공개 코드에서 분류 머리는 nn.Linear(hidden_dim, num_classes) 이고, 배경 클래스를 위한 출력은 따로 없다.

클래스별 시그모이드 쪽이 자리를 잡은 까닭은 뒤에서 볼 불균형 대처법(포컬 손실 · 사전 확률 편향)이 칸마다 독립인 시그모이드 위에서 정의되기 때문이다. 대신 칸의 수가 \(K\) 배로 늘어나고, 그 대부분이 음성이다. 이것이 다음 절의 문제다.

클래스 불균형과 포컬 손실

음성이 압도적이다

RF-DETR 는 그림 한 장에 예측 자리(7장에서 배울 객체 질의) 300개를 둔다. 클래스가 80개라면 예 / 아니오 칸은 \(300 \times 80 = 24{,}000\) 개다. 그림에 객체가 10개 있다면 양성 칸은 10개뿐이다(객체 하나가 질의 하나의, 클래스 하나의 칸에 배정된다). 나머지 23,990칸은 전부 음성이다. 양성의 비율은 \(10 / 24{,}000 = 0.04\%\) 이다. 이렇게 한쪽 정답이 압도적으로 많은 상황을 클래스 불균형(class imbalance)이라고 부른다.

원문 그림 4-3 은 탐지기의 분류 출력 (300, 80) 을 줄여 그린 격자다. 가로가 클래스 80개, 세로가 질의 300개이고, 칸마다 로짓 하나와 시그모이드 하나가 있다. 색칠된 양성 칸(\(y = 1\))은 객체 수만큼(예를 들어 10개)뿐이고, 나머지 23,990칸은 모두 음성 칸(\(y = 0\))이다.

무엇이 문제일까? 음성 칸 대부분은 쉽다. 텅 빈 하늘을 보고 “자동차 아님” 이라고 하는 것은 금방 배운다. 그런데 BCE 는 쉽게 맞힌 칸에도 작은 손실을 남긴다. 음성 칸에 \(p = 0.05\) 를 주면(95% 확신으로 맞힘) 손실은 \(-\log 0.95 = 0.0513\) 이다. 작아 보이지만 23,990개를 더하면 이야기가 달라진다.

손계산 — 쉬운 음성 23,990칸 대 어려운 양성 10칸
\(\text{양성 10칸, 아직 } p = 0.3:\qquad 10 \times (-\log 0.3) = 10 \times 1.2040 = 12.04\)
양성 칸은 아직 잘 못 맞히고 있다고 가정했다. 칸 하나의 손실은 크다.
\(\text{음성 23,990칸, 이미 } p = 0.05:\qquad 23{,}990 \times (-\log 0.95) = 23{,}990 \times 0.05129 = 1230.53\)
음성 칸은 이미 잘 맞히고 있다. 칸 하나의 손실은 양성의 23분의 1 이지만 개수가 2,399배다.
\(\frac{1230.53}{12.04 + 1230.53} = 99.0\%\)
전체 손실의 99% 가 “이미 잘 맞히고 있는” 음성 칸에서 나온다. 기울기도 손실을 따라가므로, 학습은 쉬운 음성을 더 확실히 맞히는 데 힘을 쓰고 정작 중요한 양성 10칸은 뒷전이 된다.

포컬 손실의 정의

포컬 손실(focal loss; Lin 외, 2017, RetinaNet 논문)은 이 문제를 손실 함수의 모양을 바꿔서 푼다. 논문이 다룬 탐지기는 그림 한 장에 약 10만 개의 후보 자리를 두었고, 논문은 양성 대 음성이 1 : 1000 에 이르는 극단적인 불균형을 문제로 꼽는다. 생각은 간단하다. 이미 잘 맞힌 칸의 손실을 훨씬 더 작게 깎자.

표기를 간단히 하려고 “정답 쪽에 준 확률” \(p_t\) 를 정의한다.

\(p_t = \begin{cases} p & (y = 1) \\ 1 - p & (y = 0) \end{cases}\)

\(p_t\) 가 1 에 가까우면 잘 맞힌 칸(쉬운 칸), 0 에 가까우면 크게 틀린 칸(어려운 칸)이다. 이 표기로 BCE 는 양성 · 음성 구별 없이 \(\operatorname{BCE} = -\log p_t\) 한 줄이 된다. 포컬 손실은 여기에 두 가지를 곱한다.

\(\mathrm{FL}(p_t) = -\,\alpha_t\,(1 - p_t)^{\gamma}\,\log p_t, \qquad \alpha_t = \begin{cases} \alpha & (y = 1) \\ 1 - \alpha & (y = 0) \end{cases}\)

  • 조절 인자 \((1 - p_t)^\gamma\). \(\gamma\)(감마)는 0 이상의 수다. 잘 맞힌 칸은 \(1 - p_t\) 가 0 에 가까우므로 이 인자가 아주 작아지고, 크게 틀린 칸은 \(1 - p_t\) 가 1 에 가까워 거의 그대로 남는다. \(\gamma\) 가 클수록 쉬운 칸을 더 세게 깎는다. 논문은 \(\gamma = 2\) 가 가장 좋았다고 보고한다.
  • 균형 가중치 \(\alpha_t\). 양성 칸에는 \(\alpha\)(알파), 음성 칸에는 \(1 - \alpha\) 를 곱한다. 논문은 \(\gamma = 2\) 일 때 \(\alpha = 0.25\) 가 가장 좋았다고 보고한다.
확인 — \(\gamma = 0\) 이면 (가중치 붙은) BCE 다
\(\mathrm{FL}(p_t)\Big|_{\gamma = 0} = -\,\alpha_t\,(1 - p_t)^{0}\,\log p_t = -\,\alpha_t \log p_t\)
어떤 수든 0 제곱은 1 이므로 조절 인자가 사라진다.
\(= \alpha_t \cdot \operatorname{BCE}(p, y)\)
\(-\log p_t\) 가 BCE 였다. \(\alpha_t\) 까지 빼면(양성 · 음성 모두 1) 정확히 BCE 이다. 포컬 손실은 BCE 를 품고 있는 더 넓은 손실이다.

조절 인자의 효과를 숫자로

\(\gamma = 2\) 일 때 조절 인자가 손실을 몇 분의 1 로 줄이는지, \(\alpha_t\) 는 빼고 계산해 본다.

\(p_t\)

어떤 칸인가

BCE \(= -\log p_t\)

\((1 - p_t)^2\)

포컬 손실

BCE 의 몇 분의 1

0.1

크게 틀림

2.30259

0.81

1.86509

1.2

0.5

반반

0.69315

0.25

0.17329

4

0.9

잘 맞힘

0.10536

0.01

0.00105

100

0.968

아주 잘 맞힘

0.03252

0.001024

0.0000333

약 977

0.99

거의 확실

0.01005

0.0001

0.0000010

10,000

\(p_t = 0.9\) 인 칸은 \((1 - 0.9)^2 = 0.01\) 이 곱해져 손실이 100분의 1 이 되고, \(p_t = 0.968\) 이면 \((0.032)^2 = 0.001024\) 로 약 1000분의 1 이 된다. 논문이 드는 예와 같은 숫자다. 반면 \(p_t \le 0.5\) 인 틀린 칸은 많아야 4분의 1 로 줄 뿐이다. 쉬운 칸과 어려운 칸의 차이가 그만큼 더 벌어진다.

  • 그림: 그림 4-4 왼쪽: 시그모이드. 가운데: \(\gamma\) 에 따른 포컬 손실(\(\alpha_t\) 없이). 오른쪽: 그 손실을 로짓으로 미분한 값의 크기.

그림 4-4 에서 읽을 것:

  • 왼쪽. 시그모이드는 \(z = 0\) 에서 \(p = 0.5\) 를 지나고, \(z = -4.595\) 에서 \(p = 0.01\) 이다(로그 오즈 표의 값).
  • 가운데. 파란 실선(\(\gamma = 0\))이 BCE 이다. 회색으로 칠한 “쉬운 칸” 구간(\(p_t \gt 0.6\))에서도 BCE 는 0 이 아닌 손실을 남긴다. \(\gamma\) 를 키울수록 곡선이 오른쪽에서 바닥에 붙는다. 논문의 그림 1 과 같은 그림이다.
  • 오른쪽. 로짓에 대한 기울기의 크기다. BCE 는 \(1 - p_t\) 의 직선이고, \(\gamma = 2\) 는 \(p_t \gt 0.6\) 에서 거의 0 이다. 쉬운 칸은 손실뿐 아니라 기울기도 내지 않는다. 한편 \(p_t\) 가 0.2 보다 작은 구간에서는 \(\gamma \gt 0\) 인 곡선이 BCE 보다 조금 위에 있다. 포컬 손실은 모든 칸을 깎는 것이 아니라 손실의 무게를 어려운 칸 쪽으로 옮긴다.

앞의 24,000칸 예로 돌아가, 음성 칸이 얼마나 쉬운지(\(p\) 가 얼마나 낮은지)에 따라 손실의 몫이 어떻게 달라지는지 계산한다. 포컬 손실은 \(\alpha = 0.25\), \(\gamma = 2\) 이다.

# 질의 300개 × 클래스 80개 = 24,000칸, 객체 10개. 양성은 아직 어려워 p = 0.3, 음성은 쉬워서 p = p_neg 라고 하자.
cells, num_pos = 300 * 80, 10
num_neg = cells - num_pos
print("  24,000칸 · 양성 10칸(p=0.3) · 음성 23,990칸(p=p_neg) 의 손실 합")
print("  p_neg   BCE: 양성 합  음성 합  음성 몫 |  포컬: 양성 합  음성 합  음성 몫")
for p_neg in [0.1, 0.05, 0.02, 0.01]:
    zp = torch.logit(torch.tensor(0.3, dtype=torch.float64))
    zn = torch.logit(torch.tensor(p_neg, dtype=torch.float64))
    one, zero = torch.tensor(1.0, dtype=torch.float64), torch.tensor(0.0, dtype=torch.float64)
    bce_pos = num_pos * bce_with_logits(zp, one).item()
    bce_neg = num_neg * bce_with_logits(zn, zero).item()
    fl_pos = num_pos * focal_loss_elementwise(zp, one).item()
    fl_neg = num_neg * focal_loss_elementwise(zn, zero).item()
    print(f"  {p_neg:<5}   {bce_pos:9.2f}  {bce_neg:8.2f}  {100 * bce_neg / (bce_pos + bce_neg):5.1f}%  |"
          f"  {fl_pos:10.3f}  {fl_neg:8.3f}  {100 * fl_neg / (fl_pos + fl_neg):5.1f}%")
  24,000칸 · 양성 10칸(p=0.3) · 음성 23,990칸(p=p_neg) 의 손실 합
  p_neg   BCE: 양성 합  음성 합  음성 몫 |  포컬: 양성 합  음성 합  음성 몫
  0.1         12.04   2527.60   99.5%  |       1.475    18.957   92.8%
  0.05        12.04   1230.53   99.0%  |       1.475     2.307   61.0%
  0.02        12.04    484.66   97.6%  |       1.475     0.145    9.0%
  0.01        12.04    241.11   95.2%  |       1.475     0.018    1.2%

BCE 에서는 음성이 아무리 쉬워져도(\(p = 0.01\)) 전체 손실의 95% 를 차지한다. 포컬 손실에서는 음성이 쉬워질수록 그 몫이 빠르게 줄어 \(p = 0.02\) 에서 9.0%, \(p = 0.01\) 에서 1.2% 가 된다. 다만 음성이 덜 쉬울 때(\(p = 0.1\))는 포컬 손실에서도 음성이 92.8% 이다. 포컬 손실이 지워 주는 것은 “쉬운” 음성이지 음성 전부가 아니다.

α 는 왜 양성에 0.25 인가

불균형을 고치려면 드문 양성에 더 큰 가중치를 주어야 할 것 같은데, \(\alpha = 0.25\) 는 양성에 0.25, 음성에 0.75 를 곱한다. 거꾸로처럼 보인다. 위 표의 마지막 줄이 이유를 보여 준다. \(\gamma = 2\) 의 조절 인자가 쉬운 음성을 워낙 세게 깎아서, 이번에는 양성 쪽이 손실의 대부분(98.8%)을 차지하게 된다. \(\alpha\) 는 그 쏠림을 조금 되돌리는 손잡이다. 논문도 “\(\gamma\) 를 키우면 \(\alpha\) 는 조금 줄여야 한다” 고 적고, 두 값을 함께 골라야 한다고 말한다. RF-DETR 코드의 기본값도 \(\alpha = 0.25\), \(\gamma = 2\) 이다.

포컬 손실의 기울기

BCE 의 기울기는 \(p - y\) 였다. 포컬 손실의 기울기도 같은 방법(먼저 \(p\) 로 미분하고 \(p(1 - p)\) 를 곱하기)으로 구한다. 양성 칸(\(y = 1\), \(p_t = p\))부터 한다.

양성 칸 — \(\mathrm{FL} = -\alpha\,(1 - p)^{\gamma}\log p\) 를 로짓으로 미분
\(\frac{\partial\, \mathrm{FL}}{\partial p} = -\alpha\left[\, \frac{d}{dp}(1 - p)^{\gamma} \cdot \log p + (1 - p)^{\gamma} \cdot \frac{d}{dp}\log p \,\right]\)
곱의 미분 \((fg)' = f'g + fg'\). \(f = (1 - p)^\gamma\), \(g = \log p\).
\(= -\alpha\left[\, -\gamma\,(1 - p)^{\gamma - 1}\log p + \frac{(1 - p)^{\gamma}}{p} \,\right]\)
\(\frac{d}{dp}(1 - p)^\gamma = \gamma(1 - p)^{\gamma - 1} \cdot (-1)\) (연쇄 법칙: 안쪽 \(1 - p\) 의 미분이 \(-1\)), \(\frac{d}{dp}\log p = \frac{1}{p}\).
\(\frac{\partial\, \mathrm{FL}}{\partial z} = \frac{\partial\, \mathrm{FL}}{\partial p} \cdot p\,(1 - p) = -\alpha\left[\, -\gamma\,p\,(1 - p)^{\gamma}\log p + (1 - p)^{\gamma + 1} \,\right]\)
시그모이드의 미분 \(p(1 - p)\) 를 곱했다. 첫 항은 \((1 - p)^{\gamma - 1} \cdot (1 - p) = (1 - p)^\gamma\) 에 \(p\) 가 남고, 둘째 항은 \(p\) 가 약분되고 \((1 - p)^{\gamma} \cdot (1 - p) = (1 - p)^{\gamma + 1}\).
\(\frac{\partial\, \mathrm{FL}}{\partial z} = \alpha\,(1 - p)^{\gamma}\,\big(\gamma\,p\log p + p - 1\big) \qquad (y = 1)\)
\((1 - p)^\gamma\) 를 묶어 내고 부호를 정리했다: \(-\big[-\gamma p \log p + (1 - p)\big] = \gamma p\log p + p - 1\). \(\gamma = 0\) 을 넣으면 \(\alpha(p - 1)\), 곧 BCE 의 기울기 \(p - y\) 에 \(\alpha\) 를 곱한 것으로 돌아간다.

음성 칸(\(y = 0\))은 \(\mathrm{FL} = -(1 - \alpha)\,p^{\gamma}\log(1 - p)\) 이다. 위 유도에서 \(p\) 와 \(1 - p\) 의 역할이 바뀌고(그래서 \(p\) 로 미분할 때 부호가 한 번 뒤집히고) \(\alpha\) 가 \(1 - \alpha\) 로 바뀔 뿐이므로, 같은 계산을 따라가면

\(\frac{\partial\, \mathrm{FL}}{\partial z} = (1 - \alpha)\,p^{\gamma}\,\big(p - \gamma\,(1 - p)\log(1 - p)\big) \qquad (y = 0)\)

이 된다. 두 경우를 \(p_t\) 로 한 줄에 적으면 다음과 같다(부호는 양성이 \(+\), 음성이 \(-\)).

\(\frac{\partial\, \mathrm{FL}}{\partial z} = \pm\,\alpha_t\,(1 - p_t)^{\gamma}\,\big(\gamma\,p_t\log p_t + p_t - 1\big)\)

손계산 — \(z = 2\) 인 양성 칸 (\(p = 0.8808\), 잘 맞힌 칸), \(\alpha = 0.25\), \(\gamma = 2\)
\((1 - p)^{2} = 0.1192^2 = 0.01421\)
조절 인자.
\(\gamma\,p\log p + p - 1 = 2 \times 0.8808 \times (-0.1269) + 0.8808 - 1 = -0.2236 - 0.1192 = -0.3428\)
\(\log 0.8808 = -0.1269\) 는 앞의 BCE 손계산에서 나온 값이다.
\(\frac{\partial\, \mathrm{FL}}{\partial z} = 0.25 \times 0.01421 \times (-0.3428) = -0.00122\)
같은 칸의 BCE 기울기는 \(p - y = -0.1192\) 였다. 포컬 손실에서는 그 약 98분의 1 이다. 잘 맞힌 칸은 신경망을 거의 건드리지 않는다.

공식 구현과 같은 형태로 구현하기

RF-DETR 공식 저장소의 rfdetr/models/criterion.py 에 있는 sigmoid_focal_loss 는 다음 순서로 계산한다.

  1. prob = inputs.sigmoid() — 로짓을 확률로.
  2. ce_loss = F.binary_cross_entropy_with_logits(inputs, targets, reduction="none") — 칸마다의 \(-\log p_t\) 를 수치 안정 형태로.
  3. p_t = prob * targets + (1 - prob) * (1 - targets) — 정답 쪽 확률.
  4. loss = ce_loss * ((1 - p_t) ** gamma) — 조절 인자.
  5. alpha_t = alpha * targets + (1 - alpha) * (1 - targets) 를 곱한다(alpha 가 0 이상일 때만).
  6. loss.mean(1).sum() / num_boxes 를 돌려준다. 부르는 쪽에서 여기에 질의 수를 곱하므로, 결국 모든 칸의 합을 양성(객체) 수로 나눈 값이다.

여섯째 줄이 중요하다. 24,000칸 전체의 평균을 내면 음성 칸의 0 에 가까운 손실 때문에 값이 한없이 작아진다. 그래서 탐지기는 손실의 합을 양성의 수로 나눈다. 포컬 손실 논문도 “배정된 자리의 수” 로 나눈다고 적는다. 아래 구현은 같은 순서를 따르되 둘째 줄에 이 장에서 만든 bce_with_logits 를 쓴다.

def focal_loss_elementwise(z: torch.Tensor, t: torch.Tensor, alpha: float = 0.25, gamma: float = 2.0) -> torch.Tensor:
    """원소마다의 포컬 손실 FL = −α_t · (1 − p_t)^γ · log(p_t). z: 로짓, t: 0/1 목표 (모양은 같고 무엇이든).

    공식 구현(rfdetr/models/criterion.py 의 sigmoid_focal_loss)과 같은 순서로 계산한다.
    """
    p = torch.sigmoid(z)
    ce = bce_with_logits(z, t)  # −log(p_t): 수치 안정 형태의 BCE 를 그대로 쓴다
    p_t = p * t + (1 - p) * (1 - t)  # 정답 쪽 확률: 양성이면 p, 음성이면 1 − p
    loss = ce * (1 - p_t) ** gamma  # 쉬운 칸(p_t 가 1 에 가까운 칸)의 손실을 줄이는 조절 인자
    if alpha >= 0:  # 음수를 주면 α 균형을 끈다
        alpha_t = alpha * t + (1 - alpha) * (1 - t)  # 양성이면 α, 음성이면 1 − α
        loss = alpha_t * loss
    return loss

def sigmoid_focal_loss(inputs: torch.Tensor, targets: torch.Tensor, num_boxes: float, alpha: float = 0.25,
                       gamma: float = 2.0) -> torch.Tensor:
    """모든 칸의 포컬 손실을 더해 양성(객체) 수로 나눈다.

    음성 칸까지 센 전체 칸 수로 나누면 값이 0 에 가까워져 버리므로, 양성 수로 나누는 것이 탐지기의 관례다.
    공식 구현은 (B, Q, K) 로짓에 대해 `loss.mean(1).sum() / num_boxes` 를 돌려주고 부르는 쪽에서 Q 를 곱한다.
    질의 축으로 평균 낸 뒤 Q 를 곱하면 합이므로, 결국 이 함수와 같은 값(전체 합 / num_boxes)이다.
    """
    return focal_loss_elementwise(inputs, targets, alpha, gamma).sum() / num_boxes
def focal_grad_formula(z: torch.Tensor, t: torch.Tensor, alpha: float = 0.25, gamma: float = 2.0) -> torch.Tensor:
    """본문에서 유도한 ∂FL/∂z = ± α_t · (1 − p_t)^γ · (γ · p_t · log p_t + p_t − 1). 부호는 양성 +, 음성 −."""
    p = torch.sigmoid(z)
    p_t = p * t + (1 - p) * (1 - t)
    alpha_t = alpha * t + (1 - alpha) * (1 - t)
    sign = 2 * t - 1  # 양성 +1, 음성 −1
    return sign * alpha_t * (1 - p_t) ** gamma * (gamma * p_t * torch.log(p_t) + p_t - 1)
torch.manual_seed(args.seed)
z = (torch.randn(4, 300, 80, dtype=torch.float64) * 3).requires_grad_(True)  # (B, Q, K) 로짓
t = (torch.rand(4, 300, 80) < 0.01).double()  # 양성 약 1%
p = torch.sigmoid(z.detach())
p_t = torch.where(t == 1, p, 1 - p)
alpha_t = torch.where(t == 1, torch.tensor(0.25, dtype=torch.float64), torch.tensor(0.75, dtype=torch.float64))
by_definition = -alpha_t * (1 - p_t) ** 2 * torch.log(p_t)  # 정의 FL = −α_t (1 − p_t)^γ log p_t 를 그대로
mine = focal_loss_elementwise(z, t, alpha=0.25, gamma=2.0)
print(f"  check: focal_loss_elementwise vs 정의식 최대 차이 {(mine - by_definition).abs().max().item():.1e}")
plain = focal_loss_elementwise(z, t, alpha=-1, gamma=0.0)  # γ = 0, α 균형 끔 → BCE 여야 한다
ref = F.binary_cross_entropy_with_logits(z, t, reduction="none")
print(f"  check: γ=0 · α 끔 → F.binary_cross_entropy_with_logits 와의 최대 차이 {(plain - ref).abs().max().item():.1e}")
mine.sum().backward()
diff = (z.grad - focal_grad_formula(z.detach(), t)).abs().max().item()
print(f"  check: autograd 기울기 vs 유도한 기울기 식 최대 차이 {diff:.1e}")
[5] 포컬 손실
  check: focal_loss_elementwise vs 정의식 최대 차이 4.1e-11
  check: γ=0 · α 끔 → F.binary_cross_entropy_with_logits 와의 최대 차이 8.9e-16
  check: autograd 기울기 vs 유도한 기울기 식 최대 차이 5.6e-16
  z=+0, y=1: p=0.5000  BCE=0.6931  FL=0.04332  ∂BCE/∂z=-0.5000  ∂FL/∂z=-0.07457
  z=+2, y=1: p=0.8808  BCE=0.1269  FL=0.00045  ∂BCE/∂z=-0.1192  ∂FL/∂z=-0.00122
  z=-2, y=0: p=0.1192  BCE=0.1269  FL=0.00135  ∂BCE/∂z=+0.1192  ∂FL/∂z=+0.00365
  z=+2, y=0: p=0.8808  BCE=2.1269  FL=1.23756  ∂BCE/∂z=+0.8808  ∂FL/∂z=+0.80754

출력에서 확인할 것:

  • 구현이 정의식 \(-\alpha_t(1 - p_t)^\gamma\log p_t\) 와 같고, \(\gamma = 0\) 에 \(\alpha\) 균형을 끄면 PyTorch 의 BCE 와 같다.
  • autograd 가 구한 기울기가 위에서 유도한 식과 \(10^{-16}\) 수준까지 같다.
  • 마지막 네 줄은 칸 네 종류의 손실과 기울기다. 잘 맞힌 양성(\(z = +2\), \(y = 1\))의 기울기는 손계산대로 \(-0.00122\), 잘 맞힌 음성(\(z = -2\), \(y = 0\))은 \(+0.00365\) 로 BCE 의 \(\pm 0.1192\) 보다 훨씬 작고, 크게 틀린 음성(\(z = +2\), \(y = 0\))은 \(+0.80754\) 로 BCE 의 \(0.8808\) 과 큰 차이가 없다.

이 식이 뒤 장에서 다시 나오는 곳

  • 7장 · 11장의 매칭 비용: 예측과 정답을 짝지을 때의 분류 비용이 “양성으로 볼 때의 포컬 손실 − 음성으로 볼 때의 포컬 손실” 꼴이다.
  • 9장의 IA-BCE: 음성 칸의 손실이 \(p^2 \cdot \big(-\log(1 - p)\big)\) 이다. 포컬 손실의 음성 쪽(\(\gamma = 2\))에서 \(\alpha_t\) 만 뺀 것이다. 양성 칸은 앞에서 본 부드러운 목표의 BCE 이다.
  • RF-DETR 의 기본 설정은 IA-BCE 이고(ia_bce_loss=True), sigmoid_focal_loss 는 그 설정을 껐을 때 쓰이는 손실로 코드에 남아 있다.

사전 확률 편향 초기화

불균형은 학습을 시작하는 순간에도 문제를 일으킨다. 갓 만든 신경망의 마지막 선형 층은 가중치가 0 근처의 작은 난수이고 편향이 0 근처다. 그러면 모든 칸의 로짓이 0 근처, 확률이 0.5 근처다. 24,000칸 가운데 23,990칸의 정답이 “아니오” 인데 모든 칸에 “반반” 이라고 답하고 시작하는 것이다.

포컬 손실 논문의 처방은 손실이 아니라 초기화를 바꾸는 것이다. 학습을 시작할 때 모든 칸이 “양성일 확률은 \(\pi\)(파이) 쯤” 이라고 답하게 만든다. \(\pi\) 는 양성이 드물다는 사전 지식을 담은 작은 값이고, 논문은 \(\pi = 0.01\) 을 쓴다. 이것을 사전 확률 편향 초기화(prior probability bias initialization)라고 부르겠다.

처음 예측이 \(\pi\) 가 되는 편향
\(z = w \cdot x + b \approx b\)
마지막 선형 층의 로짓. 학습 전에는 가중치 \(w\) 가 0 근처의 작은 값이라 \(w \cdot x\) 가 작고, 로짓은 거의 편향 \(b\) 로 정해진다.
\(\sigma(b) = \pi\)
처음 예측이 \(\pi\) 가 되기를 바란다.
\(b = \log\frac{\pi}{1 - \pi} = -\log\frac{1 - \pi}{\pi}\)
시그모이드의 역함수(로그 오즈)를 썼다. \(\pi = 0.01\) 이면 \(b = -\log\frac{0.99}{0.01} = -\log 99 = -4.5951\).

이 편향이 초기 손실을 얼마나 바꾸는지 24,000칸(양성 10) 예로 계산한다. 손실은 합을 양성 수 10 으로 나눈 값이다.

학습을 시작하는 순간의 손실
\(b = 0,\ \text{BCE}:\qquad \frac{24{,}000 \times (-\log 0.5)}{10} = \frac{24{,}000 \times 0.69315}{10} = 1663.55\)
모든 칸이 \(p = 0.5\) 이므로 양성이든 음성이든 칸마다 \(-\log 0.5 = 0.69315\).
\(b = -4.5951,\ \text{BCE}:\qquad \frac{10 \times (-\log 0.01) + 23{,}990 \times (-\log 0.99)}{10} = \frac{46.05 + 241.11}{10} = 28.72\)
모든 칸이 \(p = 0.01\). 양성 칸은 \(-\log 0.01 = 4.6052\) 로 크게 틀렸고, 음성 칸은 \(-\log 0.99 = 0.01005\) 로 거의 맞혔다. 초기 손실이 58분의 1 로 줄었다.
\(b = 0,\ \text{포컬}:\qquad \frac{10 \times 0.25 \times 0.5^2 \times 0.69315 + 23{,}990 \times 0.75 \times 0.5^2 \times 0.69315}{10} = \frac{0.43 + 3117.87}{10} = 311.83\)
포컬 손실(\(\alpha = 0.25\), \(\gamma = 2\))이어도 \(p = 0.5\) 에서는 조절 인자가 \(0.25\) 밖에 안 되어 음성 칸이 손실을 지배한다.
\(b = -4.5951,\ \text{포컬}:\qquad \frac{10 \times 0.25 \times 0.99^2 \times 4.6052 + 23{,}990 \times 0.75 \times 0.01^2 \times 0.01005}{10} = \frac{11.28 + 0.02}{10} = 1.13\)
음성 23,990칸의 손실 합이 0.02 로 사실상 사라지고, 손실의 거의 전부가 양성 10칸에서 나온다. 양성 한 칸의 손실 \(0.25 \times 0.9801 \times 4.6052 = 1.13\) 이 그대로 전체 손실이다.

def prior_bias(prior_prob: float = 0.01) -> float:
    """σ(b) = π 가 되는 편향 b = −log((1 − π) / π). π = 0.01 이면 −4.5951."""
    return -math.log((1 - prior_prob) / prior_prob)
# 학습을 시작하는 순간의 손실: 24,000칸 모두 같은 확률을 낸다고 보고, 양성 수(10)로 나눈 값
print(f"  사전 확률 편향: π=0.01 → b={prior_bias(0.01):.4f}, σ(b)={torch.sigmoid(torch.tensor(prior_bias(0.01))).item():.4f}")
targets = torch.zeros(300, 80, dtype=torch.float64)
targets[:num_pos, 0] = 1.0  # 양성 10칸
for name, bias in [("b = 0 (p = 0.5)       ", 0.0), ("b = −4.5951 (p = 0.01)", prior_bias(0.01))]:
    logits = torch.full((300, 80), bias, dtype=torch.float64)
    bce = bce_with_logits(logits, targets).sum().item() / num_pos
    focal = sigmoid_focal_loss(logits, targets, num_pos).item()
    print(f"  초기 손실 {name}: BCE {bce:9.2f}   포컬 {focal:8.3f}")
  사전 확률 편향: π=0.01 → b=-4.5951, σ(b)=0.0100
  초기 손실 b = 0 (p = 0.5)       : BCE   1663.55   포컬  311.830
  초기 손실 b = −4.5951 (p = 0.01): BCE     28.72   포컬    1.130

편향을 0 으로 두면 첫 스텝의 손실이 수백 – 수천이고, 그 대부분이 “음성 칸의 확률을 0.5 에서 끌어내려라” 는 신호다. 큰 손실은 큰 기울기를 만들고, 첫 몇 스텝이 마지막 층뿐 아니라 그 아래 층들까지 크게 흔든다. 논문은 이 초기화 없이 보통의 교차 엔트로피로 학습하면 금방 발산했고, \(\pi = 0.01\) 로 초기화하는 것만으로 학습이 되었다고 보고한다(5.1절). 결과가 \(\pi\) 의 정확한 값에는 둔감했다고도 적는다.

RF-DETR 의 공개 코드(rfdetr/models/lwdetr.py)는 분류 머리를 만든 직후 정확히 이 초기화를 한다.

# init prior_prob setting for focal loss
prior_prob = 0.01
bias_value = -math.log((1 - prior_prob) / prior_prob)
self.class_embed.bias.data = torch.ones(num_classes) * bias_value

class_embed 가 분류 머리(nn.Linear)이고, 그 편향을 모든 클래스에 대해 \(-4.5951\) 로 채운다. 이 장 끝의 실험에서 이 초기화가 있을 때와 없을 때를 직접 비교한다.

정규화 층과 잔차 연결

층을 깊게 쌓으면 층을 지날 때마다 값의 크기가 제멋대로 커지거나 작아지고, 학습이 불안정해진다. 정규화 층은 중간 값들을 “평균 0 · 분산 1” 로 다시 맞춰 주는 층이다. 어떤 숫자들을 한 묶음으로 보고 평균을 내느냐에 따라 종류가 갈린다. 계산은 모두 같다. 묶음의 평균 \(\mu\)(뮤)와 분산 \(s^2\) 을 구해

\(\hat{x} = \frac{x - \mu}{\sqrt{s^2 + \epsilon}}, \qquad \text{출력} = a\,\hat{x} + c\)

로 바꾼다. \(\epsilon\) 은 0 으로 나누는 것을 막는 작은 수(PyTorch 기본 \(10^{-5}\))이고, \(a\)(크기 조절)와 \(c\)(이동)는 학습되는 매개변수로 처음에는 \(a = 1\), \(c = 0\) 이다. 정규화가 지워 버린 크기와 위치를 필요하면 신경망이 되찾을 수 있게 하는 장치다.

기호 주의

논문과 PyTorch 문서는 크기 조절 · 이동 매개변수를 \(\gamma\), \(\beta\) 로 쓴다. 이 장에서는 \(\gamma\) 를 포컬 손실에, \(\beta\) 를 Adam 에 이미 썼으므로 \(a\), \(c\) 로 적는다(PyTorch 에서의 이름은 weight, bias). 분산도 보통 \(\sigma^2\) 으로 쓰지만 \(\sigma\) 는 시그모이드에 썼으므로 \(s^2\) 으로 적는다.

배치 정규화

배치 정규화(batch normalization, BatchNorm; Ioffe & Szegedy, 2015)는 특징(채널) 하나를 배치 전체에 걸쳐 한 묶음으로 본다. 입력이 (B, C) 이고 \(x_{ij}\) 가 \(i\) 번째 표본의 \(j\) 번째 특징이라면, 특징 \(j\) 마다

\(\mu_j = \frac{1}{B}\sum_{i=1}^{B} x_{ij}, \qquad s_j^2 = \frac{1}{B}\sum_{i=1}^{B} (x_{ij} - \mu_j)^2\)

를 구한다. 평균을 내는 축이 배치 축이다. 특징 맵 (B, C, H, W) 에서는 채널마다 배치 축과 위치 축 (B, H, W) 를 한꺼번에 묶어 평균을 낸다(nn.BatchNorm2d).

층 정규화

층 정규화(layer normalization, LayerNorm; Ba 외, 2016)는 표본 하나의 특징들을 한 묶음으로 본다. 표본 \(i\) 마다

\(\mu_i = \frac{1}{C}\sum_{j=1}^{C} x_{ij}, \qquad s_i^2 = \frac{1}{C}\sum_{j=1}^{C} (x_{ij} - \mu_i)^2\)

를 구한다. 평균을 내는 축이 특징 축이고, 배치 안의 다른 표본은 전혀 보지 않는다. Transformer 의 토큰 열 (B, N, D) 에서는 토큰 하나의 \(D\) 개 숫자가 한 묶음이다(5장).

원문 그림 4-5 는 입력 (B, C)(행이 표본 1 … \(B\), 열이 특징 \(j = 1 \dots C\))에서 두 정규화가 평균 · 분산을 구하는 묶음을 나란히 보여 준다. 배치 정규화는 세로 한 줄(특징 하나의 값 \(B\) 개)을 한 묶음으로 보므로 다른 표본의 값에 따라 출력이 달라진다. 층 정규화는 가로 한 줄(표본 하나의 특징 \(C\) 개)을 한 묶음으로 보므로 다른 표본과 무관하다.

손계산 — 표본 2개 · 특징 3개인 입력을 두 방법으로 정규화 (\(\epsilon\) 은 무시)
\(x = \begin{pmatrix} 1 & 2 & 3 \\ 3 & 6 & 9 \end{pmatrix} \qquad (B = 2,\ C = 3)\)
둘째 표본은 첫째 표본의 3배다.
\(\text{배치 정규화: 열마다}\quad \mu = (2,\ 4,\ 6), \qquad s^2 = (1,\ 4,\ 9)\)
첫 열 \((1, 3)\) 의 평균은 2, 분산은 \(\frac{(1-2)^2 + (3-2)^2}{2} = 1\). 둘째 열 \((2, 6)\) 은 평균 4, 분산 \(\frac{4 + 4}{2} = 4\). 셋째 열 \((3, 9)\) 는 평균 6, 분산 9.
\(\hat{x}_{\text{배치}} = \begin{pmatrix} \frac{1-2}{1} & \frac{2-4}{2} & \frac{3-6}{3} \\[2pt] \frac{3-2}{1} & \frac{6-4}{2} & \frac{9-6}{3} \end{pmatrix} = \begin{pmatrix} -1 & -1 & -1 \\ 1 & 1 & 1 \end{pmatrix}\)
열마다 (값 − 평균) ÷ 표준편차. 열마다 평균 0 · 분산 1 이 되었다. 첫째 표본의 출력이 모두 \(-1\) 인 것은 “둘째 표본보다 작다” 는 뜻이고, 둘째 표본이 달랐다면 다른 값이 나왔을 것이다.
\(\text{층 정규화: 행마다}\quad \mu = (2,\ 6), \qquad s^2 = \left(\tfrac{2}{3},\ 6\right)\)
첫 행 \((1, 2, 3)\) 의 평균 2, 분산 \(\frac{1 + 0 + 1}{3} = \frac{2}{3}\). 둘째 행 \((3, 6, 9)\) 의 평균 6, 분산 \(\frac{9 + 0 + 9}{3} = 6\).
\(\hat{x}_{\text{층}} = \begin{pmatrix} \frac{1-2}{0.8165} & 0 & \frac{3-2}{0.8165} \\[2pt] \frac{3-6}{2.4495} & 0 & \frac{9-6}{2.4495} \end{pmatrix} = \begin{pmatrix} -1.2247 & 0 & 1.2247 \\ -1.2247 & 0 & 1.2247 \end{pmatrix}\)
\(\sqrt{2/3} = 0.8165\), \(\sqrt{6} = 2.4495\). 두 행이 같아졌다. 층 정규화는 표본마다의 전체 크기(3배)를 지우고 “특징들 사이의 상대적인 모양” 만 남긴다. 각 행의 계산에 다른 행은 쓰이지 않았다.

x = torch.tensor([[1.0, 2.0, 3.0], [3.0, 6.0, 9.0]])  # (B=2, C=3): 그림 두 장, 특징 세 개

# 배치 정규화: 특징(열)마다, 배치 축(dim=0)으로 평균 · 분산
mu_b, var_b = x.mean(dim=0), x.var(dim=0, unbiased=False)  # (3,), (3,)
bn_manual = (x - mu_b) / torch.sqrt(var_b + 1e-5)

# 층 정규화: 표본(행)마다, 특징 축(dim=1)으로 평균 · 분산
mu_l, var_l = x.mean(dim=1, keepdim=True), x.var(dim=1, unbiased=False, keepdim=True)  # (2, 1), (2, 1)
ln_manual = (x - mu_l) / torch.sqrt(var_l + 1e-5)

bn, ln = nn.BatchNorm1d(3), nn.LayerNorm(3)  # 처음에는 크기 조절 1, 이동 0 → 정규화만 한다
bn.train()
print(f"  check: 배치 정규화 손계산 vs nn.BatchNorm1d 최대 차이 {(bn(x) - bn_manual).abs().max().item():.1e}")
print(f"  check: 층 정규화 손계산 vs nn.LayerNorm 최대 차이 {(ln(x) - ln_manual).abs().max().item():.1e}")
[6] 배치 정규화 · 층 정규화
  check: 배치 정규화 손계산 vs nn.BatchNorm1d 최대 차이 6.0e-08
  check: 층 정규화 손계산 vs nn.LayerNorm 최대 차이 0.0e+00
  배치 평균 [2.0, 4.0, 6.0] 배치 분산 [1.0, 4.0, 9.0]
  배치 정규화 출력 [[-1.0, -1.0, -1.0], [1.0, 1.0, 1.0]]
  행 평균 [2.0, 6.0] 행 분산 [0.6667, 6.0]
  층 정규화 출력   [[-1.2247, 0.0, 1.2247], [-1.2247, 0.0, 1.2247]]
  이동 평균 [0.2, 0.4, 0.6] 이동 분산 [1.1, 1.7, 2.7]
  추론 모드 출력   [[0.7628, 1.2271, 1.4606], [2.6697, 4.295, 5.1121]]

학습 모드와 추론 모드

배치 정규화는 추론할 때 곤란하다. 그림 한 장만 넣으면 “배치의 평균” 이 그 그림 자신이 되어 버린다. 그래서 배치 정규화는 두 가지로 동작한다.

  • 학습 모드(model.train()): 지금 배치의 평균 · 분산으로 정규화하고, 그 값을 이동 평균에 조금씩 섞어 기억해 둔다. PyTorch 기본은 (새 값) = 0.9 × (옛 값) + 0.1 × (이번 배치의 값)이다.
  • 추론 모드(model.eval()): 기억해 둔 이동 평균 · 이동 분산으로 정규화한다. 배치에 무엇이 함께 들어왔는지와 무관하다.

위 출력의 “이동 평균 [0.2, 0.4, 0.6]” 은 처음 값 0 에 배치 평균 \((2, 4, 6)\) 을 10% 섞은 \(0.9 \times 0 + 0.1 \times (2, 4, 6)\) 이다. “이동 분산 [1.1, 1.7, 2.7]” 은 처음 값 1 에 배치 분산을 10% 섞은 것인데, PyTorch 는 이동 분산에는 \(B\) 대신 \(B - 1\) 로 나눈 분산 \((2, 8, 18)\) 을 쓴다: \(0.9 \times 1 + 0.1 \times 2 = 1.1\). 추론 모드의 첫 값은 \((1 - 0.2)/\sqrt{1.1} = 0.7628\) 로, 학습 모드의 \(-1\) 과 전혀 다르다. 층 정규화는 두 모드의 동작이 같다. model.eval() 을 빼먹고 평가하는 것은 배치 정규화가 있는 모델에서 흔한 실수이고, 뒤의 도형 분류 실험에서 그 결과를 숫자로 본다.

배치가 작으면 배치 정규화가 흔들린다

배치 정규화의 평균 · 분산은 배치에서 잰 추정값이다. 표본 \(B\) 개의 평균은 표본을 뽑을 때마다 달라지고, 그 흔들림(표준편차)은 대략 \(1/\sqrt{B}\) 에 비례한다. 배치가 64장이면 통계가 안정적이지만 2장이면 \(\sqrt{64 / 2} = 5.66\) 배 더 흔들린다. 그러면 같은 그림도 함께 들어온 그림이 무엇이냐에 따라 다른 출력을 내게 되고, 그 잡음이 학습을 방해한다. 도형 세상 그림 512장을 16×16 패치마다 특징 8개를 내는 고정된 무작위 합성곱에 통과시켜 만든 특징 맵 (512, 8, 6, 6) 으로 직접 재 본다.

# 도형 세상 그림을 고정된 무작위 합성곱(16×16 패치마다 특징 8개)에 통과시킨 특징 맵으로 통계의 흔들림을 잰다
dataset = ShapesDataset(n_images, seed=0)
torch.manual_seed(args.seed)
conv = nn.Conv2d(3, 8, kernel_size=16, stride=16)
with torch.no_grad():
    feats = torch.relu(conv(dataset.images.float() / 255.0))  # (n, 8, 6, 6)
pop_mean = feats.mean(dim=(0, 2, 3))  # (8,) 전체 데이터에서의 채널 평균: 배치 통계가 맞혀야 할 값
pop_std = feats.std(dim=(0, 2, 3))
probe = feats[0]  # 늘 배치의 첫 자리에 넣을 그림 한 장 (8, 6, 6)
generator = torch.Generator().manual_seed(args.seed)
results = {}
for batch_size in [2, 4, 16, 64]:
    means, stds, bn_out, ln_out = [], [], [], []
    for _ in range(n_batches):
        batch = feats[torch.randint(0, len(feats), (batch_size,), generator=generator)]  # 무작위 배치 (B, 8, 6, 6)
        means.append(batch.mean(dim=(0, 2, 3)))  # 배치 정규화가 쓰는 통계: 채널마다 (B, H, W) 축 평균
        stds.append(batch.std(dim=(0, 2, 3), unbiased=False))
        batch = torch.cat([probe[None], batch[1:]])  # 첫 자리를 probe 로 바꾼 배치: 함께 들어간 그림만 매번 다르다
        mu, sd = batch.mean(dim=(0, 2, 3)), batch.std(dim=(0, 2, 3), unbiased=False)
        bn_out.append((probe - mu[:, None, None]) / (sd[:, None, None] + 1e-5))  # probe 의 배치 정규화 출력
        # 층 정규화(RF-DETR 프로젝터 방식): 위치마다 채널 축(dim=0)으로 평균 · 분산 → 다른 그림과 무관
        ln_out.append((probe - probe.mean(dim=0)) / (probe.std(dim=0, unbiased=False) + 1e-5))
    means, stds = torch.stack(means), torch.stack(stds)  # (n_batches, 8)
    results[batch_size] = {
        "mean_wobble": (means.std(dim=0) / pop_std).mean().item(),  # 배치 평균의 흔들림 (전체 표준편차 단위)
        "std_wobble": (stds.std(dim=0) / pop_std).mean().item(),  # 배치 표준편차의 흔들림
        "bn_out_wobble": torch.stack(bn_out).std(dim=0).mean().item(),  # 같은 그림의 출력이 배치마다 달라지는 정도
        "ln_out_wobble": torch.stack(ln_out).std(dim=0).mean().item(),
        "means_ch0": (means[:, 0] - pop_mean[0]) / pop_std[0],
    }
  특징 맵 (512, 8, 6, 6), 배치 300개씩
  배치 크기  배치 평균의 흔들림  배치 표준편차의 흔들림  같은 그림의 출력 흔들림(BN)  (LN)
       2            0.1475              0.3966                0.1159    0.0000
       4            0.1014              0.3181                0.1031    0.0000
      16            0.0516              0.2037                0.0577    0.0000
      64            0.0256              0.1094                0.0277    0.0000
  배치 2 와 64 의 평균 흔들림 비 5.77 (√(64/2) = 5.66)

  • 그림: 그림 4-6 왼쪽: 무작위 배치 300개에서 잰 채널 0 의 배치 평균(전체 데이터의 평균과 표준편차로 맞춘 눈금). 오른쪽: 같은 그림 한 장의 정규화 출력이 배치마다 달라지는 정도.

표와 그림 4-6 을 읽는다.

  • 배치 통계가 배치 크기에 따라 흔들린다. 배치 평균의 흔들림(전체 데이터의 표준편차를 1 로 본 눈금)이 배치 2 에서 0.1475, 배치 64 에서 0.0256 이다. 비는 5.77 로, 예상한 \(\sqrt{32} = 5.66\) 과 거의 같다. 왼쪽 그림에서 배치 2 의 평균은 대략 \(-0.3\) 에서 \(0.6\) 까지 퍼져 있고, 배치 64 의 평균은 0 주위에 좁게 모여 있다. 배치 표준편차도 같은 식으로 흔들린다(0.3966 대 0.1094).
  • 그 흔들림이 출력으로 옮겨 간다. 같은 그림 한 장을 배치 정규화에 통과시킨 출력이 배치마다 달라지는 정도(표준편차)가 배치 2 에서 0.1159, 배치 64 에서 0.0277 이다. 정규화된 출력은 표준편차가 1 쯤이므로, 배치 2 에서는 그 12% 쯤 되는 크기의 잡음이 “함께 들어온 그림이 무엇이냐” 에 따라 출력에 더해진다(오른쪽 그림의 빗금 막대).
  • 층 정규화의 출력 흔들림은 정확히 0 이다. 다른 그림을 보지 않으므로 배치 크기가 1 이든 64 든 같은 그림은 같은 출력을 낸다.

RF-DETR 가 프로젝터의 배치 정규화를 층 정규화로 바꾼 이유

LW-DETR 의 프로젝터(9장)는 합성곱 뒤에 배치 정규화를 쓴다. RF-DETR 는 이것을 층 정규화로 바꿨다. 논문은 그 이유를 “기울기 누적으로 소비자용 GPU 에서도 학습할 수 있게 하려고” 라고 적는다(3절). 기울기 누적은 작은 배치(공개 코드의 기본값은 4장)의 기울기를 여러 번 모아 한 번에 갱신하는 방법이다(11장). 기울기는 그렇게 모을 수 있지만, 배치 정규화의 통계는 순전파 때 실제로 함께 들어간 그림들로 계산되므로 누적으로는 안정시킬 수 없다. 층 정규화는 배치 크기와 무관하다. 논문은 이 교체가 COCO 성능을 떨어뜨리지만 소비자용 하드웨어에서 학습하려면 필요하다고 밝힌다(4절의 절제 실험 설명).

RF-DETR 프로젝터의 층 정규화는 특징 맵 (B, C, H, W) 의 위치마다 채널 축 \(C\) 개를 한 묶음으로 정규화한다(공개 코드 projector.py 의 LayerNorm: 채널 축을 맨 뒤로 보내 F.layer_norm 을 적용). 위 실험의 층 정규화도 같은 방식이다.

잔차 연결

잔차 연결(residual connection, skip connection; He 외, 2016, ResNet)은 층의 출력에 입력을 그대로 더하는 것이다. 층이 하는 계산을 \(f\) 라고 하면

\(x_{\text{out}} = x + f(x)\)

이다. 층은 “새 값 전체” 가 아니라 “입력에 더할 차이(잔차)” 만 배우면 된다. 더 중요한 효과는 역전파에서 나타난다.

잔차 연결은 기울기에 “지름길” 을 낸다 (숫자 하나가 흐르는 경우)
\(\frac{\partial x_{\text{out}}}{\partial x} = 1 + f'(x)\)
\(x + f(x)\) 를 \(x\) 로 미분. 앞의 1 이 더해 준 입력에서 나온 항이다.
\(\text{잔차 연결 없이 } D \text{ 층:}\qquad \frac{\partial x_D}{\partial x_0} = f_1'\, f_2' \cdots f_D'\)
연쇄 법칙으로 층마다의 미분이 곱해진다. 예를 들어 모두 0.5 이면 20층에서 \(0.5^{20} = 9.5 \times 10^{-7}\). 기울기가 첫 층에 닿기 전에 사라진다(기울기 소실).
\(\text{잔차 연결로 } D \text{ 층:}\qquad \frac{\partial x_D}{\partial x_0} = (1 + f_1')(1 + f_2') \cdots (1 + f_D') = 1 + \sum_{l} f_l' + \cdots\)
전개하면 맨 앞에 1 이 있다. 모든 층에서 “더해 준 입력” 쪽 길만 따라간 경로다. \(f_l'\) 들이 아무리 작아도 이 1 은 남으므로 기울기가 첫 층까지 그대로 닿는다.

def first_layer_gradient(depth: int, residual: bool, width: int = 64, seed: int = 0) -> float:
    """깊이 depth 인 MLP 에서, 출력의 합을 첫 층 입력으로 미분한 기울기의 크기(노름).

    residual=False: x ← tanh(Linear(x))          (층을 그냥 쌓음)
    residual=True : x ← x + tanh(Linear(x))      (잔차 연결)
    """
    torch.manual_seed(seed)
    layers = [nn.Linear(width, width) for _ in range(depth)]
    x0 = torch.randn(16, width, requires_grad=True)  # (16, width)
    x = x0
    for layer in layers:
        fx = torch.tanh(layer(x))
        x = x + fx if residual else fx
    x.sum().backward()
    return x0.grad.norm().item()
[7] 잔차 연결과 기울기
  층 수   그냥 쌓음       잔차 연결
     1      1.814e+01      3.521e+01
     5      1.241e+00      4.798e+01
    10      8.286e-02      7.069e+01
    20      4.599e-04      9.779e+01
    40      1.274e-09      2.647e+02

폭 64 인 층을 tanh 와 함께 쌓고, 출력의 합을 입력으로 미분한 기울기의 크기다. 그냥 쌓으면 20층에서 \(4.6 \times 10^{-4}\), 40층에서 \(1.3 \times 10^{-9}\) 으로 사라진다. 잔차 연결이 있으면 40층에서도 기울기가 살아 있다(오히려 층이 깊어질수록 조금씩 커지는데, 이것을 눌러 주는 것이 정규화 층이다). 5장의 Transformer 블록은 어텐션과 FFN 을 모두 “잔차 연결 + 층 정규화” 로 감싼다. 12층짜리 ViT 백본도, 디코더도 이 구조 덕분에 학습된다.

합성곱 기초

그림을 다루는 층이 합성곱(convolution)이다. RF-DETR 에서는 그림을 패치로 나누는 첫 층(6장)과 프로젝터(9장)에 쓰인다. 여기서는 뒤 장에 필요한 것만 짧게 정리한다. 합성곱을 숫자로 계산해 보는 예와 더 자세한 설명은 World Model 튜토리얼 4장의 “합성곱 신경망: 그림을 읽는 신경망” 에 있다.

커널 · 스트라이드 · 패딩과 출력 크기

합성곱은 작은 가중치 판을 입력 위에서 미끄러뜨리며, 판이 놓인 자리마다 “겹친 숫자끼리 곱해 모두 더한 값” 하나를 낸다. 세 가지 숫자가 모양을 정한다.

  • 커널(kernel, filter): 미끄러지는 가중치 판. 한 변의 크기를 \(F\) 라고 쓴다(3×3 이면 \(F = 3\)). 어느 자리에서나 같은 가중치를 쓰므로 매개변수가 적다.
  • 스트라이드(stride) \(S\): 한 번에 몇 칸씩 옮기는가. \(S = 2\) 면 출력의 가로 · 세로가 절반이 된다.
  • 패딩(padding) \(P\): 입력의 가장자리에 0 을 몇 줄 덧대는가. 가장자리에서도 커널을 놓을 수 있게 해 준다.

한 변이 \(n_{\text{in}}\) 인 입력의 출력 크기 \(n_{\text{out}}\) 은 다음과 같다.

\(n_{\text{out}} = \left\lfloor \frac{n_{\text{in}} - F + 2P}{S} \right\rfloor + 1\)

패딩을 덧댄 길이 \(n_{\text{in}} + 2P\) 안에서 길이 \(F\) 인 커널이 움직일 수 있는 거리는 \(n_{\text{in}} + 2P - F\) 이고, \(S\) 칸씩 가면 \(\lfloor \cdot / S \rfloor\) 번 옮길 수 있으며, 처음 자리까지 세어 1 을 더한 것이다.

손계산 — 96×96 그림에 세 가지 합성곱
\(F = 3,\ S = 1,\ P = 1:\qquad \left\lfloor \frac{96 - 3 + 2}{1} \right\rfloor + 1 = 95 + 1 = 96\)
3×3 커널에 패딩 1 이면 크기가 유지된다. 가장 흔한 설정이다.
\(F = 3,\ S = 2,\ P = 1:\qquad \left\lfloor \frac{96 - 3 + 2}{2} \right\rfloor + 1 = \lfloor 47.5 \rfloor + 1 = 48\)
스트라이드 2 로 절반이 된다. RF-DETR 프로젝터가 특징 맵을 절반으로 줄일 때 쓰는 설정이다.
\(F = 16,\ S = 16,\ P = 0:\qquad \left\lfloor \frac{96 - 16}{16} \right\rfloor + 1 = 5 + 1 = 6\)
커널과 스트라이드가 같으면 커널이 겹치지 않고 타일처럼 깔린다. 96×96 그림이 6×6 = 36칸이 된다.

채널까지 적으면 합성곱 층은 (B, C_in, H, W) → (B, C_out, H', W') 이고, 매개변수는 가중치 \(C_{\text{out}} \times C_{\text{in}} \times F \times F\) 개와 편향 \(C_{\text{out}}\) 개다. 3채널을 8채널로 바꾸는 3×3 합성곱이라면 \(8 \times 3 \times 3 \times 3 + 8 = 224\) 개다.

def conv_out(n_in: int, kernel: int, stride: int = 1, padding: int = 0) -> int:
    """출력 크기 = ⌊(n_in − F + 2P) / S⌋ + 1."""
    return (n_in - kernel + 2 * padding) // stride + 1

x = torch.randn(2, 3, 96, 96)  # (B, C, H, W): 도형 세상 그림 두 장
for kernel, stride, padding in [(3, 1, 1), (3, 2, 1), (1, 1, 0), (16, 16, 0)]:
    conv = nn.Conv2d(3, 8, kernel_size=kernel, stride=stride, padding=padding)
    n_params = sum(p.numel() for p in conv.parameters())
    print(f"  커널 {kernel:>2} · 스트라이드 {stride:>2} · 패딩 {padding}: 공식 {conv_out(96, kernel, stride, padding):>2} → 실제 {tuple(conv(x).shape)}, 매개변수 {n_params}")
up = nn.ConvTranspose2d(8, 8, kernel_size=2, stride=2)  # 전치 합성곱: (n − 1)·S − 2P + F = 2n
print(f"  전치 합성곱 커널 2 · 스트라이드 2: {tuple(torch.randn(2, 8, 6, 6).shape)} → {tuple(up(torch.randn(2, 8, 6, 6)).shape)}")

1×1 합성곱과 패치 나누기

특별한 두 경우가 뒤 장에서 자주 나온다.

  • 1×1 합성곱(1×1 convolution, pointwise convolution)(\(F = 1\))은 이웃을 전혀 보지 않는다. 위치마다 \(C_{\text{in}}\) 개의 숫자를 \(C_{\text{out}}\) 개로 바꾸는, 모든 위치가 가중치를 함께 쓰는 선형 층이다. 채널 수를 바꾸거나(프로젝터의 C2f), 위치마다 분류 로짓을 낼 때(이 장 끝의 실험) 쓴다.
  • 스트라이드 = 커널인 합성곱은 “그림을 겹치지 않는 \(F \times F\) 조각으로 자르고, 조각마다 같은 선형 층을 적용하는 것” 과 같다. 이 조각을 패치라고 부르고, 6장의 ViT 는 이 합성곱 하나로 그림을 토큰 열로 바꾼다. RF-DETR (nano) 는 384×384 그림을 16×16 패치로 나누므로 \(384 / 16 = 24\), 곧 \(24 \times 24 = 576\) 개의 토큰이 된다.

# 스트라이드 = 커널 = 16 인 합성곱은 "16×16 패치로 자르고, 패치마다 같은 선형 층" 과 같다
conv = nn.Conv2d(3, 8, kernel_size=16, stride=16)
by_conv = conv(x)  # (2, 8, 6, 6)
patches = x.reshape(2, 3, 6, 16, 6, 16).permute(0, 2, 4, 1, 3, 5).reshape(2, 36, 3 * 16 * 16)  # (2, 36, 768)
linear_w = conv.weight.reshape(8, 3 * 16 * 16)  # 커널을 펴면 선형 층의 가중치 (8, 768)
by_linear = patches @ linear_w.T + conv.bias  # (2, 36, 8): 패치 36개 각각에 같은 선형 층
by_linear = by_linear.reshape(2, 6, 6, 8).permute(0, 3, 1, 2)  # (2, 8, 6, 6) 으로 되돌려 비교
print(f"  check: 패치 나누기 + 선형 층 vs 합성곱(커널 16 · 스트라이드 16) 최대 차이 {(by_conv - by_linear).abs().max().item():.1e}")
[8] 합성곱 출력 크기 · 패치 나누기
  커널  3 · 스트라이드  1 · 패딩 1: 공식 96 → 실제 (2, 8, 96, 96), 매개변수 224
  커널  3 · 스트라이드  2 · 패딩 1: 공식 48 → 실제 (2, 8, 48, 48), 매개변수 224
  커널  1 · 스트라이드  1 · 패딩 0: 공식 96 → 실제 (2, 8, 96, 96), 매개변수 32
  커널 16 · 스트라이드 16 · 패딩 0: 공식  6 → 실제 (2, 8, 6, 6), 매개변수 6152
  전치 합성곱 커널 2 · 스트라이드 2: (2, 8, 6, 6) → (2, 8, 12, 12)
  check: 패치 나누기 + 선형 층 vs 합성곱(커널 16 · 스트라이드 16) 최대 차이 1.1e-06
  check: 1×1 합성곱 vs 위치마다의 선형 층 최대 차이 2.4e-07

공식으로 구한 출력 크기가 실제 모양과 같고, 매개변수 수도 손계산(224개)과 같다. 마지막 두 줄이 위의 두 주장을 확인해 준다. 합성곱(커널 16 · 스트라이드 16)의 출력이 “패치로 자르고 선형 층” 의 출력과, 1×1 합성곱의 출력이 “위치마다의 선형 층” 의 출력과 반올림 오차 수준(\(10^{-6}\) – \(10^{-7}\), float32)에서 같다.

전치 합성곱

합성곱이 특징 맵을 줄인다면 전치 합성곱(transposed convolution)은 늘린다. 입력의 숫자 하나하나가 커널 크기만 한 도장을 출력에 찍고, 겹친 곳은 더한다. 출력 크기는 합성곱 공식을 뒤집은 \(n_{\text{out}} = (n_{\text{in}} - 1)\,S - 2P + F\) 이다. \(F = 2\), \(S = 2\), \(P = 0\) 이면 \((n_{\text{in}} - 1) \cdot 2 + 2 = 2\,n_{\text{in}}\) 으로 정확히 두 배가 된다(위 출력의 6 → 12). RF-DETR 의 프로젝터가 특징 맵을 두 배로 키울 때 이 설정(ConvTranspose2d(kernel_size=2, stride=2))을 쓴다.

PyTorch 최소한

텐서 모양 읽기

PyTorch 의 모든 데이터는 텐서(여러 축을 가진 숫자 배열)이고, 축마다의 길이를 적은 것이 모양(shape)이다. 딥러닝 코드의 오류 대부분이 모양이 안 맞아서 생기므로, 이 튜토리얼은 모양이 바뀌는 자리마다 주석으로 모양을 적는다. 자주 나올 모양은 다음과 같다.

무엇

모양

축의 뜻

그림 배치

(B, 3, H, W)

배치 · 색 채널(RGB) · 높이 · 너비

특징 맵

(B, C, H, W)

배치 · 채널 · 높이 · 너비 (합성곱의 입출력)

토큰 열

(B, N, D)

배치 · 토큰 수 · 토큰 하나의 차원 (Transformer 의 입출력, 5장)

분류 로짓

(B, Q, K)

배치 · 질의 수 · 클래스 수 (탐지기의 출력, 7장)

박스

(B, Q, 4)

배치 · 질의 수 · (cx, cy, w, h) (2장)

nn.Module 과 학습 고리 5단계

신경망은 nn.Module 을 상속한 클래스로 만든다. __init__ 에서 층(매개변수)을 만들고, forward 에 순전파를 적는다. 역전파는 autograd 가 한다. 예로, 도형 하나가 그려진 96×96 그림을 보고 원 · 사각형 · 삼각형 가운데 무엇인지 맞히는 작은 CNN(합성곱 신경망)을 만든다. 이 장에서 배운 부품(합성곱, 배치 정규화, ReLU, 선형 층, 소프트맥스 교차 엔트로피, AdamW)이 모두 들어 있다.

class ShapeClassifier(nn.Module):
    """도형 하나가 그려진 그림 (B, 3, 96, 96) → 클래스 로짓 (B, 3).

    [합성곱 → 배치 정규화 → ReLU] 를 세 번(매번 가로 · 세로 절반), 전체 평균, 선형 층.
    """

    def __init__(self, num_classes: int = NUM_CLASSES, width: int = 16):
        super().__init__()
        chans = [3, width, 2 * width, 4 * width]
        blocks = []
        for c_in, c_out in zip(chans[:-1], chans[1:]):
            blocks += [nn.Conv2d(c_in, c_out, 3, stride=2, padding=1), nn.BatchNorm2d(c_out), nn.ReLU()]
        self.features = nn.Sequential(*blocks)  # (B, 3, 96, 96) → (B, 64, 12, 12)
        self.classifier = nn.Linear(chans[-1], num_classes)

    def forward(self, images: torch.Tensor) -> torch.Tensor:
        feature_map = self.features(images)  # (B, 64, 12, 12)
        pooled = feature_map.mean(dim=(2, 3))  # (B, 64): 위치 축 평균(전역 평균 풀링)
        return self.classifier(pooled)  # (B, 3) 로짓 — 소프트맥스는 손실 함수 안에서 한다

학습은 언제나 같은 다섯 단계를 되풀이한다. 이 튜토리얼의 모든 학습 코드가 이 뼈대 위에 있다.

  1. optimizer.zero_grad() — 지난 스텝의 기울기를 지운다(PyTorch 는 기울기를 덮어쓰지 않고 더해 두기 때문).
  2. logits = model(x) — 순전파.
  3. loss = … — 손실 계산.
  4. loss.backward() — 역전파. 모든 매개변수의 .grad 가 채워진다.
  5. optimizer.step() — 옵티마이저가 기울기를 보고 매개변수를 고친다.

torch.manual_seed(args.seed)
model = ShapeClassifier().to(device)
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-4)
batch_size = 64
history = []
for epoch in range(1, epochs + 1):
    model.train()  # 학습 모드: 배치 정규화가 배치 통계를 쓰고 이동 통계를 갱신한다
    order = torch.randperm(len(train_x), device=device)
    total = 0.0
    for start in range(0, len(order), batch_size):
        index = order[start:start + batch_size]
        optimizer.zero_grad()  # ① 지난 스텝의 기울기를 지운다
        logits = model(train_x[index])  # ② 순전파: (B, 3, 96, 96) → (B, 3)
        loss = F.cross_entropy(logits, train_y[index])  # ③ 손실: 소프트맥스 교차 엔트로피(배치 평균)
        loss.backward()  # ④ 역전파: 모든 매개변수의 .grad 를 채운다
        optimizer.step()  # ⑤ 갱신: θ ← θ − (AdamW 가 정한 양)
        total += loss.item() * len(index)
    model.eval()  # 추론 모드: 배치 정규화가 이동 통계를 쓴다
    with torch.no_grad():  # 평가에는 기울기가 필요 없다
        val_logits = model(val_x)
        val_loss = F.cross_entropy(val_logits, val_y).item()
        val_acc = (val_logits.argmax(dim=1) == val_y).float().mean().item()
    history.append((total / len(train_x), val_loss, val_acc))
    print(f"  에폭 {epoch:>2}: 학습 손실 {history[-1][0]:.4f}  검증 손실 {val_loss:.4f}  검증 정확도 {100 * val_acc:.1f}%")
[10] 도형 분류 CNN: 학습 고리 5단계
  학습 (1500, 3, 96, 96) · 검증 (500, 3, 96, 96), 클래스별 학습 그림 수 [508, 508, 484]
  에폭  1: 학습 손실 1.0374  검증 손실 1.0607  검증 정확도 42.2%
  에폭  2: 학습 손실 0.9444  검증 손실 0.9748  검증 정확도 61.4%
  에폭  3: 학습 손실 0.7705  검증 손실 0.7514  검증 정확도 67.2%
  에폭  4: 학습 손실 0.5817  검증 손실 0.5064  검증 정확도 97.8%
  에폭  5: 학습 손실 0.4259  검증 손실 0.3701  검증 정확도 99.8%
  에폭  6: 학습 손실 0.3077  검증 손실 0.2723  검증 정확도 99.2%
  에폭  7: 학습 손실 0.2336  검증 손실 0.2046  검증 정확도 100.0%
  에폭  8: 학습 손실 0.1783  검증 손실 0.1609  검증 정확도 100.0%
  혼동 행렬 (행 = 정답, 열 = 예측; 원 · 사각형 · 삼각형)
    [160, 0, 0]
    [0, 172, 0]
    [0, 0, 168]
  매개변수 24,003개, 마지막 검증 정확도 100.0% (500/500)
  (참고) model.train() 인 채로 2장씩 넣어 평가하면 검증 정확도 74.8%
  그림 저장: ch04-shape-cnn.png

  • 그림: 그림 4-7 도형 분류 CNN 의 학습 곡선(왼쪽)과 검증 그림 8장에 대한 예측(오른쪽, 제목은 예측 클래스와 그 확률).

결과를 읽는다.

  • 8 에폭 뒤 검증 정확도는 100.0%(500장 가운데 500장)이고, 혼동 행렬의 대각선 밖은 모두 0 이다. 도형 하나짜리 그림을 분류하는 것은 매개변수 24,003개짜리 CNN 으로 충분한 쉬운 문제다.
  • 그림 4-7 왼쪽에서 학습 손실과 검증 손실이 나란히 내려간다(검증 손실만 다시 올라가는 과적합의 신호가 없다). 정확도는 3 에폭까지 42 – 67% 에 머물다가 4 에폭에서 97.8% 로 뛰어오른다.
  • 오른쪽 여덟 장의 예측은 모두 맞고, 확률은 0.75 – 0.98 이다. 소프트맥스 교차 엔트로피로 학습했으므로 세 클래스의 확률을 더하면 1 이다.
  • 마지막 줄이 “학습 모드와 추론 모드” 상자의 실례다. 같은 모델을 model.train() 인 채로 2장씩 넣어 평가하면 정확도가 74.8% 로 떨어진다. 배치 정규화가 학습 때 기억해 둔 이동 통계 대신 그 2장의 통계로 정규화하기 때문이다. 평가 전에 model.eval() 을 부르는 것은 선택이 아니다.

실험: 불균형한 분류를 세 가지로 학습하기

이 장의 식들이 실제 학습에서 어떤 차이를 만드는지 도형 세상에서 확인한다. 탐지기를 통째로 만들기에는 아직 이르므로(7장), 탐지기의 분류 출력과 같은 성격의 문제를 하나 만든다.

과제: 도형 중심이 있는 칸 찾기

96×96 그림을 12×12 격자(칸 하나가 8×8 픽셀)로 나누고, 칸마다 · 클래스마다 “이 칸에 이 클래스 도형의 중심이 있는가” 를 묻는다. 그림 한 장에 칸이 \(3 \times 12 \times 12 = 432\) 개이고, 양성은 그림에 있는 도형 수(1 – 4개)뿐이다.

def center_targets(dataset: ShapesDataset, grid: int = GRID) -> torch.Tensor:
    """그림마다 (클래스 3, 격자 12, 격자 12) 의 0/1 목표. "클래스 k 인 도형의 중심이 이 칸에 있는가".

    한 그림의 칸은 3 × 12 × 12 = 432개이고 양성은 도형 수(1 – 4개)뿐이다 → 양성 약 0.6%.
    """
    targets = torch.zeros(len(dataset), NUM_CLASSES, grid, grid)
    for i, target in enumerate(dataset.targets):
        for (cx, cy, _w, _h), cls in zip(target["boxes"].tolist(), target["labels"].tolist()):
            col, row = min(int(cx * grid), grid - 1), min(int(cy * grid), grid - 1)  # 중심이 떨어지는 칸
            targets[i, cls, row, col] = 1.0
    return targets

모델은 합성곱 다섯 층과 1×1 합성곱 머리로 된 작은 CNN 이다. 출력 (B, 3, 12, 12) 의 칸마다 독립인 시그모이드를 씌운다. 탐지기의 분류 출력 (B, Q, K) 에서 질의 자리를 격자 칸으로 바꾼 축소판이라고 보면 된다.

class CenterGridNet(nn.Module):
    """그림 (B, 3, 96, 96) → 칸마다 · 클래스마다의 로짓 (B, 3, 12, 12). 클래스마다 독립인 시그모이드를 쓴다.

    prior_prob 을 주면 마지막 층의 편향을 b = −log((1 − π)/π) 로 둔다 (RF-DETR 의 class_embed 와 같은 초기화).
    주지 않으면 PyTorch 의 기본 초기화(0 근처의 작은 값)를 그대로 쓴다 → 처음 예측이 0.5 근처.
    """

    def __init__(self, num_classes: int = NUM_CLASSES, width: int = 32, prior_prob: float | None = None):
        super().__init__()
        self.body = nn.Sequential(
            nn.Conv2d(3, width, 3, stride=2, padding=1), nn.ReLU(),  # (B, 32, 48, 48)
            nn.Conv2d(width, 2 * width, 3, stride=2, padding=1), nn.ReLU(),  # (B, 64, 24, 24)
            nn.Conv2d(2 * width, 2 * width, 3, stride=2, padding=1), nn.ReLU(),  # (B, 64, 12, 12)
            nn.Conv2d(2 * width, 2 * width, 3, padding=1), nn.ReLU(),  # 12×12 를 유지하며 주변을 더 본다
            nn.Conv2d(2 * width, 2 * width, 3, padding=1), nn.ReLU(),
        )
        self.head = nn.Conv2d(2 * width, num_classes, kernel_size=1)  # 1×1 합성곱 = 칸마다의 선형 분류 머리
        if prior_prob is not None:
            nn.init.constant_(self.head.bias, prior_bias(prior_prob))

    def forward(self, images: torch.Tensor) -> torch.Tensor:
        return self.head(self.body(images))

세 가지 설정을 비교한다.

설정

손실

마지막 층 편향

처음 예측

(a) BCE + 기본 편향

BCE

PyTorch 기본 초기화(0 근처)

모든 칸 0.5 근처

(b) BCE + 사전 확률 편향

BCE

\(-4.5951\) (\(\pi = 0.01\))

모든 칸 0.01 근처

(c) 포컬 + 사전 확률 편향

포컬 손실 (\(\alpha = 0.25\), \(\gamma = 2\))

\(-4.5951\) (\(\pi = 0.01\))

모든 칸 0.01 근처

나머지 조건은 모두 같다.

  • 데이터: 학습 2,000장(시드 0), 검증 500장(시드 1). 배치 32.
  • 손실의 크기: 세 설정 모두 배치 안 모든 칸의 손실 합을 그 배치의 양성 수로 나눈다(공식 구현과 같은 방식).
  • 옵티마이저: AdamW(학습률 \(10^{-3}\), 가중치 감쇠 \(10^{-4}\))로 30 에폭. 그리고 포컬 손실 논문이 쓴 옵티마이저인 SGD(학습률 0.01, 모멘텀 0.9)로도 12 에폭을 따로 돌려 초기 안정성을 본다.
  • 설정이 달라도 같은 시드이면 몸통의 초기 가중치와 배치 순서가 같다. 시드 3개(0, 1, 2)로 되풀이해 평균과 표준편차를 본다.

지표는 검증 데이터의 모든 칸(500 × 432 = 216,000칸)을 한 줄로 펴서 잰다.

  • 양성 재현율 · 정밀도(3장): 확률이 문턱값 0.5 이상인 칸을 “양성이라고 예측한 칸” 으로 보고 계산한다.
  • AP(3장): 칸을 확률이 높은 순으로 늘어놓고, 양성 칸이 나올 때마다 그때까지의 정밀도를 적어 평균 낸 값. 문턱값을 정하지 않아도 되는 지표다.
  • 평균 \(p\): 모든 칸의 예측 확률의 평균. 실제 양성 비율과 비교한다.

@torch.no_grad()
def cell_metrics(logits: torch.Tensor, targets: torch.Tensor, threshold: float = 0.5) -> dict:
    """모든 칸을 한 줄로 펴서 잰 양성 재현율 · 정밀도(문턱값 0.5)와 평균 정밀도(AP, 문턱값과 무관).

    AP: 칸을 점수가 높은 순으로 늘어놓고, 양성 칸이 나올 때마다 그때까지의 정밀도를 적어 평균 낸 값.
    """
    scores, labels = torch.sigmoid(logits).flatten(), targets.flatten() > 0.5
    predicted = scores >= threshold
    tp = (predicted & labels).sum().item()
    order = scores.argsort(descending=True)
    hits = labels[order].double()
    precision_at = hits.cumsum(0) / torch.arange(1, len(hits) + 1, device=hits.device)
    return {
        "recall": tp / max(labels.sum().item(), 1),
        "precision": tp / max(predicted.sum().item(), 1),
        "ap": ((precision_at * hits).sum() / hits.sum()).item(),
        "mean_p": scores.mean().item(),
    }
def train_center(train_x, train_t, val_x, val_t, loss_name: str, prior_prob, optimizer_name: str, epochs: int,
                 seed: int, batch_size: int = 32) -> dict:
    """설정 하나를 학습한다. 돌려주는 값: 스텝마다의 손실, 에폭마다의 검증 지표(0번은 학습 전), 모델."""
    torch.manual_seed(seed)  # 설정이 달라도 몸통의 초기 가중치와 배치 순서는 같다
    model = CenterGridNet(prior_prob=prior_prob).to(train_x.device)
    if optimizer_name == "adamw":
        optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-4)
    else:
        optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9, weight_decay=1e-4)

    def loss_fn(logits, targets):
        num_pos = targets.sum().clamp(min=1.0)  # 이 배치의 양성(도형) 수
        if loss_name == "bce":
            return bce_with_logits(logits, targets).sum() / num_pos
        return sigmoid_focal_loss(logits, targets, num_pos, alpha=0.25, gamma=2.0)

    def evaluate():
        model.eval()
        with torch.no_grad():
            logits = torch.cat([model(val_x[i:i + 256]) for i in range(0, len(val_x), 256)])
        model.train()
        return cell_metrics(logits, val_t)

    losses, history, diverged = [], [evaluate()], False
    generator = torch.Generator().manual_seed(seed)
    for _epoch in range(epochs):
        order = torch.randperm(len(train_x), generator=generator).to(train_x.device)
        for start in range(0, len(order) - batch_size + 1, batch_size):
            index = order[start:start + batch_size]
            optimizer.zero_grad()  # ① 기울기 비우기
            logits = model(train_x[index])  # ② 순전파 (B, 3, 12, 12)
            loss = loss_fn(logits, train_t[index])  # ③ 손실
            if not torch.isfinite(loss):
                diverged = True
                break
            loss.backward()  # ④ 역전파
            optimizer.step()  # ⑤ 매개변수 갱신
            losses.append(loss.item())
        if diverged:
            break
        history.append(evaluate())
    return {"losses": losses, "history": history, "model": model, "diverged": diverged}

결과

실행 출력의 [9] 부분이다. 옵티마이저마다 표가 셋(학습 초반, 마지막 에폭, 에폭별 AP)이고, 끝에 문턱값을 바꿔 본 표가 있다.

[9] 불균형 실험: 도형 중심이 있는 칸 찾기
  학습 2000장 · 검증 500장, 목표 모양 (2000, 3, 12, 12), 그림당 칸 432개
  양성 칸: 학습 4995개 / 864000칸 = 0.578% (그림당 평균 2.50개)
  모델 매개변수 130,371개, 배치 32 (에폭당 62 스텝), 시드 [0, 1, 2]
  ── 옵티마이저 AdamW (lr 1e-3), 30 에폭, 시드 3개 평균
  설정                         처음 평균 p | 손실: 1스텝째  10스텝째  100스텝째 | 1에폭 뒤: 평균 p    AP
  (a) BCE + 기본 편향            0.4991   |       121.03     18.73       4.75  |        0.0071  0.016
  (b) BCE + 사전 확률 편향       0.0101   |         6.36      5.45       2.32  |        0.0060  0.341
  (c) 포컬 + 사전 확률 편향      0.0101   |         1.13      0.56       0.45  |        0.0597  0.048
  마지막 에폭(30)의 검증 지표 (평균±표준편차)   평균 p     재현율         정밀도         AP          발산
  (a) BCE + 기본 편향                         0.0057   0.829±0.027   0.872±0.014   0.928±0.010   0/3
  (b) BCE + 사전 확률 편향                    0.0057   0.834±0.017   0.862±0.020   0.928±0.010   0/3
  (c) 포컬 + 사전 확률 편향                   0.0105   0.710±0.030   0.923±0.006   0.914±0.005   0/3
  에폭별 검증 AP                       1       2       4       8      12      20      30
  (a) BCE + 기본 편향             0.016   0.132   0.504   0.813   0.878   0.918   0.928
  (b) BCE + 사전 확률 편향        0.341   0.599   0.807   0.888   0.917   0.929   0.928
  (c) 포컬 + 사전 확률 편향       0.048   0.074   0.295   0.641   0.819   0.889   0.914
  ── 옵티마이저 SGD (lr 0.01, 모멘텀 0.9), 12 에폭, 시드 3개 평균
  설정                         처음 평균 p | 손실: 1스텝째  10스텝째  100스텝째 | 1에폭 뒤: 평균 p    AP
  (a) BCE + 기본 편향            0.4991   |       121.03      9.18       5.54  |        0.0071  0.039
  (b) BCE + 사전 확률 편향       0.0101   |         6.36      6.22       5.15  |        0.0047  0.100
  (c) 포컬 + 사전 확률 편향      0.0101   |         1.13      1.12       0.56  |        0.0358  0.031
  마지막 에폭(12)의 검증 지표 (평균±표준편차)   평균 p     재현율         정밀도         AP          발산
  (a) BCE + 기본 편향                         0.0049   0.445±0.320   0.750±0.136   0.661±0.270   0/3
  (b) BCE + 사전 확률 편향                    0.0060   0.783±0.027   0.839±0.032   0.891±0.030   0/3
  (c) 포컬 + 사전 확률 편향                   0.0301   0.284±0.101   0.875±0.028   0.714±0.009   0/3
  에폭별 검증 AP                       1       2       4       8      12
  (a) BCE + 기본 편향             0.039   0.077   0.217   0.424   0.661
  (b) BCE + 사전 확률 편향        0.100   0.183   0.531   0.822   0.891
  (c) 포컬 + 사전 확률 편향       0.031   0.062   0.209   0.511   0.714
  ── 문턱값에 따른 검증 재현율 · 정밀도 (AdamW, 첫 시드, 마지막 에폭)
  (a) BCE + 기본 편향          문턱 0.3: 0.907 · 0.820   문턱 0.5: 0.866 · 0.864   문턱 0.7: 0.809 · 0.899   | 양성 칸의 확률 중앙값 0.991
  (b) BCE + 사전 확률 편향     문턱 0.3: 0.859 · 0.853   문턱 0.5: 0.823 · 0.885   문턱 0.7: 0.784 · 0.912   | 양성 칸의 확률 중앙값 0.996
  (c) 포컬 + 사전 확률 편향    문턱 0.3: 0.900 · 0.765   문턱 0.5: 0.742 · 0.915   문턱 0.7: 0.513 · 0.979   | 양성 칸의 확률 중앙값 0.709
  그림 저장: ch04-centers.png
  그림 저장: ch04-imbalance.png
  • 그림: 그림 4-8 위: 검증 그림 4장과 양성 칸(초록 네모, 옆의 글자는 클래스: cir 원, rec 사각형, tri 삼각형). 아래: 설정 (c) 로 학습한 모델(시드 0)이 예측한 확률을 칸마다 세 클래스 가운데 최댓값으로 그린 것. 흰 표식이 정답 칸이다.

그림 4-8 의 위 줄에서 과제를 확인한다. 144칸 가운데 초록 네모는 도형 수만큼뿐이다. 아래 줄에서 모델은 대부분의 칸에 0 에 가까운 확률을, 정답 칸과 그 바로 옆 칸에 높은 확률을 준다. 중심이 칸의 경계 가까이 있으면 옆 칸과 헷갈리는 것이 이 과제의 주된 오류다(이 때문에 AP 가 1 에 닿지 않는다).

  • 그림: 그림 4-9 위 줄 AdamW(30 에폭), 아래 줄 SGD(12 에폭). 왼쪽: 처음 150 스텝의 학습 손실(두 축 모두 로그 눈금). 가운데: 검증 양성 재현율(문턱값 0.5). 오른쪽: 검증 AP. 선은 시드 3개의 평균, 옅은 띠는 최솟값 – 최댓값. 실선 (a), 파선 (b), 일점쇄선 (c).

결과 읽기: 사전 확률 편향

첫 손실이 계산대로다. 그림당 칸 432개, 양성 평균 2.5개로 손계산하면 다음과 같고, 출력의 “1스텝째” 열과 맞다.

설정

손계산

실제 첫 손실

(a)

\(432 \times 0.6931 / 2.5 = 119.8\)

121.03 (처음 예측이 정확히 0.5 는 아니어서 조금 다름)

(b)

\((2.5 \times 4.6052 + 429.5 \times 0.01005) / 2.5 = 6.33\)

6.36

(c)

\(0.25 \times 0.99^2 \times 4.6052 = 1.13\) (음성의 몫은 무시할 만큼 작음)

1.13

(a) 는 처음 수십 스텝을 “음성 칸 끌어내리기” 에 쓴다.

  • 그림 4-9 왼쪽 위에서 (a) 의 손실은 121 에서 출발해 10스텝째 18.73, 100스텝째 4.75 로 가파르게 떨어진다. 이 구간에서 배우는 것은 “거의 모든 칸이 음성” 이라는, 편향 하나로 표현되는 사실뿐이다. (b) 는 그 사실을 알고 시작한다.
  • 그 차이가 초반 성능에 그대로 나타난다. 1 에폭 뒤 검증 AP 가 (a) 0.016, (b) 0.341 이고, 4 에폭 뒤 0.504 대 0.807 이다.
  • 가운데 그림에서 (a) 의 0 에폭 재현율이 0.5 근처인 것은 성능이 아니다. 모든 칸의 확률이 0.5 근처라 절반쯤이 우연히 문턱값을 넘은 것이고, 1 에폭 뒤에는 0 으로 떨어진다.

AdamW 에서는 (a) 가 결국 따라잡는다. 20 에폭에서 0.918 대 0.929, 30 에폭에서는 둘 다 \(0.928 \pm 0.010\) 이다. Adam 은 기울기의 크기를 지우므로 첫 손실이 121 이든 6 이든 한 스텝에 움직이는 양이 비슷하고, 그래서 큰 초기 손실이 학습을 망가뜨리지 않는다.

SGD 에서는 차이가 훨씬 크다. SGD 는 기울기에 비례해 움직이므로 큰 초기 손실이 그대로 큰 갱신이 된다.

  • 12 에폭 뒤 검증 AP 가 (a) \(0.661 \pm 0.270\), (b) \(0.891 \pm 0.030\) 이다. (a) 는 평균도 낮지만 시드에 따라 결과가 크게 갈린다(그림 4-9 아래 줄의 넓은 파란 띠).
  • 이 실험에서는 손실이 nan 이 되는 발산은 한 번도 없었다(“발산” 열 0/3). 포컬 손실 논문이 보고한 발산은 훨씬 크고 깊은 탐지기(RetinaNet)에서 약 10만 개의 자리를 두고 일어난 일이다. 여기서는 “발산” 대신 “느리고 시드에 따라 들쭉날쭉한 학습” 으로 나타났다.

결과 읽기: 포컬 손실은 왜 이기지 못했나

이 실험에서 포컬 손실 (c) 는 BCE (b) 를 이기지 못했다. 결과를 그대로 적으면 다음과 같다.

AdamW, 검증

(b) BCE + 사전 확률 편향

(c) 포컬 + 사전 확률 편향

AP, 4 에폭 뒤

0.807

0.295

AP, 12 에폭 뒤

0.917

0.819

AP, 30 에폭 뒤

\(0.928 \pm 0.010\)

\(0.914 \pm 0.005\)

재현율(문턱값 0.5), 30 에폭 뒤

\(0.834 \pm 0.017\)

\(0.710 \pm 0.030\)

정밀도(문턱값 0.5), 30 에폭 뒤

\(0.862 \pm 0.020\)

\(0.923 \pm 0.006\)

양성 칸의 확률 중앙값 (시드 0)

0.996

0.709

포컬 손실은 배우는 속도가 느렸고, 30 에폭 뒤 AP 는 0.014 낮은 데까지 따라왔으며(시드 간 표준편차가 0.005 – 0.010 이므로 큰 차이는 아니다), 문턱값 0.5 에서의 재현율은 뚜렷이 낮았다. SGD 에서도 12 에폭 뒤 AP 가 0.714 대 0.891 로 뒤졌다. 이유를 셋으로 나누어 본다.

① 포컬 손실은 확률을 1 까지 밀어 올리지 않는다.

  • 양성 칸의 확률이 0.7 쯤 되면 조절 인자 \((1 - 0.7)^2 = 0.09\) 가 그 칸의 손실을 11분의 1 로 줄여 버린다. 더 올릴 이유가 거의 없어진다. 그래서 양성 칸의 확률 중앙값이 BCE 는 0.996, 포컬은 0.709 이다.
  • 재현율의 차이는 대부분 여기서 나온다. 문턱값을 0.3 으로 낮추면 포컬의 재현율은 0.900 으로 BCE 의 0.859 보다 높아지고(대신 정밀도가 0.765 대 0.853 으로 낮다), 문턱값 0.7 에서는 0.513 으로 뚝 떨어진다. 출력의 마지막 표가 이것을 보여 준다.
  • 문턱값과 무관한 AP 로 보면 두 모델의 “순서를 매기는 능력” 은 거의 같다. 포컬 손실로 학습한 모델의 확률은 낮게 나오므로, 문턱값을 BCE 모델과 같은 값으로 두면 안 된다.
  • 평균 \(p\) 도 같은 이야기를 한다. 실제 양성 비율은 0.58% 인데, 30 에폭 뒤 평균 \(p\) 가 BCE 는 0.0057 로 그 비율과 같고(확률이 잘 맞춰져 있음), 포컬은 0.0105 로 거의 두 배다. 포컬 손실은 쉬운 음성 칸의 확률을 0 까지 끌어내리는 데에도 관심이 적다.

② 포컬 손실은 출발이 느리다. 모든 칸이 \(p = 0.01\) 인 학습 시작 순간에, 그림 한 장의 음성 칸 429.5개가 “내려라” 고 미는 힘과 양성 칸 2.5개가 “올려라” 고 미는 힘(로짓에 대한 기울기의 합)을 비교한다.

손계산 — 학습 시작 순간(\(p = 0.01\))의 기울기
\(\text{BCE:}\quad \text{음성 한 칸 } p - 0 = 0.01, \qquad \text{양성 한 칸 } p - 1 = -0.99\)
BCE 의 기울기는 \(p - y\).
\(\text{BCE, 그림 한 장:}\quad 429.5 \times 0.01 = 4.30 \ \text{(내려라)} \quad\text{대}\quad 2.5 \times 0.99 = 2.48 \ \text{(올려라)}\)
음성 쪽과 양성 쪽이 비슷한 크기로 맞선다. 처음부터 “어느 칸이 양성인가” 를 가려내는 신호가 흐른다.
\(\text{포컬, 음성 한 칸:}\quad (1 - \alpha)\,p^{\gamma}\big(p - \gamma(1 - p)\log(1 - p)\big) = 0.75 \times 0.01^2 \times (0.01 + 0.0199) = 2.24 \times 10^{-6}\)
앞에서 유도한 음성 칸의 기울기 식. \(-2 \times 0.99 \times \log 0.99 = 0.0199\). 조절 인자 \(p^2 = 10^{-4}\) 때문에 BCE 의 약 4,500분의 1 이다.
\(\text{포컬, 양성 한 칸:}\quad \alpha\,(1 - p)^{\gamma}\big(\gamma\,p \log p + p - 1\big) = 0.25 \times 0.99^2 \times (-0.0921 - 0.99) = -0.265\)
\(2 \times 0.01 \times \log 0.01 = -0.0921\).
\(\text{포컬, 그림 한 장:}\quad 429.5 \times 2.24 \times 10^{-6} = 0.00096 \ \text{(내려라)} \quad\text{대}\quad 2.5 \times 0.265 = 0.66 \ \text{(올려라)}\)
“내려라” 가 “올려라” 의 약 700분의 1 이다. 음성 칸이 거의 저항하지 않는다.

그래서 포컬 손실로 학습을 시작하면 신경망은 먼저 모든 칸의 확률을 함께 올린다(편향만 키우면 되는 가장 쉬운 방법). 음성 칸의 확률이 충분히 올라와 조절 인자가 커진 뒤에야 음성 쪽의 저항이 생기고, 그제야 양성과 음성을 가려내기 시작한다. 출력에 그 흔적이 있다. 1 에폭 뒤 평균 \(p\) 가 (b) 는 0.0060 인데 (c) 는 0.0597 로, 실제 양성 비율의 열 배다. 그 뒤의 AP 곡선(그림 4-9 오른쪽 위)은 (b) 보다 몇 에폭씩 늦게 따라간다.

③ 이 과제에는 포컬 손실이 고칠 병이 별로 없다.

  • 양성 대 음성이 약 1 : 172 이고 칸은 그림당 432개다. 포컬 손실 논문이 겨냥한 것은 그림당 약 10만 자리, 1 : 1000 수준의 불균형이다.
  • 도형 세상의 음성 칸은 대부분 밋밋한 어두운 배경이라 아주 쉽다. (b) 의 BCE 는 1 에폭 만에 평균 \(p\) 를 실제 양성 비율 근처(0.0060)로 맞추고, 그 뒤로는 음성 칸의 손실 합이 학습을 가로막지 않는다. 앞의 24,000칸 계산에서 가정한 “쉬운 음성의 손실 합이 양성을 압도하는” 상황이 이 작은 과제에서는 오래 지속되지 않는다.
  • 그러면 포컬 손실의 이득(쉬운 음성 지우기)은 얻을 것이 적고, 비용(①의 낮은 확률, ②의 느린 출발)만 남는다.

이 실험에서 말할 수 있는 것과 없는 것

  • 이 튜토리얼의 실험은 작은 CNN, 그림 2,000장, 설정마다 하이퍼파라미터 한 벌(\(\alpha = 0.25\), \(\gamma = 2\), 학습률 고정)로 한 것이다. 포컬 손실에 맞춰 학습률이나 \(\alpha\) 를 따로 고르지 않았다.
  • 포컬 손실 논문은 COCO 에서 RetinaNet 을 학습할 때 \(\gamma = 2\) 의 포컬 손실이 \(\alpha\) 균형만 쓴 교차 엔트로피보다 AP 가 2.9 높았다고 보고한다(5.1절). 조건이 전혀 다른 두 결과이므로 서로 모순이 아니다.
  • 가져갈 것은 “포컬 손실이 늘 더 좋다” 도 “쓸모없다” 도 아니다. 포컬 손실은 쉬운 음성이 압도적으로 많아 그 손실 합이 학습을 지배하는 병에 대한 처방이고, 병이 가벼우면 약효도 작다. 그리고 사전 확률 편향 초기화는 손실이 무엇이든 싸고 확실하게 듣는다.

RF-DETR 가 쓰는 IA-BCE(9장)는 이 실험의 두 관찰과 맞닿아 있다. 음성 칸에는 포컬 손실과 같은 조절 인자 \(p^2\) 를 써서 쉬운 음성을 지우되, 양성 칸에는 조절 인자 없이 부드러운 목표의 BCE 를 써서 점수가 목표(박스가 맞은 정도)까지 올라가게 한다.

정리

  • 신경망은 매개변수 \(\theta\) 를 가진 함수다. 선형 층 \(h = Wx + b\) 는 마지막 축 \(n \to m\), 매개변수 \(mn + m\) 개. 활성 함수는 ReLU(디코더 FFN), GELU(ViT), SiLU(프로젝터).
  • 학습은 \(\theta \leftarrow \theta - \eta\nabla_\theta L\). 역전파는 손실에서 거꾸로 (받은 기울기) × (국소 미분) 을 넘기는 연쇄 법칙이고, autograd 가 대신 한다.
  • Adam 은 기울기의 크기를 지우고 방향을 남긴다. AdamW 는 가중치 감쇠를 그 나눗셈 밖에 두어 \(\theta \leftarrow (1 - \eta\lambda)\theta\) 로 따로 줄인다.
  • 시그모이드 \(\sigma(z) = 1/(1 + e^{-z})\): \(\sigma(-z) = 1 - \sigma(z)\), \(\sigma' = \sigma(1 - \sigma)\), 로짓 \(z = \log\frac{p}{1 - p}\) 는 로그 오즈.
  • BCE \(= -y\log p - (1 - y)\log(1 - p)\) 는 베르누이 가능도의 음의 로그. 로짓에 대한 기울기는 \(p - y\). 계산은 로짓에서 바로: \(\max(z, 0) - zy + \log(1 + e^{-|z|})\). 부드러운 목표 \(t\) 의 최솟점은 \(p = t\).
  • DETR 은 소프트맥스 + 배경 클래스, Deformable DETR 이후와 RF-DETR 는 클래스별 시그모이드. “없음” 은 모든 클래스의 확률이 낮은 것이다.
  • 포컬 손실 \(\mathrm{FL} = -\alpha_t(1 - p_t)^\gamma\log p_t\) 는 잘 맞힌 칸의 손실을 깎는다(\(\gamma = 2\), \(p_t = 0.9\) 면 100분의 1). \(\gamma = 0\) 이면 BCE. 손실은 합을 양성 수로 나눈다.
  • 사전 확률 편향 초기화 \(b = -\log\frac{1 - \pi}{\pi}\) (\(\pi = 0.01\) 이면 \(-4.5951\))는 처음 예측을 \(\pi\) 로 맞춰 초기 손실을 크게 줄인다. RF-DETR 의 분류 머리가 이렇게 초기화된다.
  • 배치 정규화는 배치 축으로, 층 정규화는 특징 축으로 평균을 낸다. 배치가 작으면 배치 정규화의 통계가 \(1/\sqrt{B}\) 로 흔들린다. 잔차 연결 \(x + f(x)\) 는 미분에 1 을 더해 기울기의 지름길을 낸다.
  • 합성곱의 출력 크기는 \(\lfloor (n_{\text{in}} - F + 2P)/S \rfloor + 1\). 스트라이드 = 커널인 합성곱은 패치 나누기 + 선형 층이다.
  • 이 튜토리얼의 불균형 실험에서는 사전 확률 편향이 초반 학습(특히 SGD)을 뚜렷이 도왔고, 포컬 손실은 BCE 보다 느리게 배워 30 에폭 뒤 AP 가 비슷한 수준(0.914 대 0.928)에 닿았다.

이제 탐지기를 만드는 데 필요한 “일반적인” 부품은 갖추었다. 하지만 RF-DETR 의 몸통은 합성곱이 아니라 어텐션이다. 백본도, 디코더도, 예측 자리가 그림의 어느 곳을 볼지 정하는 방법도 모두 어텐션 위에 서 있다. 5장에서는 어텐션을 숫자 몇 개로 손계산하는 데서 출발해, 이 장의 선형 층 · 소프트맥스 · 층 정규화 · 잔차 연결을 조립해 Transformer 블록을 만든다.

확인 문제

1. nn.Linear(256, 4) 에 모양 (2, 300, 256) 인 텐서를 넣으면 출력 모양은? 이 층의 매개변수는 몇 개인가?
선형 층은 마지막 축만 바꾸므로 (2, 300, 4). 매개변수는 가중치 \(4 \times 256 = 1024\) 개와 편향 4개, 모두 1,028개다. (질의 300개마다 박스 좌표 4개를 내는 층의 모양이다.)
2. 본문의 2층 신경망에서 \(b_1 = 0.1\) 을 \(b_1 = -1.5\) 로 바꾸면(\(x = 2\), \(w_1 = 0.5\), \(w_2 = -1.5\), \(b_2 = 0.2\), \(y = 1\) 은 그대로) \(\frac{\partial L}{\partial w_1}\) 은 얼마인가?
\(u = 0.5 \cdot 2 - 1.5 = -0.5 \lt 0\) 이므로 \(h = \max(0, -0.5) = 0\), \(\hat{y} = -1.5 \cdot 0 + 0.2 = 0.2\), \(L = (0.2 - 1)^2 = 0.64\). 역전파에서 \(\frac{\partial L}{\partial \hat{y}} = -1.6\), \(\frac{\partial L}{\partial h} = -1.6 \times (-1.5) = 2.4\) 까지는 값이 있지만, ReLU 의 미분이 0(\(u \lt 0\))이라 \(\frac{\partial L}{\partial u} = 0\) 이고 \(\frac{\partial L}{\partial w_1} = 0 \cdot x = 0\) 이다. 1층은 이 입력에서 아무것도 배우지 못한다.
3. 로짓 \(z = -1\) 인 칸이 있다(\(\sigma(-1) = 0.2689\)). (1) 정답이 \(y = 1\) 일 때 BCE 와 로짓에 대한 기울기를 구하라. (2) 같은 손실을 수치 안정 형태로 계산해 값이 같은지 확인하라.
(1) \(\operatorname{BCE} = -\log 0.2689 = 1.3133\). 기울기는 \(p - y = 0.2689 - 1 = -0.7311\)(로짓을 키워라). (2) \(\max(-1, 0) - (-1)(1) + \log(1 + e^{-|-1|}) = 0 + 1 + \log(1.3679) = 1 + 0.3133 = 1.3133\). 같다.
4. 양성 칸의 목표가 \(t = 0.8\) 인 부드러운 목표 BCE 로 학습한다. 지금 예측이 \(p = 0.5\) 라면 로짓에 대한 기울기는 얼마이고, 학습이 충분히 되면 \(p\) 는 어디로 가는가? 그때의 손실은?
기울기는 \(p - t = 0.5 - 0.8 = -0.3\)(로짓을 키워라). 최솟점은 \(p = t = 0.8\) 이고, 그때의 손실은 \(-0.8\log 0.8 - 0.2\log 0.2 = 0.1785 + 0.3219 = 0.5004\) 이다. 0 이 아니다.
5. 음성 칸(\(y = 0\))에 모델이 \(p = 0.1\) 을 주었다. \(\alpha = 0.25\), \(\gamma = 2\) 인 포컬 손실과 BCE 를 각각 구하고, 포컬 손실이 BCE 의 몇 분의 1 인지 계산하라.
\(p_t = 1 - p = 0.9\). BCE \(= -\log 0.9 = 0.10536\). 포컬 손실은 \(\alpha_t = 1 - \alpha = 0.75\), 조절 인자 \((1 - 0.9)^2 = 0.01\) 이므로 \(0.75 \times 0.01 \times 0.10536 = 0.00079\). BCE 의 \(1 / (0.75 \times 0.01) \approx 133\) 분의 1 이다(조절 인자로 100분의 1, \(\alpha_t\) 로 다시 0.75배).
6. 사전 확률을 \(\pi = 0.05\) 로 잡으면 마지막 층의 편향은 얼마로 초기화해야 하는가? 칸이 1,000개이고 그 가운데 양성이 5개일 때, 이 초기화에서의 BCE 초기 손실(합 ÷ 양성 수)을 편향 0 일 때와 비교하라.
\(b = -\log\frac{0.95}{0.05} = -\log 19 = -2.944\). 편향 0: \(1000 \times 0.6931 / 5 = 138.6\). 편향 \(-2.944\): 양성 \(5 \times (-\log 0.05) = 5 \times 2.9957 = 14.98\), 음성 \(995 \times (-\log 0.95) = 995 \times 0.05129 = 51.04\), 합 \(66.02 / 5 = 13.2\). 약 10분의 1 이다.
7. 입력 \(x = \begin{pmatrix} 0 & 4 \\ 2 & 8 \end{pmatrix}\) (표본 2개, 특징 2개)의 첫째 표본을 배치 정규화와 층 정규화로 각각 정규화하라(\(\epsilon\) 은 무시, \(a = 1\), \(c = 0\)).
배치 정규화(열마다): 첫 열 \((0, 2)\) 는 평균 1, 분산 1 → \((0 - 1)/1 = -1\). 둘째 열 \((4, 8)\) 은 평균 6, 분산 4 → \((4 - 6)/2 = -1\). 첫째 표본은 \((-1, -1)\). 층 정규화(행마다): 첫 행 \((0, 4)\) 는 평균 2, 분산 4 → \(\big((0 - 2)/2,\ (4 - 2)/2\big) = (-1, 1)\). 둘째 표본이 무엇이든 이 답은 변하지 않는다.
8. RF-DETR (small) 은 512×512 그림을 16×16 패치로 나눈다. (1) 패치 나누기를 합성곱으로 한다면 커널 · 스트라이드 · 패딩은? (2) 토큰은 몇 개가 되는가? (3) 그 특징 맵에 커널 2 · 스트라이드 2 인 전치 합성곱을 적용하면 한 변의 크기는?
(1) 커널 16, 스트라이드 16, 패딩 0. (2) \(\lfloor (512 - 16)/16 \rfloor + 1 = 31 + 1 = 32\) 이므로 \(32 \times 32 = 1024\) 개. (3) \((32 - 1) \times 2 + 2 = 64\).

See also

Favorite site

author MCPBot sitemap