CHAPTER 10

RF-DETR 의 구조

부품은 다 모였습니다. 6장의 ViT 와 DINOv2, 7장의 집합 예측, 8장의 변형 어텐션과 2단계 방식, 9장의 윈도 어텐션 · 프로젝터 · 박스 재매개변수화를 이 장에서 한 대로 조립합니다. 그림 한 장이 들어가서 박스 300개가 나올 때까지 텐서의 모양이 어떻게 바뀌는지를 처음부터 끝까지 따라가고, 매개변수 3,047만 개가 어느 부품에 몇 개씩 있는지를 손으로 세어 실제 모델과 맞춥니다. 진짜 RF-DETR Nano 에서 잰 값과 도형 세상의 미니 RF-DETR 을 늘 나란히 놓습니다.

읽는 시간 약 100분난이도 ★★★★☆코드: code/ch10_rfdetr_model.py
이 장에서 배우는 것
이 장의 표기

조립할 부품과 완성품

RF-DETRRF-DETR 은 Roboflow 와 카네기 멜런 대학의 연구자들이 2025년에 내놓은 실시간 탐지기입니다(Robinson 외, ICLR 2026). 1장에서 한 문장으로 요약했습니다. LW-DETR 의 뼈대에 DINOv2 백본을 끼우고 가중치 공유 NAS 를 얹은 것. 이 장은 그 가운데 뼈대와 백본, 곧 “모델 하나가 어떻게 생겼는가” 만 다룹니다. 어떻게 학습시키는지는 11장, 한 번의 학습으로 여러 크기를 얻는 NAS 는 12장, 분할 머리는 13장입니다.

이 장에서 새로 배우는 연산은 거의 없습니다. 이미 만든 부품을 어떤 순서로, 어떤 모양으로 잇는지가 내용입니다. 부품과 그것을 배운 장을 먼저 적어 둡니다.

부품하는 일배운 곳이 장에서 더하는 것
패치 임베딩 · ViT 블록그림을 토큰 열로 바꾸고 어텐션으로 다듬는다5장 · 6장DINOv2-S 의 실제 크기, 패치 16
윈도 어텐션 · 윈도 우선 배치일부 블록은 윈도 안에서만 어텐션9장윈도마다 CLS 토큰 복제, 어느 블록이 윈도인가
프로젝터(C2f)여러 층의 특징을 탐지용 특징 맵 한 장으로9장Nano 의 모양과 매개변수 수
2단계 질의 선택그림을 보고 질의의 출발 박스를 고른다8장묶음별 머리, 재매개변수화, refpoint_embed
변형 교차 어텐션질의가 기준 박스 둘레의 몇 점만 읽는다8장머리 16 · 표본점 2 · 레벨 1 의 실제 설정
Group DETR학습 때 질의 묶음을 여러 개 둔다9장추론 때 쓰이지 않는 매개변수의 수
박스 재매개변수화델타로 기준 박스를 옮기고 키운다9장세 군데(제안 · 기준 · 머리)에서 쓰이는 방식
집합 손실 · 보조 손실모든 층의 출력에 헝가리안 손실7장출력 사전의 모양(손실 자체는 11장)

전체 지도

그림 10-1 이 이 장 전체의 지도입니다. 1장의 그림 1-7 과 같은 흐름이지만 이번에는 상자마다 텐서 모양 이 적혀 있습니다. 윗줄은 RF-DETR Nano 에 384×384 그림을 넣고 실제로 잰 모양이고, 아랫줄(흐린 글씨)은 도형 세상의 미니 RF-DETR 에 96×96 그림을 넣은 모양입니다. 둘 다 추론 모드입니다.

① 그림 RGB (B, 3, 384, 384) (B, 3, 96, 96) ② 패치 임베딩 + CLS · 위치, 윈도로 나눔 (4B, 145, 384) (4B, 37, 96) ③ ViT 블록 × 12 (미니 6) 윈도 블록 ↔ 전역 블록, view 만 바뀜 (4B, 145, 384) ↔ (B, 580, 384) (4B, 37, 96) ↔ (B, 148, 96) ④ 꺼낸 특징 맵 CLS 를 떼고 격자로 (B, 384, 24, 24) × 4 (B, 96, 12, 12) × 3 ⑤ 프로젝터 (P4) 채널로 이어 붙여 C2f (B, 256, 24, 24) (B, 128, 12, 12) memory 칸을 한 줄로 편 것 (B, 576, 256) (B, 144, 128) ⑥ 2단계 질의 선택 점수 상위 칸의 박스 → 기준 박스 (B, 300, 4) (B, 12, 4) 학습되는 질의 임베딩 query_feat · refpoint_embed (300, 256) · (300, 4) (12, 128) · (12, 4) 내용 질의 기준 박스 (모든 층 공유) 교차 어텐션이 읽는 특징 ⑦ 디코더 층 × 2 (미니 3) 자기 어텐션 → 변형 교차 어텐션 → FFN. 층마다의 출력에 층 정규화를 한 것이 hs hs: (2, B, 300, 256) hs: (3, B, 12, 128) ⑧ 분류 머리 (B, 300, 91) / (B, 12, 3) ⑧ 박스 머리 (B, 300, 4) / (B, 12, 4) 모양의 윗줄 = RF-DETR Nano (384×384, 실측), 아랫줄 = 미니 RF-DETR (96×96). B = 배치 크기, 추론 모드
그림 10-1. RF-DETR 의 순전파 지도. ① – ④ 가 백본, ⑤ 가 프로젝터, ⑥ 이 2단계 질의 선택, ⑦ 이 디코더, ⑧ 이 머리입니다. 점선 상자는 그림과 무관하게 학습되는 임베딩입니다.

그림 10-1 에서 미리 눈에 담아 둘 것이 넷입니다. 이 장의 나머지는 이 네 가지를 차례로 풀어 가는 것입니다.

  1. 백본 안에서는 모양이 두 가지를 오갑니다. 윈도 블록에서는 배치 축이 4배(윈도 2×2)로 늘어난 (4B, 145, 384), 전역 블록에서는 (B, 580, 384) 입니다. 원소의 수는 같고($4 \times 145 = 580$) 보는 방법만 다릅니다.
  2. 백본을 나오면 공간 해상도는 끝까지 그대로입니다. 특징 맵도, 프로젝터 출력도 24×24 입니다. 프로젝터는 채널 수만 $384 \times 4 = 1536$ 에서 256 으로 바꿉니다.
  3. 디코더로 들어가는 길이 셋입니다. 그림에서 고른 기준 박스, 그림과 무관한 내용 질의, 그리고 교차 어텐션이 읽을 특징(memory)입니다.
  4. 머리는 하나씩뿐입니다. 디코더의 모든 층이 같은 분류 머리 · 박스 머리를 씁니다. hs 의 맨 앞 축(층)마다 머리를 적용한 결과 가운데 마지막 층의 것이 최종 출력입니다.

두 모델을 나란히: Nano 와 미니

이 장의 숫자는 두 모델에서 옵니다. 하나는 공개된 RF-DETR Nano 입니다. rfdetr 패키지(1.12.1)로 모델을 만들어 384×384 그림 한 장을 넣고, 모듈마다 훅을 걸어 입출력 모양과 매개변수 수를 쟀습니다. 다른 하나는 이 튜토리얼의 미니 RF-DETR(MiniRFDETR)로, 구조와 계산은 공식 구현을 따르고 크기만 도형 세상에 맞게 줄인 것입니다.

설정미니 RF-DETRRF-DETR Nano (실측)
입력 해상도 / 패치 크기96 / 8 → 격자 12×12 = 144 토큰384 / 16 → 격자 24×24 = 576 토큰
백본의 차원 · 블록 수 · 머리 수96 · 6 · 4384 · 12 · 6 (DINOv2-S, 레지스터 토큰 없음)
특징을 꺼내는 자리 out_feature_indexes(2, 4, 6)[3, 6, 9, 12]
윈도 블록 / 전역 블록 (0 부터 센 번호)[0, 1, 3, 5] / [2, 4][0, 1, 2, 4, 5, 7, 8, 10, 11] / [3, 6, 9]
한 변의 윈도 수2 (윈도마다 패치 36 + CLS 1)2 (윈도마다 패치 144 + CLS 1)
프로젝터P4, 입력 3 × 96 → 128, C2f 병목 3개P4, 입력 4 × 384 → 256, C2f 병목 3개
hidden_dim128256
디코더 층 수32
자기 / 교차 어텐션의 머리 수8 / 168 / 16
표본점 수 dec_n_points22
FFN 은닉 차원2562048
질의 수 × 묶음 수12 × 4300 × 13
클래스 로짓의 수391
매개변수 (전체 / 추론에 쓰이는 것)1,832,707 / 1,675,87030,467,298 / 26,863,662

미니 모델의 디코더가 Nano(2층)보다 깊은 3층인 것은 7 · 8장의 모델과 맞추고, 12장에서 디코더 층 수를 0 – 3 으로 바꿔 보기 위해서입니다. Nano 의 클래스 로짓이 91개인 것은 COCO 의 범주 번호가 1 부터 90 까지여서입니다. 설정의 num_classes=90 에 1 을 더해 로짓 칸을 만들고, 범주 번호를 그대로 칸 번호로 씁니다(공식 코드의 주석은 이 값을 “가장 큰 범주 번호 + 1” 이라고 설명합니다).

$ python ch10_rfdetr_model.py            # 노트북 GPU 약 35초 (RF-DETR Nano 대조는 CPU 에서 돈다)
$ python ch10_rfdetr_model.py --quick    # CPU 약 15초 (Nano 대조는 건너뛴다)

이 파일은 학습을 하지 않습니다. 모델을 만들고, 모양을 추적하고, 매개변수를 세고, 구조에서 따라 나오는 성질을 확인합니다. Nano 대조 부분만 rfdetr 패키지가 있어야 돌고(pip install rfdetr), 없으면 한 줄을 출력하고 건너뜁니다. 가중치 파일(rf-detr-nano.pth, 366 MB)이 실행 폴더에 없으면 패키지가 내려받습니다. Nano 의 모양은 추론 모드 · 배치 1 로만 쟀습니다. 학습 모드의 모양은 미니 모델로 확인합니다.

LW-DETR 에서 바뀐 것

RF-DETR 논문 3절의 표현은 “LW-DETR 을 현대화한다” 입니다. 구조만 보면 RF-DETR 은 9장의 LW-DETR 과 거의 같고, 바뀐 곳은 손에 꼽습니다. 논문이 적은 것을 표로 모았습니다.

항목LW-DETRRF-DETR자세히
백본CAEv2 로 사전 학습한 ViT (논문: 인코더 10층, 패치 16)DINOv2 로 사전 학습한 ViT (12층)이 장 · 6장
CLS 토큰없음(논문 부록 L: CAEv2 백본은 클래스 토큰을 쓰지 않는다)있음. 윈도마다 복제이 장
프로젝터의 정규화배치 정규화층 정규화이 장
윈도 블록의 자리{0, 1, 3, 6, 7, 9} (논문 부록 A){0, 1, 3, 4, 6, 7, 9, 10} (논문 부록 A. 공개 코드의 동작은 다름)이 장
윈도 수16개(한 변 4개)크기마다 NAS 가 고름. N – L 은 한 변 2개이 장 · 12장
분할없음가벼운 분할 머리(RF-DETR-Seg)13장
크기 가족을 만드는 방법크기마다 손으로 설계해 따로 학습가중치 공유 NAS: 한 번 학습해 여러 구성을 꺼냄12장
학습 설정학습률 4e-4 등학습률 1e-4, 워밍업 없음, 기울기 자르기 0.1 등11장

디코더(자기 어텐션 → 변형 교차 어텐션 → FFN), 2단계 질의 선택, Group DETR, IA-BCE 손실, 박스 재매개변수화는 LW-DETR 에서 그대로 왔습니다. 공개 코드에서 모델 클래스의 이름이 아직 LWDETR 인 것도 그래서입니다.

백본을 바꾼 이유는 6장에서 보았습니다. 논문은 DINOv2 의 사전 학습 가중치로 시작하면 작은 데이터셋에서 탐지 정확도가 크게 오른다고 적습니다. 대가도 적습니다. DINOv2 의 인코더는 12층이라 10층인 CAEv2 인코더보다 느리고, 논문은 이 지연 시간을 NAS 로 만회한다고 말합니다.

배치 정규화를 층 정규화로 바꾼 이유

논문의 문장은 짧습니다. 다중 스케일 프로젝터에서 배치 정규화 대신 층 정규화를 써서, 기울기 누적으로 소비자용 GPU 에서 학습할 수 있게 했다는 것입니다. 왜 정규화의 종류가 GPU 의 크기와 얽히는지 풀어 봅니다. 두 정규화는 4장에서 배웠습니다. 배치 정규화는 배치 안의 모든 그림 에 걸쳐 평균 · 분산을 내고, 층 정규화는 그림 하나(토큰 하나) 안에서 냅니다.

메모리가 작은 GPU 에는 그림을 한 번에 몇 장밖에 올리지 못합니다. 기울기 누적은 작은 배치 여러 개의 기울기를 더해 두었다가 한 번에 갱신해서 큰 배치를 흉내 내는 방법입니다(자세한 것은 11장). 그림 16장짜리 배치를 4장씩 네 번에 나눠 계산한다고 합시다. $\theta$ 는 모델의 매개변수, $\ell_i(\theta)$ 는 그림 $i$ 의 손실, $\mathcal{B}_t$ 는 $t$ 번째 작은 배치(그림 4장)입니다.

기울기 누적이 큰 배치와 같아지는 조건
$$ \nabla_\theta \Big( \frac{1}{16} \sum_{i=1}^{16} \ell_i(\theta) \Big) = \frac{1}{16} \sum_{i=1}^{16} \nabla_\theta\, \ell_i(\theta) $$
큰 배치의 손실은 그림별 손실의 평균이고, 합의 기울기는 기울기의 합입니다.
$$ = \frac{1}{4} \sum_{t=1}^{4} \Big( \frac{1}{4} \sum_{i \in \mathcal{B}_t} \nabla_\theta\, \ell_i(\theta) \Big) $$
16개의 합을 4개씩 네 묶음으로 나눠 적었습니다. $\tfrac{1}{4} \times \tfrac{1}{4} = \tfrac{1}{16}$ 입니다.
$$ = \frac{1}{4} \sum_{t=1}^{4} \nabla_\theta \Big( \frac{1}{4} \sum_{i \in \mathcal{B}_t} \ell_i(\theta) \Big) $$
괄호 안은 작은 배치 하나의 손실입니다. 작은 배치 네 개의 기울기를 평균하면 큰 배치의 기울기와 같습니다. 단, 이 등식은 $\ell_i$ 가 그림 $i$ 에만 달려 있을 때 성립합니다.

