RF-DETR:Tutorial:10-Architecture
lastmod 2026-11-18created 2026-11-189 edits
RF-DETR 의 구조는 RF-DETR 튜토리얼의 10장이다. 6장의 ViT 와 DINOv2, 7장의 집합 예측, 8장의 변형 어텐션과 2단계 방식, 9장의 윈도 어텐션 · 프로젝터 · 박스 재매개변수화를 한 대로 조립해, 그림 한 장이 들어가서 박스 300개가 나올 때까지 텐서의 모양이 어떻게 바뀌는지를 처음부터 끝까지 따라간다. 매개변수 3,047만 개가 어느 부품에 몇 개씩 있는지를 손으로 세어 실제 모델과 맞추고, 진짜 RF-DETR Nano 에서 잰 값과 도형 세상의 미니 RF-DETR 을 늘 나란히 놓으며, 논문의 서술과 공개 코드의 동작이 다른 곳을 구별한다. 이렇게 조립한 구조를 실제로 학습시키는 것은 11장이다.
- 원문: 10. RF-DETR 의 구조
- 실습 코드:
code/ch10_rfdetr_model.py. 학습은 하지 않고, 미니 RF-DETR(MiniRFDETR)을 만들어 단계별 텐서 모양을 추적하고, 매개변수를 세고, 구조에서 따라 나오는 성질을 확인한다. 노트북 GPU 약 35초(--quick은 CPU 약 15초). RF-DETR Nano 대조 부분은rfdetr패키지가 있어야 돈다. 원문 기준 읽는 시간 약 100분, 난이도 ★★★★☆. - 이전: 09. 실시간 DETR: RT-DETR 과 LW-DETR / 다음: 11. RF-DETR 의 학습
- 이 장에서 배우는 것
- RF-DETR 의 순전파를 여덟 단계로 나누고, 단계마다의 텐서 모양을 RF-DETR Nano(384×384)와 미니 모델(96×96)에서 말하기
- RF-DETR 이 LW-DETR 에서 바꾼 것과, 프로젝터의 배치 정규화를 층 정규화로 바꾼 이유
- 백본:
num_windows의 뜻, 입력 해상도의 나누어떨어짐 제약, 윈도마다 복제되는 CLS 토큰, 윈도 블록과 전역 블록의 배치(논문의 표기와 공개 코드의 동작) - 프로젝터가 특징 맵 네 장을 한 장(P4)으로 만드는 과정과 그 매개변수 수
- 2단계 질의 선택의 실제 계산: 제안 박스 격자, 묶음별 머리, 상위 300칸, 기울기 차단,
refpoint_embed와query_feat의 역할 - 디코더 한 층의 세 단계와, 모든 층이 처음 기준 박스를 함께 쓰는
lite_refpoint_refine - 시그모이드 없이 박스를 내는 머리, 출력 사전의 네 항목, 추론 때 달라지는 것
- 매개변수 30,467,298개를 부품별로 세고, 그 가운데 추론에 쓰이는 것이 몇 개인지 가르기
- 미니 RF-DETR(
MiniRFDETR)의 코드를 읽고, 공식 구현과 무엇이 같고 다른지 알기
- 이 장의 표기
- \(S\): 입력 그림의 한 변(픽셀). \(p\): 패치 크기. \(g = S/p\): 토큰 격자의 한 변. \(W_n\): 한 변의 윈도 수(
num_windows). \(n = (g/W_n)^2\): 윈도 하나에 든 패치 토큰의 수. - \(C\): 백본 토큰의 차원(Nano 384, 미니 96). \(D\): 프로젝터 출력과 디코더의 차원(
hidden_dim; Nano 256, 미니 128). 8장에서는 차원이 하나뿐이라 \(D\) 만 썼다. - \(B\): 배치 크기. \(N\): 묶음 하나의 질의 수(Nano 300, 미니 12). \(G\): 학습 때의 질의 묶음 수(Nano 13, 미니 4). \(HW\): 프로젝터 출력의 칸 수(Nano 576, 미니 144).
- \(M\), \(L\), \(K\): 변형 어텐션의 머리 수 · 특징 레벨 수 · 표본점 수(8장과 같다). 클래스 로짓의 수에는 기호를 붙이지 않고 숫자(Nano 91, 미니 3)로 적는다. 코드의 모양 주석
(B, Q, K)의K는 클래스 로짓의 수이다. - \(b^{\text{격자}}\): 칸마다 놓는 제안 박스(8장과 같은 기호). \(\hat{b}^{\text{enc}}\): 2단계 질의 선택이 낸 박스(인코더 제안). \(r\): 디코더의 기준 박스. \(\hat{b}^{d}\): 디코더 층 \(d\) 의 예측 박스. 박스는 모두 정규화 좌표의 \((c_x, c_y, w, h)\) 이고, 성분은 \(r = (r_x, r_y, r_w, r_h)\) 처럼 적는다.
- \(\delta = (\delta_x, \delta_y, \delta_w, \delta_h)\): 머리가 내는 박스 델타. \(e_q\): 질의 \(q\) 의
refpoint_embed행(숫자 4개). \(\operatorname{reparam}(\delta, r)\): 9장의 박스 재매개변수화. - 블록 번호는 0 부터 센다(블록 0 – 11).
out_feature_indexes의 숫자만은 “블록 몇 개를 지난 뒤” 라는 개수이다. 이 차이가 뒤에서 중요해진다.
조립할 부품과 완성품
RF-DETR 은 Roboflow 와 카네기 멜런 대학의 연구자들이 2025년에 내놓은 실시간 탐지기이다(Robinson 외, ICLR 2026). 1장에서 한 문장으로 요약했다. LW-DETR 의 뼈대에 DINOv2 백본을 끼우고 가중치 공유 NAS 를 얹은 것. 이 장은 그 가운데 뼈대와 백본, 곧 “모델 하나가 어떻게 생겼는가” 만 다룬다. 어떻게 학습시키는지는 11장, 한 번의 학습으로 여러 크기를 얻는 NAS 는 12장, 분할 머리는 13장이다.
이 장에서 새로 배우는 연산은 거의 없다. 이미 만든 부품을 어떤 순서로, 어떤 모양으로 잇는지가 내용이다. 부품과 그것을 배운 장을 먼저 적어 둔다.
| 부품 | 하는 일 | 배운 곳 | 이 장에서 더하는 것 |
| 패치 임베딩 · ViT 블록 | 그림을 토큰 열로 바꾸고 어텐션으로 다듬는다 | DINOv2-S 의 실제 크기, 패치 16 | |
| 윈도 어텐션 · 윈도 우선 배치 | 일부 블록은 윈도 안에서만 어텐션 | 윈도마다 CLS 토큰 복제, 어느 블록이 윈도인가 | |
| 프로젝터(C2f) | 여러 층의 특징을 탐지용 특징 맵 한 장으로 | 9장 | Nano 의 모양과 매개변수 수 |
| 2단계 질의 선택 | 그림을 보고 질의의 출발 박스를 고른다 | 묶음별 머리, 재매개변수화, | |
| 변형 교차 어텐션 | 질의가 기준 박스 둘레의 몇 점만 읽는다 | 8장 | 머리 16 · 표본점 2 · 레벨 1 의 실제 설정 |
| Group DETR | 학습 때 질의 묶음을 여러 개 둔다 | 9장 | 추론 때 쓰이지 않는 매개변수의 수 |
| 박스 재매개변수화 | 델타로 기준 박스를 옮기고 키운다 | 9장 | 세 군데(제안 · 기준 · 머리)에서 쓰이는 방식 |
| 집합 손실 · 보조 손실 | 모든 층의 출력에 헝가리안 손실 | 출력 사전의 모양(손실 자체는 11장) |
전체 지도
그림 10-1 이 이 장 전체의 지도이다. 1장의 그림 1-7 과 같은 흐름이지만 이번에는 상자마다 텐서 모양 이 적혀 있다. 윗줄은 RF-DETR Nano 에 384×384 그림을 넣고 실제로 잰 모양이고, 아랫줄(흐린 글씨)은 도형 세상의 미니 RF-DETR 에 96×96 그림을 넣은 모양이다. 둘 다 추론 모드이다.
원문 그림 10-1. RF-DETR 의 순전파 지도. ① – ④ 가 백본, ⑤ 가 프로젝터, ⑥ 이 2단계 질의 선택, ⑦ 이 디코더, ⑧ 이 머리다. 상자마다 텐서 모양이 두 줄로 적혀 있는데, 윗줄은 RF-DETR Nano(384×384, 실측), 아랫줄은 미니 RF-DETR(96×96)이다(\(B\) = 배치 크기, 추론 모드). 그림의 흐름을 옮기면 다음과 같다.
- ① 그림(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). 학습되는 임베딩에서 온 내용 질의, ⑥ 의 기준 박스(모든 층 공유), memory(교차 어텐션이 읽는 특징) 세 갈래가 들어온다. 자기 어텐션 → 변형 교차 어텐션 → FFN 이고, 층마다의 출력에 층 정규화를 한 것이
hs:(2, B, 300, 256)/(3, B, 12, 128) - ⑧ 분류 머리
(B, 300, 91)/(B, 12, 3), 박스 머리(B, 300, 4)/(B, 12, 4)
그림 10-1 에서 미리 눈에 담아 둘 것이 넷이다. 이 장의 나머지는 이 네 가지를 차례로 풀어 가는 것이다.
- 백본 안에서는 모양이 두 가지를 오간다. 윈도 블록에서는 배치 축이 4배(윈도 2×2)로 늘어난
(4B, 145, 384), 전역 블록에서는(B, 580, 384)이다. 원소의 수는 같고(\(4 \times 145 = 580\)) 보는 방법만 다르다. - 백본을 나오면 공간 해상도는 끝까지 그대로이다. 특징 맵도, 프로젝터 출력도 24×24 이다. 프로젝터는 채널 수만 \(384 \times 4 = 1536\) 에서 256 으로 바꾼다.
- 디코더로 들어가는 길이 셋이다. 그림에서 고른 기준 박스, 그림과 무관한 내용 질의, 그리고 교차 어텐션이 읽을 특징(memory)이다.
- 머리는 하나씩뿐이다. 디코더의 모든 층이 같은 분류 머리 · 박스 머리를 쓴다.
hs의 맨 앞 축(층)마다 머리를 적용한 결과 가운데 마지막 층의 것이 최종 출력이다.
두 모델을 나란히: Nano 와 미니
이 장의 숫자는 두 모델에서 온다. 하나는 공개된 RF-DETR Nano 이다. rfdetr 패키지(1.12.1)로 모델을 만들어 384×384 그림 한 장을 넣고, 모듈마다 훅을 걸어 입출력 모양과 매개변수 수를 쟀다. 다른 하나는 이 튜토리얼의 미니 RF-DETR(MiniRFDETR)로, 구조와 계산은 공식 구현을 따르고 크기만 도형 세상에 맞게 줄인 것이다.
| 설정 | 미니 RF-DETR | RF-DETR Nano (실측) |
| 입력 해상도 / 패치 크기 | 96 / 8 → 격자 12×12 = 144 토큰 | 384 / 16 → 격자 24×24 = 576 토큰 |
| 백본의 차원 · 블록 수 · 머리 수 | 96 · 6 · 4 | 384 · 12 · 6 (DINOv2-S, 레지스터 토큰 없음) |
| 특징을 꺼내는 자리 | (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개 |
| | 128 | 256 |
| 디코더 층 수 | 3 | 2 |
| 자기 / 교차 어텐션의 머리 수 | 8 / 16 | 8 / 16 |
| 표본점 수 | 2 | 2 |
| FFN 은닉 차원 | 256 | 2048 |
| 질의 수 × 묶음 수 | 12 × 4 | 300 × 13 |
| 클래스 로짓의 수 | 3 | 91 |
| 매개변수 (전체 / 추론에 쓰이는 것) | 1,832,707 / 1,675,870 | 30,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-DETR | RF-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) | |
| 크기 가족을 만드는 방법 | 크기마다 손으로 설계해 따로 학습 | 가중치 공유 NAS: 한 번 학습해 여러 구성을 꺼냄 | 12장 |
| 학습 설정 | 학습률 4e-4 등 | 학습률 1e-4, 워밍업 없음, 기울기 자르기 0.1 등 |
디코더(자기 어텐션 → 변형 교차 어텐션 → 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)\)
- 큰 배치의 손실은 그림별 손실의 평균이고, 합의 기울기는 기울기의 합이다.
- 16개의 합을 4개씩 네 묶음으로 나눠 적었다. \(\tfrac{1}{4} \times \tfrac{1}{4} = \tfrac{1}{16}\) 이다.
- 괄호 안은 작은 배치 하나의 손실이다. 작은 배치 네 개의 기울기를 평균하면 큰 배치의 기울기와 같다. 단, 이 등식은 \(\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\) | 384 | DINOv2 ViT-S 그대로 |
| 블록 수 | 12 | 그대로 |
| 어텐션 머리 수 | 6 (머리마다 64차원) | 그대로 |
| 블록 안 MLP 의 은닉 차원 | 1536 (= 4 × 384) | 그대로 |
| 패치 크기 | 16 — 패치 임베딩 합성곱의 가중치 | DINOv2 는 14 로 사전 학습됨 |
| 위치 임베딩 | | |
| CLS 토큰 | 있음 | 윈도마다 복제해 쓴다 |
| 레지스터 토큰 | 0개 | 6장에서 본 대로 공개 설정은 쓰지 않는다 |
| 윈도 블록 | [0, 1, 2, 4, 5, 7, 8, 10, 11] | 9개. 나머지 3개가 전역 블록 |
고친 곳은 셋이다.
- 패치 크기 14 → 16. 사전 학습된 DINOv2 의 패치 임베딩은 14×14 픽셀 조각을 받는데 Nano 의 것은 16×16 이다. 가중치의 모양부터 다르므로 그대로 실을 수 없고, 변환이 필요하다. 왜 16 이고 어떻게 바꾸는지는 패치 크기가 NAS 의 손잡이이기 때문에 12장에서 다룬다. 이 장에서는 “탐지 N – L 의 패치는 16” 이라는 결과만 쓴다.
- 위치 임베딩의 격자.
positional_encoding_size는 모델이 갖고 있는 위치 임베딩 격자의 한 변이다. Nano 는 24 로, 기본 해상도의 토큰 격자(\(384 / 16 = 24\))와 같다. 그래서 384×384 입력에서는 위치 임베딩을 그대로 더한다. 다른 해상도의 그림이 들어오면 6장에서 배운 위치 임베딩 보간으로 격자를 맞춘다(공식 구현 · 미니 모델 모두 쌍삼차 보간). - 윈도 어텐션과 CLS 토큰 복제. 아래에서 자세히 본다.
토큰 수와 나누어떨어짐 제약
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\) 의 배수여야 한다.
- 격자의 한 변 \(g\) 칸을 윈도 \(W_n\) 개로 똑같이 나눠야 한다. 윈도 한 변의 칸 수가 \(g / W_n\) 이다.
- \(g = S/p\) 를 넣었다. 이 조건이 성립하면 \(S/p\) 도 정수이므로 첫 줄은 따로 볼 필요가 없다.
- 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\) → 토큰 수 |
| N | 384 | 16 | 2 | 32 | 12 | 24 → 576 |
| S | 512 | 16 | 2 | 32 | 16 | 32 → 1,024 |
| M | 576 | 16 | 2 | 32 | 18 | 36 → 1,296 |
| L | 704 | 16 | 2 | 32 | 22 | 44 → 1,936 |
| XL | 700 | 20 | 1 | 20 | 35 | 35 → 1,225 |
| 2XL | 880 | 20 | 2 | 40 | 22 | 44 → 1,936 |
| 미니 | 96 | 8 | 2 | 16 | 6 | 12 → 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 의 설명은 이렇다.
- LW-DETR 의 CAEv2 백본은 클래스 토큰을 쓰지 않지만, RF-DETR 의 DINOv2 백본은 클래스 토큰이 사전 학습의 핵심이다.
- 윈도 어텐션과 클래스 토큰이 함께 가도록, 윈도마다 클래스 토큰을 복제한다.
- 전역 어텐션에서는 윈도별 클래스 토큰들이 서로를 보고, 다른 모든 토큰도 모든 클래스 토큰을 본다.
이 장에서는 이것을 윈도별 CLS 토큰 복제(per-window class token) 라고 부르겠다. 공식 구현의 임베딩 단계는 다음 순서이다.
- 패치 임베딩으로 패치 토큰
(B, 576, 384)를 만들고, CLS 토큰을 앞에 붙여(B, 577, 384), 위치 임베딩(1, 577, 384)를 더한다. 여기까지는 6장의 ViT 그대로이다. - CLS 토큰(위치 임베딩까지 더한 것)과 패치 토큰을 다시 뗀다.
- 패치 토큰을 윈도 우선으로 재배열한다:
(B, 576, 384)→(4B, 144, 384). - 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)\)
원문 그림 10-2. RF-DETR Nano 의 백본 안에서 토큰이 놓이는 두 가지 모양(그림 한 장, \(B = 1\)). 원소는 그대로이고 텐서를 보는 방법만 바뀐다.
- 윈도 블록(왼쪽): 배치 축에 윈도 네 줄이 놓인다. 줄마다 맨 앞에 CLS 토큰(주황 칸) 하나, 이어서 그 윈도의 패치 토큰 144개가 있다. 모양은
(4, 145, 384)이고 줄마다 따로 어텐션한다. 어텐션 쌍의 수는 \(4 \times 145^2 = 84{,}100\) 이다. - 전역 블록(오른쪽): view 로 네 줄을 한 줄로 이어 붙여
(1, 580, 384)가 되고, 모든 토큰이(CLS 4개끼리도) 서로 본다. 쌍의 수는 \(580^2 = 336{,}400\) 이다. - 주황 칸 넷은 같은 값에서 출발한 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\) | 전역 블록의 쌍 |
| 1 | 1 | 577 | 577 | 332,929 | 332,929 |
| 2 | 4 | 145 | 580 | 84,100 | 336,400 |
| 4 | 16 | 37 | 592 | 21,904 | 350,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 한 함수에 있으니, 위의 네 단계와 맞대어 다시 한번 보자.
ch09_lwdetr_parts.py · windowed-vit — 원문에서 접어 둔 긴 코드라 옮기지 않는다. code/ch09_lwdetr_parts.py 의 windowed-vit 영역에 있다.
어느 블록이 윈도 블록인가
12개 블록 가운데 어느 것이 윈도 블록이고 어느 것이 전역 블록인지는, 논문의 서술과 공개 코드의 실제 동작이 다르다. 1장에서 미뤄 둔 이야기이다. 둘을 나란히 놓는다.
| 블록 번호 (0 부터) | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 |
| 논문 부록 A 의 표기 | 윈도 | 윈도 | 전역 | 윈도 | 윈도 | 전역 | 윈도 | 윈도 | 전역 | 윈도 | 윈도 | 전역 |
| 공개 코드의 실제 동작 (Nano 실측) | 윈도 | 윈도 | 윈도 | 전역 | 윈도 | 윈도 | 전역 | 윈도 | 윈도 | 전역 | 윈도 | 윈도 |
| 이 블록의 출력을 특징으로 꺼내는가 | 꺼냄 | 꺼냄 | 꺼냄 | 꺼냄 |
- 논문 부록 A. “윈도 어텐션 블록을 층 {0, 1, 3, 4, 6, 7, 9, 10} 에 둔다” 고 적는다. 윈도 8개, 전역 4개(2, 5, 8, 11)이다. 논문은 윈도 블록이 잇달아 있으면 그 사이에 모양을 바꾸는 연산이 필요 없어서 LW-DETR 의 배치({0, 1, 3, 6, 7, 9})보다 조금 더 효율적이라고 설명한다.
- 공개 코드. Nano 의 백본 설정에서 읽은 윈도 블록은 [0, 1, 2, 4, 5, 7, 8, 10, 11] 이다. 윈도 9개, 전역 3개(3, 6, 9)이다.
코드가 이렇게 되는 이유는 윈도 블록을 정하는 규칙에 있다. 공개 코드의 compute_window_block_indexes 는 윈도 블록을 따로 지정받지 않으면 out_feature_indexes 의 여집합 으로 정한다.
- 공개 코드의 규칙을 손으로 따라가기 (Nano)
- \(\{0, 1, 2, \dots, 12\}\)
-
range(out_feature_indexes[-1] + 1). 마지막 값이 12 이므로 0 부터 12 까지 13개의 수이다.
-
out_feature_indexes = [3, 6, 9, 12]를 뺀다. 남은 9개가 윈도 블록의 번호가 된다. 12 는 블록 번호(0 – 11)에 없으니 빠져도 영향이 없다.
- 윈도 블록이 아닌 나머지이다. 로그의 “전역 블록의 어텐션 입력 (블록 [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 은 임베딩 직후를 뜻한다). 꺼낸 토큰마다 세 가지를 한다.
- 층 정규화. 백본 끝의 층 정규화 하나를 네 군데 모두에 함께 쓴다. 모양은 그대로
(4B, 145, 384). - CLS 토큰을 뗀다. 줄마다 맨 앞의 토큰을 버려
(4B, 144, 384). CLS 는 윈도 안의 토큰들에게 요약을 건네는 노릇만 하고, 탐지에는 쓰이지 않는다. - 윈도 우선 → 행 우선. 윈도 넷을 제자리에 다시 맞춰
(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 의 숫자로 다시 따라간다.
- 채널 방향으로 이어 붙이기.
(B, 384, 24, 24)네 장을 채널 축으로 붙여(B, 1536, 24, 24). \(384 \times 4 = 1536\) 이다. 같은 칸의 얕은 층 · 깊은 층 특징이 한 벡터에 나란히 놓인다. - C2f 블록. 1×1 합성곱으로 1536 채널을 256 채널로 줄이고, 반으로 나눈 128 채널에 3×3 합성곱 두 번짜리 병목을 세 번 차례로 적용하면서 중간 결과를 모두 모아(\(128 \times 5 = 640\) 채널) 다시 1×1 합성곱으로 256 채널을 만든다. 합성곱마다 층 정규화와 SiLU 가 따른다.
- 층 정규화. 마지막에 채널 방향 층 정규화를 한 번 더 한다. 출력은
(B, 256, 24, 24).
해상도는 들어올 때와 같은 24×24 이다. 공개 설정의 projector_scale=["P4"] 가 이것을 뜻한다. P4(P4 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 이므로 가중치는 입력 채널 × 출력 채널이다.
- 병목 하나: 128 채널 → 128 채널의 3×3 합성곱이 두 번이다.
- 병목이 세 개이다.
- 마지막 1×1 합성곱(
cv2): 나눈 두 쪽과 병목 셋의 출력 \(128 \times 5 = 640\) 채널을 256 채널로.
- 실측값 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 가 이것을 켠다.
다섯 단계로 보기
원문 그림 10-3. RF-DETR Nano 의 2단계 질의 선택(추론 모드, 묶음 하나). 고른 칸의 특징은 박스 머리와 enc_outputs 까지만 가고, 디코더로 들어가는 것은 박스(기준 박스)뿐이다. 내용 질의는 그림과 무관한 임베딩에서 온다. 그림의 흐름은 다음과 같다.
- 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 의 번호를 따라 읽는다. 모양은 Nano(추론 모드)의 것이다.
- 제안 박스 격자. 576칸마다 고정된 출발 박스를 하나씩 놓는다: 칸의 중심에, 너비 · 높이 0.05 로. 학습되는 값이 아니다.
- Linear + 층 정규화.
memory의 모든 칸에enc_output(256 → 256 선형 층)과enc_output_norm을 적용한다.(B, 576, 256). - 클래스 로짓. 그 결과에
enc_out_class_embed(256 → 91 선형 층)를 적용해 칸마다 클래스 로짓 91개를 낸다.(B, 576, 91). - 상위 \(N\) 칸. 칸마다 로짓 91개 가운데 최댓값 을 그 칸의 점수로 삼아, 점수가 높은 300칸의 번호를 얻는다(
topk). 결과는 점수 내림차순으로 놓인다. - 박스. 고른 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픽셀)보다 작다. 어느 쪽이든 실제 객체보다는 훨씬 작은 박스에서 출발한다.
- 그림: 그림 10-4 미니 모델의 제안 박스 격자(12×12 칸, 칸마다 0.05 × 0.05 박스). 왼쪽 · 가운데는 검증 그림 두 장 위의 제안 박스 144개(노랑)와 정답(흰 점선), 가는 흰 선은 칸의 경계이다. 오른쪽은 객체마다 그 중심이 놓인 칸의 제안 박스(굵은 색)와, 그것을 정답 박스로 바꾸는 델타 d = (δx, δy, δw, δh)이다.
그림 10-4 에서 읽을 것은 세 가지이다.
- 제안 박스는 객체보다 훨씬 작다. 노란 박스 하나는 4.8픽셀이고 도형은 수십 픽셀이다. 제안 박스는 “여기쯤” 이라는 자리 표시에 가깝고, 크기는 머리가 델타로 만들어야 한다.
- 오른쪽 그림의 델타는 모델의 출력이 아니다. 정답 박스에서 거꾸로 계산한 값, 곧 그 칸이 선택되었을 때 머리가 맞혀야 할 목표이다. 학습된 모델이 실제로 어느 칸을 고르는지는 11장에서 본다.
- 목표 델타의 크기가 고르다. \(\delta_w, \delta_h\) 는 1.1 – 1.8 이다. \(e^{1.8} \approx 6\) 이므로 “0.05 를 6배로 키워라” 는 뜻이다. \(\delta_x, \delta_y\) 는 \(-0.7\) 에서 \(-0.1\) 사이이다. 객체의 중심이 그 칸 안에 있으면 중심의 어긋남은 반 칸을 넘지 않으므로, 미니 모델에서는 \(|\delta_x| \le \tfrac{1}{2} \cdot \tfrac{1}{12} \div 0.05 = 0.833\), Nano 에서는 \(\tfrac{1}{2} \cdot \tfrac{1}{24} \div 0.05 = 0.417\) 을 넘지 않는다.
- 가장자리 칸의 제안은 버려진다 — 격자가 클 때만
- 공식 구현(
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,\ \operatorname{sg}(\hat{b}^{\text{enc}}_q) \big)\)
- \(\delta^{\text{enc}}_q\): 뽑힌 칸의 특징 \(z_{j_q}\) 에
enc_out_bbox_embed를 적용해 얻은 델타. 그림에 따라 달라진다. - \(\hat{b}^{\text{enc}}_q\): 인코더 제안 박스. 기울기가 흐르는 채로
enc_outputs에 들어가 손실을 받는다. - \(\operatorname{sg}(\cdot)\): 기울기 차단. 디코더 쪽으로 넘길 때는 값만 넘긴다.
- \(e_q\):
refpoint_embed의 \(q\) 번째 행(숫자 4개). 그림과 무관하게 학습되는 값이고 0 으로 초기화 된다. - \(r_q\): 디코더가 쓰는 기준 박스.
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칸에 들었다고 하자.
- 박스 머리가 이 칸의 특징에서 낸 델타라고 가정한 값이다(실제 값은 그림과 가중치에 따라 다르다).
- 중심: 델타에 제안 박스의 크기를 곱해 더한다. \(0.4\) 는 “박스 너비의 0.4배만큼 오른쪽” 이고, 박스가 0.05 이니 실제 이동은 \(0.02\) 이다.
- 크기: \(e^{\delta}\) 배. 384픽셀 그림에서 너비 86픽셀, 높이 64픽셀쯤 되는 박스이다. 이 박스가
enc_outputs의pred_boxes에 들어간다.
- 이 순위의
refpoint_embed행이 학습되어 이런 값이 되었다고 가정한다. 처음에는 \((0, 0, 0, 0)\) 이다.
- 같은 연산을 한 번 더 한다. 이번에는 출발 박스가 \(\operatorname{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\) | 뽑힌 칸의 인코더 제안 박스(기울기 차단)를 | 예 | |
| 내용 질의 | | 아니오 | |
| 질의 위치 임베딩 | 기준 박스의 사인 임베딩 → | 예(기준 박스를 따라) | |
위치는 그림에서, 내용은 학습된 값에서 오는 이 방식을 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장 | 이 장 |
| 제안 → 박스 | \(\sigma(\Delta b + \sigma^{-1}(b^{\text{격자}}))\) — 로짓 공간에서 더하기 | \(\operatorname{reparam}(\delta, b^{\text{격자}})\) — 시그모이드 없음 |
| 박스 델타를 계산하는 칸 | 모든 칸 | 뽑힌 칸만(값은 같고 계산이 적다) |
| 선택의 기준 | 클래스 로짓의 최댓값 상위 \(N\) | 같음 |
| 질의 묶음 | 하나 | 학습 때 \(G\) 개, 묶음마다 Linear · 층 정규화 · 머리가 따로 |
| | 없음(뽑힌 박스가 곧 기준 박스) | 뽑힌 박스에 재매개변수화로 얹음(0 초기화) |
| 내용 질의 | | 같음 |
| 질의 위치 임베딩 | 기준 박스의 사인 임베딩 → 2층 MLP | 같음 |
| 디코더 안의 기준 박스 | 층마다 갱신(박스 반복 정제) | 모든 층이 처음 것을 공유 |
| 분류 · 박스 머리 | 층마다 따로 | 모든 층이 하나를 공유 |
| 특징 | CNN 백본, 레벨 2개(12×12, 6×6) | 윈도 ViT + 프로젝터, 레벨 1개(12×12) |
디코더 층
그림 10-1 의 ⑦ 이다. 디코더는 같은 구조의 층을 Nano 는 2개, 미니 모델은 3개 쌓은 것이다. 한 층이 받는 것은 넷이다.
-
tgt(B, 300, 256): 질의 벡터. 첫 층에는 내용 질의가 들어가고, 층을 지날 때마다 갱신된다. -
query_pos(B, 300, 256): 질의 위치 임베딩. 모든 층에 같은 값이 들어간다. - 기준 박스
(B, 300, 1, 4): 가운데의 1 은 레벨 축이다(P4 한 장). 역시 모든 층에 같은 값이다. -
memory(B, 576, 256): 프로젝터 출력.
한 층의 세 단계
층 안의 순서는 7장의 DETR 디코더, 8장의 Deformable DETR 디코더와 같은 post-norm 구조이다. 단계마다 “계산하고, 더하고, 층 정규화” 이다.
| 단계 | 연산 | 질의 · 열쇠 · 값 | 공식 설정 (Nano 실측) |
| ① 자기 어텐션 | | 질의 · 열쇠 = | 머리 8개( |
| ② 변형 교차 어텐션 | | 머리 16개( | |
| ③ FFN | Linear → ReLU → Linear | — | 256 → 2048 → 256 |
①은 질의끼리 서로를 참고하는 단계이다. 같은 객체를 겹쳐 맡지 않게 조율하는 일이 여기서 일어난다(7장). 학습 때는 질의가 13묶음이므로, 9장에서 본 대로 같은 묶음 안에서만 자기 어텐션을 한다. 질의 축을 묶음별로 잘라 배치 축에 올렸다가 되돌리는 방식이다. 묶음끼리 서로 볼 수 없어야 추론 때 첫 묶음만 써도 학습 때와 같은 계산이 된다.
②는 질의가 그림을 들여다보는 유일한 자리이다. memory 에는 위치 정보를 더하지 않는다. 변형 어텐션은 열쇠와의 내적 없이 좌표로 직접 값을 읽기 때문에, 어느 칸의 값인지를 값에 새겨 둘 필요가 없다. 자기 어텐션과 교차 어텐션의 머리 수가 8 과 16 으로 다른 것은 8장의 모델과 다른 점이다. 디코더에 드롭아웃은 없다(기본값 0).
ch10_rfdetr_model.py · decoder-layer
class RFDETRDecoderLayer(nn.Module):
"""RF-DETR 디코더 한 층 (post-norm): ① 묶음별 자기 어텐션 → ② 변형 교차 어텐션 → ③ FFN, 각각 뒤에 더하고 층 정규화.
8장의 DeformableDecoderLayer 와 다른 점: 자기 어텐션과 교차 어텐션의 머리 수가 다르고 (공식 8 · 16),
학습 때 자기 어텐션을 질의 묶음 안에서만 한다 (Group DETR, 9장 group_self_attention).
매개변수 이름은 공식 TransformerDecoderLayer 와 같다.
"""
def __init__(self, dim: int, sa_heads: int, ca_heads: int, ffn_dim: int, n_levels: int, n_points: int):
super().__init__()
self.self_attn = nn.MultiheadAttention(dim, sa_heads, batch_first=True)
self.norm1 = nn.LayerNorm(dim)
self.cross_attn = MSDeformAttn(dim, n_levels, ca_heads, n_points)
self.norm2 = nn.LayerNorm(dim)
self.linear1 = nn.Linear(dim, ffn_dim)
self.linear2 = nn.Linear(ffn_dim, dim)
self.norm3 = nn.LayerNorm(dim)
def forward(self, tgt, query_pos, reference, memory, spatial_shapes, groups: int = 1, return_details=False):
"""tgt · query_pos (B, G·N, D), reference (B, G·N, L, 4) 기준 박스, memory (B, ΣHW, D).
돌려주는 값: 새 tgt (B, G·N, D). return_details=True 면 (tgt, 표본점 (B, G·N, M, L, K, 2), 가중치).
"""
attended = group_self_attention(self.self_attn, tgt + query_pos, tgt, groups) # ① 같은 묶음끼리만 본다
tgt = self.norm1(tgt + attended)
attended, locations, weights = self.cross_attn(tgt + query_pos, reference, memory, spatial_shapes,
return_details=True) # ② 기준 박스 안팎의 M·L·K 곳만 읽는다
tgt = self.norm2(tgt + attended)
tgt = self.norm3(tgt + self.linear2(F.relu(self.linear1(tgt)))) # ③ FFN
return (tgt, locations, weights) if return_details else tgt
미니 모델의 디코더 층이다. 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곳을 읽는다.
- 질의 300개가 한 층에서 읽는 (질의, 자리) 쌍의 수이다.
- 보통의 교차 어텐션이었다면 질의마다 576칸을 모두 읽는다.
- 읽는 자리가 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 의 논문 본문에는 이 선택에 대한 설명이 없다. 코드에서 확인한 동작만 적는다.
원문 그림 10-5. 디코더가 3층일 때 기준 박스가 쓰이는 방식. 왼쪽은 8장의 박스 반복 정제, 오른쪽은 RF-DETR 의 공개 설정이다. 가로 화살표는 층에서 층으로 넘어가는 질의 벡터다.
- 왼쪽(8장: 박스 반복 정제): 처음 기준 → 층 1 → 박스 1. 박스 1 이 점선(기울기 차단)을 따라 층 2 의 기준 박스가 되어 박스 2 를 내고, 박스 2 가 층 3 의 기준이 되어 박스 3 을 낸다. 박스 \(d\) 는 박스 \(d-1\) 을 고친 것이다.
- 오른쪽(RF-DETR: 모든 층이 처음 기준을 공유): 기준 박스 \(r\) 과 질의 위치 임베딩을 한 번만 계산해 층 1 · 2 · 3 에 모두 넣는다. 층과 층 사이로는 질의 벡터만 넘어간다. 박스 \(d\) 는 \(\operatorname{reparam}(\text{층 } d \text{ 의 델타},\ r)\) 로, 언제나 \(r\) 에서 출발한다.
| 항목 | 8장: 박스 반복 정제 | RF-DETR: lite 기준점 정제 |
| 층 \(d\) 의 교차 어텐션이 쓰는 기준 박스 | 층 \(d - 1\) 의 예측 박스(기울기 차단) | 언제나 처음 기준 박스 \(r\) |
| 층 \(d\) 의 예측 박스 | \(\sigma(\Delta b^{d} + \sigma^{-1}(\operatorname{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 이다.
이 구성에는 Transformer 인코더가 없고, 변형 교차 어텐션은 좌표로 직접 읽기 때문이다. RF-DETR 에서 위치 정보를 맡는 것은 둘이다. 백본 안에서 패치 토큰에 더하는 학습되는 위치 임베딩(6장)과, 질의 쪽의 기준 박스에서 만든 질의 위치 임베딩이다. 미니 모델은 그래서 2차원 사인 위치 인코딩을 모델 안에서 계산하지 않는다.
머리와 출력
그림 10-1 의 ⑧ 이다. 디코더가 내놓은 hs 는 (층 수, B, 300, 256) 모양이고, 여기에 머리 둘을 적용하면 층마다의 예측이 한꺼번에 나온다.
분류 머리와 박스 머리
- 분류 머리
class_embed: 선형 층 하나(256 → 91). 출력은 클래스별 로짓이고, 8장부터 써 온 대로 ∅ 칸 없이 클래스마다 시그모이드를 쓴다. 편향은 4장의 사전 확률 편향 초기화를 따라 \(-\log\frac{1 - 0.01}{0.01} = -\log 99 = -4.595\) 로 둔다. \(\sigma(-4.595) = 0.01\) 이므로 처음에는 모든 질의가 모든 클래스에 대해 “1% 쯤” 이라고 답한다. - 박스 머리
bbox_embed: 3층 MLP(256 → 256 → 256 → 4, 사이에 ReLU). 출력은 박스가 아니라 델타 \(\delta^{d}_q\) 네 숫자이다. 마지막 층의 가중치와 편향을 0 으로 초기화한다.
두 머리는 모든 디코더 층이 함께 쓴다. 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)\)
- 기준 박스는 질의 선택에서 구한 값, 델타는 박스 머리가 냈다고 가정한 값이다.
- 중심: 기준 박스 너비의 5% 만큼 왼쪽, 높이의 10% 만큼 아래로.
- 크기: 너비 5.1% 확대, 높이 2.0% 축소. 예측 박스는 \((0.3448,\ 0.2358,\ 0.2132,\ 0.1627)\) 이다. 기준 박스가 이미 객체 근처에 있으면 디코더의 델타는 이렇게 작은 값이면 된다.
0 으로 초기화한 것들을 모아 보면, 학습을 시작하는 순간의 모델이 무엇을 내는지 계산 없이 알 수 있다.
-
enc_out_bbox_embed의 마지막 층이 0 → \(\delta^{\text{enc}} = 0\) → \(\hat{b}^{\text{enc}}_q = b^{\text{격자}}_{j_q}\) (제안 박스 그대로) -
refpoint_embed가 0 → \(r_q = \hat{b}^{\text{enc}}_q\) -
bbox_embed의 마지막 층이 0 → \(\delta^{d} = 0\) → \(\hat{b}^{d}_q = r_q\)
그러므로 처음에는 인코더 제안도, 모든 디코더 층의 예측도 뽑힌 칸의 제안 박스(칸 중심의 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\)) |
| | 마지막 디코더 층의 클래스 로짓 | | | |
| | 마지막 디코더 층의 박스 \((c_x, c_y, w, h)\), 정규화 좌표 | | | |
| | 앞 층들의 | 1개 | 2개 | 2개 |
| | 인코더 제안의 | | | |
-
aux_outputs의 개수는 (디코더 층 수 − 1)이다. Nano 는 2층이라 1개, 미니 모델은 3층이라 2개이다. 7장의 보조 손실이 여기에 걸린다. - 학습 모드에서는 질의 축이 \(G \cdot N\) 이다(미니 \(4 \times 12 = 48\)). 묶음 순서대로 놓여서, 미니 모델이면 첫 묶음이 질의 0 – 11, 둘째 묶음이 12 – 23 이다.
- Nano 는 추론 모드에서도
aux_outputs와enc_outputs를 함께 돌려준다(실측한 출력 사전의 이름:['aux_outputs', 'enc_outputs', 'pred_boxes', 'pred_logits']). 추론에는 앞의 둘만 쓰인다. - 손실은 마지막 층 · 앞 층들 · 인코더 제안, 세 종류의 출력 모두에 같은 방식으로 걸린다. 어떻게 거는지가 11장이다.
추론 후처리
출력에서 최종 예측 목록을 만드는 일은 8장의 방식과 같다. 로짓에 시그모이드를 적용한 (B, 300, 91) 을 질의 × 클래스의 한 줄 \(300 \times 91 = 27{,}300\) 칸으로 펴고, 점수가 높은 순으로 num_select 개(기본 300)를 고른다. 뽑힌 칸의 번호를 91 로 나눈 몫이 질의 번호, 나머지가 클래스 번호이다. NMS 는 없다.
ch10_rfdetr_model.py · postprocess
@torch.no_grad()
def postprocess(outputs, num_select: int | None = None):
"""RF-DETR 의 후처리 = 8장의 postprocess_sigmoid: (질의, 클래스) 쌍의 시그모이드 점수 상위 num_select 개. NMS 없음."""
return postprocess_sigmoid(outputs, num_select)
def parameter_groups(model: MiniRFDETR):
"""부품별 매개변수 수. 돌려주는 값: [(이름, 전체 수, 추론 때 쓰이는 수)].
묶음마다 따로 있는 것(enc_output …, 질의 임베딩)은 추론 때 첫 묶음 것만 쓰인다.
"""
groups = model.group_detr
rows = [("backbone (WindowedViT)", count_parameters(model.backbone), count_parameters(model.backbone)),
("projector (C2f)", count_parameters(model.projector), count_parameters(model.projector))]
two_stage = sum(count_parameters(m) for m in (model.enc_output, model.enc_output_norm, model.enc_out_class_embed,
model.enc_out_bbox_embed))
rows.append(("two-stage heads (x groups)", two_stage, two_stage // groups))
decoder = sum(count_parameters(m) for m in (model.decoder, model.decoder_norm, model.ref_point_head))
rows.append(("decoder layers", decoder, decoder))
heads = count_parameters(model.class_embed) + count_parameters(model.bbox_embed)
rows.append(("class + box heads", heads, heads))
queries = count_parameters(model.query_feat) + count_parameters(model.refpoint_embed)
rows.append(("query embeddings (x groups)", queries, queries // groups))
return rows
미니 모델의 postprocess 는 8장의 postprocess_sigmoid 를 그대로 부른다(\(12 \times 3 = 36\) 칸에서 12개). 같은 영역의 parameter_groups 는 뒤의 매개변수 표를 만드는 함수이다. 공식 구현의 PostProcess 는 여기에 박스를 원본 그림의 픽셀 좌표로 바꾸는 일을 더한다. 점수 문턱값과 num_select 를 바꿨을 때의 모습은 14장에서 실제 패키지로 본다.
추론 때 달라지는 것
학습 때와 추론 때 순전파가 달라지는 곳은 하나, 질의 묶음 이다. 추론 때는 query_feat · refpoint_embed 의 앞 \(N\) 행과 묶음 0 의 2단계 층만 쓴다. 여기에 더해, 학습을 마친 뒤 구조를 줄여서 쓸 수 있는 길이 둘 있다. 논문이 NAS 의 손잡이로 삼은 다섯 가지 가운데 둘이고, 논문은 이 둘을 추론 때만 줄인다고 적는다.
- 디코더 층을 덜 쓰기. 모든 층의 출력에 손실을 걸어 학습했으므로 어느 층에서 멈춰도 쓸 수 있는 예측이 나온다. 머리가 공유되고 기준 박스가 층마다 같으므로, 앞의 \(d\) 층만 돌린 결과는 전체 모델에서 층 \(d\) 가 내던 출력과 같은 계산 이다. 층을 전부 떼면(\(d = 0\)) 인코더 제안이 곧 최종 출력이 된다. 이때는 질의끼리의 자기 어텐션도, 특징을 읽는 교차 어텐션도 없다. 논문은 이 상태를 NMS 없는 1단계 탐지기와 닮았다고 표현한다.
- 질의를 덜 쓰기. 질의는 인코더 점수의 내림차순으로 놓이므로, 앞의 \(N'\) 개만 쓰면 점수가 낮은 제안부터 버리는 것이 된다. 논문 부록 B 가 설명하는 방식이다.
미니 모델에서 이 성질들을 확인한 출력이다(학습 전 가중치, 추론 모드).
[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
- check 의 첫 줄. 추론 출력은 학습 모드 출력의 첫 묶음(질의 0 – 11)과 차이가 0 이다. 묶음끼리 서로 보지 않기 때문에 나머지 세 묶음을 떼어도 첫 묶음의 계산은 변하지 않는다.
- 둘째 – 넷째 줄. 디코더를 0 · 1 · 2 층만 쓴 출력은 전체 모델의
enc_outputs,aux_outputs[0],aux_outputs[1]과 차이가 0 이다. 층을 떼는 것은 새로운 모델을 만드는 것이 아니라, 이미 나오고 있던 보조 출력을 최종 출력으로 삼는 것이다. - 다섯째 줄. 디코더 없이 질의 6개만 쓰면 인코더 제안 12개 가운데 앞의 6개(점수 상위 6개)와 같다.
- 여섯째 줄. 디코더가 있을 때 질의를 6개로 줄이면, 남은 6개의 로짓은 질의가 12개일 때와 달라진다(최대 차이 0.298). 자기 어텐션에서 서로 참고하던 상대가 절반으로 줄었기 때문이다. 질의 수는 층 수와 달리 “떼어도 남은 것이 그대로” 인 손잡이가 아니다.
- 일곱째 줄. 뽑힌 칸은 점수 내림차순으로 놓인다. 다섯째 줄의 “앞의 6개 = 점수 상위 6개” 가 성립하는 근거이다.
- 공식 구현에서는 만들 때 정한다
- 미니 모델은
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
- 그림: 그림 10-6 미니 RF-DETR 에서 손잡이 하나만 바꿨을 때 그림 한 장당 순전파 시간(ms). 왼쪽은 배치 1, 오른쪽은 배치 64. 파랑 = 기본 설정, 주황 = 디코더 층 수, 초록 = 질의 수, 분홍 = 윈도 수, 노랑 = 패치 크기, 하늘 = 해상도. 회색 점선은 기본 설정의 값이다.
그림 10-6 은 왼쪽과 오른쪽이 전혀 다른 이야기를 한다.
- 배치 1(왼쪽): 디코더 층 수만 보인다. 3.03 ms 에서 층을 하나씩 떼면 2.68, 2.30, 1.64 ms 로 내려간다. 나머지 손잡이는 2.98 – 3.12 ms 로 사실상 그대로이다. 모델이 너무 작아서 시간이 계산량이 아니라 층과 연산을 부르는 횟수로 정해지기 때문이다. GPU 는 대부분 놀고 있다.
- 배치 64(오른쪽): 토큰 격자의 크기가 시간을 정한다. 격자 8×8 이면 0.095 · 0.088 ms, 12×12(기본)면 0.135 ms, 16×16 이면 0.241 · 0.250 ms 이다. “패치를 키우는 것” 과 “해상도를 낮추는 것” 은 격자가 같으면 시간이 거의 같다(패치 12 와 해상도 64, 패치 6 과 해상도 128). 논문 부록 L 이 정확도에 대해 말한 것 — 성능은 해상도나 패치 크기 각각보다 공간 위치의 수와 더 상관이 있다 — 을 속도 쪽에서 본 모습이다.
- 디코더 층과 질의 수는 배치 64 에서 조금만 든다. 디코더 셋을 다 떼도 0.135 → 0.112 ms(17% 감소)이다. 이 미니 모델에서는 백본과 프로젝터가 시간의 대부분이다.
- 윈도를 늘려도 빨라지지 않았다. 배치 64 에서 윈도 1×1(전부 전역) 0.140, 2×2 0.135, 3×3 0.151 ms 이다. 12×12 격자에서는 어텐션이 원래 싸고(9장), 윈도를 늘리면 CLS 토큰이 윈도 수만큼 붙는다. 차이는 ±10% 안이고 원인을 따로 가려 보지는 않았다.
측정의 한계도 적어 둔다. 설정을 하나씩 차례로 쟀을 때는 같은 설정이 실행에 따라 두 배 가까이 다르게 나오기도 해서, 모든 설정을 번갈아 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.
- 그림: 그림 10-7 부품별 매개변수 수. 왼쪽은 미니 RF-DETR(단위 천 개), 오른쪽은 RF-DETR Nano(단위 백만 개). 파랑 = 전체(학습 때), 주황 빗금 = 추론 때 쓰이는 것(묶음 하나). 부품 이름은 위에서부터 백본, 프로젝터, 2단계 층(× 묶음), 디코더 층, 분류 · 박스 머리, 질의 임베딩(× 묶음)이다.
그림 10-7 과 표에서 읽을 것이다.
- 백본이 압도적이다. Nano 의 21,821,184개는 전체의 71.6% 이다. 미니 모델에서도 백본이 가장 크지만(705,024개) 몫은 38.5% 로, 미니 모델은 백본을 상대적으로 더 많이 줄인 셈이다.
- 파랑과 주황이 다른 부품은 둘뿐이다. “two-stage heads” 와 “query embeddings” — 묶음 수만큼 있는 부품이다. Nano 는 이 둘을 합쳐 3,903,939개 가운데 300,303개만 추론에 쓰인다.
- 디코더는 2층에 314만 개이다. 이 줄에는 디코더 층 둘과 공유 층 정규화,
ref_point_head가 들어 있다. 한 층이 얼마인지는 아래에서 센다. - 머리는 아주 작다. 분류 머리와 박스 머리를 합쳐 155,999개, 전체의 0.5% 이다.
손으로 세어 맞추기
선형 층 하나의 매개변수는 (입력 차원 × 출력 차원) + 출력 차원(편향)이다. 이것만으로 표의 여러 줄을 맞출 수 있다. Nano 의 숫자(\(D = 256\))로 센다.
- 분류 머리 · 박스 머리 (표의 class + box heads)
- \(\texttt{class\_embed}: \quad 256 \times 91 + 91 = 23{,}296 + 91 = 23{,}387\)
- 선형 층 256 → 91.
- 3층 MLP: 256 → 256 이 두 번, 256 → 4 가 한 번.
- 표의 155,999 와 같다.
- 질의 임베딩 (표의 query embeddings)
- \(\texttt{query\_feat}: \quad (13 \times 300) \times 256 = 3{,}900 \times 256 = 998{,}400\)
- 묶음 13개 × 질의 300개, 행마다 256차원.
- 행마다 숫자 4개.
- 표의 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}}\)
- 묶음 하나의 네 층. 뒤의 둘은 분류 머리 · 박스 머리와 구조가 같으므로 수도 같다.
- 묶음 하나의 수. 표의 “추론 때” 열과 같다.
- 표의 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)는 매개변수 수에 영향이 없다.
- 오프셋 층의 출력은 \(2MLK = 64\), 가중치 층의 출력은 \(MLK = 32\). 열쇠 투영이 없어서 보통 어텐션보다 작다.
- 256 → 2048 → 256. 은닉 차원이 8배라 한 층에서 가장 큰 부품이다.
- 디코더 한 층은 약 147만 개이고 그 가운데 71% 가 FFN 이다.
- 표의 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) 둘.
- \(384^2 = 147{,}456\) 이므로 어텐션이 \(4 \times 147{,}840 = 591{,}360\), MLP 가 \(591{,}360 + 590{,}208 = 1{,}181{,}568\) 이다.
- 패치 16×16 의 합성곱, 위치 임베딩 \((24^2 + 1) \times 384\), CLS 토큰과 마스크 토큰(사전 학습에서 쓰던 것으로, 탐지 때는 쓰이지 않는다).
- 표의 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 |
| N | DINOv2-S | 384 | 16 | 2 | 2 | 300 | 30.5M | 31.9 | 2.3 | 48.0 |
| S | DINOv2-S | 512 | 16 | 2 | 3 | 300 | 32.1M | 59.8 | 3.5 | 52.9 |
| M | DINOv2-S | 576 | 16 | 2 | 4 | 300 | 33.7M | 78.8 | 4.4 | 54.7 |
| L | DINOv2-S | 704 | 16 | 2 | 4 | 300 | 33.9M | 125.6 | 6.8 | 56.5 |
| XL | DINOv2-B | 700 | 20 | 1 | 5 | 300 | 126.4M | 299.3 | 11.5 | 58.6 |
| 2XL | DINOv2-B | 880 | 20 | 2 | 5 | 300 | 126.9M | 438.4 | 17.2 | 60.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\) 에 맞춰 커진다.
- 해상도 512 이면 격자 \(g = 32\). 논문의 32.1M 과 맞다.
- 해상도 576, \(g = 36\). 논문의 33.7M.
- 해상도 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줄 남짓에 담은 것이다. 새로 만든 것은 디코더 층과 조립하는 코드뿐이고, 부품은 앞 장의 파일에서 가져온다.
-
ch07_detr.py:MLP,sine_embed(좌표의 사인 임베딩) -
ch08_deformable.py:MSDeformAttn,gen_proposals(제안 박스 격자),postprocess_sigmoid -
ch09_lwdetr_parts.py:WindowedViT,MultiScaleProjector,box_reparam,group_self_attention
설정
ch10_rfdetr_model.py · config
DEFAULT_CONFIG = {
"num_classes": NUM_CLASSES, # 3 (원 · 사각형 · 삼각형)
"num_queries": 12, # 묶음 하나의 질의 수 (공식 300)
"group_detr": 4, # 학습 때의 질의 묶음 수 (공식 13). 추론 때는 첫 묶음만 쓴다
"hidden_dim": 128, # 프로젝터 출력 · 디코더의 차원 (공식 256)
"dec_layers": 3, # 디코더 층 수 (Nano 2, Small 3, Medium 4)
"sa_heads": 8, # 디코더 자기 어텐션의 머리 수 (공식 8)
"ca_heads": 16, # 디코더 변형 교차 어텐션의 머리 수 (공식 16)
"dec_n_points": 2, # 머리 · 레벨마다의 표본점 수 (공식 2)
"ffn_dim": 256, # 디코더 FFN 의 은닉 차원 (공식 2048)
"img_size": 96, # 기본 입력 해상도 (Nano 384)
"patch_size": 8, # 기본 패치 크기 (Nano 16) → 토큰 격자 12×12 (Nano 24×24)
"vit_dim": 96, # 백본의 차원 (DINOv2-S 384)
"vit_depth": 6, # 백본의 블록 수 (DINOv2-S 12)
"vit_heads": 4, # 백본의 머리 수 (DINOv2-S 6)
"out_feature_indexes": (2, 4, 6), # 특징을 꺼내는 층 (Nano [3, 6, 9, 12]) → 윈도 블록 0, 1, 3, 5 / 전역 블록 2, 4
"num_windows": 2, # 한 변의 윈도 수 (Nano 2)
"projector_scale": ("P4",), # 프로젝터가 만드는 스케일 (공식 ["P4"])
}
줄마다 주석에 공식 값이 적혀 있다. 이름은 공식 설정과 되도록 같게 했다. MiniRFDETR(group_detr=1) 처럼 일부만 덮어써서 만들 수 있고, 11 – 13장의 코드가 그렇게 쓴다.
모델
ch10_rfdetr_model.py · model — 원문에서 접어 둔 긴 코드라 옮기지 않는다. code/ch10_rfdetr_model.py 의 model 영역에 있다.
forward 를 그림 10-1 의 번호와 맞춰 읽는다.
- ① – ⑤
extract_features. 백본이 특징 맵 세 장을, 프로젝터가 P4 한 장을 낸다.flatten(2).transpose(1, 2)가(B, 128, 12, 12)를memory(B, 144, 128)로 편다. - ⑥
select_queries. 묶음마다 반복문을 한 번 돈다.all_logits.max(-1).values.topk(num_queries)가 “클래스 로짓의 최댓값 상위 \(N\) 칸” 이고,box_reparam(delta, proposals[top])이 인코더 제안 박스이다. 공식 구현은 고른 칸의 특징에 층 정규화를 적용하고 이 코드는 모든 칸에 적용한 뒤 고르지만, 층 정규화는 토큰마다 따로 계산되므로 결과가 같다. - 기준 박스와 질의.
box_reparam(self.refpoint_embed.weight[:total][None], enc_boxes.detach())한 줄이 \(r_q = \operatorname{reparam}(e_q, \operatorname{sg}(\hat{b}^{\text{enc}}_q))\) 이다.query_pos는 반복문 밖에서 한 번만 계산한다.tgt는query_feat를 배치만큼 늘린 것이다. - ⑦ 디코더. 반복문 안에서 바뀌는 것은
tgt뿐이다.query_pos와reference_input은 모든 층에 같은 것이 들어간다. 층마다decoder_norm(tgt)를hs에 모은다. - ⑧ 머리.
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개): | 1.43e-06 (보조 출력 1.43e-06, |
| P4, 추론 모드: | 9.54e-07 (보조 출력 9.54e-07, |
| 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 입력의 열 순서만 다름. 가중치를 옮길 때 첫 층의 열을 바꾸면 일치 |
| | | 모델을 만들 때의 설정 | 동작은 같음 |
| 패딩 마스크 · 유효 비율 | 없음 | 있음 | 그림 크기가 모두 같으면 없음 |
| 입력 정규화 | 모델 안에서 | 모델 밖에서 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개
정리
- RF-DETR 의 순전파는 패치 임베딩 → 윈도를 넣은 DINOv2 ViT → 특징 맵 여러 장 → 프로젝터(P4) → 2단계 질의 선택 → 디코더 → 공유 머리다. Nano(384×384)에서는 576 토큰, 특징 맵
(B, 384, 24, 24)× 4, 프로젝터 출력(B, 256, 24, 24), 출력(B, 300, 91)과(B, 300, 4). - LW-DETR 에서 바뀐 것은 백본(CAEv2 → DINOv2), 프로젝터의 정규화(배치 → 층), 윈도 블록의 배치, 분할 머리, NAS 다. 층 정규화는 그림 하나 안에서 계산되므로 기울기 누적이 큰 배치와 같은 기울기를 낸다.
-
num_windows는 한 변의 윈도 수 \(W_n\) 이다. 입력의 한 변은 \(p \cdot W_n\) 의 배수여야 한다(Nano 는 32 의 배수). - CLS 토큰은 윈도마다 복제된다. 윈도 블록에서는 \((B W_n^2,\ n + 1,\ C)\), 전역 블록에서는 \((B,\ W_n^2(n + 1),\ C)\) 로 보기만 바꾼다. Nano:
(4B, 145, 384)↔(B, 580, 384). - 윈도 블록은 논문 부록 A 의 표기로는 {0, 1, 3, 4, 6, 7, 9, 10}, 공개 코드의 실제 동작으로는
out_feature_indexes=[3, 6, 9, 12]의 여집합 {0, 1, 2, 4, 5, 7, 8, 10, 11} 이다(전역 3 · 6 · 9). - 프로젝터는 특징 네 장을 채널로 이어 붙여(1536) C2f 와 층 정규화로 256 채널을 만든다. 해상도는 바꾸지 않는다.
- 2단계 질의 선택: 모든 칸의 제안 박스(칸 중심, 0.05) → 묶음별 Linear + 층 정규화 → 클래스 로짓의 최댓값 상위 \(N\) 칸 → 그 칸의 델타로 \(\hat{b}^{\text{enc}} = \operatorname{reparam}(\delta^{\text{enc}}, b^{\text{격자}})\). 이 예측은
enc_outputs로 손실을 받는다. - 기준 박스는 \(r_q = \operatorname{reparam}(e_q, \operatorname{sg}(\hat{b}^{\text{enc}}_q))\), 내용 질의는 그림과 무관한
query_feat다.refpoint_embed\(e_q\) 는 0 에서 출발하는, 순위에 붙은 보정이다. - 디코더 층은 묶음별 자기 어텐션(머리 8) → 변형 교차 어텐션(머리 16 · 레벨 1 · 표본점 2, 질의당 32곳) → FFN(2048)이다. 모든 층이 같은 기준 박스 · 같은 질의 위치 임베딩 · 같은 머리를 쓴다.
- 박스는 \(\hat{b}^{d}_q = \operatorname{reparam}(\delta^{d}_q, r_q)\) 로 시그모이드 없이 낸다. 0 초기화 때문에 처음에는 모든 출력이 뽑힌 칸의 제안 박스다.
- 추론 때는 첫 묶음만 쓴다. 디코더를 앞의 몇 층만 쓴 출력은 그 층의 보조 출력과 같고, 0층이면 인코더 제안이 출력이다. 질의를 줄이면 남은 질의의 출력도 달라진다.
- Nano 의 매개변수는 30,467,298개(논문 30.5M)이고, 추론에 쓰이는 것은 26,863,662개다. N → L 은 백본이 같아서, 늘어나는 것은 디코더 층(층당 1,471,840)과 위치 임베딩뿐이다.
이제 RF-DETR 한 대가 어떻게 생겼는지 안다. 그림이 576개의 토큰이 되고, 윈도와 전역을 오가며 다듬어지고, 프로젝터를 거쳐 300개의 질의가 읽을 특징 맵이 되고, 질의는 그림에서 고른 박스에서 출발해 두 층 만에 답을 낸다. 그런데 이 장의 미니 모델은 한 번도 학습하지 않았다. 초기화 직후의 출력은 0.05 × 0.05 박스 12개와 1% 남짓한 점수가 전부였다. 11장에서는 이 구조를 실제로 학습시킨다. 묶음별 헝가리안 매칭과 IA-BCE 손실을 모든 층과 인코더 제안에 걸고, 백본에는 층마다 다른 학습률을 주고, EMA 로 가중치를 평균한다. 논문이 “스케줄러 없는” 학습이라고 부른 설정이 무엇인지, 사전 학습이 얼마나 큰 차이를 만드는지도 도형 세상에서 확인한다.
확인 문제
- 문제 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\) 까지의 계산에만 달려 있으므로, 뒤 층을 떼면 앞 층의 보조 출력이 그대로 남는다. 달라지는 것은 머리가 층마다 따로라는 점뿐이고, 떼어 낸 층의 머리는 함께 버리면 된다. 어느 쪽이든 필요한 조건은 “모든 층의 출력에 손실을 걸어 학습했다” 이다.
See also
Favorite site
- 10. RF-DETR 의 구조
- code/ch10_rfdetr_model.py
- RF-DETR: Neural Architecture Search for Real-Time Detection Transformers (arXiv:2511.09554)
- LW-DETR: A Transformer Replacement to YOLO for Real-Time Detection (arXiv:2406.03459)
- DINOv2: Learning Robust Visual Features without Supervision (arXiv:2304.07193)
- Github - roboflow/rf-detr
- RF-DETR:Tutorial
- RF-DETR:Tutorial:01-WhatIsRFDETR
- RF-DETR:Tutorial:04-DeepLearningBasics
- RF-DETR:Tutorial:06-ViT-DINOv2
- RF-DETR:Tutorial:08-DeformableDETR
- RF-DETR:Tutorial:09-RT-DETR-LW-DETR
- RF-DETR:Tutorial:11-Training
- RF-DETR:Tutorial:12-NAS
- RF-DETR:Tutorial:13-Segmentation
- RF-DETR:Tutorial:14-Practice
- RF-DETR:Tutorial:15-Appendix