층 정규화만 쓰는 모델에서는 그림 하나의 출력이 같은 배치의 다른 그림과 무관하므로 조건이 성립합니다. 4장씩 나눠 계산해도 16장을 한 번에 넣은 것과 같은 기울기가 나옵니다. 배치 정규화가 있으면 그림 $i$ 의 출력이 같이 들어온 그림들의 평균 · 분산 에 따라 달라집니다. 4장으로 낸 통계와 16장으로 낸 통계가 다르므로 등식이 깨지고, 4장의 통계는 흔들림도 큽니다. 기울기 누적으로 배치를 키워도 배치 정규화가 보는 배치는 여전히 4장인 것입니다.

이 바꿈은 정확도를 올리려는 것이 아닙니다. 논문 표 5 의 절제에서, LW-DETR (M) 에 “순한 하이퍼파라미터”(더 작은 배치, 더 낮은 학습률, 배치 정규화 → 층 정규화)를 적용하면 AP 가 52.6 에서 51.6 으로 내려갑니다. 잃은 만큼은 백본을 DINOv2 로 바꿔 되찾습니다(53.6). 논문은 낮은 학습률과 층 정규화가 DINOv2 의 사전 학습 지식을 보존하는 데에도 도움이 된다고 덧붙입니다. 세 가지를 한꺼번에 바꾼 절제라서, 층 정규화 하나의 몫이 얼마인지는 이 표로 알 수 없습니다.

9장에서 본 대로 공개 코드의 프로젝터에서 정규화 층의 이름은 여전히 bn 입니다. 이름만 그렇고, layer_norm=True(기본값)이면 채널 방향의 층 정규화가 들어갑니다.

백본: 윈도를 넣은 DINOv2

그림 10-1 의 ① – ④ 입니다. 6장의 ViT 에 9장의 윈도 어텐션을 넣은 것이고, 공개 코드에서 이 백본의 이름은 dinov2_windowed_small 입니다. 미니 모델에서는 9장에서 만든 WindowedViT 가 같은 일을 합니다.

DINOv2-S 에서 온 것과 고친 것

RF-DETR 의 N · S · M · L 은 모두 DINOv2 의 가장 작은 모델인 ViT-S 를 백본으로 씁니다. Nano 에서 잰 값입니다.

항목값 (Nano 실측)비고
토큰 차원 $C$384DINOv2 ViT-S 그대로
블록 수12그대로
어텐션 머리 수6 (머리마다 64차원)그대로
블록 안 MLP 의 은닉 차원1536 (= 4 × 384)그대로
패치 크기16 — 패치 임베딩 합성곱의 가중치 (384, 3, 16, 16)DINOv2 는 14 로 사전 학습됨
위치 임베딩(1, 577, 384) — CLS 자리 1 + 격자 24×24positional_encoding_size=24
CLS 토큰있음 (1, 1, 384)윈도마다 복제해 쓴다
레지스터 토큰0개6장에서 본 대로 공개 설정은 쓰지 않는다
윈도 블록[0, 1, 2, 4, 5, 7, 8, 10, 11]9개. 나머지 3개가 전역 블록

고친 곳은 셋입니다.

토큰 수와 나누어떨어짐 제약

Nano 의 토큰 수부터 셉니다. 한 변이 $S = 384$ 픽셀인 그림을 $p = 16$ 픽셀 패치로 자르면 격자의 한 변은 $g = S / p = 24$, 패치 토큰은 $g^2 = 576$ 개입니다.

설정의 num_windows 는 윈도의 개수가 아니라 한 변을 몇으로 나누는가 입니다. 1장에서 약속한 이야기입니다. num_windows=2 이면 격자를 가로 2 · 세로 2 로 나눠 윈도가 $2 \times 2 = 4$ 개, num_windows=4 이면 16개입니다. LW-DETR 논문의 “윈도 16개” 와 RF-DETR 논문 표 5 의 “윈도 4” 가 같은 것을 가리킵니다. 이 튜토리얼에서는 한 변의 윈도 수를 $W_n$ 으로 적습니다.

입력 해상도가 지켜야 하는 조건
$$ g = \frac{S}{p} \ \text{가 정수} $$
그림이 패치로 남김없이 잘려야 합니다. $S$ 는 $p$ 의 배수여야 합니다.
$$ \frac{g}{W_n} \ \text{가 정수} $$
격자의 한 변 $g$ 칸을 윈도 $W_n$ 개로 똑같이 나눠야 합니다. 윈도 한 변의 칸 수가 $g / W_n$ 입니다.
$$ \frac{g}{W_n} = \frac{S}{p \cdot W_n} \ \text{가 정수} $$
$g = S/p$ 를 넣었습니다. 이 조건이 성립하면 $S/p$ 도 정수이므로 첫 줄은 따로 볼 필요가 없습니다.
$$ S \ \text{는} \ p \cdot W_n \ \text{의 배수}: \qquad \text{Nano} \ \ 384 = (16 \times 2) \times 12, \qquad n = \Big(\frac{g}{W_n}\Big)^2 = 12^2 = 144 $$
Nano 는 $p \cdot W_n = 32$ 이고 $384 = 32 \times 12$ 입니다. 윈도 하나는 12×12 칸, 패치 토큰 144개입니다. 윈도 넷을 합치면 $4 \times 144 = 576$ 으로 처음 수와 같습니다.

공식 구현은 임베딩 단계에서 이 조건을 검사해, 높이나 너비가 patch_size × num_windows 로 나누어떨어지지 않으면 오류를 냅니다. 논문 표 7 의 구성이 모두 이 조건을 지키는지 확인해 볼 수 있습니다.

크기해상도 $S$패치 $p$$W_n$$p \cdot W_n$$S / (p \cdot W_n)$ = 윈도 한 변의 칸 수격자 $g$ → 토큰 수
N384162321224 → 576
S512162321632 → 1,024
M576162321836 → 1,296
L704162322244 → 1,936
XL700201203535 → 1,225
2XL880202402244 → 1,936
미니968216612 → 144

XL 의 해상도가 704 가 아니라 700 인 것도 이 표로 읽힙니다. 패치가 20 이면 704 는 나누어떨어지지 않고 700 이 떨어집니다. 자기 그림으로 추론하거나 학습할 때 해상도를 바꾸려면 이 조건을 지켜야 합니다. 실전에서 부딪히는 모습은 14장에 있습니다.

윈도마다 CLS 토큰을 복제한다

9장에서 배운 윈도 어텐션의 구현은 한 줄로 요약됩니다. 윈도를 배치 축에 올린다. 패치 토큰 (B, 576, 384) 를 윈도 우선 순서로 다시 늘어놓아 (4B, 144, 384) 로 만들면, 보통의 자기 어텐션이 저절로 윈도 안에서만 일어납니다. 배치의 다른 줄은 서로 보지 않기 때문입니다.

LW-DETR 은 여기서 끝이었습니다. RF-DETR 에는 문제가 하나 더 있습니다. CLS 토큰을 어느 윈도에 넣을 것인가. 6장에서 보았듯 DINOv2 의 사전 학습은 CLS 토큰의 출력에 손실을 걸어 이루어졌고, 블록들은 CLS 토큰이 수열 맨 앞에 있는 채로 학습되었습니다. 논문 부록 L 의 설명은 이렇습니다.

이 장에서는 이것을 윈도별 CLS 토큰 복제per-window class token 라고 부르겠습니다. 공식 구현의 임베딩 단계는 다음 순서입니다.

  1. 패치 임베딩으로 패치 토큰 (B, 576, 384) 를 만들고, CLS 토큰을 앞에 붙여 (B, 577, 384), 위치 임베딩 (1, 577, 384) 를 더합니다. 여기까지는 6장의 ViT 그대로입니다.
  2. CLS 토큰(위치 임베딩까지 더한 것)과 패치 토큰을 다시 뗍니다.
  3. 패치 토큰을 윈도 우선으로 재배열합니다: (B, 576, 384) → (4B, 144, 384).
  4. CLS 토큰을 윈도 수만큼 복제해 윈도마다 맨 앞에 붙입니다: (4B, 145, 384).

일반식으로 적으면 윈도 블록에서의 모양은 $(B \cdot W_n^2,\ n + 1,\ C)$ 입니다. 전역 블록에 들어갈 때는 같은 텐서를 $(B,\ W_n^2 (n + 1),\ C)$ 로 보기만 바꿉니다(view). 값을 옮기지 않습니다. 9장의 윈도 우선 배치 덕분에 한 그림의 윈도 넷이 배치 축에서 이웃해 있어서, 이어 붙이기만 하면 한 그림의 토큰 전체가 됩니다. Nano 의 숫자를 넣습니다.

$$ \underbrace{(B \cdot W_n^2,\ n + 1,\ C)}_{\text{윈도 블록}} = (4B,\ 145,\ 384) \qquad\longleftrightarrow\qquad \underbrace{(B,\ W_n^2 (n + 1),\ C)}_{\text{전역 블록}} = (B,\ 580,\ 384) $$
윈도 블록: 배치 축에 윈도 네 줄 윈도 0 의 패치 토큰 144개 윈도 1 의 패치 토큰 144개 윈도 2 의 패치 토큰 144개 윈도 3 의 패치 토큰 144개 (4, 145, 384): 줄마다 따로 어텐션 쌍의 수 4 × 145² = 84,100 view 전역 블록: 한 줄로 이어 붙임 윈도 0 윈도 1 윈도 2 윈도 3 주황 = CLS 토큰 (같은 값에서 출발한 사본 4개) (1, 580, 384): 모든 토큰이 서로 본다 (CLS 4개끼리도) 쌍의 수 580² = 336,400
그림 10-2. RF-DETR Nano 의 백본 안에서 토큰이 놓이는 두 가지 모양(그림 한 장, $B = 1$). 원소는 그대로이고 텐서를 보는 방법만 바뀝니다. 주황 칸이 윈도마다 복제된 CLS 토큰입니다.

그림 10-2 의 왼쪽에서 CLS 토큰 네 개는 임베딩 직후에는 똑같은 값입니다. 그러나 첫 윈도 블록을 지나면 저마다 자기 윈도의 패치 토큰 144개를 보고 달라집니다. 윈도마다 “이 구역의 요약” 을 하나씩 갖게 되는 셈입니다. 오른쪽의 전역 블록에서는 580개 토큰이 모두 서로를 보므로 네 요약이 서로 섞입니다.

복제에는 값이 있습니다. 토큰이 $W_n^2$ 개 늘어납니다. Nano 의 격자(576 토큰)에서 윈도 수에 따라 어텐션 한 번이 다루는 (질의, 열쇠) 쌍의 수를 세어 보면 다음과 같습니다(이 튜토리얼이 계산한 값입니다. 지연 시간이 아닙니다).

$W_n$윈도 수윈도 하나의 토큰 $n + 1$전체 토큰 $W_n^2 (n + 1)$윈도 블록의 쌍 $W_n^2 (n + 1)^2$전역 블록의 쌍
11577577332,929332,929
2414558084,100336,400
4163759221,904350,464

윈도를 잘게 나눌수록 윈도 블록은 싸지지만(84,100 → 21,904), 복제된 CLS 가 3개에서 15개로 늘어 전역 블록은 오히려 비싸집니다(336,400 → 350,464, 윈도가 없을 때보다 5.3% 많음). 논문 부록 L 은 파레토 최적 모델의 대부분이 윈도 2 에서 가장 좋았고(LW-DETR 은 4), 그 까닭을 CLS 토큰의 처리에서 찾습니다. 클래스 토큰을 더 많은 윈도에 복제하면 실행 효율이 떨어져서, LW-DETR 과 달리 RF-DETR 은 윈도를 4 로 늘려서 얻는 것이 없다는 것입니다. 논문 표 5 의 절제(M 크기)에서 윈도를 4 에서 2 로 바꾸면 AP 가 53.6 에서 54.3 으로 오르고 지연 시간은 4.0 ms 에서 4.3 ms 로 늘어납니다.

미니 모델의 WindowedViT 는 9장에서 읽었습니다. 임베딩 뒤의 재배열 · CLS 복제 · 블록 실행 · 특징 꺼내기가 forward 한 함수에 있으니, 위의 네 단계와 맞대어 다시 한번 보세요.



  

어느 블록이 윈도 블록인가

12개 블록 가운데 어느 것이 윈도 블록이고 어느 것이 전역 블록인지는, 논문의 서술과 공개 코드의 실제 동작이 다릅니다. 1장에서 미뤄 둔 이야기입니다. 둘을 나란히 놓습니다.

블록 번호 (0 부터)01234567891011
논문 부록 A 의 표기윈도윈도전역윈도윈도전역윈도윈도전역윈도윈도전역
공개 코드의 실제 동작 (Nano 실측)윈도윈도윈도전역윈도윈도전역윈도윈도전역윈도윈도
이 블록의 출력을 특징으로 꺼내는가꺼냄꺼냄꺼냄꺼냄

코드가 이렇게 되는 이유는 윈도 블록을 정하는 규칙에 있습니다. 공개 코드의 compute_window_block_indexes 는 윈도 블록을 따로 지정받지 않으면 out_feature_indexes 의 여집합 으로 정합니다.

공개 코드의 규칙을 손으로 따라가기 (Nano)
$$ \{0, 1, 2, \dots, 12\} $$
range(out_feature_indexes[-1] + 1). 마지막 값이 12 이므로 0 부터 12 까지 13개의 수입니다.
$$ \{0, 1, \dots, 12\} \setminus \{3, 6, 9, 12\} = \{0, 1, 2, 4, 5, 7, 8, 10, 11\} $$
out_feature_indexes = [3, 6, 9, 12] 를 뺍니다. 남은 9개가 윈도 블록의 번호가 됩니다. 12 는 블록 번호(0 – 11)에 없으니 빠져도 영향이 없습니다.
$$ \text{전역 블록} = \{0, \dots, 11\} \setminus \{0, 1, 2, 4, 5, 7, 8, 10, 11\} = \{3, 6, 9\} $$
윈도 블록이 아닌 나머지입니다. 로그의 “전역 블록의 어텐션 입력 (블록 [3, 6, 9])” 과 같습니다. 훅으로 잰 값이므로 실제로 이 세 블록만 (1, 580, 384) 모양으로 어텐션을 했습니다.

어긋남이 어디서 오는지도 숫자로 짚을 수 있습니다. out_feature_indexes 의 3 은 “블록 3” 이 아니라 “블록 3개를 지난 뒤” 라는 뜻이어서, 실제로 특징을 내놓는 것은 블록 2 의 출력입니다(다음 소절). 그런데 여집합 규칙은 이 숫자를 블록 번호로 그대로 씁니다. 같은 규칙에 [2, 5, 8, 11] 을 넣으면 윈도 블록은 {0, 1, 3, 4, 6, 7, 9, 10} 이 되어 논문의 표기와 정확히 같아집니다. [2, 5, 8, 11] 은 공개 코드의 기본 설정(RFDETRBaseConfig)에 적힌 out_feature_indexes 의 값이고, Nano · Small · Medium · Large 의 설정은 이것을 [3, 6, 9, 12] 로 덮어씁니다. 공개 저장소(develop)의 독스트링도 이 유도가 out_feature_indexes 의 번호를 0 부터 세는 블록 번호로 바꾸지 않으며, 공개된 모든 체크포인트가 이 동작에 맞춰져 있고, 논문에 적힌 층 배치와 같다는 보장이 없다고 적고 있습니다.

어느 쪽을 믿어야 하나

공개된 가중치로 추론하거나 미세 조정한다면 답은 코드의 동작 입니다. 그 가중치는 전역 블록이 3 · 6 · 9 인 채로 학습되었습니다. 이 튜토리얼의 미니 모델도 공개 코드의 규칙을 따릅니다(out_feature_indexes=(2, 4, 6) → 윈도 [0, 1, 3, 5], 전역 [2, 4]). 논문의 수치(표 2 등)를 낸 모델이 어느 배치였는지는 논문만으로는 알 수 없습니다.

코드의 배치에서 따라 나오는 성질이 하나 있습니다. 특징을 꺼낸 바로 다음 블록이 전역 블록입니다. 그래서 첫 번째로 꺼내는 특징(블록 0 · 1 · 2 를 지난 것)은 전역 블록을 한 번도 거치지 않았습니다. 이 특징 맵의 한 칸은 자기 윈도(그림의 4분의 1) 안의 정보만 담고 있습니다. 둘째 · 셋째 · 넷째 특징은 전역 블록을 각각 1 · 2 · 3번 거쳤습니다. 미니 모델도 같습니다(첫 특징은 윈도 블록 0 · 1 만 지남). 윈도 블록만으로는 윈도 밖의 정보가 전혀 들어오지 않는다는 것은 9장의 실험에서 확인했습니다.

특징 네 장을 꺼내 격자로 되돌리기

백본의 마지막 일은 프로젝터에 줄 특징 맵을 만드는 것입니다. 6장에서 예고한 대로 RF-DETR 은 마지막 층의 출력만 쓰지 않고 여러 깊이의 출력 을 함께 꺼냅니다(LW-DETR 논문의 다층 특징 집계). out_feature_indexes = [3, 6, 9, 12] 는 블록을 3 · 6 · 9 · 12개 지난 뒤의 토큰, 곧 블록 2 · 5 · 8 · 11 의 출력입니다(0 은 임베딩 직후를 뜻합니다). 꺼낸 토큰마다 세 가지를 합니다.

  1. 층 정규화. 백본 끝의 층 정규화 하나를 네 군데 모두에 함께 씁니다. 모양은 그대로 (4B, 145, 384).
  2. CLS 토큰을 뗍니다. 줄마다 맨 앞의 토큰을 버려 (4B, 144, 384). CLS 는 윈도 안의 토큰들에게 요약을 건네는 노릇만 하고, 탐지에는 쓰이지 않습니다.
  3. 윈도 우선 → 행 우선. 윈도 넷을 제자리에 다시 맞춰 (B, 576, 384) 로, 그것을 채널 축이 앞에 오는 특징 맵 (B, 384, 24, 24) 로 바꿉니다. 9장의 from_window_major 가 하는 일이고, 순서를 실제로 바꾸는 연산은 여기 한 군데뿐입니다.

결과는 모양이 같은 특징 맵 네 장 (B, 384, 24, 24) × 4 입니다. CNN 백본의 여러 단계가 해상도가 서로 다른 특징 맵을 내는 것과 달리, ViT 는 깊이가 달라도 해상도가 같습니다. 한 칸은 원래 그림의 16×16 픽셀 패치 하나에 해당합니다.

프로젝터: 네 장을 한 장으로

그림 10-1 의 ⑤ 입니다. 백본이 내놓은 특징 맵 네 장을 디코더가 쓸 특징 맵 한 장으로 만드는 부품이고, 구조는 9장에서 만든 MultiScaleProjector 그대로입니다. Nano 의 숫자로 다시 따라갑니다.

  1. 채널 방향으로 이어 붙이기. (B, 384, 24, 24) 네 장을 채널 축으로 붙여 (B, 1536, 24, 24). $384 \times 4 = 1536$ 입니다. 같은 칸의 얕은 층 · 깊은 층 특징이 한 벡터에 나란히 놓입니다.
  2. C2f 블록. 1×1 합성곱으로 1536 채널을 256 채널로 줄이고, 반으로 나눈 128 채널에 3×3 합성곱 두 번짜리 병목을 세 번 차례로 적용하면서 중간 결과를 모두 모아($128 \times 5 = 640$ 채널) 다시 1×1 합성곱으로 256 채널을 만듭니다. 합성곱마다 층 정규화와 SiLU 가 따릅니다.
  3. 층 정규화. 마지막에 채널 방향 층 정규화를 한 번 더 합니다. 출력은 (B, 256, 24, 24).

해상도는 들어올 때와 같은 24×24 입니다. 공개 설정의 projector_scale=["P4"] 가 이것을 뜻합니다. P4P4 feature level 는 특징 피라미드에서 온 이름으로, 관례상 P3 · P4 · P5 는 한 칸이 원래 그림의 8 · 16 · 32 픽셀에 해당하는 특징 맵을 가리킵니다($2^3, 2^4, 2^5$). RF-DETR 의 코드에서 P4 는 “백본 특징의 해상도를 바꾸지 않는다(배율 1.0)” 는 뜻이고, 한 칸의 크기는 패치 크기와 같습니다. 탐지 N – L 은 패치가 16 이라 이름과 실제가 맞습니다. P3(배율 2.0, 전치 합성곱으로 두 배) 와 P5(배율 0.5, 스트라이드 2 합성곱으로 절반)도 코드에 있지만, Nano · Small · Medium · Large 의 설정은 모두 P4 한 장만 씁니다. 8장에서 변형 어텐션의 레벨 수를 $L$ 이라 했는데, RF-DETR 에서는 $L = 1$ 입니다.

프로젝터의 매개변수 수를 손으로 세어 실측값과 맞춰 봅니다. 합성곱에는 편향이 없고, 층 정규화는 채널마다 배율과 이동 값 둘을 가집니다.

손계산: Nano 프로젝터의 매개변수 수
$$ \underbrace{1536 \times 256}_{1\times1 \text{ 합성곱}} + \underbrace{2 \times 256}_{\text{층 정규화}} = 393{,}216 + 512 = 393{,}728 $$
C2f 의 첫 1×1 합성곱(cv1): 입력 1536 채널, 출력 256 채널. 1×1 이므로 가중치는 입력 채널 × 출력 채널입니다.
$$ 2 \times \big( \underbrace{128 \times 128 \times 3 \times 3}_{3\times3 \text{ 합성곱}} + \underbrace{2 \times 128}_{\text{층 정규화}} \big) = 2 \times (147{,}456 + 256) = 295{,}424 $$
병목 하나: 128 채널 → 128 채널의 3×3 합성곱이 두 번입니다.
$$ 3 \times 295{,}424 = 886{,}272 $$
병목이 세 개입니다.
$$ \underbrace{640 \times 256}_{1\times1 \text{ 합성곱}} + 2 \times 256 = 163{,}840 + 512 = 164{,}352 $$
마지막 1×1 합성곱(cv2): 나눈 두 쪽과 병목 셋의 출력 $128 \times 5 = 640$ 채널을 256 채널로.
$$ 393{,}728 + 886{,}272 + 164{,}352 + \underbrace{512}_{\text{끝의 층 정규화}} = 1{,}444{,}864 $$
실측값 1,444,864 와 같습니다. 3×3 합성곱 여섯 개가 61%(884,736)를 차지합니다. 미니 모델(입력 $3 \times 96 = 288$ 채널 → 128)에 같은 계산을 하면 $37{,}120 + 221{,}952 + 41{,}216 + 256 = 300{,}544$ 로 역시 실측값과 같습니다.

프로젝터 출력을 칸마다 한 줄로 펴면 (B, 576, 256) 이 됩니다(행 우선). 공식 코드와 이 튜토리얼의 코드는 이것을 memory 라고 부릅니다. DETR 에서 인코더의 출력을 부르던 이름입니다. RF-DETR 에는 Transformer 인코더가 따로 없고, ViT 백본과 프로젝터가 그 자리를 맡습니다. 그래서 공식 코드와 논문이 “인코더의 출력” 이라고 할 때 그것은 이 memory 입니다. 이제부터 memory 는 두 군데에서 쓰입니다. 2단계 질의 선택이 칸마다 점수를 매기는 데, 그리고 디코더의 교차 어텐션이 값을 읽는 데.

2단계 질의 선택

그림 10-1 의 ⑥ 입니다. 8장에서 생각과 미니 구현을 보았고, RF-DETR 의 실제 코드는 여기서 보기로 했습니다. 2단계 질의 선택two-stage query selection 은 프로젝터 출력의 모든 칸 에 점수를 매겨 높은 순으로 $N$ 칸을 고르고, 그 칸이 낸 박스를 디코더 질의의 출발점(기준 박스)으로 삼는 절차입니다. 공개 설정의 two_stage=True 가 이것을 켭니다.

다섯 단계로 보기

memory (B, 576, 256) ② Linear + 층 정규화 (B, 576, 256) ③ 클래스 로짓 (B, 576, 91) ④ 최댓값 상위 300칸 칸 번호 (B, 300) 고른 칸의 것만 모은다 ① 제안 박스 격자 (576, 4) 고른 칸의 제안 · 특징 (B, 300, 4) · (B, 300, 256) ⑤ 박스 머리 → 델타 (B, 300, 4) ⑤ 재매개변수화 인코더 제안 박스 (B, 300, 4) enc_outputs 고른 칸의 로짓 · 박스 → 손실 (11장) 기울기 차단 → refpoint_embed 로 보정 기준 박스 (B, 300, 4) query_feat (학습되는 임베딩) 내용 질의 (B, 300, 256) 디코더 (모든 층이 같은 기준 박스를 쓴다)
그림 10-3. RF-DETR Nano 의 2단계 질의 선택(추론 모드, 묶음 하나). 고른 칸의 특징은 박스 머리와 enc_outputs 까지만 가고, 디코더로 들어가는 것은 박스(기준 박스)뿐입니다. 내용 질의는 그림과 무관한 임베딩에서 옵니다.

그림 10-3 의 번호를 따라 읽습니다. 모양은 Nano(추론 모드)의 것입니다.

  1. 제안 박스 격자. 576칸마다 고정된 출발 박스를 하나씩 놓습니다: 칸의 중심에, 너비 · 높이 0.05 로. 학습되는 값이 아닙니다.
  2. Linear + 층 정규화. memory 의 모든 칸에 enc_output(256 → 256 선형 층)과 enc_output_norm 을 적용합니다. (B, 576, 256).
  3. 클래스 로짓. 그 결과에 enc_out_class_embed(256 → 91 선형 층)를 적용해 칸마다 클래스 로짓 91개를 냅니다. (B, 576, 91).
  4. 상위 $N$ 칸. 칸마다 로짓 91개 가운데 최댓값 을 그 칸의 점수로 삼아, 점수가 높은 300칸의 번호를 얻습니다(topk). 결과는 점수 내림차순으로 놓입니다.
  5. 박스. 고른 300칸의 특징에 enc_out_bbox_embed(3층 MLP)를 적용해 델타 (B, 300, 4) 를 내고, 그 칸의 제안 박스에 재매개변수화로 적용합니다. 이 박스가 인코더 제안 박스 $\hat{b}^{\text{enc}}$ 입니다.

고른 300칸의 로짓과 박스를 묶은 것이 출력 사전의 enc_outputs 이고, 이 튜토리얼에서는 인코더 제안encoder proposals 이라고 부릅니다. 여기에도 디코더 출력과 같은 손실(헝가리안 매칭 + 분류 · 박스 손실)이 걸립니다. 2 – 5번의 층들을 가르치는 것은 이 손실뿐입니다. 고르는 연산(topk)으로는 기울기가 흐르지 않고, 디코더로 넘어가는 박스는 기울기를 끊기 때문입니다.

묶음마다 따로

2 · 3 · 5번의 층 네 가지(enc_output, enc_output_norm, enc_out_class_embed, enc_out_bbox_embed)는 질의 묶음마다 한 벌씩, 모두 13벌이 있습니다(9장의 Group DETR). 학습 때는 묶음마다 자기 층으로 점수를 매겨 자기의 상위 300칸을 고르므로, 묶음마다 고르는 칸이 다를 수 있습니다. 결과를 질의 축으로 이어 붙이면 $13 \times 300 = 3{,}900$ 개입니다. 추론 때는 첫 묶음의 층만 씁니다. 미니 모델에서 확인한 모양은 학습 모드 (2, 48, 3)($= 4 \times 12$), 추론 모드 (2, 12, 3) 입니다.

제안 박스 격자와 실제 크기

1번의 제안 박스는 8장의 식 그대로입니다. 레벨이 하나뿐이므로 크기는 모든 칸에서 $0.05$ 입니다. 어떤 칸의 제안 박스는 그 칸의 행 번호와 열 번호(둘 다 0 부터)로 정해집니다.

$$ b^{\text{격자}} = \Big( \frac{\text{열} + 0.5}{W},\ \ \frac{\text{행} + 0.5}{H},\ \ 0.05,\ \ 0.05 \Big), \qquad H = W = 24 \ \ (\text{Nano}) $$

$H, W$ 는 프로젝터 출력의 높이 · 너비(칸 수)입니다. Nano 의 (행 5, 열 7) 칸이면 $(7.5/24,\ 5.5/24,\ 0.05,\ 0.05) = (0.3125,\ 0.2292,\ 0.05,\ 0.05)$ 입니다. 픽셀로 바꾸면 한 변이 $0.05 \times 384 = 19.2$ 픽셀로, 한 칸(16픽셀)보다 조금 큽니다. 미니 모델에서는 $0.05 \times 96 = 4.8$ 픽셀로 한 칸(8픽셀)보다 작습니다. 어느 쪽이든 실제 객체보다는 훨씬 작은 박스에서 출발합니다.

왼쪽과 가운데: 도형 세상의 검증 그림 두 장 위에 12×12 칸마다 놓인 노란 제안 박스 144개와 흰 점선의 정답 박스. 오른쪽: 각 객체의 중심이 놓인 칸의 제안 박스와 그것을 정답 박스로 바꾸는 델타
그림 10-4. 미니 모델의 제안 박스 격자(12×12 칸, 칸마다 0.05 × 0.05 박스). 왼쪽 · 가운데는 검증 그림 두 장 위의 제안 박스 144개(노랑)와 정답(흰 점선), 가는 흰 선은 칸의 경계입니다. 오른쪽은 객체마다 그 중심이 놓인 칸의 제안 박스(굵은 색)와, 그것을 정답 박스로 바꾸는 델타 d = (δx, δy, δw, δh)입니다.

그림 10-4 에서 읽을 것은 세 가지입니다.

가장자리 칸의 제안은 버려진다 — 격자가 클 때만

공식 구현(gen_encoder_output_proposals)은 제안 박스의 네 숫자가 모두 $0.01$ 보다 크고 $0.99$ 보다 작은 칸만 유효하다고 보고, 나머지 칸은 특징과 제안을 0 으로 채웁니다. 첫 칸의 중심은 $0.5 / W$ 이므로 격자 한 변이 50 이상이면($0.5/50 = 0.01$) 가장자리 칸이 여기에 걸립니다. N – L 의 격자(24 – 44)에서는 해당하는 칸이 없습니다($0.5/44 = 0.0114$). 미니 모델은 이 검사를 넣지 않았습니다.

칸마다 점수를 매겨 상위 칸을 고른다

3 · 4번을 식으로 적습니다. $z_j$ 를 칸 $j$ 의 특징(2번의 출력), $s_{j,c}$ 를 칸 $j$ 의 클래스 $c$ 로짓이라고 하면, 칸의 점수와 선택은

$$ s_j = \max_{c}\, s_{j,c}, \qquad \mathcal{T} = \text{점수 } s_j \text{ 가 가장 높은 } N \text{ 칸} $$

입니다. “이 칸에 어떤 클래스든 객체가 있을 법한가” 를 가장 자신 있는 클래스의 로짓으로 재는 것입니다. RF-DETR 논문은 이 순서를 “인코더 출력에서 토큰마다의 클래스 로짓의 시그모이드 최댓값” 이라고 적습니다. 시그모이드는 단조 증가 함수이므로 로짓의 최댓값으로 순위를 매기든 시그모이드를 거친 뒤 매기든 순서는 같습니다. 코드는 시그모이드 없이 로짓을 그대로 씁니다.

Nano 에서는 576칸 가운데 300칸, 절반이 넘는 칸(52%)이 뽑힙니다. 그림 한 장에 객체가 300개씩 있지는 않으니 뽑힌 칸의 대부분은 배경이고, 그런 질의는 디코더를 지나 낮은 점수를 내고 끝납니다. 격자가 커지면 비율은 내려갑니다(L 은 1,936칸 가운데 300칸, 15%). 미니 모델은 144칸 가운데 12칸(8%)입니다. 칸 수가 질의 수보다 적은 구성이 되면 공식 코드는 칸 수만큼만 고릅니다(min(num_queries, 칸 수)).

고른 칸이 점수 내림차순 으로 놓인다는 점도 기억해 두세요. 질의 0 은 언제나 점수가 가장 높은 칸에서, 질의 299 는 300번째 칸에서 출발합니다. 이 순서가 뒤에서 “질의를 덜 쓰기” 손잡이의 바탕이 됩니다.

고른 칸의 박스와 기준 박스

5번에서 박스를 만드는 연산은 9장에서 유도한 박스 재매개변수화입니다(bbox_reparam=True). 식을 다시 적습니다.

$$ \operatorname{reparam}(\delta, r) = \big( \delta_x\, r_w + r_x,\ \ \ \delta_y\, r_h + r_y,\ \ \ e^{\delta_w}\, r_w,\ \ \ e^{\delta_h}\, r_h \big) $$

$r$ 은 출발 박스, $\delta$ 는 델타입니다. 중심은 “출발 박스 크기의 몇 배” 만큼 옮기고, 크기는 $e^{\delta}$ 배로 키웁니다. $\delta = 0$ 이면 출발 박스가 그대로 나옵니다. RF-DETR 은 이 연산을 세 군데 에서 씁니다. 그 가운데 둘이 질의 선택 안에 있습니다. $j_q$ 를 $q$ 번째로 뽑힌 칸의 번호라고 하면,

$$ \hat{b}^{\text{enc}}_q = \operatorname{reparam}\big( \delta^{\text{enc}}_q,\ b^{\text{격자}}_{j_q} \big), \qquad r_q = \operatorname{reparam}\big( e_q,\ \sg(\hat{b}^{\text{enc}}_q) \big) $$

refpoint_embed 의 역할은 이름만 보고는 짐작하기 어렵습니다. 원래 DETR 계열에서 이것은 질의마다 학습되는 기준점이었습니다(8장의 two_stage=False 가 그 방식입니다). 2단계 방식에서는 기준이 그림에서 오므로, 이 임베딩은 뽑힌 박스에 얹는 학습되는 보정 으로 쓰임새가 바뀌었습니다. $e_q$ 는 칸이 아니라 순위 에 붙어 있습니다. “$q$ 번째로 점수가 높은 제안은 대체로 이만큼 옮기고 이만큼 키우면 좋다” 는 값을 배우는 자리입니다. 0 으로 초기화되므로 학습을 시작할 때는 $r_q = \hat{b}^{\text{enc}}_q$ 입니다.

손계산: 칸 하나가 기준 박스가 되기까지 (Nano 의 행 5, 열 7 칸)
$$ b^{\text{격자}} = (0.3125,\ 0.2292,\ 0.05,\ 0.05) $$
앞에서 구한 제안 박스입니다. 이 칸이 상위 300칸에 들었다고 합시다.
$$ \delta^{\text{enc}} = (0.4,\ -0.2,\ 1.5,\ 1.2) $$
박스 머리가 이 칸의 특징에서 낸 델타라고 가정한 값입니다(실제 값은 그림과 가중치에 따라 다릅니다).
$$ \hat{b}^{\text{enc}}_x = 0.4 \times 0.05 + 0.3125 = 0.3325, \qquad \hat{b}^{\text{enc}}_y = -0.2 \times 0.05 + 0.2292 = 0.2192 $$
중심: 델타에 제안 박스의 크기를 곱해 더합니다. $0.4$ 는 “박스 너비의 0.4배만큼 오른쪽” 이고, 박스가 0.05 이니 실제 이동은 $0.02$ 입니다.
$$ \hat{b}^{\text{enc}}_w = e^{1.5} \times 0.05 = 4.4817 \times 0.05 = 0.2241, \qquad \hat{b}^{\text{enc}}_h = e^{1.2} \times 0.05 = 3.3201 \times 0.05 = 0.1660 $$
크기: $e^{\delta}$ 배. 384픽셀 그림에서 너비 86픽셀, 높이 64픽셀쯤 되는 박스입니다. 이 박스가 enc_outputs 의 pred_boxes 에 들어갑니다.
$$ e_q = (0.1,\ 0,\ -0.1,\ 0) $$
이 순위의 refpoint_embed 행이 학습되어 이런 값이 되었다고 가정합니다. 처음에는 $(0, 0, 0, 0)$ 입니다.
$$ r_q = \big( 0.1 \times 0.2241 + 0.3325,\ \ 0 \times 0.1660 + 0.2192,\ \ e^{-0.1} \times 0.2241,\ \ e^{0} \times 0.1660 \big) = (0.3549,\ 0.2192,\ 0.2028,\ 0.1660) $$
같은 연산을 한 번 더 합니다. 이번에는 출발 박스가 $\sg(\hat{b}^{\text{enc}})$ 이므로 중심의 이동은 “인코더 제안 너비의 0.1배” 이고, $e^{-0.1} = 0.9048$ 입니다. $e_q = 0$ 이었다면 $r_q = \hat{b}^{\text{enc}}_q$ 그대로입니다.

박스에 시그모이드가 없다는 점에 주의하세요. 8장의 방식은 로짓 공간에서 더한 뒤 시그모이드를 거쳐 박스가 언제나 0 – 1 안에 있었습니다. 재매개변수화는 정규화 좌표에서 직접 계산하므로 박스가 그림 밖으로 조금 나갈 수 있습니다. 공식 구현도 모델 안에서는 이것을 자르지 않습니다.

내용 질의는 그림에서 오지 않는다

디코더에 들어가는 질의는 두 부분으로 되어 있습니다. 어디를 보는가(기준 박스와 거기서 만든 위치 임베딩)와 무엇을 담고 있는가(디코더 층을 지나며 갱신되는 벡터)입니다. 뒤의 것의 처음 값을 내용 질의content query 라고 합니다.

자연스러운 짐작은 “뽑힌 칸의 특징을 내용 질의로 쓰겠지” 입니다. RF-DETR 은 그렇게 하지 않습니다. 내용 질의는 학습되는 임베딩 query_feat 의 $q$ 번째 행이고, 그림과 무관합니다. 뽑힌 칸의 특징 $z_{j_q}$ 는 박스 머리와 enc_outputs 까지만 쓰이고 디코더에는 들어가지 않습니다. 그림 10-3 에서 디코더로 내려가는 화살표가 기준 박스와 query_feat 둘뿐인 것이 이것입니다.

질의의 부분어디서 오나그림에 따라 달라지나모양 (Nano, 추론)
기준 박스 $r_q$뽑힌 칸의 인코더 제안 박스(기울기 차단)를 refpoint_embed 로 보정예(B, 300, 4)
내용 질의query_feat 의 행(학습되는 임베딩)아니오(B, 300, 256)
질의 위치 임베딩기준 박스의 사인 임베딩 → ref_point_head예(기준 박스를 따라)(B, 300, 256)

위치는 그림에서, 내용은 학습된 값에서 오는 이 방식을 LW-DETR 논문은 “섞은 질의 선택(mixed-query selection)” 이라고 부르고, DINO(Zhang 외의 탐지기. 6장의 자기 증류 DINO 와 이름만 같습니다) 논문의 방식을 따랐다고 적습니다. 내용 질의가 그림과 무관하다고 해서 정보가 모자라지는 않습니다. 첫 디코더 층의 교차 어텐션이 기준 박스 둘레에서 특징을 읽어 오기 때문입니다. query_feat 도 refpoint_embed 처럼 순위에 붙어 있어서, 질의 0 의 내용 질의는 “점수가 가장 높은 제안을 맡을 질의” 의 출발 벡터입니다. 두 임베딩 모두 묶음 13개 분량($3{,}900$ 행)이 있고 추론 때는 앞의 300행만 씁니다.

8장의 미니 구현과 달라진 곳

8장의 MiniDeformableDETR(two_stage=True) 도 같은 생각을 구현했습니다. 이 장의 MiniRFDETR 이 그것과 다른 곳을 모았습니다. 오른쪽 열이 공식 구현의 방식입니다.

항목8장 MiniDeformableDETR이 장 MiniRFDETR (= 공식 방식)
제안 → 박스$\sigma(\Delta b + \sigma^{-1}(b^{\text{격자}}))$ — 로짓 공간에서 더하기$\operatorname{reparam}(\delta, b^{\text{격자}})$ — 시그모이드 없음
박스 델타를 계산하는 칸모든 칸뽑힌 칸만(값은 같고 계산이 적다)
선택의 기준클래스 로짓의 최댓값 상위 $N$같음
질의 묶음하나학습 때 $G$ 개, 묶음마다 Linear · 층 정규화 · 머리가 따로
refpoint_embed없음(뽑힌 박스가 곧 기준 박스)뽑힌 박스에 재매개변수화로 얹음(0 초기화)
내용 질의query_feat같음
질의 위치 임베딩기준 박스의 사인 임베딩 → 2층 MLP같음
디코더 안의 기준 박스층마다 갱신(박스 반복 정제)모든 층이 처음 것을 공유
분류 · 박스 머리층마다 따로모든 층이 하나를 공유
특징CNN 백본, 레벨 2개(12×12, 6×6)윈도 ViT + 프로젝터, 레벨 1개(12×12)

디코더 층

그림 10-1 의 ⑦ 입니다. 디코더는 같은 구조의 층을 Nano 는 2개, 미니 모델은 3개 쌓은 것입니다. 한 층이 받는 것은 넷입니다.

한 층의 세 단계

층 안의 순서는 7장의 DETR 디코더, 8장의 Deformable DETR 디코더와 같은 post-norm 구조입니다. 단계마다 “계산하고, 더하고, 층 정규화” 입니다.

단계연산질의 · 열쇠 · 값공식 설정 (Nano 실측)
① 자기 어텐션nn.MultiheadAttention질의 · 열쇠 = tgt + query_pos, 값 = tgt머리 8개(sa_nheads)
② 변형 교차 어텐션MSDeformAttn질의 = tgt + query_pos, 값 = memory, 읽을 자리 = 기준 박스 둘레머리 16개(ca_nheads), 표본점 2개(dec_n_points), 레벨 1개
③ FFNLinear → ReLU → Linear—256 → 2048 → 256

①은 질의끼리 서로를 참고하는 단계입니다. 같은 객체를 겹쳐 맡지 않게 조율하는 일이 여기서 일어납니다(7장). 학습 때는 질의가 13묶음이므로, 9장에서 본 대로 같은 묶음 안에서만 자기 어텐션을 합니다. 질의 축을 묶음별로 잘라 배치 축에 올렸다가 되돌리는 방식입니다. 묶음끼리 서로 볼 수 없어야 추론 때 첫 묶음만 써도 학습 때와 같은 계산이 됩니다.

②는 질의가 그림을 들여다보는 유일한 자리입니다. memory 에는 위치 정보를 더하지 않습니다. 변형 어텐션은 열쇠와의 내적 없이 좌표로 직접 값을 읽기 때문에, 어느 칸의 값인지를 값에 새겨 둘 필요가 없습니다. 자기 어텐션과 교차 어텐션의 머리 수가 8 과 16 으로 다른 것은 8장의 모델과 다른 점입니다. 디코더에 드롭아웃은 없습니다(기본값 0).


  

미니 모델의 디코더 층입니다. group_self_attention 은 9장, MSDeformAttn 은 8장에서 만든 것을 그대로 가져왔고, 매개변수 이름은 공식 TransformerDecoderLayer 와 맞췄습니다. 층을 다 지난 뒤가 아니라 층마다의 출력 에 공유 층 정규화(decoder.norm)를 한 번 더 적용한 것이 머리로 가는 hs 입니다. 다음 층으로 넘어가는 tgt 는 이 정규화를 거치지 않은 값입니다.

질의 하나가 읽는 점은 서른두 개

8장에서 질의 하나가 교차 어텐션 한 번에 읽는 자리의 수는 $M \cdot L \cdot K$ 라고 했습니다. RF-DETR 의 설정을 넣습니다.

손계산: 읽는 자리의 수 (Nano)
$$ M \cdot L \cdot K = 16 \times 1 \times 2 = 32 $$
머리 16개, 레벨 1개, 머리 · 레벨마다 표본점 2개. 질의 하나가 한 층에서 특징 맵의 32곳을 읽습니다.
$$ N \cdot M L K = 300 \times 32 = 9{,}600 $$
질의 300개가 한 층에서 읽는 (질의, 자리) 쌍의 수입니다.
$$ N \cdot HW = 300 \times 576 = 172{,}800 $$
보통의 교차 어텐션이었다면 질의마다 576칸을 모두 읽습니다.
$$ \frac{172{,}800}{9{,}600} = 18 $$
읽는 자리가 18분의 1 입니다. 8장에서 강조했듯 이것은 “읽는 자리” 의 비이고 시간의 비가 아닙니다. 값 투영은 여전히 576칸 모두에 합니다. 오프셋을 내는 선형 층의 출력은 $2MLK = 64$ 개, 가중치를 내는 선형 층의 출력은 $MLK = 32$ 개입니다(Nano 의 모듈에서 확인: Linear(256, 64), Linear(256, 32)).

기준이 4차원 박스 라는 점이 표본점의 자리를 정합니다. 8장의 식에서 레벨이 하나이니 첨자 $l$ 을 떼면, 질의 $q$ 의 머리 $m$, $k$ 번째 표본점은

$$ p_{mqk} = (r_x,\ r_y) + \frac{\Delta p_{mqk}}{K} \cdot \frac{(r_w,\ r_h)}{2} $$

입니다. $\Delta p_{mqk}$ 는 질의 벡터에서 선형 층으로 낸 오프셋(2차원)이고, 단위는 “박스 절반 크기의 $1/K$” 입니다. 박스가 크면 넓게, 작으면 좁게 봅니다. 앞의 손계산에서 얻은 기준 박스 $r = (0.3549,\ 0.2192,\ 0.2028,\ 0.1660)$ 에 넣어 봅니다. 8장에서 본 초기화에서는 머리 0 의 두 표본점이 $\Delta p = (1, 0)$ 과 $(2, 0)$ 에서 출발합니다.

$$ k = 1: \ \Big( 0.3549 + \frac{1}{2} \times \frac{0.2028}{2},\ 0.2192 \Big) = (0.4056,\ 0.2192), \qquad k = 2: \ \Big( 0.3549 + \frac{2}{2} \times \frac{0.2028}{2},\ 0.2192 \Big) = (0.4563,\ 0.2192) $$

$k = 2$ 의 점은 박스의 오른쪽 변($0.3549 + 0.1014 = 0.4563$) 위에, $k = 1$ 의 점은 중심과 변의 한가운데에 있습니다. 머리 16개가 16방향을 나눠 맡으므로, 학습을 시작할 때 질의 하나는 기준 박스의 테두리 위 16점과 절반 크기 사각형 위 16점을 읽습니다. 학습이 진행되면 오프셋이 질의의 내용에 따라 달라집니다. 이 점들은 칸의 중심에 떨어지지 않으므로 값은 쌍선형 보간으로 읽습니다. 논문 그림 2 의 설명이 “변형 교차 어텐션 층이 프로젝터의 출력을 쌍선형 보간한다” 고 한 것이 이것입니다.

기준 박스를 층마다 고치지 않는다

8장의 Deformable DETR 은 층마다 박스를 예측하고, 그 박스를 다음 층의 기준 박스로 넘겼습니다(박스 반복 정제). 층이 깊어질수록 기준이 객체에 가까워지는 구조였습니다. RF-DETR 의 공개 설정은 lite_refpoint_refine=True 이고, 이때는 모든 디코더 층이 처음 기준 박스 $r_q$ 를 그대로 함께 씁니다. 이 튜토리얼에서는 이것을 lite 기준점 정제lite reference point refinement 라고 부르겠습니다. 이름은 설정 이름을 옮긴 것이고, LW-DETR 과 RF-DETR 의 논문 본문에는 이 선택에 대한 설명이 없습니다. 코드에서 확인한 동작만 적습니다.

8장: 박스 반복 정제 처음 기준 층 1 층 2 층 3 박스 1 박스 2 박스 3 점선 = 다음 층의 기준 박스로 (기울기 차단) 박스 d = 박스 d−1 을 고친 것 RF-DETR: 모든 층이 처음 기준을 공유 기준 박스 r 과 질의 위치 임베딩 (한 번만 계산) 층 1 층 2 층 3 박스 1 박스 2 박스 3 층과 층 사이로는 질의 벡터만 넘어간다 박스 d = reparam(층 d 의 델타, r) — 언제나 r 에서 출발
그림 10-5. 디코더가 3층일 때 기준 박스가 쓰이는 방식. 왼쪽은 8장의 박스 반복 정제, 오른쪽은 RF-DETR 의 공개 설정입니다. 가로 화살표는 층에서 층으로 넘어가는 질의 벡터입니다.
항목8장: 박스 반복 정제RF-DETR: lite 기준점 정제
층 $d$ 의 교차 어텐션이 쓰는 기준 박스층 $d - 1$ 의 예측 박스(기울기 차단)언제나 처음 기준 박스 $r$
층 $d$ 의 예측 박스$\sigma(\Delta b^{d} + \sigma^{-1}(\sg(\hat{b}^{d-1})))$$\operatorname{reparam}(\delta^{d},\ r)$
질의 위치 임베딩(8장의 미니 구현은 한 번만 계산)한 번만 계산해 모든 층이 공유
박스 머리층마다 따로모든 층이 하나를 공유
층이 깊어질 때 나아지는 것기준 박스와 질의 벡터 둘 다질의 벡터만

오른쪽 방식에서 표본점의 바탕(기준 박스)은 층이 깊어져도 움직이지 않습니다. 깊은 층이 다른 곳을 보려면 오프셋 $\Delta p$ 를 다르게 내야 하고, 오프셋은 질의 벡터에서 나오므로 그렇게 할 수 있습니다. 박스도 마찬가지입니다. 층마다 “처음 기준 박스에서 얼마나 옮기고 키울지” 를 처음부터 다시 답하고, 깊은 층일수록 더 다듬어진 질의 벡터로 답할 뿐입니다. 공식 코드에는 lite_refpoint_refine=False 일 때 층마다 기준을 갱신하는 경로도 남아 있습니다.

질의 위치 임베딩query positional embedding 은 기준 박스의 네 숫자에서 만듭니다. 숫자 하나마다 5장의 사인 임베딩으로 $D/2$ 차원 벡터를 만들어 이어 붙이고, 2층 MLP(ref_point_head)에 넣습니다.

$$ \underbrace{(B, 300, 4)}_{\text{기준 박스}} \ \xrightarrow{\ \text{사인 임베딩}\ } \ \underbrace{(B, 300, 4 \times 128)}_{= (B, 300, 512)} \ \xrightarrow{\ \texttt{ref\_point\_head}\ } \ \underbrace{(B, 300, 256)}_{\text{질의 위치 임베딩}} $$

Nano 에서 잰 ref_point_head 의 입력 · 출력이 (1, 300, 512) 와 (1, 300, 256) 입니다. 미니 모델은 $4 \times 64 = 256$ 차원을 받아 128차원을 냅니다. 이 임베딩은 자기 어텐션과 교차 어텐션의 질의에 더해져(tgt + query_pos), 질의가 “나는 이 자리의 이 크기 박스를 맡고 있다” 를 알게 합니다.

계산은 되지만 쓰이지 않는 2차원 사인 위치 인코딩

7장의 DETR 에서는 특징 맵의 칸마다 2차원 사인 위치 인코딩을 만들어 인코더와 디코더의 어텐션에 더했습니다. RF-DETR 의 공식 구현에도 그 코드가 남아 있어, 순전파마다 (1, 256, 24, 24) 모양의 위치 인코딩을 계산해 디코더까지 넘깁니다. 그런데 디코더 층은 그것을 받아 쓰지 않습니다. 실제로 Nano 에서 이 위치 인코딩을 모두 0 으로 바꿔 넣고 출력을 비교하면 차이가 정확히 0 입니다.

  check 사인 위치 인코딩을 모두 0 으로 바꿔도 출력이 같은가: 최대 차이 0.00e+00 → 이 구성(인코더 없음 + 변형 교차 어텐션)에서는 쓰이지 않는다

이 구성에는 Transformer 인코더가 없고, 변형 교차 어텐션은 좌표로 직접 읽기 때문입니다. RF-DETR 에서 위치 정보를 맡는 것은 둘입니다. 백본 안에서 패치 토큰에 더하는 학습되는 위치 임베딩(6장)과, 질의 쪽의 기준 박스에서 만든 질의 위치 임베딩입니다. 미니 모델은 그래서 2차원 사인 위치 인코딩을 모델 안에서 계산하지 않습니다.

머리와 출력

그림 10-1 의 ⑧ 입니다. 디코더가 내놓은 hs 는 (층 수, B, 300, 256) 모양이고, 여기에 머리 둘을 적용하면 층마다의 예측이 한꺼번에 나옵니다.

분류 머리와 박스 머리

두 머리는 모든 디코더 층이 함께 씁니다. 8장의 박스 반복 정제에서는 층마다 머리가 따로 있었습니다. 층마다 기준 박스가 달라 “얼마나 고칠지” 의 뜻이 층마다 달랐기 때문입니다. RF-DETR 에서는 모든 층이 같은 기준 박스에서 출발하므로 같은 질문에 같은 머리로 답할 수 있습니다. 2단계 질의 선택의 머리(enc_out_class_embed, enc_out_bbox_embed)는 구조가 같은 별개의 층이고, 이 두 머리를 초기화까지 복사한 값에서 출발합니다.

박스는 시그모이드 없이

박스 재매개변수화가 세 번째로 쓰이는 자리입니다. $h^{d}_q$ 를 층 $d$ 가 낸 질의 $q$ 의 벡터(hs 의 원소)라고 하면,

$$ \delta^{d}_q = \texttt{bbox\_embed}\big( h^{d}_q \big), \qquad \hat{b}^{d}_q = \operatorname{reparam}\big( \delta^{d}_q,\ r_q \big) = \big( \delta^{d}_{x}\, r_w + r_x,\ \ \delta^{d}_{y}\, r_h + r_y,\ \ e^{\delta^{d}_{w}}\, r_w,\ \ e^{\delta^{d}_{h}}\, r_h \big) $$

입니다(오른쪽 식의 성분에서는 첨자 $q$ 를 생략했습니다). 기준 박스 $r_q$ 는 층 번호 $d$ 와 무관합니다. 이것이 lite 기준점 정제입니다. 앞의 손계산을 이어 갑니다.

손계산: 기준 박스에서 예측 박스로
$$ r = (0.3549,\ 0.2192,\ 0.2028,\ 0.1660), \qquad \delta^{d} = (-0.05,\ 0.10,\ 0.05,\ -0.02) $$
기준 박스는 질의 선택에서 구한 값, 델타는 박스 머리가 냈다고 가정한 값입니다.
$$ \hat{b}_x = -0.05 \times 0.2028 + 0.3549 = 0.3448, \qquad \hat{b}_y = 0.10 \times 0.1660 + 0.2192 = 0.2358 $$
중심: 기준 박스 너비의 5% 만큼 왼쪽, 높이의 10% 만큼 아래로.
$$ \hat{b}_w = e^{0.05} \times 0.2028 = 1.0513 \times 0.2028 = 0.2132, \qquad \hat{b}_h = e^{-0.02} \times 0.1660 = 0.9802 \times 0.1660 = 0.1627 $$
크기: 너비 5.1% 확대, 높이 2.0% 축소. 예측 박스는 $(0.3448,\ 0.2358,\ 0.2132,\ 0.1627)$ 입니다. 기준 박스가 이미 객체 근처에 있으면 디코더의 델타는 이렇게 작은 값이면 됩니다.

0 으로 초기화한 것들을 모아 보면, 학습을 시작하는 순간의 모델이 무엇을 내는지 계산 없이 알 수 있습니다.

그러므로 처음에는 인코더 제안도, 모든 디코더 층의 예측도 뽑힌 칸의 제안 박스(칸 중심의 0.05 × 0.05 박스) 입니다. 미니 모델을 새로 만들어 확인한 결과입니다.

  초기화 직후의 박스(디코더 3개 층 + 인코더 제안) = 선택된 칸의 제안 박스: 최대 차이 0.00e+00, 박스 크기 0.05 – 0.05
  초기화 직후의 클래스 확률: 평균 0.0157, 범위 0.0043 – 0.0368 (편향 −log 99 = −4.595 → σ = 0.01 근처)

클래스 확률이 정확히 0.01 이 아니라 0.0043 – 0.0368 인 것은, 편향 $-4.595$ 에 무작위로 초기화된 가중치의 기여가 더해지기 때문입니다. 평균은 0.0157 로 0.01 근처입니다. 학습은 “칸 중심의 작은 박스, 낮은 점수” 라는 출발점에서 델타와 로짓을 배워 가는 과정입니다.

출력 사전

모델의 forward 는 사전 하나를 돌려줍니다. 항목은 넷이고, 7장부터 써 온 이름 그대로입니다.

이름내용Nano, 추론 ($B = 1$)미니, 추론 ($B = 2$)미니, 학습 ($B = 2$)
pred_logits마지막 디코더 층의 클래스 로짓(1, 300, 91)(2, 12, 3)(2, 48, 3)
pred_boxes마지막 디코더 층의 박스 $(c_x, c_y, w, h)$, 정규화 좌표(1, 300, 4)(2, 12, 4)(2, 48, 4)
aux_outputs앞 층들의 {pred_logits, pred_boxes} 목록1개2개2개
enc_outputs인코더 제안의 {pred_logits, pred_boxes}(1, 300, 91), (1, 300, 4)(2, 12, 3), (2, 12, 4)(2, 48, 3), (2, 48, 4)

추론 후처리

출력에서 최종 예측 목록을 만드는 일은 8장의 방식과 같습니다. 로짓에 시그모이드를 적용한 (B, 300, 91) 을 질의 × 클래스의 한 줄 $300 \times 91 = 27{,}300$ 칸으로 펴고, 점수가 높은 순으로 num_select 개(기본 300)를 고릅니다. 뽑힌 칸의 번호를 91 로 나눈 몫이 질의 번호, 나머지가 클래스 번호입니다. NMS 는 없습니다.


  

미니 모델의 postprocess 는 8장의 postprocess_sigmoid 를 그대로 부릅니다($12 \times 3 = 36$ 칸에서 12개). 같은 영역의 parameter_groups 는 뒤의 매개변수 표를 만드는 함수입니다. 공식 구현의 PostProcess 는 여기에 박스를 원본 그림의 픽셀 좌표로 바꾸는 일을 더합니다. 점수 문턱값과 num_select 를 바꿨을 때의 모습은 14장에서 실제 패키지로 봅니다.

추론 때 달라지는 것

학습 때와 추론 때 순전파가 달라지는 곳은 하나, 질의 묶음 입니다. 추론 때는 query_feat · refpoint_embed 의 앞 $N$ 행과 묶음 0 의 2단계 층만 씁니다. 여기에 더해, 학습을 마친 뒤 구조를 줄여서 쓸 수 있는 길이 둘 있습니다. 논문이 NAS 의 손잡이로 삼은 다섯 가지 가운데 둘이고, 논문은 이 둘을 추론 때만 줄인다고 적습니다.

미니 모델에서 이 성질들을 확인한 출력입니다(학습 전 가중치, 추론 모드).

[check] 구조에서 따라 나오는 성질
  추론 출력 = 학습 모드 출력의 첫 묶음 (질의 0 – 11): 최대 차이 0.00e+00
  dec_layers=0 의 출력 = 전체 모델의 enc_outputs: 최대 차이 0.00e+00
  dec_layers=1 의 출력 = 전체 모델의 aux_outputs[0]: 최대 차이 0.00e+00
  dec_layers=2 의 출력 = 전체 모델의 aux_outputs[1]: 최대 차이 0.00e+00
  num_queries=6, dec_layers=0 의 출력 = 인코더 제안 12개의 앞 6개 (점수 순): 최대 차이 0.00e+00
  num_queries=6, 디코더 3층의 로짓 vs 질의 12개일 때의 앞 6개: 최대 차이 2.98e-01 (같지 않다 — 자기 어텐션의 상대가 줄었다)
  선택된 칸은 점수 내림차순으로 놓인다: True
공식 구현에서는 만들 때 정한다

미니 모델은 dec_layers 와 num_queries 를 forward 의 인자로 받게 만들었습니다. 12장의 실험을 위해서입니다. 공식 구현에는 호출할 때마다 바꾸는 인자가 없고, 모델을 만들 때의 설정 으로 정해집니다(dec_layers=0 이면 인코더 제안이 예측으로 나오고, 질의 임베딩은 앞의 num_queries 행을 씁니다). 동작은 같습니다.

손잡이를 돌려 본 시간

미니 모델의 가중치를 그대로 두고 손잡이를 하나씩만 바꿔 순전파 시간을 쟀습니다. 속도는 가중치의 값과 무관하므로 학습 전 모델로 쟀습니다. 노트북 GPU 에서 PyTorch 로 잰 참고값 이고, 논문의 지연 시간(T4, TensorRT)과는 견줄 수 없습니다.

[손잡이] 같은 가중치, forward 인자만 바꿈 — 추론 모드, 배치 1 과 배치 64 의 순전파 시간
  (40바퀴 가운데 앞 8바퀴를 버린 최솟값)
  설정                                     | 출력 pred_boxes | 배치 1 (ms) | 배치 64 (ms/장)
  기본 (96, 패치 8, 윈도 2, 디코더 3, 질의 12)      | (64, 12, 4)     |        3.03 |      0.135
  디코더 2층                                 | (64, 12, 4)     |        2.68 |      0.130
  디코더 1층                                 | (64, 12, 4)     |        2.30 |      0.123
  디코더 0층                                 | (64, 12, 4)     |        1.64 |      0.112
  질의 6개                                  | (64, 6, 4)      |        3.02 |      0.130
  윈도 1×1 (전부 전역)                         | (64, 12, 4)     |        2.98 |      0.140
  윈도 3×3                                 | (64, 12, 4)     |        3.01 |      0.151
  패치 12 (격자 8×8)                         | (64, 12, 4)     |        3.12 |      0.095
  패치 6 (격자 16×16)                        | (64, 12, 4)     |        3.00 |      0.241
  해상도 64 (격자 8×8)                        | (64, 12, 4)     |        3.08 |      0.088
  해상도 128 (격자 16×16)                     | (64, 12, 4)     |        3.03 |      0.250
미니 RF-DETR 에서 손잡이 하나만 바꿨을 때의 순전파 시간 막대 그래프. 왼쪽은 배치 1, 오른쪽은 배치 64 에서의 그림 한 장당 시간
그림 10-6. 미니 RF-DETR 에서 손잡이 하나만 바꿨을 때 그림 한 장당 순전파 시간(ms). 왼쪽은 배치 1, 오른쪽은 배치 64. 파랑 = 기본 설정, 주황 = 디코더 층 수, 초록 = 질의 수, 분홍 = 윈도 수, 노랑 = 패치 크기, 하늘 = 해상도. 회색 점선은 기본 설정의 값입니다.

그림 10-6 은 왼쪽과 오른쪽이 전혀 다른 이야기를 합니다.

측정의 한계도 적어 둡니다. 설정을 하나씩 차례로 쟀을 때는 같은 설정이 실행에 따라 두 배 가까이 다르게 나오기도 해서, 모든 설정을 번갈아 40바퀴 재고 설정별 최솟값을 썼습니다. 그래도 배치 1 에서 0.1 ms, 배치 64 에서 0.01 ms 안쪽의 차이는 읽지 않는 것이 좋습니다. 이 손잡이들이 탐지 성능을 어떻게 바꾸는지가 12장의 주제입니다.

매개변수 수 세기

논문 표 2 는 RF-DETR Nano 의 매개변수를 30.5M 으로 적습니다. 이 수가 어디서 나오는지, 그리고 그 가운데 추론에 실제로 쓰이는 것이 얼마인지 세어 봅니다.

부품별 표

미니 모델과 Nano 를 같은 여섯 부품으로 나눠 센 결과입니다. 오른쪽 열은 묶음마다 따로 있는 부품에서 첫 묶음 것만 센 수입니다.

[매개변수] 부품별
    부품                          |    전체   | 추론 때 쓰이는 것 (묶음 1개)
    backbone (WindowedViT)        |   705,024 |   705,024
    projector (C2f)               |   300,544 |   300,544
    two-stage heads (x groups)    |   202,780 |    50,695
    decoder layers                |   584,096 |   584,096
    class + box heads             |    33,927 |    33,927
    query embeddings (x groups)   |     6,336 |     1,584
    합계                          | 1,832,707 | 1,675,870
    check 표의 합계 = 모델 전체 매개변수 1,832,707: True
  부품별 매개변수 수
    부품                          |      전체     | 추론 때 쓰이는 것 (묶음 1개)
    backbone (windowed DINOv2-S)  |    21,821,184 |    21,821,184
    projector (C2f)               |     1,444,864 |     1,444,864
    two-stage heads (x groups)    |     2,889,939 |       222,303
    decoder layers                |     3,141,312 |     3,141,312
    class + box heads             |       155,999 |       155,999
    query embeddings (x groups)   |     1,014,000 |        78,000
    합계                          |    30,467,298 |    26,863,662
    check 표의 합계 = 모델 전체 매개변수 30,467,298: True
    → 전체 30.47M 은 논문 표 2 의 30.5M 과 맞아떨어진다 (학습용 질의 묶음 13개를 모두 센 수). 추론에 실제로 쓰이는 것은 26.86M.
부품별 매개변수 수의 가로 막대 그래프. 왼쪽은 미니 RF-DETR, 오른쪽은 RF-DETR Nano. 부품마다 전체 수와 추론 때 쓰이는 수를 나란히 그렸다
그림 10-7. 부품별 매개변수 수. 왼쪽은 미니 RF-DETR(단위 천 개), 오른쪽은 RF-DETR Nano(단위 백만 개). 파랑 = 전체(학습 때), 주황 빗금 = 추론 때 쓰이는 것(묶음 하나). 부품 이름은 위에서부터 백본, 프로젝터, 2단계 층(× 묶음), 디코더 층, 분류 · 박스 머리, 질의 임베딩(× 묶음)입니다.

그림 10-7 과 표에서 읽을 것입니다.

손으로 세어 맞추기

선형 층 하나의 매개변수는 (입력 차원 × 출력 차원) + 출력 차원(편향)입니다. 이것만으로 표의 여러 줄을 맞출 수 있습니다. Nano 의 숫자($D = 256$)로 셉니다.

분류 머리 · 박스 머리 (표의 class + box heads)
$$ \texttt{class\_embed}: \quad 256 \times 91 + 91 = 23{,}296 + 91 = 23{,}387 $$
선형 층 256 → 91.
$$ \texttt{bbox\_embed}: \quad 2 \times (256 \times 256 + 256) + (256 \times 4 + 4) = 2 \times 65{,}792 + 1{,}028 = 132{,}612 $$
3층 MLP: 256 → 256 이 두 번, 256 → 4 가 한 번.
$$ 23{,}387 + 132{,}612 = 155{,}999 $$
표의 155,999 와 같습니다.
질의 임베딩 (표의 query embeddings)
$$ \texttt{query\_feat}: \quad (13 \times 300) \times 256 = 3{,}900 \times 256 = 998{,}400 $$
묶음 13개 × 질의 300개, 행마다 256차원.
$$ \texttt{refpoint\_embed}: \quad 3{,}900 \times 4 = 15{,}600 $$
행마다 숫자 4개.
$$ 998{,}400 + 15{,}600 = 1{,}014{,}000, \qquad \text{추론 때}: \ 300 \times (256 + 4) = 78{,}000 $$
표의 1,014,000 과 78,000 입니다. 추론에는 13분의 1 만 쓰입니다.
2단계 질의 선택의 층 (표의 two-stage heads)
$$ \underbrace{(256 \times 256 + 256)}_{\texttt{enc\_output}} + \underbrace{2 \times 256}_{\texttt{enc\_output\_norm}} + \underbrace{23{,}387}_{\texttt{enc\_out\_class\_embed}} + \underbrace{132{,}612}_{\texttt{enc\_out\_bbox\_embed}} $$
묶음 하나의 네 층. 뒤의 둘은 분류 머리 · 박스 머리와 구조가 같으므로 수도 같습니다.
$$ = 65{,}792 + 512 + 23{,}387 + 132{,}612 = 222{,}303 $$
묶음 하나의 수. 표의 “추론 때” 열과 같습니다.
$$ 13 \times 222{,}303 = 2{,}889{,}939 $$
표의 2,889,939 와 같습니다.
디코더 한 층, 그리고 디코더 전체 (표의 decoder layers)
$$ \text{자기 어텐션}: \quad \underbrace{3 \times (256 \times 256 + 256)}_{\text{질의 · 열쇠 · 값 투영}} + \underbrace{(256 \times 256 + 256)}_{\text{출력 투영}} = 4 \times 65{,}792 = 263{,}168 $$
5장의 다중 머리 어텐션. 머리 수(8)는 매개변수 수에 영향이 없습니다.
$$ \text{변형 교차 어텐션}: \quad \underbrace{(256 \times 64 + 64)}_{\text{오프셋}} + \underbrace{(256 \times 32 + 32)}_{\text{가중치}} + \underbrace{2 \times 65{,}792}_{\text{값 · 출력 투영}} = 16{,}448 + 8{,}224 + 131{,}584 = 156{,}256 $$
오프셋 층의 출력은 $2MLK = 64$, 가중치 층의 출력은 $MLK = 32$. 열쇠 투영이 없어서 보통 어텐션보다 작습니다.
$$ \text{FFN}: \quad (256 \times 2048 + 2048) + (2048 \times 256 + 256) = 526{,}336 + 524{,}544 = 1{,}050{,}880 $$
256 → 2048 → 256. 은닉 차원이 8배라 한 층에서 가장 큰 부품입니다.
$$ \text{한 층}: \quad 263{,}168 + 156{,}256 + 1{,}050{,}880 + \underbrace{3 \times 512}_{\text{층 정규화 셋}} = 1{,}471{,}840 $$
디코더 한 층은 약 147만 개이고 그 가운데 71% 가 FFN 입니다.
$$ 2 \times 1{,}471{,}840 + \underbrace{512}_{\text{공유 층 정규화}} + \underbrace{(512 \times 256 + 256) + (256 \times 256 + 256)}_{\texttt{ref\_point\_head} \ = \ 197{,}120} = 3{,}141{,}312 $$
표의 3,141,312 와 같습니다. ref_point_head 는 512 → 256 → 256 의 2층 MLP 입니다.

백본도 같은 방법으로 셀 수 있습니다. 6장에서 ViT 의 매개변수를 세던 식에 Nano 의 숫자($C = 384$)를 넣습니다.

백본 (표의 backbone)
$$ \text{블록 하나}: \quad \underbrace{4 \times (384^2 + 384)}_{\text{어텐션}} + \underbrace{(384 \times 1536 + 1536) + (1536 \times 384 + 384)}_{\text{MLP}} + \underbrace{2 \times 768}_{\text{층 정규화 둘}} + \underbrace{2 \times 384}_{\text{LayerScale 둘}} $$
어텐션의 질의 · 열쇠 · 값 · 출력 투영, 은닉 1536 의 MLP, 층 정규화 둘, 그리고 DINOv2 블록에 있는 채널별 배율(LayerScale) 둘.
$$ = 591{,}360 + 1{,}181{,}568 + 1{,}536 + 768 = 1{,}775{,}232 $$
$384^2 = 147{,}456$ 이므로 어텐션이 $4 \times 147{,}840 = 591{,}360$, MLP 가 $591{,}360 + 590{,}208 = 1{,}181{,}568$ 입니다.
$$ \text{임베딩}: \quad \underbrace{(384 \times 3 \times 16 \times 16 + 384)}_{\text{패치 임베딩}} + \underbrace{577 \times 384}_{\text{위치 임베딩}} + \underbrace{384 + 384}_{\text{CLS · 마스크 토큰}} = 295{,}296 + 221{,}568 + 768 = 517{,}632 $$
패치 16×16 의 합성곱, 위치 임베딩 $(24^2 + 1) \times 384$, CLS 토큰과 마스크 토큰(사전 학습에서 쓰던 것으로, 탐지 때는 쓰이지 않습니다).
$$ 12 \times 1{,}775{,}232 + 517{,}632 + \underbrace{768}_{\text{끝의 층 정규화}} = 21{,}302{,}784 + 517{,}632 + 768 = 21{,}821{,}184 $$
표의 21,821,184 와 같습니다. 위치 임베딩의 크기가 해상도에 따라 달라진다는 점을 기억해 두세요. 바로 뒤에서 쓰입니다.

프로젝터(1,444,864)는 앞에서 세었습니다. 여섯 줄을 더하면 $21{,}821{,}184 + 1{,}444{,}864 + 2{,}889{,}939 + 3{,}141{,}312 + 155{,}999 + 1{,}014{,}000 = 30{,}467{,}298$ 입니다. 모델의 모든 매개변수를 한 줄씩 손으로 다시 센 것이고, 실제 모델의 합계와 한 개도 다르지 않습니다.

논문의 30.5M 과 추론에 쓰이는 수

Nano 의 전체 매개변수 30,467,298개는 반올림하면 30.5M 으로, 논문 표 2 의 값과 맞아떨어집니다. 그런데 이 수에는 학습할 때만 쓰이는 매개변수가 들어 있습니다. 질의 묶음 13개 가운데 뒤의 12개 분량입니다.

$$ \underbrace{12 \times 222{,}303}_{\text{2단계 층}} + \underbrace{12 \times 78{,}000}_{\text{질의 임베딩}} = 2{,}667{,}636 + 936{,}000 = 3{,}603{,}636 $$

전체의 11.8% 입니다. 이것을 빼면 추론에 실제로 쓰이는 매개변수는 $30{,}467{,}298 - 3{,}603{,}636 = 26{,}863{,}662$ 개(26.9M)입니다. 미니 모델은 1,832,707개 가운데 156,837개(8.6%)가 추론 때 쓰이지 않습니다.

논문은 매개변수 수를 어떻게 세었는지 적지 않습니다. 확인할 수 있는 것은 “공개된 Nano 모델의 전체 매개변수 수가 논문의 30.5M 과 일치한다” 까지입니다. 다른 탐지기와 매개변수 수를 견줄 때는 이런 차이가 있을 수 있다는 것만 알아 두면 됩니다. 엄밀히는 추론에 쓰이지 않는 것이 조금 더 있습니다(백본의 마스크 토큰 384개, 그리고 보조 출력과 enc_outputs 를 쓰지 않는다면 그것만을 위한 계산).

크기 가족

RF-DETR 은 모델 하나가 아니라 크기가 다른 가족입니다. 논문 표 7 의 COCO 탐지 구성을 옮기고, 매개변수 수와 성능(논문 표 2 와 부록 표 12)을 붙였습니다.

크기백본해상도패치윈도 (한 변)디코더 층질의매개변수 (논문)GFLOPs지연 시간 (ms)COCO AP
NDINOv2-S384162230030.5M31.92.348.0
SDINOv2-S512162330032.1M59.83.552.9
MDINOv2-S576162430033.7M78.84.454.7
LDINOv2-S704162430033.9M125.66.856.5
XLDINOv2-B7002015300126.4M299.311.558.6
2XLDINOv2-B8802025300126.9M438.417.260.1

N · S · M · L 은 같은 백본(DINOv2-S, 블록 12개, 차원 384)에 같은 프로젝터, 같은 hidden_dim 을 씁니다. 공개 코드의 설정에서 구조를 정하는 값 가운데 네 크기가 서로 다른 것은 해상도 · 디코더 층 수 · 위치 임베딩 격자입니다. XL 과 2XL 은 백본이 DINOv2-B 로 바뀌고 패치가 20 입니다(논문 표 7). 표에서 눈에 띄는 것은 N 에서 L 까지 GFLOPs 는 31.9 에서 125.6 으로 네 배가 되는데 매개변수는 30.5M 에서 33.9M 으로 거의 그대로 라는 점입니다. 이유를 숫자로 확인합니다.

N 에서 S · M · L 로: 늘어나는 매개변수
$$ \text{디코더 한 층} = 1{,}471{,}840, \qquad \text{위치 임베딩} = (g^2 + 1) \times 384 $$
크기에 따라 달라지는 부품은 이 둘뿐입니다. 해상도가 커지면 토큰이 늘지만, 토큰을 처리하는 층의 가중치는 토큰 수와 무관합니다. 위치 임베딩만 격자 $g \times g$ 에 맞춰 커집니다.
$$ \text{S}: \quad 30{,}467{,}298 + \underbrace{1{,}471{,}840}_{\text{디코더 2 → 3층}} + \underbrace{(32^2 - 24^2) \times 384}_{= 172{,}032} = 32{,}111{,}170 $$
해상도 512 이면 격자 $g = 32$. 논문의 32.1M 과 맞습니다.
$$ \text{M}: \quad 32{,}111{,}170 + \underbrace{1{,}471{,}840}_{\text{3 → 4층}} + \underbrace{(36^2 - 32^2) \times 384}_{= 104{,}448} = 33{,}687{,}458 $$
해상도 576, $g = 36$. 논문의 33.7M.
$$ \text{L}: \quad 33{,}687{,}458 + \underbrace{0}_{\text{4층 그대로}} + \underbrace{(44^2 - 36^2) \times 384}_{= 245{,}760} = 33{,}933{,}218 $$
해상도 704, $g = 44$. 논문의 33.9M. M 과 L 은 디코더 층 수가 같아서 차이가 위치 임베딩 24.6만 개뿐입니다.

손으로 구한 세 값은, 설치한 패키지(rfdetr 1.12.1)의 설정으로 Small · Medium · Large 모델을 가중치 없이 만들어 센 수(32,111,170 · 33,687,458 · 33,933,218)와 정확히 같았습니다. 매개변수 수는 모델의 “기억 용량” 이고 GFLOPs 와 지연 시간은 “일의 양” 입니다. 같은 가중치로 더 많은 토큰을 처리하면 일의 양만 늘어납니다. RF-DETR 의 크기 가족은 주로 토큰 수와 디코더 깊이 로 크기를 조절하고, 그래서 가중치 공유 NAS 로 한 번에 얻을 수 있습니다(12장). XL 과 2XL 의 차이 0.5M 도 같은 식으로 맞습니다. 두 모델은 디코더가 5층으로 같고, 위치 임베딩의 차이가 $(44^2 - 35^2) \times 768 = 546{,}048$ 입니다(DINOv2-B 의 차원 768. 이 두 모델은 이 환경에서 만들어 보지 못했고, 논문의 수치와 산수가 맞는다는 것만 확인했습니다).

미니 RF-DETR 따라 읽기

code/ch10_rfdetr_model.py 의 MiniRFDETR 은 이 장에서 본 모든 것을 200줄 남짓에 담은 것입니다. 새로 만든 것은 디코더 층과 조립하는 코드뿐이고, 부품은 앞 장의 파일에서 가져옵니다.

설정


  

줄마다 주석에 공식 값이 적혀 있습니다. 이름은 공식 설정과 되도록 같게 했습니다. MiniRFDETR(group_detr=1) 처럼 일부만 덮어써서 만들 수 있고, 11 – 13장의 코드가 그렇게 씁니다.

모델


  

forward 를 그림 10-1 의 번호와 맞춰 읽습니다.

  1. ① – ⑤ extract_features. 백본이 특징 맵 세 장을, 프로젝터가 P4 한 장을 냅니다. flatten(2).transpose(1, 2) 가 (B, 128, 12, 12) 를 memory (B, 144, 128) 로 폅니다.
  2. ⑥ select_queries. 묶음마다 반복문을 한 번 돕니다. all_logits.max(-1).values.topk(num_queries) 가 “클래스 로짓의 최댓값 상위 $N$ 칸” 이고, box_reparam(delta, proposals[top]) 이 인코더 제안 박스입니다. 공식 구현은 고른 칸의 특징에 층 정규화를 적용하고 이 코드는 모든 칸에 적용한 뒤 고르지만, 층 정규화는 토큰마다 따로 계산되므로 결과가 같습니다.
  3. 기준 박스와 질의. box_reparam(self.refpoint_embed.weight[:total][None], enc_boxes.detach()) 한 줄이 $r_q = \operatorname{reparam}(e_q, \sg(\hat{b}^{\text{enc}}_q))$ 입니다. query_pos 는 반복문 밖에서 한 번만 계산합니다. tgt 는 query_feat 를 배치만큼 늘린 것입니다.
  4. ⑦ 디코더. 반복문 안에서 바뀌는 것은 tgt 뿐입니다. query_pos 와 reference_input 은 모든 층에 같은 것이 들어갑니다. 층마다 decoder_norm(tgt) 를 hs 에 모읍니다.
  5. ⑧ 머리. self.class_embed(hs) 와 box_reparam(self.bbox_embed(hs), reference) 가 모든 층의 예측을 한 번에 냅니다. 마지막 층이 pred_*, 나머지가 aux_outputs 입니다.

num_layers == 0 인 갈래가 “디코더를 전부 뗀” 경우입니다. 질의 선택의 결과를 그대로 pred_logits · pred_boxes 로 돌려주고 끝납니다. __init__ 의 초기화도 공식 구현을 따랐습니다. 분류 편향 $-\log 99$, 박스 머리 마지막 층 0, refpoint_embed 0, 2단계 머리는 디코더 머리의 사본에서 출발합니다.

실행과 모양 추적

실행하면 먼저 미니 모델의 설정(위의 DEFAULT_CONFIG 그대로라 여기서는 생략합니다)과 단계별 모양이 나옵니다. 도형 세상의 검증 그림 두 장($B = 2$)을 넣은 결과입니다.

  윈도 블록 [0, 1, 3, 5], 전역 블록 [2, 4]
[모양 추적] 입력 (2, 3, 96, 96) — 추론 모드 (묶음 1개)
    그림                                     (2, 3, 96, 96)
    패치 임베딩 + CLS + 위치 임베딩                  (2, 145, 96)
    윈도 우선 재배열 + 윈도마다 CLS                   (8, 37, 96)
    백본 특징 맵 × 3 (층 [2, 4, 6])              (2, 96, 12, 12)
    프로젝터 출력 (P4)                           (2, 128, 12, 12)
    memory (칸을 한 줄로)                       (2, 144, 128)
    제안 박스 (칸마다 하나)                         (144, 4)
    칸마다의 클래스 로짓                            (2, 144, 3)
    선택된 칸 번호 topk                          (2, 12)
    인코더 제안: 로짓 / 박스                        ((2, 12, 3), (2, 12, 4))
    기준 박스 (모든 층 공유)                        (2, 12, 4)
    기준 박스의 사인 임베딩 → ref_point_head         ((2, 12, 256), (2, 12, 128))
    디코더 층별 질의 임베딩 hs                       (3, 2, 12, 128)
    pred_logits / pred_boxes               ((2, 12, 3), (2, 12, 4))
    aux_outputs                            2개 (앞 층들), 각각 같은 모양
    (참고) 2차원 사인 위치 인코딩          (144, 128) — 공식 구현은 이것을 계산해 디코더에 넘기지만 디코더가 쓰지 않는다 (아래 Nano 대조에서 확인)
  학습 모드 (묶음 4개): pred_logits (2, 48, 3), enc_outputs (2, 48, 3), hs (3, 2, 48, 128)

그림 10-1 의 아랫줄(흐린 글씨)이 이 출력입니다. 몇 줄만 짚습니다. 임베딩 직후의 (2, 145, 96) 은 CLS 1 + 패치 144 이고, 윈도 우선으로 재배열해 CLS 를 윈도마다 붙이면 (8, 37, 96)($8 = 2 \times 4$, $37 = 36 + 1$)입니다. 기준 박스의 사인 임베딩은 $4 \times 64 = 256$ 차원이고 ref_point_head 가 128차원으로 만듭니다. 학습 모드에서는 질의 축이 $4 \times 12 = 48$ 이 됩니다.

이어서 Nano 의 모양이 나옵니다. 모듈마다 훅을 걸어 실제 입출력에서 읽은 값입니다.

[RF-DETR Nano 대조] rfdetr 1.12.1, 가중치 rf-detr-nano.pth, 장치 cpu
  설정: resolution 384, patch_size 16, num_windows 2, out_feature_indexes [3, 6, 9, 12], hidden_dim 256, dec_layers 2, num_queries 300, group_detr 13, sa_nheads 8, ca_nheads 16, dec_n_points 2, projector_scale ['P4']
  백본: 차원 384, 블록 12, 머리 6, 윈도 블록 [0, 1, 2, 4, 5, 7, 8, 10, 11], 레지스터 토큰 0
  단계별 텐서 모양 (추론 모드, 배치 1, 훅으로 실제로 잰 값)
    그림                                           (1, 3, 384, 384)
    임베딩 출력 (윈도 우선 + 윈도마다 CLS)                    (4, 145, 384)
    윈도 블록의 어텐션 입력 (예: 블록 0)                      (4, 145, 384)
    전역 블록의 어텐션 입력 (블록 [3, 6, 9])                 (1, 580, 384)
    백본 특징 맵 × 4                                  (1, 384, 24, 24)
    프로젝터 출력                                      (1, 256, 24, 24)
    2차원 사인 위치 인코딩                                (1, 256, 24, 24)
    enc_output (모든 칸)                            (1, 576, 256)
    칸마다의 클래스 로짓 (순위를 매길 때)                       (1, 576, 91)
    선택된 칸의 클래스 로짓 (enc_outputs)                  (1, 300, 91)
    선택된 칸의 박스 델타                                 (1, 300, 4)
    ref_point_head 입력 → 출력                       ((1, 300, 512), (1, 300, 256))
    변형 교차 어텐션 입력: 질의 / 기준 박스 / memory            ((1, 300, 256), (1, 300, 1, 4), (1, 576, 256))
    디코더 층 출력 × 2                                 (1, 300, 256)
    class_embed 출력 (층 축 포함)                      (2, 1, 300, 91)
    pred_logits / pred_boxes                     ((1, 300, 91), (1, 300, 4))
    → 패치 토큰 24×24 = 576개, 윈도 2×2 로 나누면 윈도마다 144개 + CLS 1개. 전역 블록은 [3, 6, 9] (0 부터 센 번호)
    → 특징을 꺼내는 자리: 블록 [2, 5, 8, 11] 의 출력 (out_feature_indexes [3, 6, 9, 12] 는 '블록 몇 개를 지난 뒤' 라는 뜻)
    → 출력 키: ['aux_outputs', 'enc_outputs', 'pred_boxes', 'pred_logits']  (추론 모드에서도 aux_outputs · enc_outputs 가 나온다)

이 출력이 그림 10-1 의 윗줄입니다. “칸마다의 클래스 로짓” 이 576칸짜리와 300칸짜리로 두 번 나오는 것은, 공식 구현이 같은 선형 층을 한 순전파에서 두 번 부르기 때문입니다(모든 칸의 순위를 매길 때 한 번, 고른 칸의 enc_outputs 를 만들 때 한 번). 미니 모델은 한 번 계산해 골라 씁니다. 변형 교차 어텐션의 기준 박스가 (1, 300, 1, 4) 인 것에서 레벨이 하나임을, class_embed 의 출력 (2, 1, 300, 91) 에서 머리가 층 축(2)을 포함한 hs 전체에 한 번에 적용됨을 읽을 수 있습니다.

공식 구현과 대조

“구조와 계산이 공식 구현과 같다” 는 말을 숫자로 확인했습니다. MiniRFDETR 의 프로젝터 뒤 부분(2단계 질의 선택 · 디코더 · 머리)의 가중치를 공식 Transformer 와 LWDETR 클래스에 그대로 복사하고, 같은 그림을 넣어 출력을 견주었습니다. 0 으로 초기화되는 가중치는 무작위 값으로 흔든 뒤 복사해서 모든 경로가 계산에 참여하게 했습니다. 튜토리얼 코드에는 없는 임시 대조입니다(백본과 프로젝터의 대조는 9장).

대조출력의 최대 차이
P4, 학습 모드(묶음 4개): pred_logits · pred_boxes (3, 48, ·)1.43e-06 (보조 출력 1.43e-06, enc_outputs 4.77e-07)
P4, 추론 모드: (3, 12, ·)9.54e-07 (보조 출력 9.54e-07, enc_outputs 0)
P3 · P4 · P5(레벨 3개), 학습 / 추론1.91e-06 / 1.43e-06

로짓의 평균 절댓값이 4.7 인 입력에서 잰 값이므로 차이는 32비트 실수의 반올림 수준입니다. 가중치를 옮기면 같은 출력이 나온다는 뜻입니다. 미니 모델이 공식 구현과 다르게 한 곳 도 있습니다. 크기 말고 다른 점을 모두 적습니다.

항목미니 RF-DETR공식 구현영향
2차원 사인 위치 인코딩계산하지 않음계산해 넘기지만 디코더가 쓰지 않음없음(Nano 에서 출력 차이 0)
제안 박스의 유효 범위 검사없음0.01 – 0.99 밖의 칸은 버림격자 한 변이 50 미만이면 없음
사인 임베딩의 좌표 순서$(x, y, w, h)$$(y, x, w, h)$MLP 입력의 열 순서만 다름. 가중치를 옮길 때 첫 층의 열을 바꾸면 일치
dec_layers · num_queriesforward 의 인자모델을 만들 때의 설정동작은 같음
패딩 마스크 · 유효 비율없음있음그림 크기가 모두 같으면 없음
입력 정규화모델 안에서 (images − 0.5) / 0.25모델 밖에서 ImageNet 평균 · 표준편차전처리의 차이
패치 크기를 호출마다 바꾸기가능(패치 임베딩 가중치를 보간)만들 때 고정12장의 실험용
분할 머리 · 키포인트 · 혼합 정밀도없음옵션으로 있음분할 머리는 13장
백본의 가중치무작위 초기화에서 시작DINOv2 사전 학습 가중치11장에서 다룸

다중 스케일도 만들 수는 있습니다. MiniRFDETR(projector_scale=("P3", "P4", "P5")) 는 레벨 셋(24×24, 12×12, 6×6)을 쓰고, 순전파의 모양과 공식 구현과의 수치 일치만 확인했습니다. 학습해 보지는 않았습니다.

[다중 스케일] projector_scale = (P3, P4, P5): spatial_shapes [(24, 24), (12, 12), (6, 6)], memory (2, 756, 128), pred_boxes (2, 12, 4), 매개변수 2,794,515개
이 장의 정리

확인 문제

문제 1 · 토큰 수와 모양

RF-DETR Small 은 해상도 512, 패치 16, num_windows=2 이고 백본은 Nano 와 같습니다(차원 384). 그림 한 장($B = 1$)에 대해 (가) 패치 토큰의 수, (나) 윈도 블록에서의 텐서 모양, (다) 전역 블록에서의 텐서 모양, (라) 백본이 내놓는 특징 맵 한 장의 모양을 구하세요.

답 보기

(가) $g = 512 / 16 = 32$ 이므로 $32^2 = 1{,}024$ 개.

(나) 윈도는 $2 \times 2 = 4$ 개, 윈도 하나의 패치 토큰은 $n = (32/2)^2 = 256$ 개. CLS 를 붙이면 257 이므로 (4, 257, 384).

(다) $4 \times 257 = 1{,}028$ 이므로 (1, 1028, 384). 윈도가 없을 때($1{,}024 + 1 = 1{,}025$)보다 토큰이 3개 많습니다.

(라) CLS 를 떼고 격자로 되돌려 (1, 384, 32, 32). 이런 것이 네 장입니다.

문제 2 · 나누어떨어짐 제약

(가) 패치 16, num_windows=2 인 모델에 600×600 그림을 넣을 수 있습니까? 넣을 수 없다면 600 에 가장 가까운 가능한 해상도 둘을 구하세요. (나) 패치 20, num_windows=2 라면 600×600 은 가능합니까? 가능하면 토큰 수를 구하세요.

답 보기

(가) 한 변이 $p \cdot W_n = 32$ 의 배수여야 합니다. $600 / 32 = 18.75$ 이므로 넣을 수 없습니다. 가까운 배수는 $32 \times 18 = 576$ 과 $32 \times 19 = 608$ 입니다.

(나) $p \cdot W_n = 40$ 이고 $600 / 40 = 15$ 이므로 가능합니다. 격자는 $600 / 20 = 30$, 토큰은 $900$ 개이고 윈도 하나는 $15 \times 15 = 225$ 개입니다.

문제 3 · 윈도 블록 정하기

공개 코드의 규칙(“0 부터 out_feature_indexes 의 마지막 값까지의 수에서 out_feature_indexes 를 뺀다”)을 (가) [2, 5, 8, 11] 과 (나) 미니 모델의 (2, 4, 6) 에 적용해 윈도 블록과 전역 블록을 구하세요. 블록은 각각 12개, 6개입니다. (다) (나)에서 첫 번째로 꺼내는 특징은 전역 블록을 몇 번 거쳤습니까?

답 보기

(가) $\{0, \dots, 11\} \setminus \{2, 5, 8, 11\} = \{0, 1, 3, 4, 6, 7, 9, 10\}$ 이 윈도 블록, 전역 블록은 $\{2, 5, 8, 11\}$. 논문 부록 A 의 표기와 같은 집합입니다.

(나) $\{0, \dots, 6\} \setminus \{2, 4, 6\} = \{0, 1, 3, 5\}$ 가 윈도 블록(6 은 블록 번호에 없음), 전역 블록은 $\{2, 4\}$. 로그의 “윈도 블록 [0, 1, 3, 5], 전역 블록 [2, 4]” 와 같습니다.

(다) 0번. out_feature_indexes 의 2 는 “블록 2개를 지난 뒤” 이므로 블록 0 · 1 의 출력이고, 둘 다 윈도 블록입니다. 둘째 특징(블록 0 – 3 을 지남)은 전역 블록 2 를 한 번, 셋째 특징은 두 번 거칩니다.

문제 4 · 제안 박스에서 인코더 제안 박스로

RF-DETR Small(격자 32×32, 해상도 512)에서 (행 10, 열 20) 칸이 뽑혔고 박스 머리가 $\delta^{\text{enc}} = (-0.5,\ 0.2,\ \log 4,\ \log 2)$ 를 냈습니다. (가) 이 칸의 제안 박스, (나) 인코더 제안 박스, (다) 그 박스의 픽셀 크기를 구하세요. (라) refpoint_embed 가 아직 0 이라면 기준 박스는 무엇입니까?

답 보기

(가) $\big( \tfrac{20.5}{32},\ \tfrac{10.5}{32},\ 0.05,\ 0.05 \big) = (0.6406,\ 0.3281,\ 0.05,\ 0.05)$.

(나) $c_x = -0.5 \times 0.05 + 0.6406 = 0.6156$, $c_y = 0.2 \times 0.05 + 0.3281 = 0.3381$, $w = e^{\log 4} \times 0.05 = 0.2$, $h = e^{\log 2} \times 0.05 = 0.1$. 박스는 $(0.6156,\ 0.3381,\ 0.2,\ 0.1)$.

(다) $0.2 \times 512 = 102.4$ 픽셀, $0.1 \times 512 = 51.2$ 픽셀.

(라) $\operatorname{reparam}(0, \hat{b}^{\text{enc}}) = \hat{b}^{\text{enc}}$ 이므로 (나)의 박스 그대로입니다(기울기만 끊깁니다).

문제 5 · 미니 모델의 매개변수 세기

미니 RF-DETR 은 $D = 128$, 클래스 3개, 질의 12개 × 묶음 4개입니다. (가) 분류 머리와 박스 머리의 매개변수 수의 합, (나) 질의 임베딩(query_feat + refpoint_embed)의 전체 수와 추론 때 쓰이는 수, (다) 2단계 질의 선택의 층 한 묶음의 수와 네 묶음의 수를 구해 로그와 맞추세요.

답 보기

(가) 분류 머리 $128 \times 3 + 3 = 387$. 박스 머리 $2 \times (128 \times 128 + 128) + (128 \times 4 + 4) = 2 \times 16{,}512 + 516 = 33{,}540$. 합 $33{,}927$ (로그의 class + box heads).

(나) $48 \times 128 + 48 \times 4 = 6{,}144 + 192 = 6{,}336$. 추론 때는 $12 \times 132 = 1{,}584$.

(다) 한 묶음: $(128 \times 128 + 128) + 2 \times 128 + 387 + 33{,}540 = 16{,}512 + 256 + 387 + 33{,}540 = 50{,}695$. 네 묶음: $4 \times 50{,}695 = 202{,}780$.

문제 6 · 디코더 층을 하나 더

Nano 의 디코더 한 층은 1,471,840개입니다. (가) FFN 의 은닉 차원을 2048 에서 1024 로 줄이면 한 층은 몇 개가 됩니까? (나) Nano 의 설정에서 디코더만 2층에서 6층으로 늘리면(해상도는 384 그대로) 전체 매개변수는 몇 개입니까? (다) 교차 어텐션의 표본점을 2개에서 4개로 늘리면 한 층의 매개변수는 몇 개 늘어납니까?

답 보기

(가) FFN 이 $(256 \times 1024 + 1024) + (1024 \times 256 + 256) = 263{,}168 + 262{,}400 = 525{,}568$ 이 됩니다. 원래 $1{,}050{,}880$ 이었으므로 $525{,}312$ 가 줄어 $1{,}471{,}840 - 525{,}312 = 946{,}528$ 개.

(나) $30{,}467{,}298 + 4 \times 1{,}471{,}840 = 30{,}467{,}298 + 5{,}887{,}360 = 36{,}354{,}658$ 개. 해상도가 같으므로 위치 임베딩은 그대로입니다.

(다) 오프셋 층의 출력이 $2 \times 16 \times 1 \times 4 = 128$, 가중치 층의 출력이 $64$ 가 됩니다. $(256 \times 128 + 128) + (256 \times 64 + 64) = 32{,}896 + 16{,}448 = 49{,}344$ 이고 원래 $16{,}448 + 8{,}224 = 24{,}672$ 였으므로 $24{,}672$ 개 늘어납니다. 표본점을 늘리는 것은 매개변수로는 아주 쌉니다.

문제 7 · 떼어도 되는 것과 안 되는 것

학습을 마친 RF-DETR 에서 (가) 디코더의 마지막 층을 떼어 낸 모델의 출력은 원래 모델의 어떤 출력과 같습니까? 왜 정확히 같습니까? (나) 질의를 300개에서 100개로 줄인 모델의 출력은 원래 모델의 앞 100개 질의의 출력과 같습니까? 이유를 설명하세요. (다) 박스 반복 정제(8장)를 쓰는 모델이었다면 (가)의 답이 달라집니까?

답 보기

(가) 원래 모델의 마지막 보조 출력(aux_outputs[-1])과 같습니다. 디코더 층은 앞에서 뒤로만 계산이 흐르므로, 뒤 층을 떼어도 앞 층의 계산은 변하지 않습니다. 머리가 모든 층에 공유되고 기준 박스가 층마다 같으므로, 앞 층의 출력에 머리를 적용한 것은 원래 모델이 보조 출력을 내던 계산 그대로입니다. 미니 모델의 check 에서 차이가 0 이었습니다.

(나) 같지 않습니다. 디코더의 자기 어텐션에서 각 질의는 같은 묶음의 다른 질의를 모두 참고합니다. 질의 200개가 사라지면 남은 100개가 참고하는 상대가 달라지므로 출력이 변합니다(미니 모델에서 로짓의 최대 차이 0.298). 다만 디코더가 0층이면 자기 어텐션이 없으므로, 이때는 인코더 제안의 앞 100개와 정확히 같습니다.

(다) 답은 같습니다. 박스 반복 정제에서도 층 $d$ 의 출력은 층 $d$ 까지의 계산에만 달려 있으므로, 뒤 층을 떼면 앞 층의 보조 출력이 그대로 남습니다. 달라지는 것은 머리가 층마다 따로라는 점뿐이고, 떼어 낸 층의 머리는 함께 버리면 됩니다. 어느 쪽이든 필요한 조건은 “모든 층의 출력에 손실을 걸어 학습했다” 입니다.

이제 RF-DETR 한 대가 어떻게 생겼는지 압니다. 그림이 576개의 토큰이 되고, 윈도와 전역을 오가며 다듬어지고, 프로젝터를 거쳐 300개의 질의가 읽을 특징 맵이 되고, 질의는 그림에서 고른 박스에서 출발해 두 층 만에 답을 냅니다. 그런데 이 장의 미니 모델은 한 번도 학습하지 않았습니다. 초기화 직후의 출력은 0.05 × 0.05 박스 12개와 1% 남짓한 점수가 전부였습니다. 11장에서는 이 구조를 실제로 학습시킵니다. 묶음별 헝가리안 매칭과 IA-BCE 손실을 모든 층과 인코더 제안에 걸고, 백본에는 층마다 다른 학습률을 주고, EMA 로 가중치를 평균합니다. 논문이 “스케줄러 없는” 학습이라고 부른 설정이 무엇인지, 사전 학습이 얼마나 큰 차이를 만드는지도 도형 세상에서 확인합니다.