yg log --graph --oneline --all

2. CIGPose 구현 해설 - 관절 벡터 하나를 바꾸면 어디까지 학습될까?

Tue, 08 Sep 2026 00:00:00 +0900

들어가며

1편에서는 CIGPose가 왜 불확실한 관절 특징을 바꾸는지 살펴봤다. 그런데 코드를 읽기 시작하면 질문이 조금 달라진다.

“관절 특징이 512차원이라는데, 그 안에 좌표가 들어 있는 건가?”
“손목 특징을 바꾸면 원래 손목을 뽑은 인코더는 학습을 못 하는 건가?”
“관찰 경로를 고정한다면서 같은 GNN을 어떻게 학습하지?”

이 글은 그 질문들을 하나씩 따라간다. 먼저 전체 지도를 보고, 각 모듈의 입력과 출력을 확인한 뒤, 마지막에 두 손실의 gradient를 연결한다. 계산은 조금 길지만 어디에서 무엇이 바뀌는지 정리하면 모듈 이름만 외울 때보다 훨씬 편하다.

읽는 기준
공식 저장소의 commit b7444d8과 CIGPose-x · COCO-WholeBody · 384×288 설정을 기준으로 한다. 학습을 직접 재현한 실험 기록이 아니라, 원문·보충자료와 해당 소스의 정적 분석을 대조한 해설이다. 다른 모델 크기나 커밋에서는 설정이 달라질 수 있다.

Part 1. 전체 텐서 지도부터

출처: 논문 Fig. 5. 먼저 위쪽의 Encoder → CIM → HGNN → prediction을 따라가고, 아래의 세부 구조는 HGNN 절에서 다시 보자.

아래 표의 크기는 [코드 기반 재구성]이다. B는 배치 크기다. 한 샘플은 원본 사진 전체가 아니라, 사람 영역을 변환한 crop이다.

순서	코드에서 하는 일	출력 크기
1	RGB 사람 crop 입력	`[B, 3, 384, 288]`
2	CSPNeXt-x backbone	`[B, 1280, 12, 9]`
3	7×7 convolution, `final_layer`	`[B, 133, 12, 9]`
4	공간축 flatten	`[B, 133, 108]`
5	ScaleNorm + Linear	`[B, 133, 512]`
6	GAU	`[B, 133, 512]`
7	CIM의 일부 특징 치환	`[B, 133, 512]`
8	HGNN	`[B, 133, 512]`
9	최종 x / y 선형 head	`[B, 133, 576]` / `[B, 133, 768]`

가장 먼저 주의할 것은 config의 input_size=(288, 384)는 (W, H) 순서라는 점이다. PyTorch 이미지 텐서는 [B, C, H, W]이므로 순서가 바뀐다. x축이 576개, y축이 768개인 이유도 여기에 있다.

그리고 [B, 133, 512]에서 133은 관절 수지만, 512는 좌표의 수가 아니다. 각 관절을 표현하는 학습된 feature의 차원이다. 좌표 후보 bin으로 바뀌는 것은 마지막 선형 head를 통과한 뒤다. CIGHead

Part 2. Keypoint Encoder — 이미지가 관절 토큰이 되기까지

CSPNeXt와 7×7 convolution

선택한 설정은 MMDetection의 CSPNeXt-x를 backbone으로 사용한다. config에 _scope_='mmdet'가 있으므로, 저장소에 이름이 같은 파일이 있다고 해서 그것이 실제 runtime의 backbone이라고 단정하면 안 된다. 모델 설정

큰 흐름은 downsampling으로 공간 해상도를 줄이고, CSP 계열 블록과 SPP로 특징을 처리하는 것이다. 역할을 구분해보면 다음과 같다.

구성	이해할 포인트
Downsampling	공간 크기를 줄여 더 넓은 영역의 특징을 다룬다
CSP 계열 블록	특징을 두 경로로 처리하고 다시 결합한다. 모든 short branch를 단순 identity로 생각하면 안 된다
SPP	서로 다른 크기의 pooling 결과를 결합해 여러 수용영역의 정보를 모은다

이 글에서는 backbone 내부의 모든 convolution을 나열하기보다, CIGPose head로 넘어오는 경계부터 구체적으로 보자. 최종 feature map은 1280개 채널과 12×9 공간 위치를 가진다. 여기에 출력 채널이 133개인 7×7 convolution을 적용한다.

[코드 기반 재구성: 선택 config와 CIGHead의 특징 처리]

\[[B,1280,12,9] \xrightarrow{\operatorname{Conv}_{7\times7}} [B,133,12,9] \xrightarrow{\operatorname{flatten}} [B,133,108]\]

7×7은 커널 크기, 133은 출력 채널 수다. 적절한 padding으로 공간 크기를 유지한다. 각 출력 채널의 12×9 위치를 펼치면 관절별 108차원 벡터가 된다.

그렇다고 이때의 각 채널이 이미 정답 관절 좌표를 뜻하는 것은 아니다. 뒤의 좌표 예측 손실을 통해 관절별 표현이 학습되는 구조라고 이해하면 된다.

ScaleNorm과 Linear는 다른 일을 한다

ScaleNorm은 벡터의 크기를 정규화하고, Linear는 학습한 가중치로 특징을 다른 차원으로 옮긴다. ‘정규화해서 512차원이 된다’가 아니라 정규화 후 Linear가 108차원을 512차원으로 바꾸는 것이다.

[코드 기반 재구성: ScaleNorm의 연산 형태]

\[\operatorname{ScaleNorm}(v) =\frac{g\,v}{\max(\lVert v\rVert_2/\sqrt d,\epsilon)}\]

여기서 차원 수는 d, 학습되는 크기 파라미터는 g다. 벡터의 성분 사이 비율을 유지하면서 크기를 조절한다. 이어지는 bias 없는 Linear가 관절별 108차원 벡터를 512차원으로 사상한다. ScaleNorm 구현 · RTMCC 구현

GAU는 관절 사이에서 정보를 섞는다

GAU, Gated Attention Unit은 133개의 관절 토큰 사이의 정보를 섞는 단계다. 이 설정에서는 입력과 출력 모두 [B, 133, 512]다.

정규화한 입력을 선형 변환하고 SiLU를 적용한 뒤 세 덩어리로 나눈다. 아래 크기는 [코드 기반 재구성]이다.

텐서	크기	역할
U	`[B, 133, 1024]`	모은 정보를 조절하는 gate
V	`[B, 133, 1024]`	다른 토큰에 전달할 특징
R	`[B, 133, 256]`	query와 key를 만드는 공통 base

총 2304차원을 1024, 1024, 256으로 자르는 셈이다. 여기서는 정준 임베딩 테이블과 기호가 겹치지 않도록 코드의 base를 R로 적었다.

[코드 기반 재구성: GAU, 위치 인코딩·상대 위치 편향이 꺼진 설정]

\[Q=R\odot\gamma_Q+\beta_Q,\qquad K_{\mathrm{attn}}=R\odot\gamma_K+\beta_K\] \[A=\operatorname{ReLU}\left(\frac{QK_{\mathrm{attn}}^\top}{\sqrt{256}}\right)^2\] \[F=r\odot F_{\mathrm{in}}+W_o\left(U\odot(AV)\right)\]

소문자 r은 512차원의 학습 가능한 residual scale이다. 여기서 A는 [B, 133, 133], AV는 [B, 133, 1024]다. 마지막 투영으로 다시 512차원이 된다.

익숙한 Transformer와 비슷해 보여도 이 구현의 attention kernel은 softmax가 아니라 ReLU를 제곱한 값이다. U와 곱하는 부분은 원소별 gating이다. 또 query·key를 만드는 첫 식은 곱셈뿐 아니라 덧셈까지 포함한 affine transformation이다. 이런 작은 구분을 놓치면 GAU를 그냥 ‘일반 attention’으로 설명하게 된다. RTMCCBlock

Part 3. CIM — 점수를 계산하고, 고르고, 바꾼다

초기 SimCC는 선택용이다

GAU가 만든 관절 특징을 x축과 y축의 초기 선형 head에 각각 넣는다.

[코드 기반 재구성: 초기 예측 head]

\[h^{\mathrm{init}}_{k,x}=W_x f_k+b_x,\qquad h^{\mathrm{init}}_{k,y}=W_y f_k+b_y\]

좌표의 split ratio가 2이므로 x축은 288×2=576개, y축은 384×2=768개 bin을 갖는다. 여기서 나오는 값은 logits다. 확률로 사용하려면 각 축에 softmax를 적용한다.

[코드 기반 재구성: x축 정규화, y축도 같은 방식]

\[P_{b,k,x}(i)=\frac{\exp(h^{\mathrm{init}}_{b,k,x,i})} {\sum_{\ell=0}^{575}\exp(h^{\mathrm{init}}_{b,k,x,\ell})}\]

b는 배치 안의 사람 crop 번호, k는 관절 번호, i는 x축 좌표 bin이다. y축의 bin index와 혼동하지 말자.

출처: 보충자료 Fig. 7. 저자들은 분포의 퍼짐을 통해 위치 판단의 모호성을 설명한다. 이 그림이 특정 공개 커밋의 초기 head가 어떻게 학습되었는지까지 증명하는 것은 아니다.

Top-k는 배치 전체가 아니라 사람별로 고른다

[논문 원문: 식 (2), 배치 index를 추가한 표기]

\[s_c(b,k)=1-\frac12\left(\max_i P_{b,k,x}(i)+\max_j P_{b,k,y}(j)\right)\]

점수가 큰 관절을 사람마다 선택한다. 검토한 설정은 학습에서 13개, 검증·추론에서 1개를 고른다. torch.topk(..., dim=1)이 관절축에서 실행되는 이유다.

이 설정은 고정 개수를 고르는 방식이다. 모든 관절이 비교적 확실해도 Top-1은 하나를 선택한다. ‘점수가 임계값을 넘은 관절만 바꾼다’는 설명은 별도의 threshold 전략에 해당한다. 보충자료 Table 9도 이 두 전략을 구분해서 비교한다. CIM 구현 · 설정

정준 임베딩은 공유하지만, 선택은 이미지마다 다르다

정준 임베딩 테이블은 nn.Embedding(133, 512)다. 133개 관절 유형마다 512차원 벡터 하나가 있다. 표준편차 0.01의 정규분포로 초기화하고 학습 중 최적화한다.

[보충자료: C절 식 (8)]

\[f'_{b,k}=(1-m_{b,k})f_{b,k}+m_{b,k}z_k\]

마스크가 1이면 공유 테이블의 벡터, 0이면 현재 이미지의 원래 특징을 사용한다. 공유 테이블에는 배치축이 없지만, 어떤 행을 가져올지는 이미지별 점수에 따라 달라진다.

코드의 핵심 동작을 줄이면 아래와 같다. 아래 블록은 [코드 기반 재구성]이며 설명용 발췌다.

indices = torch.where(intervened_mask)   # (batch indices, keypoint indices)
canonical = self.canonical_features(indices[1])
f_prime = f_kpts.clone()
f_prime[indices] = canonical

clone() 자체는 gradient를 끊지 않는다. 다만 덮어쓴 위치에서는 값의 출처가 원래 특징에서 정준 임베딩으로 바뀐다. 뒤에서 loss를 계산하면 그 위치의 gradient는 정준 임베딩으로 이어진다.

출처: 논문 Fig. 4. 이미지별 특징은 여러 점으로, 관절별 공유 정준 벡터는 하나의 점으로 표현된다. 관절 종류 사이의 구분은 볼 수 있지만, 하나의 공유 벡터가 한 점이라는 사실만으로 모든 문맥 편향이 제거되었다고 결론 내릴 수는 없다.

코드에서 추가로 확인해야 했던 부분

여기에는 그냥 넘어가기 어려운 지점이 있다. 학습 함수는 초기 head에 f_kpts.detach()를 넣고, CIM 안에서는 초기 logits의 softmax·점수·Top-k를 모두 torch.no_grad() 안에서 계산한다.

따라서 검토한 학습 경로에서는 초기 예측 head로 loss gradient가 연결되지 않는다. 초기 x/y head는 최종 x/y head와도 별개다. ‘선택용이므로 인코더만 detach했다’는 말로 끝낼 수 없고, 초기 head 자체를 학습시키는 경로가 따로 있는지도 확인해야 한다.

검토한 CIGHead.loss()와 설정에서는 그 head를 직접 지도하는 별도 손실을 찾지 못했다. 그러므로 이 코드만 근거로 초기 head를 ‘학습된 uncertainty estimator’라고 단정하지 않는다. 실제 공개 체크포인트에서의 상태나 전체 학습 재현은 별도 검증이 필요하다. 학습 함수 · config

Part 4. HGNN — 관절과 부위를 번갈아 본다

출처: 논문 Fig. 5 하단을 원문에서 추출. 아래 수식은 이 개요 그림을 공개 코드의 실제 연산 순서로 풀어 쓴 것이다.

이제 CIM 출력은 [B, 133, 512]다. HGNN의 최종 출력도 같은 크기다. 크기를 유지한다고 같은 정보인 것은 아니다. 연결된 관절과 부위 정보를 반영해 표현을 바꾼다.

① 입력 투영과 국소 EdgeConv

먼저 입력을 Linear → BatchNorm → SiLU로 처리한다. BatchNorm을 위해 배치와 관절을 합쳐 [B×133, 512]로 다룬다.

[코드 기반 재구성: HGNN 입력 투영]

\[x_i=\operatorname{SiLU}\left(\operatorname{BN}(W_{\mathrm{in}}f'_i+b_{\mathrm{in}})\right)\]

선택한 config의 골격 연결 180쌍은 양방향 360개 edge로 바뀐다. 각 edge에서 현재 관절의 특징과 이웃과의 차이를 이어 붙인다.

[코드 기반 재구성: 국소 EdgeConv와 집계]

\[m_{i\leftarrow j}=\operatorname{SiLU}\left( \operatorname{BN}\left(W_p[x_i\,\Vert\,(x_j-x_i)]\right)\right)\] \[v_i=\operatorname{BN}\left(\sum_{j\in\mathcal N(i)}m_{i\leftarrow j}\right)\]

512차원 두 개를 이어 붙여 1024차원이 되고, 1×1 Conv가 이를 512차원으로 바꾼다. 여기서 1×1은 이미지의 2차원 이웃을 훑는 필터라고 생각하기보다, edge 특징의 채널을 변환하는 연산으로 보면 된다.

그렇다면 이웃의 정보는 어디에 들어갈까? 이미 concat 입력에 이웃과의 차이가 들어 있고, 연결된 이웃의 메시지를 더하는 단계에서도 관계를 사용한다. 코드의 index_add_는 합 집계다. 이 구현을 max aggregation이라고 설명하면 틀린다. EdgeConv·HGNN 구현

② 관절을 의미 그룹으로 묶기

다음 단계에서는 관절 특징을 512차원에서 128차원으로 줄이고, 그룹 안의 관절을 평균낸다. 선택 config에는 32개 그룹이 있다. 그룹은 서로 겹칠 수 있다. 얼굴 전체 그룹과 눈·코·입 그룹이 함께 있는 식이다.

[코드 기반 재구성: 채널 축소와 그룹 평균]

\[d_i=\operatorname{SiLU}\left(\operatorname{BN}(W_dv_i+b_d)\right),\qquad g_e=\frac1{|e|}\sum_{i\in e}d_i\]

이 단계의 크기는 [코드 기반 재구성]으로 [B, 133, 128] → [B, 32, 128]이다. 논문이 semantic hypergraph라고 부르는 관계를 코드에서는 관절의 그룹 소속과 그룹 특징 간 그래프 연산으로 구현한다.

각 그룹은 자기 자신을 제외한 다른 31개 그룹과 연결된다. 따라서 그룹 그래프는 992개의 방향성 edge를 갖는다. 이 그래프에서 다시 EdgeConv를 적용해 전신의 부위 정보를 교환한다.

[코드 기반 재구성: 그룹 간 메시지 집계]

\[u_e=\sum_{q\ne e}\operatorname{SiLU}\left( \operatorname{BN}\left(W_h[g_e\,\Vert\,(g_q-g_e)]\right)\right)\]

③ 그룹 gate를 다시 관절로 돌려주기

그룹의 128차원 특징을 Linear로 512차원으로 늘리고 sigmoid를 적용한다. 이렇게 만든 각 성분은 0과 1 사이의 조절 계수다.

[코드 기반 재구성: 그룹 gate와 관절별 평균]

\[a_e=\sigma(W_au_e+b_a),\qquad a_i=\frac1{|\mathcal E_i|}\sum_{e\in\mathcal E_i}a_e\]

한 관절이 여러 그룹에 포함되면 그 그룹들의 gate를 평균한다. 어떤 그룹에도 포함되지 않은 관절에는 코드가 gate 1을 유지한다. 선택 config에서 실제로 어떤 그룹에 속하는지는 그룹 정의를 기준으로 확인해야 한다.

이제 처음의 국소 특징과 원소별로 곱한 뒤 residual을 더한다.

[코드 기반 재구성: HGNN 한 층의 출력]

\[x_i^{\mathrm{out}}=\operatorname{SiLU}\left(x_i+v_i\odot a_i\right)\]

이 식을 말로 풀면 “연결된 이웃에서 모은 특징을 전신 그룹의 정보로 조절하고, 기본 특징에 더한다”다. 잔차로 더하는 것은 입력 투영 후의 특징이다. 논문 본문의 간략한 gate 식에는 생략된 투영·정규화·잔차까지 공개 코드에는 들어 있으므로, 위 식들은 논문 원문 식과 구분했다.

Part 5. 마지막 SimCC head — 이제 좌표를 만든다

HGNN 출력에 서로 다른 두 선형층 cls_gx, cls_gy를 적용한다. [코드 기반 재구성]으로 x logits는 [B, 133, 576], y logits는 [B, 133, 768]이다. CIM의 초기 head와 이름도, 파라미터도 다르다.

학습에서는 이 logits와 정답 SimCC label을 비교한다. 추론에서는 각 축의 최대 위치를 선택하고 split ratio로 나눈다.

[코드 기반 재구성: SimCC decode의 좌표 선택, split ratio=2]

\[\hat x_k=\frac{\arg\max_i h_{k,x}(i)}2,\qquad \hat y_k=\frac{\arg\max_j h_{k,y}(j)}2\]

이 좌표는 변환된 사람 crop의 좌표다. 원본 이미지에 관절을 그리려면 crop을 만들 때의 변환을 되돌리는 과정까지 필요하다. 모델 출력 벡터, crop 내부 좌표, 원영상 좌표를 같은 것으로 취급하면 안 된다. SimCC decoder

Part 6. 두 손실을 실제 학습 경로에 연결하기

Keypoint loss는 교체된 관절에만 걸리지 않는다

먼저 정답 자세를 맞히는 기본 손실이다.

[논문 원문: 식 (5)]

\[\mathcal L_{\mathrm{kpt}}=\sum_{k=1}^{K}w_k D_{\mathrm{KL}}\left(Q_k\parallel P(Y_k\mid do(F))\right)\]

정답 분포가 Q, 반사실 경로의 최종 예측이 비교 대상이다. 이 식의 개입 표기는 논문의 표기를 따른다. 실제 코드에서는 특징을 바꾼 경로의 출력을 사용한다.

핵심은 개입하지 않은 관절도 기본 손실에 들어간다는 것이다. 정답 가중치가 유효하면 모두 자세를 맞혀야 한다. 반대로 정답 가중치가 0인 키포인트는 이 손실에 기여하지 않는다. 가중치는 치환 마스크가 아니다.

실제 KLDiscretLoss에는 논문의 간략한 식보다 세부 계산이 더 있다. 선택 설정은 예측 logits에 beta=10을 곱하고, 정답 label에도 softmax를 적용한다. 각 축의 bin에 대해 평균을 구한 뒤 가중치를 곱하고, 배치·관절의 합을 K로 나눈다. 코드의 loss 숫자를 논문 식의 단순 KL 합과 같은 척도로 비교하면 안 된다. KLDiscretLoss

Consistency loss는 멀쩡한 관절의 예측을 기준에 묶는다

[논문 원문: 식 (6)]

\[\mathcal L_{\mathrm{cf}}=\frac1{|S|}\sum_{k\in S} D_{\mathrm{KL}}\left(\operatorname{sg}[P(Y_k\mid F)]\parallel P(Y_k\mid do(F))\right)\]

관찰 경로의 예측은 고정된 목표다. 반사실 경로가 그 목표에서 불필요하게 멀어지는 것을 막는다. 코드에서 실제로 선택하는 mask는 다음과 같다.

stable_mask = (~intervened_mask) & (keypoint_weights > 0)

출처: CounterfactualConsistencyLoss. 개입하지 않았다는 조건과 정답 가중치가 유효하다는 조건을 동시에 사용한다.

KL의 방향도 확인해야 한다. PyTorch의 kl_div는 첫 인자로 예측의 log probability, 두 번째 인자로 목표 probability를 받는다. 이 코드가 계산하는 것은 관찰 분포를 기준으로 한 반사실 분포의 KL, 즉 논문 식과 같은 방향이다. 함수의 인자 순서를 수식의 분포 순서로 그대로 옮기면 헷갈린다.

두 좌표축의 KL을 더해 유효한 안정 키포인트 수로 평균하고, loss 내부에서 가중치 0.1을 곱한다. 따라서 설정을 따라 코드를 구현할 때 바깥에서 다시 0.1을 곱하면 중복 적용이다. 안정 키포인트가 하나도 없으면 코드가 이 손실을 0으로 반환한다.

같은 GNN인데 한쪽만 고정할 수 있나?

학습 함수에서 경로를 나누면 다음과 같다. [코드 기반 재구성: 핵심 동작을 줄인 의사코드]

features = encoder(images)

# 초기 logits는 선택용. CIM 내부의 점수·Top-k도 no_grad 안에 있다.
initial = initial_heads(features.detach())
changed, mask = cim(features, initial)
pred_cf = final_heads(hgnn(changed))

# 동일한 가중치를 쓰지만 이 forward에는 autograd graph를 만들지 않는다.
with torch.no_grad():
    pred_obs = final_heads(hgnn(features))

loss_kpt = supervised_loss(pred_cf, target, target_weights)
loss_cf = consistency_loss(pred_obs, pred_cf, mask, target_weights)
loss = loss_kpt + loss_cf   # 0.1은 consistency_loss 내부에 반영됨

같은 파라미터를 공유해도 어떤 forward 계산의 gradient를 추적하는지는 경로마다 정할 수 있다. 관찰 경로로는 gradient가 돌아가지 않고, 반사실 경로로는 GNN과 최종 head를 학습한다. CIGHead.loss

여기서 no_grad()는 eval()과도 다르다. 전자는 autograd 기록을 끄고, 후자는 BatchNorm·Dropout 등의 동작 모드를 바꾼다. 이 학습 함수는 관찰 경로를 eval()로 전환하지 않는다. 따라서 ‘고정 목표’는 역전파 기준으로 고정이라는 의미이지, BatchNorm 통계까지 모두 고정한다는 뜻이 아니다.

결국 어느 파라미터까지 gradient가 가는가?

아래 표는 [코드 기반 재구성: 검토한 학습 경로의 도달 가능성]이다. reachable은 그래프상 연결될 수 있다는 뜻이며, 매 샘플에서 반드시 0이 아닌 gradient가 생긴다는 보장은 아니다.

파라미터 또는 경로	Keypoint loss	Consistency loss
Backbone · 7×7 Conv · 투영 · GAU	reachable — 유지된 특징을 통해	reachable — 반사실 경로의 유지된 특징을 통해
선택된 정준 임베딩 행	reachable	reachable — GNN의 특징 혼합 등을 통해 안정 관절에도 영향을 줄 수 있음
해당 배치에서 선택되지 않은 정준 임베딩 행	not involved — lookup되지 않음	not involved — lookup되지 않음
HGNN	reachable — 반사실 경로	reachable — 반사실 경로
최종 x/y head	reachable	reachable
초기 x/y head	blocked by no_grad — 선택 경로만 사용	blocked by no_grad — 선택 경로만 사용
부모 RTMCCHead에서 생성됐으나 대체된 `mlp`, `cls_x`, `cls_y`	not involved — CIGHead의 이 학습 경로에서는 호출하지 않음	not involved — 이 학습 경로에서는 호출하지 않음
관찰 경로의 forward	not involved	blocked by no_grad / detach — 목표만 제공
Top-k 선택 자체	blocked by no_grad — 이산 선택	blocked by no_grad — 이산 선택

두 가지를 더 구분하자.

첫째, 원래 관절 특징을 덮어쓴 그 위치의 직접 경로는 끊기지만, Encoder 전체가 학습되지 않는 것은 아니다. 유지된 다른 관절 특징으로 gradient가 갈 수 있고, GAU 앞쪽에서는 토큰 사이의 관계도 이미 섞여 있다.

둘째, Consistency loss는 바꾸지 않은 관절의 출력에서 계산되지만, 그 출력은 GNN을 통해 바꾼 관절의 특징에도 의존할 수 있다. 그래서 이 손실도 선택된 정준 임베딩을 학습시킬 수 있다. ‘loss를 계산한 관절’과 ‘gradient를 받는 모든 파라미터’는 같은 범위가 아니다.

[보충자료: C절 식 (9), 치환 마스크를 고정했을 때]

\[\frac{\partial\mathcal L}{\partial z_k} =\sum_{b=1}^{B}m_{b,k}\frac{\partial\mathcal L}{\partial f'_{b,k}}\]

선택된 이미지들에서 같은 관절의 정준 벡터로 gradient가 모인다. 선택되지 않은 행은 이 loss의 gradient를 받지 않지만, 그것을 곧바로 ‘optimizer step 후 파라미터 값이 절대 안 바뀐다’로 확대하면 안 된다. optimizer의 상태나 weight decay에 따른 갱신은 loss gradient와 구분해야 한다.

Part 7. 코드까지 읽고 나면 설명이 조금 달라진다

처음에는 “불확실한 관절을 기준 벡터로 바꾸고 GNN으로 보완한다”로 이해했다. 코드를 읽고 나니 그 문장에 조건들이 붙었다.

바꾸는 대상은 좌표가 아니라 특징 벡터다.
기준 벡터는 이미지마다 새로 만드는 것이 아니라 관절 유형별 공유 파라미터다.
선택한 config는 학습 Top-13, 추론 Top-1을 사용한다.
초기 선택용 head와 최종 좌표 head는 별개이며, 검토한 학습 코드에서 초기 head로 이어지는 loss gradient는 확인되지 않는다.
기본 손실은 유효한 모든 관절, 일관성 손실은 개입하지 않은 유효 관절의 출력에서 계산한다.
관찰 경로는 gradient를 막지만, 같은 HGNN과 최종 head는 반사실 경로에서 학습된다.

내가 이 구현에서 가장 오래 헷갈렸던 것은 ‘어디를 바꿨는가’, ‘어디에서 loss를 계산하는가’, ‘어디까지 gradient가 흐르는가’가 모두 다른 질문이라는 점이었다. 세 개를 나눠 보고 나니, 정준 임베딩이 어떻게 학습되는지도 훨씬 선명해졌다.

인과적 목표와 특징 치환의 관계는 여전히 따져볼 부분이 남는다. 하지만 적어도 모델이 실제로 하는 계산을 분리해서 설명할 수는 있다. 논문의 이름에 담긴 해석과 코드의 연산을 함께 보되, 한쪽을 다른 쪽의 증명으로 대신하지 않는 것이 이 리뷰에서 가져가고 싶은 읽기 방식이다.

참고 자료와 코드 위치

1. CIGPose 논문 리뷰 - 가려진 관절을 문맥에 맡겨도 될까?

Tue, 08 Sep 2026 00:00:00 +0900

들어가며

CIGPose를 공부하면서 가장 오래 붙잡고 있었던 질문은 “관절 특징을 다른 벡터로 바꾸는 게 왜 인과 개입이지?”였다. 전체 구조만 보면 이미지에서 특징을 뽑고, 일부를 바꾸고, GNN에 넣는 모델이다. 그런데 논문은 여기에 confounder, backdoor adjustment, counterfactual이라는 말을 붙인다. 구조는 따라갈 만한데, 그 구조가 왜 필요한지를 설명하려니 훨씬 어려워졌다.

그래서 이번에는 문제에서 출발해보려고 한다. 모델이 사람을 보고 자세를 추정한다고 생각했는데, 사실은 사람 옆의 물체를 보고 답을 찍고 있었다면? 그리고 그 물체가 사라지거나 엉뚱한 곳에 나타나면?

CIGPose: Causal Intervention Graph Neural Network for Whole-Body Pose Estimation
Bohao Li, Zhicheng Cao, Huixian Li, Yangming Guo · CVPR 2026
논문 · 보충자료 · 공식 코드

한 줄로 요약하면, CIGPose는 불확실한 관절 특징을 학습 가능한 관절별 기준 벡터로 바꾸고, 주변 관절과 전신의 관계를 이용해 자세를 다시 추정하는 모델이다.

이 글은 그 아이디어와 실험을 중심으로 읽는다. “그래서 실제 텐서는 어떻게 움직이는데?”가 궁금하다면 2편의 구현 해설에서 코드와 수식까지 이어서 볼 수 있다.

Part 1. Why CIGPose? — 사람 대신 의자를 보고 있었다면

관절 133개를 한꺼번에 찾는 문제

Whole-body pose estimation은 몸통과 팔다리뿐 아니라 얼굴과 손가락까지 함께 찾는 작업이다. COCO-WholeBody에서는 몸 17개, 발 6개, 얼굴 68개, 손 42개를 합쳐 133개 키포인트를 다룬다.

팔꿈치 몇 개를 찾는 것도 쉽지 않은데, 작게 찍힌 손가락과 가려진 얼굴까지 찾아야 한다. CIGPose는 사람 영역을 먼저 얻은 뒤 그 crop 안에서 자세를 추정하는 top-down 방식이다. 사람을 찾는 검출 단계와, crop 안에서 관절을 찾는 단계는 구분해야 한다.

문맥은 도움이 되지만, 지름길이 되기도 한다

설명을 위해 이런 학습 데이터를 생각해보자. 앉아 있는 사람 뒤에는 대부분 의자가 있다. 모델은 사람의 관절 배치를 자세히 보지 않고도 “의자가 보이네? 앉아 있겠군”이라는 규칙으로 꽤 많은 문제를 맞힐 수 있다.

그러다 서 있는 사람 뒤에 의자가 나타나면 어떻게 될까? 의자의 등받이를 사람의 몸통처럼 해석하는 식으로 틀릴 수 있다. 자세를 설명하는 증거와, 자세와 자주 함께 등장했던 배경을 혼동한 것이다. 이것이 이 논문이 문제 삼는 지름길 학습과 허위 상관관계다. 의자 예시는 직관을 위한 상황이고, 실제 논문의 비교는 아래 그림에서 확인할 수 있다.

출처: 논문 Fig. 1. 위쪽은 성능 비교, 아래쪽은 RTMPose-x와 CIGPose-x의 예측 비교다. 배경 구조에 예측이 끌려가는 부분을 보자. 이미지를 누르면 크게 볼 수 있다.

문맥을 모두 없애자는 이야기는 아니다. 손목이 가려졌을 때 팔꿈치와 어깨가 어디 있는지는 분명 좋은 단서다. 문제는 어떤 문맥을 믿고, 어떤 시각적 단서를 덜 믿을 것인가다.

Part 2. 관찰 분포와 개입 분포 — 문맥의 가중치가 달라진다

관찰한 상관관계와 알고 싶은 효과

논문은 이 문제를 SCM, 즉 Structural Causal Model로 표현한다. 기호부터 정리하면 다음과 같다. 아래 표는 논문 3.1절의 정의를 설명용으로 정리한 것이다.

기호	의미	이 글에서 떠올릴 대상
이미지 X	입력 이미지	사람을 잘라낸 RGB 이미지
특징 F	키포인트 임베딩	관절마다 가진 특징 벡터
문맥 C	관측되지 않은 시각적 교란 요인	차폐 물체, 복잡한 배경, 조명
예측 Y	추정한 자세	각 키포인트의 좌표 분포

출처: 논문 Fig. 2. 왼쪽은 저자들이 제시한 인과 모형, 오른쪽은 CIM의 구현 아이디어다. 오른쪽에서는 점수를 계산한 뒤 일부 특징만 빨간 기준 벡터로 바뀌는 과정을 보면 된다.

관찰 데이터에서 예측하는 분포는, 각 문맥에서의 예측을 그 특징과 함께 나타나는 문맥의 빈도로 가중한 것으로 풀어 쓸 수 있다.

[설명용 유도: 조건부확률의 전확률 공식]

\[P(Y\mid F=f)=\sum_c P(Y\mid F=f,C=c)P(C=c\mid F=f)\]

의자 예시로 돌아가면, 특정 몸통 특징을 가진 학습 이미지에 의자가 자주 나왔을수록 의자가 있는 상황의 예측이 크게 반영된다. 마지막 가중치는 ‘허위 상관관계의 확률’이라는 별도 수치가 아니라, 특징이 주어졌을 때 문맥이 나타날 조건부확률이다.

논문은 대신 다음의 개입 분포를 목표로 제시한다.

[논문 원문: 식 (1), 특징을 f로 고정한 표기]

\[P(Y\mid do(F=f))=\sum_c P(Y\mid F=f,C=c)P(C=c)\]

차이는 마지막 가중치다. 특정 특징과 문맥이 함께 나타난 빈도 대신, 문맥 자체의 분포를 사용한다. 이것이 논문이 제시하는 backdoor adjustment의 목표다. 이 식을 적용하려면 저자들이 가정한 인과 모형과 조정 조건이 성립해야 한다.

그런데 배경의 모든 경우를 어떻게 더하지?

바로 이 부분이 걸린다. ‘의자가 있음/없음’ 정도면 간단해 보이지만, 실제 이미지의 문맥은 물체, 조명, 가림, 배경 질감이 뒤섞여 있다. 모든 문맥에 라벨이 달려 있는 것도 아니다.

논문도 이 합을 직접 계산할 수 없다고 말한다. 그래서 CIM이라는 실용적인 대체 방법을 제안한다. 교란의 영향을 받았을 법한 관절 특징을 찾아, 현재 이미지에서 가져오지 않은 기준 벡터로 바꾸는 것이다.

여기서 두 층위를 나눠두면 뒤가 편해진다. 위의 식은 논문의 인과적 목표, 다음에 나오는 특징 치환은 그 목표를 구현하려고 제안한 방법이다. 둘의 연결은 마지막에 다시 따져보자.

Part 3. CIGPose는 실제로 무엇을 바꾸는가

전체 구조부터 보기

출처: 논문 Fig. 5, 원문 PDF 5쪽에서 고해상도로 재추출. 위쪽은 전체 흐름, 아래쪽은 Hierarchical GNN이다. 학습할 때 원래 특징을 사용하는 관찰 경로가 함께 등장한다.

크게 네 단계로 볼 수 있다.

Keypoint Encoder: 이미지에서 관절별 특징을 만든다.
CIM: 불확실성 점수가 높은 관절 특징을 정준 임베딩으로 바꾼다.
Hierarchical GNN: 가까운 관절과 전신 부위 사이의 관계를 반영한다.
SimCC Head: x축과 y축의 좌표 분포를 예측한다.

포인트는 2번과 3번의 연결이다. 관절 특징을 바꾸고 끝내면 이미지에 맞는 자세를 얻기 어렵다. 바꾼 특징을 다른 관절과 함께 해석해야 한다.

CIM ① 어느 관절을 덜 믿을 것인가

SimCC는 좌표를 x축과 y축의 1차원 분류 문제로 표현한다. x축에서 어디에 있을지, y축에서 어디에 있을지 각각 분포를 만든다.

분포가 한 위치에 뾰족하게 모이면 모델이 한 후보를 강하게 선택하고 있다는 뜻이다. 반대로 여러 위치에 퍼지면 어느 후보인지 애매하다. 논문은 각 축의 최대 확률을 이용해 점수를 만든다.

[논문 원문: 식 (2)]

\[s_c(k)=1-\frac12\left(\max P_{k,x}+\max P_{k,y}\right)\]

직관을 위한 숫자를 넣어보면 이렇다. 아래 값은 실제 실험에서 측정한 수치가 아니다.

설명용 예시	x축 최대 확률	y축 최대 확률	교란 점수
한 위치에 비교적 집중	0.8	0.9	0.15
여러 위치에 분산	0.2	0.3	0.75

[설명용 유도] 최대 확률의 평균을 1에서 빼므로, 집중도가 낮을수록 점수가 커진다. 다만 실제 좌표 bin 수나 분포 설정에 따라 확률값의 크기는 달라진다. 이 숫자 자체를 개입 임계값으로 해석하면 안 된다.

출처: 논문 Fig. 3. 차폐된 키포인트 쪽의 점수가 더 높다는 비교로, 저자들은 이 점수를 대리 지표로 사용하는 근거를 제시한다.

이름은 ‘교란 점수’지만, 실제 계산은 예측 분포의 집중도를 이용한 모호성 점수다. 교란 원인을 직접 측정하거나, 불확실성을 원인별로 분리하는 계산은 아니다. 논문의 검증도 어떤 상황에서 이 점수가 유용한지를 뒷받침하는 근거로 읽는 것이 적절하다.

CIM ② 정준 임베딩은 정답 좌표인가?

처음에는 ‘정준’이라는 말 때문에 표준적인 사람 자세나 평균 좌표를 떠올리기 쉽다. 하지만 여기서 정준 임베딩은 좌표가 아니라 학습 가능한 특징 벡터다. 관절 종류마다 하나씩 있으며, 여러 이미지가 같은 테이블을 공유한다.

예를 들어 왼쪽 손목 특징을 바꾸기로 했다면, 현재 이미지에서 얻은 왼쪽 손목 벡터 대신 테이블의 왼쪽 손목 벡터를 넣는다.

[논문 원문: 식 (3)]

\[f'_k=\begin{cases} z_k,&k\text{가 개입 대상으로 선택되었을 때}\\ f_k,&\text{그 외} \end{cases}\]

같은 기준 벡터를 넣는다고 모든 사람의 손목 좌표가 같아지는 것은 아니다. 뒤의 GNN이 함께 들어온 어깨, 팔꿈치, 몸통 등의 특징을 반영하고, 최종 head가 그 결과를 좌표 분포로 바꾼다.

정준 임베딩은 별도의 관절 데이터셋에서 미리 학습해 가져오는 것이 아니라, 보충자료와 공개 코드에서 확인할 수 있는 학습 파라미터다. 무작위로 초기화한 뒤 전체 모델의 손실을 통해 함께 학습한다. 보충자료 C절

HGNN — 가까운 관절에서 전신 관계까지

GNN은 두 수준의 관계를 사용한다.

단계	관계를 보는 단위	하는 일
국소 골격 그래프	관절과 연결된 이웃 관절	어깨·팔꿈치·손목처럼 연결된 특징을 모은다
의미 그룹 간 그래프	손, 팔, 얼굴 등의 그룹	그룹끼리 정보를 교환하고 관절 특징을 조절할 gate를 만든다

손목이 애매할 때 팔꿈치를 보는 것이 첫 단계라면, 팔의 특징을 몸 전체의 관계 속에서 다시 조절하는 것이 두 번째 단계다. 논문은 이를 local-to-global 구조로 설명한다.

여기서 ‘관계’는 사람이 미리 정해둔 연결을 이용하지만, 그 연결에서 어떤 특징을 전달하고 얼마나 반영할지는 학습된다. 이전에 정리한 GCN 리뷰와 연결되는 부분이다. 다만 CIGPose의 실제 연산은 그 글의 기본 GCN 전파식을 그대로 사용하는 것이 아니라 EdgeConv와 그룹 gate를 사용한다.

Part 4. 바꾸면서도 멀쩡한 관절은 지켜야 한다

학습할 때는 두 경로를 사용한다. 일부 특징을 바꾼 반사실 경로가 최종 예측을 학습하고, 원래 특징으로 예측한 관찰 경로가 안정적인 키포인트의 기준을 제공한다. 추론할 때는 반사실 경로를 사용한다.

[논문 원문: 3.4절 전체 목적 함수]

\[\mathcal L=\mathcal L_{\mathrm{kpt}}+\lambda\mathcal L_{\mathrm{cf}}\]

손실	비교 대상	적용 대상
Keypoint loss	최종 예측과 정답 SimCC 분포	정답 가중치가 유효한 키포인트, 개입 여부와 무관
Counterfactual consistency loss	관찰 경로의 예측과 반사실 경로의 예측	개입하지 않은 키포인트 중 정답 가중치가 유효한 것

예를 들어 왼쪽 손목만 바꿨다고 해보자. GNN에서는 관절들이 서로 연결되어 있으므로, 손목의 변화가 멀쩡했던 팔꿈치에도 영향을 줄 수 있다. 일관성 손실은 그 팔꿈치의 예측까지 불필요하게 흔들리지 않도록 제약한다.

관찰 경로는 gradient를 차단한 기준으로 사용한다. 그렇다고 GNN 전체가 학습되지 않는 것은 아니다. 같은 GNN 파라미터가 반사실 경로에서는 학습된다. 이 부분은 2편의 손실·gradient 해설에서 따로 풀어본다.

Part 5. 실험 결과 — GNN과 CIM의 기여

같은 크기의 모델끼리 비교하기

아래는 논문 Table 1에서 관련 행과 열을 발췌한 것이다. 입력은 모두 384×288, 지표는 COCO-WholeBody V1.0의 Whole-body AP, 원문 표는 flip test를 사용한다. 여기서는 UBody를 추가하지 않은 RTMPose와 CIGPose를 비교한다.

방법	GFLOPs	Whole-body AP
RTMPose-l	10.1	64.8
CIGPose-l	10.7	66.3
RTMPose-x	18.1	65.3
CIGPose-x	18.7	67.0

출처: 논문 Table 1 발췌. 원문 표 전체 보기. AP는 원문 표의 백분율 스케일이며, 수치는 직접 재현한 결과가 아니라 논문 보고값이다.

l 모델은 1.5 AP 포인트, x 모델은 1.7 AP 포인트 높아진다. x 모델에 UBody를 추가한 설정은 67.5 AP지만, 그것은 추가 학습 데이터를 사용한 별도 조건이므로 위의 네 행과 구분해서 봐야 한다.

GNN만 넣어도 꽤 오르는데?

이 논문에서 가장 유심히 볼 표는 ablation이라고 생각한다. 인과 개입이라는 이름이 강렬해도, 모델에는 GNN도 새로 들어간다. 전체 성능 향상이 모두 CIM 덕분이라고 읽으면 안 된다.

구성 — x 모델 기준	AP	baseline 대비
RTMPose-x baseline	65.3	—
CIM만 추가	66.1	+0.8
국소 골격 GNN만 추가	66.3	+1.0
국소 + 의미 그룹 GNN	66.8	+1.5
CIM + 전체 GNN	67.0	+1.7

출처: 논문 Table 4에서 x 모델 행을 발췌·재배열. 원문 ablation 표 보기. 각 증가량은 해당 표의 점수 차이다.

이 표에서는 전체 GNN을 붙였을 때 이미 66.8 AP이고, 여기에 CIM을 더하면 0.2 AP 포인트가 추가된다. CIM 단독으로도 향상이 있지만, 이 실험에서 구조적 관계 추론의 기여 역시 크다. 각 모듈의 효과는 결합 방식에 따라 달라지므로 증가량을 독립적인 기여도로 단순 합산하지는 말자.

숫자로 보기 어려운 변화

출처: 논문 Fig. 6. 각 비교는 입력 이미지 → RTMPose-x → CIGPose-x 순서다. 복잡한 배경과 차폐 근처에서 관절 배치가 어떻게 달라졌는지 보면 된다.

정성적 예시는 구조적으로 더 자연스러워진 결과를 보여준다. 다만 선택된 사례 몇 장이 모든 배경이나 모든 가림 상황에서의 강건성을 보장하지는 않는다. 전체 지표, ablation, 그리고 실패 사례를 함께 봐야 한다.

Part 6. 읽고 나서 남은 질문

특징 치환은 backdoor 평균과 같은 계산인가?

처음의 질문으로 돌아왔다. 논문은 모든 문맥에 대해 평균하는 식을 목표로 제시하지만, 구현은 불확실한 관절을 골라 정준 벡터로 바꾼다. 코드 안에서 문맥의 분포를 추정하고 그 합을 직접 계산하지는 않는다.

보충자료 A절은 저자들이 이 치환을 인과적 근사로 해석하는 근거를 설명한다. 하지만 그것을 곧바로 “일반적인 이미지 분포에서 backdoor 평균과 정확히 같은 계산임을 보였다”로 받아들이기는 어렵다. 목표, 근사의 가정, 실험으로 확인된 효과를 구분하는 편이 낫다.

Fig. 2(b)도 저자들이 제안한 모형으로 읽어야 한다. 표준적인 do-연산은 개입한 변수로 들어오는 연결을 제거하는 방식으로 정의된다. 그림에서 교란 연결에 그려진 X 표시를 보고, “특징을 바꾸면 모든 배경 영향이 실제로 끊겼다”고 단정하는 것은 설명을 건너뛰는 셈이다. 논문 3.1절·보충자료 A절

정준 벡터가 현재 이미지와 무관한 공유 파라미터라는 점도, 학습 데이터의 모든 편향으로부터 자유롭다는 뜻은 아니다. 학습 데이터로 최적화되는 파라미터이기 때문이다. 이 구분이 논문을 읽으며 가장 신경 쓰였던 부분이다.

불확실한데 맞는 자세, 확신하는데 틀린 자세

출처: 보충자료 Fig. 8·F절. 위쪽은 드물지만 타당한 자세를 과하게 교정할 수 있는 사례, 아래쪽은 가로등을 사람으로 오인한 사례다.

보충자료는 두 가지 한계를 설명한다.

드물지만 올바른 자세: 익숙하지 않아서 불확실하다는 이유로 타당한 특징까지 바꿔버릴 수 있다. 개인의 실제 자세보다 평범한 패턴에 가까운 결과를 선호할 위험이다.
확신에 찬 오류: 가로등처럼 사람을 닮은 구조에서 확신하며 틀리면 불확실성 기반 점수가 이를 잘 잡지 못한다. 특히 사람 검출부터 잘못된 top-down 입력을 CIM만으로 해결한다고 볼 수 없다.

논문은 이를 낮은 점수가 개입을 우회하는 문제로 설명한다. 한편 검토한 공개 설정은 추론에서도 Top-1을 선택한다. 따라서 코드 기준으로는 ‘관절을 하나도 바꾸지 않는다’기보다, 점수의 순위가 확신에 찬 오류를 식별하고 거부할 기준이 되기 어렵다고 구분해 적는 편이 정확하다.

내 생각

CIGPose에서 흥미로웠던 것은 모든 관절 특징을 끝까지 같은 신뢰도로 사용하는 대신, 의심스러운 특징을 바꾸고 관계를 이용해 보완한다는 설계였다. 여기에 “멀쩡했던 예측은 지키자”는 일관성 손실까지 붙으니 각 구성의 목적이 연결된다.

반면 인과 추론의 언어로 문제를 정리하는 것과, 구현의 인과적 타당성을 입증하는 것은 다른 단계다. 이 논문은 그 사이를 어떻게 읽어야 하는지 연습하기 좋은 사례이기도 했다. 좋은 결과가 나왔다는 사실과, 그 결과를 설명하는 이론이 어디까지 검증되었는지를 함께 따져보게 된다.

다음 글에서는 이 아이디어를 실제 코드의 텐서 흐름과 gradient 경로로 내려가 본다. 관절 벡터 하나가 바뀌면 어느 파라미터가 학습되는지까지 보면, 정준 임베딩이 무엇인지도 훨씬 구체적으로 이해할 수 있다.

참고 자료

2. FFDP 수식과 학습 구조 - 좌표가 복원되는 과정을 따라가기

Tue, 08 Sep 2026 00:00:00 +0900

들어가며

1편에서는 FFDP가 가려진 관절을 왜 주파수 영역에서 복원하는지 살펴봤다. 이제 블록 이름을 실제 계산으로 바꿔 볼 차례다.

손필기에는 한 관절의 좌표를 두 개씩 묶어 평균과 차이를 계산한 흔적이 있다. 이어서 프레임과 관절 좌표를 행렬로 적고, DWT 식의 $m,n,k_1,k_2$가 어디를 가리키는지 하나씩 추적했다. 마지막에 남은 질문은 더 구체적이었다.

“인코더가 정확하게 어떤 입력, 어떤 출력을 해서 어떻게 학습을 하게 되는건지가 중요한 거 아냐?”

“인코더, 디코더의 입출력과 역전파 시 어디가 학습되는지, 어느 부분의 가중치가 업데이트 되는지 다 알려줘.”

이 글은 그 질문에 답하기 위해 좌표 하나에서 출발한다. DWT로 네 부대역을 만들고, 학습된 계수 맵으로 조절한 뒤, 검출 좌표 중심의 확산과 DDIM을 거쳐 2D·3D 동작이 학습되는 경로를 따라간다.

읽는 기준
논문 본문과 보충자료로 확인한 사실, 계산을 이해하기 위해 이번에 만든 예시를 구분한다. FFDP 공식 코드 공개 주소는 확인 시점에 접근할 수 없었다. 따라서 wavelet family, 경계 처리, 관절 수와 배열 순서, coefficient map의 활성함수, 정확한 DDIM schedule은 구현 사실로 단정하지 않는다.

1. 한 관절의 좌표를 평균과 차이로 나눈다

손필기의 첫 계산은 다음 시계열이었다.

[설명용 유도] 손필기에 남은 평균·반차 방식의 Haar 예시

\[z=[10,12,14,30,31,32,33,34].\]

인접한 값을 두 개씩 묶고 평균과 반차를 계산한다.

[설명용 유도]

\[L_1[k]=\frac{z[2k]+z[2k+1]}{2}, \qquad H_1[k]=\frac{z[2k]-z[2k+1]}{2}.\]

그러면 첫 level의 결과는 다음과 같다.

[설명용 유도]

\[L_1=[11,22,31.5,33.5], \qquad H_1=[-1,-8,-0.5,-0.5].\]

$H_1$의 두 번째 값이 $-8$인 이유는 $14$와 $30$의 차이가 크기 때문이다.

[설명용 유도]

\[H_1[1]=\frac{14-30}{2}=-8.\]

이 값은 3번째와 4번째 위치 사이에 큰 변화가 있다는 사실을 드러낸다. 하지만 여기서 바로 “$-8$은 잡음이다”라고 말할 수는 없다. 사람이 실제로 팔을 빠르게 움직여도 큰 고주파 계수가 생기고, 가려진 관절의 검출 좌표가 튀어도 같은 현상이 생긴다.

DWT가 해 주는 일은 변화의 위치와 크기를 다른 성분으로 펼쳐 보이는 데까지다. 그 변화가 보존할 동작인지 억제할 오류인지는 뒤의 학습 모델이 주변 프레임과 관절의 관계를 보고 판단해야 한다.

더 깊은 level은 더 넓은 구간을 본다

$L_1$에 같은 연산을 한 번 더 적용하면 다음 결과를 얻는다.

[설명용 유도]

\[L_2=[16.5,32.5], \qquad H_2=[-5.5,-1].\]

$H_1$의 원소 하나는 원래 좌표 두 개의 차이를 요약한다. $H_2$의 원소 하나는 첫 level에서 두 쌍을 평균 낸 값들의 차이이므로 원래 좌표 네 개 범위에 대응한다. 손필기에서 이를 “마치 심층 convolution 연산처럼”이라고 적은 이유도 각 level에서 보는 시간 범위가 넓어지기 때문이다.

다만 이것은 다중 level을 이해하기 위한 예시다. FFDP 보충자료가 밝힌 실제 decomposition level은 1이다. 또한 위 계산은 $1/2$를 쓰는 평균·반차 방식이다. 정규직교 Haar에서 자주 쓰는 $1/\sqrt2$ 정규화와 같지 않으며, FFDP가 어떤 wavelet family와 정규화를 썼는지는 공개 문헌에 명시되지 않았다.

2. 한 줄 좌표가 프레임과 관절의 행렬이 된다

한 관절의 한 좌표만 보면 입력은 $z$라는 벡터다. 실제 모델은 여러 프레임의 여러 관절을 함께 본다.

[논문 원문] 2D 키포인트 시퀀스의 형태

\[P_t\in\mathbb{R}^{N\times2J}.\]

$N$: 한 입력 window의 프레임 수
$J$: 사용하는 관절 수
$2J$: 각 관절의 $x,y$ 좌표를 펼친 열의 수
$t$: diffusion의 noise level

[보충자료] FFDP의 temporal window는 36프레임이다. 따라서 한 번의 모델 호출은 36프레임 전체의 좌표 배열을 받는다. 손필기에는 $36\times28$, 즉 14관절을 가정한 크기가 적혀 있었지만, FFDP 본문과 보충자료만으로 실제 $J=14$와 열 순서를 확정할 수는 없다. OcMotion과 연결된 다른 저장소에서 14관절을 썼다는 사실도 FFDP 모델의 입력 크기를 대신 증명하지 않는다.

$m,n$이 움직이는 두 축

논문의 DWT 식은 두 축을 한꺼번에 처리한다.

[논문 원문] 식 (3)

\[y_{h,v}[k_1,k_2] =\sum_m\sum_n P[m,n]f_h[m-2k_1]f_v[n-2k_2], \qquad h,v\in\{L,H\}.\]

이 글에서는 다음과 같이 고정해서 읽는다.

기호	이 글에서의 의미
$m$	입력의 프레임축 인덱스
$n$	펼친 관절·좌표축 인덱스
$k_1$	시간축 필터링 뒤 출력 위치
$k_2$	관절·좌표축 필터링 뒤 출력 위치
$f_L$	low-pass filter
$f_H$	high-pass filter

손필기 3쪽에서는 $m$을 시간축, $n$을 관절·좌표축으로 적었지만 5쪽에서는 둘을 반대로 적었다. 계산의 핵심은 기호 이름 자체가 아니라 각 필터가 어느 축을 따라 이동하는가다. 그래서 여기서는 논문 식의 첫 합을 시간축, 두 번째 합을 펼친 좌표축으로 일관되게 사용한다.

stride 2가 입력을 두 칸씩 묶는다

1차원 low-pass 식부터 보면 인덱스가 선명해진다.

[설명용 유도] 손필기의 1차원 식을 정리한 형태

\[y[k]=\sum_m z[m]f_L[m-2k].\]

$f_L[0]$과 $f_L[1]$에서만 값이 있고 나머지는 0이라고 하자. 그러면 $k=0$일 때는 $z[0],z[1]$, $k=1$일 때는 $z[2],z[3]$만 남는다.

[설명용 유도]

\[\begin{aligned} y[0]&=z[0]f_L[0]+z[1]f_L[1],\\ y[1]&=z[2]f_L[0]+z[3]f_L[1],\\ y[2]&=z[4]f_L[0]+z[5]f_L[1]. \end{aligned}\]

설명용 필터에서 support 밖의 값은 0이므로 해당 항은 계산에서 제외된다. 복잡해 보이는 $m-2k$는 결국 필터를 두 칸씩 옮기는 인덱스다.

[설명용 유도] 작은 행렬에 평균·반차 필터를 적용해 LL·LH·HL·HH가 만들어지는 위치를 나타낸 그림이다. FFDP의 미명시 wavelet 설정을 재현한 그림은 아니다.

그림의 입력과 결과는 다음과 같다. 첫 글자는 시간축, 두 번째 글자는 펼친 좌표 열축의 filter다.

[설명용 유도] 실행으로 검증한 계산

\[P= \begin{bmatrix} 10&12&20&22\\14&16&24&26\\18&20&28&30\\30&32&40&50 \end{bmatrix},\] \[LL=\begin{bmatrix}13&23\\25&37\end{bmatrix},\quad LH=\begin{bmatrix}-1&-1\\-1&-3\end{bmatrix},\] \[HL=\begin{bmatrix}-2&-2\\-6&-8\end{bmatrix},\quad HH=\begin{bmatrix}0&0\\0&2\end{bmatrix}.\]

같은 평균·반차 규칙으로 iDWT를 적용하면 원래 $P$가 정확히 복원된다. 계산은 검증 스크립트에서 다시 실행할 수 있다.

2차원에서는 시간축과 관절·좌표축에 low/high filter를 조합해 네 부대역을 만든다.

부대역	시간축	펼친 관절·좌표축	읽을 수 있는 성질
LL	Low	Low	두 축에서 완만한 변화
LH	Low	High	시간에는 완만하고 인접 열 사이 차이는 큰 변화
HL	High	Low	시간에는 빠르고 인접 열에서는 비슷한 변화
HH	High	High	두 축 모두에서 빠른 변화

여기서 “LH는 팔을 든 동작”, “HH는 떨림”처럼 동작 이름을 고정하면 안 된다. 부대역은 필터 응답의 종류다. 실제 움직임의 의미는 관절 배열, 주변 프레임, 모델이 학습한 관계까지 함께 봐야 정해진다.

펼친 관절·좌표축에는 더 근본적인 질문도 남는다. 배열에서 이웃한 열이 골격에서 이웃한 관절이라는 보장은 없다. $x,y$가 어떤 순서로 배치되는지에 따라 high-pass 응답도 달라진다. 정확한 joint ordering이 공개되지 않은 현재에는 “공간축 DWT가 골격의 국소 이웃을 직접 본다”고 단정할 수 없다.

3. 계수를 만든 뒤 모델이 배율을 학습한다

DWT는 고정 변환이다. 같은 입력과 같은 filter를 넣으면 같은 부대역을 만든다. DWT 자체가 데이터에서 “이 값은 잡음”이라는 규칙을 배우지는 않는다.

FFDP의 prior network는 네 부대역을 받아 refined coefficient와 coefficient map을 함께 출력한다.

[논문 원문] 식 (4)

\[\hat y_{h,v},m_{h,v}=F_{h,v}(y).\]

그리고 둘을 원소별로 곱한다.

[논문 원문] coefficient selection

\[\bar y_{h,v}=m_{h,v}\odot\hat y_{h,v}.\]

$\odot$는 같은 위치의 값을 곱하는 Hadamard product다. 예를 들어 한 위치에서 refined coefficient가 $-8$이고 map 값이 $0.2$라면 출력은 $-1.6$이 된다.

[설명용 유도]

\[(-8)\times0.2=-1.6.\]

이 숫자는 곱의 역할만 보여 주는 예시다. 논문은 $m$의 범위나 활성함수를 밝히지 않았으므로 실제 값이 $0$과 $1$ 사이인지도 확인할 수 없다.

논문이 이 과정을 coefficient selection이라고 부르지만, top-k나 binary mask를 사용한다고 명시하지는 않는다. 확인 가능한 정의는 각 위치에서 예측한 값들을 원소별로 곱하는 연산이다. 모든 고주파를 제거하는 fixed cutoff로 해석해서도 안 된다.

필터링한 네 부대역은 iDWT로 다시 좌표 배열이 된다.

[설명용 유도] 논문 식 (5)를 압축한 표기

\[P=\operatorname{iDWT}(\bar y_{LL},\bar y_{HL},\bar y_{LH},\bar y_{HH}).\]

이 간단한 표기는 논문 식 (5)의 합을 역할 중심으로 줄여 쓴 것이다. 모델은 좌표를 직접 한 번에 회귀하는 대신, 주파수 위치별 계수를 조절한 뒤 좌표 영역으로 돌아온다.

4. 가우시안은 좌표를 고치는 장치가 아니라 출발점이다

손필기 다음 부분에는 “가림 영역의 키포인트를 가우시안으로 억제한다는 의미”라는 질문이 있었다. 여기에는 분포와 denoiser의 역할이 섞여 있다.

가우시안은 가림 잡음을 억제하지 않는다. 신뢰하기 어려운 검출 좌표의 불확실성을 표현하고 초기 좌표 표본을 만드는 역할을 한다. 실제 복원은 학습된 network가 담당한다.

한 관절의 검출 좌표가 다음과 같다고 하자.

[설명용 유도] 손필기의 좌표 예시

\[p=(100,200).\]

논문은 불신뢰 관절에 대해 이 좌표를 평균으로 하고 단위행렬을 공분산으로 하는 분포를 둔다.

[논문 원문] 불신뢰 관절의 초기분포

\[\mathcal N(p,I).\]

여기서 모델에 들어가는 것은 “가우시안”이라는 수학 객체 자체가 아니다. 분포에서 뽑은 구체적인 2차원 좌표다.

[설명용 유도] $\mathcal N(p,I)$에서 좌표 표본을 만드는 정의

\[\epsilon\sim\mathcal N(0,I), \qquad p_T=p+\epsilon.\]

같은 $p$에서도 표본은 매번 달라질 수 있다. 하지만 random sample과 학습 가능한 복원 함수는 충돌하지 않는다. 같은 정답을 여러 잡음 상태로 보여 주면 network는 주변 관절과 프레임을 이용해 깨끗한 좌표를 되찾는 공통 규칙을 학습할 수 있다.

confidence는 어느 관절을 믿을지 나누는 기준이다. [보충자료] FFDP는 ViTPose++-B와 threshold 0.7을 사용한다. 다만 0.7은 보충자료에서 선택한 설정이지 모든 detector와 dataset에 보편적인 임계값은 아니다. confidence가 관절별 가우시안 분산으로 직접 바뀐다는 설명도 논문에는 없다.

5. forward 식은 정답에서 검출 좌표 쪽으로 이동한다

일반 diffusion은 깨끗한 데이터를 표준정규분포 쪽으로 흐리게 만드는 설명으로 자주 배운다. FFDP는 detector 좌표라는 중심을 활용한다.

[논문 원문] 식 (1)

\[q(p_t\mid\hat p_0) =p+\sqrt{\hat\alpha_t}(\hat p_0-p) +\sqrt{1-\hat\alpha_t}\epsilon, \qquad \epsilon\sim\mathcal N(0,I).\]

[논문 원문] 누적 계수

\[\hat\alpha_t=\prod_{i=0}^{t}\alpha_i.\]

기호를 좌표의 종류로 읽어 보자.

기호	의미
$p$	2D detector가 낸 관절 좌표
$\hat p_0$	학습 때 사용하는 깨끗한 정답 좌표
$p_t$	noise level $t$의 noisy 좌표 표본
$\epsilon$	표준정규분포에서 뽑은 잡음
$\hat\alpha_t$	처음부터 $t$까지 곱한 누적 계수

누적 계수가 1에 가까우면 정답 좌표의 영향이 크다. 0에 가까워질수록 중심이 detector 좌표 $p$ 쪽으로 이동하고 잡음 비중이 커진다.

[설명용 유도] 식 (1)의 조건부 평균

\[\mathbb E[p_t\mid\hat p_0,p] =(1-\sqrt{\hat\alpha_t})p +\sqrt{\hat\alpha_t}\hat p_0.\]

$p_T=p+\epsilon$은 $\mathcal N(p,I)$에서 표본을 만드는 정의다. 이와 달리 forward 식 (1)의 유한한 마지막 시점이 그 표본과 같아지는지는 $\hat\alpha_T$에 달려 있다. $\hat\alpha_T$가 충분히 작으면 식 (1)이 detector 중심 가우시안에 가까워진다고 설명할 수 있지만, 공개된 schedule에서 정확히 0인지는 확인되지 않았다. 두 식은 학습과 추론에 서로 다른 forward 공식을 쓴다는 뜻이 아니다.

또한 이 확산은 불신뢰 관절에 적용된다. 논문은 reliable keypoint가 forward와 reverse diffusion에서 원래 관측값을 유지한다고 명시한다.

6. 36프레임과 DDIM 5 step은 다른 축이다

대화에서 가장 오래 걸린 지점은 두 종류의 시간이 같은 문자 주변에 나타난다는 점이었다.

“5번 반복한다고 했는데 어떻게 5번 반복해서 36프레임이 나오는거야?”

36은 영상 프레임 축의 길이다. DDIM 5 step은 같은 36프레임 좌표 배열을 서로 다른 noise level에서 다섯 번 정제하는 계산 축이다.

36프레임 전체가 각 sampling step을 통과한다. 다섯 번의 모델 호출이 다섯 프레임을 생성하는 구조가 아니다.

[보충자료] 학습 diffusion timestep은 100이고, 추론은 DDIM 5 step을 사용한다. 이것은 다음 뜻이다.

한 모델 평가의 입력: 36프레임 전체의 noisy keypoint sequence
                     ↓
다음 noise level:    같은 36프레임 전체의 다음 상태 sequence
                     ↓
최종 출력:           같은 window에 대한 복원 결과

손필기에는 100개 중 “무작위 5개”를 고른다는 설명도 있었다. 하지만 보충자료는 5-step DDIM이라고만 밝힌다. 매 추론마다 무작위 시점을 고르는지, 어떤 index를 선택하는지, noise schedule과 DDIM의 $\eta$가 무엇인지는 명시하지 않았다.

100,75,50,25,0처럼 상태 다섯 개를 나열하면 상태 사이 이동은 네 번이라는 점도 조심해야 한다. 이 숫자를 FFDP의 정확한 다섯 번 모델 호출 schedule로 사용할 수 없다.

7. 현재 입력과 깨끗한 좌표 예측을 DDIM 식에 넣는다

논문은 reverse distribution을 다음처럼 쓴다.

[논문 원문] 식 (2)

\[q(P_{t-1}\mid P_t) =\mathcal N\!\left(P_{t-1};\mu_\alpha(P_t),\tilde\gamma_tI\right).\]

이어 모델이 매 timestep마다 $P_0$를 예측하고, 식 (1)을 이용해 다음 상태를 구성한다고 설명한다. 그러나 $\mu_\alpha$의 닫힌식과 DDIM update를 본문에 풀어 쓰지는 않는다.

그래서 다음 계산은 FFDP의 공개 구현을 옮긴 것이 아니다. FFDP 식 (1)을 detector-centered residual 좌표로 바꾸고, 원 DDIM의 deterministic update를 적용해 현재 입력과 깨끗한 예측의 역할을 보여 주는 유도다.

먼저 detector 좌표 $p$를 원점으로 옮긴다.

[설명용 유도]

\[z_t=P_t-p, \qquad z_0=P_0-p.\]

그러면 forward 식은 표준 diffusion 형태가 된다.

[설명용 유도]

\[z_t=\sqrt{\bar\alpha_t}z_0 +\sqrt{1-\bar\alpha_t}\epsilon.\]

현재 noisy input $P_t$와 모델이 방금 예측한 clean pose $P_0^{\mathrm{pred},(t)}$를 이용하면, 둘과 일관된 예측 잡음을 역산할 수 있다.

[설명용 유도]

\[\epsilon_t^{\mathrm{pred}} =\frac{ P_t-p-\sqrt{\bar\alpha_t} \left(P_0^{\mathrm{pred},(t)}-p\right) }{\sqrt{1-\bar\alpha_t}}.\]

여기서 $P_t$는 현재 상태에, $P_0^{\mathrm{pred},(t)}$는 clean coordinate 항에 들어간다. 이전 DDIM 결과를 식의 정답 자리에 단순 대입하는 계산이 아니다.

더 이른 noise level $s<t$로 이동할 때 deterministic DDIM, 즉 $\eta=0$인 설명용 갱신은 다음과 같다.

[설명용 유도: DDIM 원 논문의 $\eta=0$ 구조를 FFDP residual 좌표에 적용]

\[P_s =p+\sqrt{\bar\alpha_s} \left(P_0^{\mathrm{pred},(t)}-p\right) +\sqrt{1-\bar\alpha_s}\epsilon_t^{\mathrm{pred}}.\]

$\bar\alpha_t$는 현재 noise level, $\bar\alpha_s$는 이동할 noise level의 누적 계수다. 모델을 다시 호출하면 새로운 $P_s$에서 clean pose를 다시 예측하므로 $\epsilon^{\mathrm{pred}}$도 매 step 새로 계산된다.

작은 숫자로 대입하면 각 항이 더 잘 보인다. 검출 좌표 $p=[100,200]$, clean prediction $[104,192]$, 예측 잡음 $[0.25,-0.5]$, $\bar\alpha_t=0.25$, $\bar\alpha_s=0.64$로 둔다. 먼저 forward 관계로 만든 현재 상태는 $P_t=[102.216506\ldots,195.566987\ldots]$다. 이 $P_t$와 clean prediction을 예측 잡음 식에 넣으면 $[0.25,-0.5]$가 다시 나오고, update 뒤 좌표는 $P_s=[103.35,193.3]$이 된다. 이 값들은 스크립트로 검산한 교육용 예시이며 FFDP의 실제 schedule이나 출력이 아니다.

이 유도의 경계는 분명하다.

FFDP 문헌은 DDIM 5 step을 사용한다고 밝힌다.
FFDP가 실제로 $\eta=0$을 썼는지는 밝히지 않는다.
선택 timestep, $\alpha$ schedule, variance 설정도 공개 문헌에 없다.
따라서 위 식은 [설명용 유도]이며 FFDP 실제 sampler의 확정 구현이 아니다.

초기 표본을 뽑은 뒤 매 step에서 detector를 다시 실행하거나 가우시안에서 독립 표본을 다시 뽑는 것도 아니다. 현재 상태를 network가 정제해 다음 상태로 넘긴다. reliable keypoint는 그 과정에서 원래 관측 좌표로 유지된다.

8. Stage 1은 2D 복원 규칙을 학습한다

이제 수식을 module과 loss에 연결할 수 있다.

[논문 원문] Stage 1의 전체 흐름. [보충자료] Encoder와 2D decoder의 구성.

GT 2D keypoint + detector 좌표 + noise level
    → noisy 2D sequence P_t 구성
    → 고정 DWT
    → spatial Transformer / temporal Transformer 기반 prior encoder
    → 2D decoder: LayerNorm + Linear
    → refined coefficient × coefficient map
    → 고정 iDWT
    → clean 2D prediction P_0^pred
    → L1 keypoint loss

[논문 원문] 식 (6)

\[\mathcal L_{keyp}=|P-\hat P|.\]

논문은 이를 $L_1$ keypoint loss라고 설명한다. 합인지 평균인지 같은 reduction 세부는 명시하지 않는다.

학습 표본과 예측 함수를 함께 쓰면 역할이 더 잘 보인다.

[설명용 유도] Stage 1의 계산 관계를 압축한 표기

\[P_0^{\mathrm{pred}} =\operatorname{iDWT}\!\left( F_\theta(\operatorname{DWT}(P_t)) \right), \qquad \mathcal L_{2D} =\lVert P_0^{\mathrm{pred}}-P_0^{GT}\rVert_1.\]

$F_\theta$는 실제 논문의 한 함수 이름이 아니라 prior encoder, 2D decoder, coefficient scaling을 묶어 나타낸 설명용 기호다.

Stage 1에서 학습되는 것은 prior encoder와 2D decoder의 parameter다. DWT와 iDWT filter는 고정 연산이라 업데이트할 parameter가 없다. ViTPose detector까지 이 loss로 공동 학습한다는 근거도 없다.

[보충자료] prior encoder는 spatial information과 temporal information을 위한 서로 분리된 두 Transformer를 사용한다. 2D decoder는 Transformer가 아니라 LayerNorm과 Linear로 구성된다. head 수, layer 수, embedding dimension은 공개 문헌에 명시되지 않았다.

9. Stage 2는 고정한 prior를 3D 복원에 사용한다

Stage 1이 끝나면 논문은 학습된 prior encoder를 고정한다. 이어 3D Transformer decoder가 3D motion의 wavelet subband와 shape parameter를 예측한다.

[논문 원문] 식 (7)

\[Y_{h,v},\beta=D(y,z,I).\]

$y$: DWT로 분해한 2D 입력 subband
$z$: 고정된 prior encoder가 만든 latent embedding
$I$: RGB image에서 추출한 ViT feature
$Y_{h,v}$: 3D motion의 예측 subband
$\beta$: 사람의 shape parameter

예측한 3D subband는 iDWT를 거쳐 motion parameter가 된다.

[논문 원문] 식 (8)

\[x=\operatorname{iDWT}(Y).\]

논문의 사전 정의에서 $x$는 pose $\theta$와 translation $\tau$로 구성된다. SMPL을 통해 3D joint와 vertex를 얻고, 카메라로 2D에 재투영한다.

[논문 원문] 식 (9)

\[\mathcal L =\mathcal L_{smpl} +\mathcal L_{joint} +\mathcal L_{verts} +\mathcal L_{keyp}.\]

[논문 원문] 손실 항의 정의

\[\mathcal L_{smpl} =\lVert[\beta,\theta]-[\hat\beta,\hat\theta]\rVert_2^2,\] \[\mathcal L_{joint} =\lVert J_{3D}-\hat J_{3D}\rVert_2^2, \qquad \mathcal L_{vert} =\lVert V_{3D}-\hat V_{3D}\rVert_2^2.\]

$\mathcal L_{keyp}$는 재투영한 2D keypoint에 식 (6)의 $L_1$ loss를 적용한다. 논문 식에는 네 항의 단순 합으로 적혀 있지만, 실제 reduction과 loss weight는 공개 문헌에 명시되지 않았다. 이를 모두 구현 가중치 1이라고 단정하지 않는다.

[보충자료] 재투영에는 CLIFF perspective camera를 사용한다. principal point는 image center, focal length는 $\sqrt{w^2+h^2}$로 추정한다.

Stage 2에서 확실히 말할 수 있는 업데이트 범위는 다음과 같다.

구성요소	Stage 1	Stage 2
DWT/iDWT filter	고정	고정
Prior encoder	2D loss로 학습	논문에서 freeze 명시
2D decoder	2D loss로 학습	Stage 2의 사용·동결 범위 미명시
3D Transformer decoder	해당 없음	3D·재투영 loss로 학습
RGB ViT feature extractor	해당 없음	freeze/update 여부 미명시
ViTPose detector	입력 keypoint 제공	공동 학습 근거 없음

“Stage 2에서 prior encoder를 고정한다”는 사실로 “ViT도 고정한다”거나 “ViT는 반드시 3D decoder와 함께 fine-tuning한다”고 결론 내릴 수 없다.

10. 고정된 iDWT를 지나도 gradient는 흐른다

고정된 연산에는 학습할 parameter가 없다. 그렇다고 그 연산의 앞쪽까지 gradient가 갈 수 없다는 뜻은 아니다.

iDWT를 고정 선형 변환 $A$로 단순화하고, decoder 출력 coefficient를 $y_\theta$라고 하자.

[설명용 유도] 고정 선형 변환을 지나는 연쇄법칙

\[x=Ay_\theta, \qquad \frac{\partial\mathcal L}{\partial y_\theta} =A^\top\frac{\partial\mathcal L}{\partial x}.\]

$A$ 자체를 바꾸지는 않지만, $A^\top$을 통해 decoder 출력에 대한 gradient를 계산할 수 있다. 그래서 좌표 영역이나 SMPL 결과에 둔 loss로 주파수 영역 coefficient를 예측한 decoder를 학습할 수 있다.

Stage 1에서는 $L_1$ loss의 gradient가 iDWT와 coefficient scaling을 지나 2D decoder와 prior encoder로 흐른다. Stage 2에서는 SMPL·joint·vertex·reprojection loss의 gradient가 3D decoder 쪽으로 흐르지만 prior encoder의 parameter는 freeze되어 업데이트되지 않는다.

여기서도 계산 가능성과 실제 optimizer 설정은 구분해야 한다. 문헌은 encoder freeze를 밝히지만, 공개 코드가 없으므로 detach 위치, optimizer parameter group, ViT의 update 여부를 확인할 수 없다.

계산을 끝내고 다시 보는 전체 경로

처음에는 DWT가 평균과 차이를 만든다는 사실만 보였다. 전체 경로를 따라가면 각 단계의 책임이 나뉜다.

DWT는 좌표 변화를 네 부대역으로 펼친다.
Prior network는 refined coefficient와 coefficient map을 예측한다.
$m\odot\hat y$는 각 위치의 coefficient를 학습된 배율로 조절한다.
iDWT는 조절된 부대역을 다시 좌표로 복원한다.
검출 좌표 중심 가우시안은 불신뢰 관절의 초기 표본을 만든다.
Forward 식은 학습 때 GT와 detector 좌표 사이의 noisy sample을 만든다.
DDIM은 같은 36프레임 배열을 여러 noise level에서 반복해 정제한다.
Stage 1은 2D 복원 prior를 학습하고, Stage 2는 그 encoder를 고정해 3D decoder를 학습한다.

이제 $-8$ 같은 큰 high-frequency coefficient를 다시 보면 질문도 달라진다. “이 값이 잡음인가”를 DWT 하나에 묻는 대신, 어떤 주변 관측을 조건으로 network가 이 위치의 배율을 어떻게 조절했는가를 물어야 한다.

아직 재현을 위해 남은 정보도 많다. wavelet family와 boundary mode, joint ordering, coefficient map의 범위, Transformer 세부 구조, noise schedule, DDIM의 $\eta$와 selected timestep은 공개 문헌에서 확인되지 않았다. 관절 순서를 바꾸거나 frame을 shift했을 때 coefficient가 어떻게 달라지는지, 실제 급변과 검출 오류가 어떤 부대역에서 구분되는지도 아직 수행하지 않은 후속 실험이다.

이 미확인 항목을 구현 기본값으로 채우지 않는 것이 중요하다. 현재 확인할 수 있는 수식과 학습 경로는 분명하지만, 독립 재현에서 선택한 값은 논문의 확정 설정과 따로 기록해야 한다.

참고 자료

Buzhen Huang et al., Occluded Human Body Capture with Frequency Domain Denoising Prior, CVPR 2026.
FFDP 공식 본문 PDF
FFDP 공식 보충자료 PDF
Jiaming Song, Chenlin Meng, Stefano Ermon, Denoising Diffusion Implicit Models. 이 글의 deterministic DDIM 식은 원 논문의 구조를 FFDP residual 좌표에 적용한 [설명용 유도]다.

6. PyTorch 06 - Strided CNN과 Depthwise Separable CNN

Mon, 07 Sep 2026 09:50:00 +0900

들어가며

MLP는 MNIST 이미지를 (784,)로 펼쳐서 처리한다. 숫자의 모양을 이루는 인접 픽셀 관계도 함께 납작하게 만들어버린다. CNN은 작은 kernel을 이미지 위로 움직이며 지역 패턴을 먼저 찾는다.

Day5 실습에서는 기본 CNN을 그대로 만드는 대신 두 가지 변형을 구현했다.

Max Pooling을 stride가 2인 convolution으로 바꾼 StridedCNN
convolution을 depthwise와 pointwise로 나눈 DepthwiseCNN

코드를 작성하면서 Conv2d의 인자는 정리했지만, layer를 통과할 때마다 왜 공간 크기가 26, 14, 12, 7로 바뀌는지, 그리고 depthwise convolution을 썼는데도 왜 전체 parameter가 더 많아졌는지가 더 중요한 질문으로 남았다.

1. `Conv2d`에서 먼저 볼 네 가지

nn.Conv2d(
    in_channels=1,
    out_channels=16,
    kernel_size=3,
    stride=1,
    padding=0,
)

인자	의미
`in_channels`	입력 feature map의 채널 수
`out_channels`	만들 filter 수이자 출력 채널 수
`kernel_size`	filter의 공간 크기
`stride`	filter가 한 번에 이동하는 간격
`padding`	입력 테두리에 추가하는 값의 폭
`dilation`	kernel 원소 사이의 간격
`groups`	입력·출력 채널을 연결하는 묶음 수

공간 출력 크기는 한 축을 기준으로 다음처럼 계산한다.

\[H_{out}=\left\lfloor \frac{H_{in}+2P-D(K-1)-1}{S}+1 \right\rfloor\]

여기서 $K$는 kernel, $S$는 stride, $P$는 padding, $D$는 dilation이다.

2. StridedCNN: downsampling도 학습시키기

class StridedCNN(nn.Module):
    def __init__(self):
        super().__init__()

        self.conv1 = nn.Conv2d(1, 16, kernel_size=3)
        self.down1 = nn.Conv2d(
            16, 16, kernel_size=2, stride=2, padding=1
        )

        self.conv2 = nn.Conv2d(16, 32, kernel_size=3)
        self.down2 = nn.Conv2d(
            32, 32, kernel_size=2, stride=2, padding=1
        )

        self.relu = nn.ReLU()
        self.flatten = nn.Flatten()
        self.fc1 = nn.Linear(32 * 7 * 7, 256)
        self.fc2 = nn.Linear(256, 10)

    def forward(self, x):
        x = self.relu(self.conv1(x))
        x = self.down1(x)
        x = self.relu(self.conv2(x))
        x = self.down2(x)
        x = self.flatten(x)
        x = self.relu(self.fc1(x))
        return self.fc2(x)

Max Pooling은 정해진 영역의 최댓값을 남긴다. 여기서는 stride 2 convolution이 공간 크기를 줄인다. downsampling에 쓰는 filter weight도 loss를 통해 학습된다는 차이가 있다.

shape를 한 단계씩 계산하면 fc1의 32 * 7 * 7이 어디서 나왔는지 보인다.

단계	출력 shape
입력	`(B, 1, 28, 28)`
`conv1`, $K=3$	`(B, 16, 26, 26)`
`down1`, $K=2,S=2,P=1$	`(B, 16, 14, 14)`
`conv2`, $K=3$	`(B, 32, 12, 12)`
`down2`, $K=2,S=2,P=1$	`(B, 32, 7, 7)`
`flatten`	`(B, 1568)`
`fc1`	`(B, 256)`
`fc2`	`(B, 10)`

실습 코드에서 계산된 총 parameter는 414,202개였다.

3. Depthwise Separable Convolution

일반 convolution은 각 출력 filter가 모든 입력 채널을 함께 본다. 입력 채널이 $C_{in}$, 출력 채널이 $C_{out}$이면 weight 수는 bias를 제외하고 다음과 같다.

\[C_{out}\times C_{in}\times K\times K\]

Depthwise separable convolution은 이 일을 두 단계로 나눈다.

Depthwise convolution: 채널마다 공간 filter 하나를 적용
Pointwise convolution: $1\times1$ convolution으로 채널 정보를 결합

self.depthwise_conv = nn.Conv2d(
    in_channels=32,
    out_channels=32,
    kernel_size=3,
    padding=1,
    dilation=2,
    groups=32,
)

self.pointwise_conv = nn.Conv2d(
    in_channels=32,
    out_channels=64,
    kernel_size=1,
)

groups=32이고 입력·출력 채널도 32이므로 각 filter는 입력 채널 하나만 본다. depthwise 단계에서는 채널 사이를 섞지 않고 공간 패턴만 추출한다. 이어지는 pointwise 단계가 32개 채널을 조합해 64개 출력 채널을 만든다.

방식	weight 수
일반 $3\times3$, 32→64	$64\times32\times3\times3=18,432$
Depthwise $3\times3$	$32\times1\times3\times3=288$
Pointwise $1\times1$	$64\times32=2,048$
분리한 합계	2,336

이 convolution block만 보면 weight가 크게 줄어든다.

4. dilation을 넣은 DepthwiseCNN

class DepthwiseCNN(nn.Module):
    def __init__(self):
        super().__init__()

        self.conv1 = nn.Conv2d(1, 32, kernel_size=3)
        self.depthwise_conv = nn.Conv2d(
            32, 32,
            kernel_size=3,
            padding=1,
            dilation=2,
            groups=32,
        )
        self.pointwise_conv = nn.Conv2d(
            32, 64, kernel_size=1
        )
        self.relu = nn.ReLU()
        self.pool = nn.MaxPool2d(
            kernel_size=2,
            stride=2,
            padding=1,
        )
        self.flatten = nn.Flatten()
        self.fc1 = nn.Linear(64 * 7 * 7, 256)
        self.fc2 = nn.Linear(256, 10)

    def forward(self, x):
        x = self.relu(self.conv1(x))
        x = self.pool(x)

        x = self.depthwise_conv(x)
        x = self.pointwise_conv(x)
        x = self.relu(x)
        x = self.pool(x)

        x = self.flatten(x)
        x = self.relu(self.fc1(x))
        return self.fc2(x)

dilation=2인 $3\times3$ kernel의 실제 receptive field 크기는 $5\times5$다.

\[K_{effective}=D(K-1)+1=2(3-1)+1=5\]

따라서 padding이 1이어도 공간 크기가 유지되지 않는다.

단계	출력 shape
입력	`(B, 1, 28, 28)`
`conv1`	`(B, 32, 26, 26)`
첫 번째 pool	`(B, 32, 14, 14)`
dilated depthwise conv	`(B, 32, 12, 12)`
pointwise conv	`(B, 64, 12, 12)`
두 번째 pool	`(B, 64, 7, 7)`
flatten	`(B, 3136)`
출력	`(B, 10)`

5. Depthwise를 썼는데 왜 전체 모델은 더 클까?

노트북이 출력한 parameter 수는 다음과 같다.

모델	전체 parameter
`StridedCNN`	414,202
`DepthwiseCNN`	808,394

Depthwise block은 분명 효율적인데 전체 모델은 약 두 배가 됐다. 원인은 convolution이 아니라 fc1이다.

DepthwiseCNN은 마지막 feature map이 (64, 7, 7)이므로 flatten 결과가 3,136차원이다.

\[3136\times256+256=803,072\]

총 808,394개 중 803,072개가 fc1에 몰려 있다. 반면 StridedCNN은 (32, 7, 7)을 펼쳐 1,568차원이므로 fc1 parameter가 401,664개다.

Depthwise convolution은 해당 convolution 연산을 줄여준다. 모델의 출력 채널을 늘린 뒤 큰 feature map을 그대로 Linear layer에 연결하면 전체 parameter는 오히려 커질 수 있다.

이런 구조에서는 global average pooling처럼 공간 축을 먼저 요약하는 방식도 검토할 수 있다.

6. 저장된 학습 결과 비교

두 노트북 모두 5 epoch, AdamW, 같은 MNIST split을 사용해 다음 결과를 기록했다.

모델	Final train acc	Final test acc	Train-test gap
StridedCNN	99.42%	98.78%	0.64%p
DepthwiseCNN	99.14%	98.61%	0.53%p

이 실행에서는 StridedCNN의 test accuracy가 0.17%p 높았다. 그러나 여기서 “strided convolution이 depthwise convolution보다 좋다”고 결론 내릴 수는 없다.

입력·출력 채널 수가 서로 다르다.
downsampling 방식도 다르다.
전체 parameter 수가 약 두 배 차이 난다.
seed 하나, 실행 한 번의 결과다.

비교하려면 채널 수와 parameter budget을 맞추고 여러 seed에서 평균과 분산을 확인해야 한다. 현재 결과는 두 구현이 정상적으로 학습됐다는 관찰값으로 보는 것이 적절하다.

7. weight 변화량 추적하기

실습에서는 각 layer의 현재 weight를 초기값·직전 epoch와 비교했다.

initial_weights = {
    name: parameter.detach().cpu().clone()
    for name, parameter in model.named_parameters()
    if name.endswith(".weight")
}

상대 변화율은 weight 크기가 서로 다른 layer도 비교하기 위해 기준 weight의 norm으로 나눈다.

\[\text{relative change}(\%)= 100\times\frac{\|W_t-W_{ref}\|_2} {\|W_{ref}\|_2+\epsilon}\]

직전 epoch를 기준으로 하면 update가 점점 안정되는지 볼 수 있고, 초기값을 기준으로 하면 학습 전체에서 어느 layer가 많이 이동했는지 볼 수 있다. 단, norm 변화량이 크다고 그 layer가 더 중요하다는 뜻은 아니다. parameter 규모와 최적화 환경을 함께 봐야 한다.

헷갈리기 쉬운 포인트

`MaxPool2d`에 input size와 output size를 적지 않는 이유는?

Pooling layer는 입력 feature map에 같은 규칙을 적용하므로 Linear처럼 고정된 in_features, out_features를 받을 필요가 없다. kernel, stride, padding과 실제 입력 크기로 출력 공간 크기가 계산된다.

`groups`는 채널을 groups개씩 묶는다는 뜻인가?

정확히는 입력·출력 채널의 연결을 groups개의 독립된 묶음으로 나눈다. groups=1이면 모든 입력 채널이 모든 출력 채널에 연결된다. groups=in_channels이고 out_channels=in_channels이면 채널마다 filter 하나를 적용하는 depthwise convolution이 된다.

`padding=1`이면 항상 크기가 유지되나?

아니다. kernel, stride, dilation을 함께 봐야 한다. 특히 kernel_size=3, dilation=2의 effective kernel은 5이므로 stride 1에서 크기를 유지하려면 일반적으로 padding 2가 필요하다.

logits에 softmax를 넣고 CrossEntropyLoss를 써야 하나?

학습 시에는 넣지 않는다. 모델은 logits를 반환하고 CrossEntropyLoss에 그대로 전달한다. 확률을 표시할 때만 softmax를 적용한다.

정리하며

CNN 구조를 읽을 때 layer 이름만 보면 연결이 잘 보이지 않았다. 이번 실습에서는 각 단계의 (C,H,W)를 직접 계산하자 구조가 선명해졌다.

StridedCNN은 downsampling filter까지 학습한다.
Depthwise convolution은 채널별 공간 연산을, pointwise convolution은 채널 결합을 담당한다.
dilation은 parameter 수를 늘리지 않고 receptive field를 넓힌다.
전체 parameter는 convolution 하나의 효율보다 마지막 feature map과 Linear layer에서 더 크게 좌우될 수 있다.

결국 Conv2d를 이해하는 가장 확실한 방법도 shape를 끝까지 따라가는 것이었다. (B,C,H,W)가 어디서 어떻게 바뀌는지만 놓치지 않으면 Flatten → Linear의 입력 크기도 계산으로 확인할 수 있다.

이전 글: PyTorch 05 - MNIST 학습과 평가 루프 완성하기

참고

5. PyTorch 05 - MNIST 학습과 평가 루프 완성하기

Mon, 07 Sep 2026 09:40:00 +0900

들어가며

Dataset과 DataLoader를 만들고 나면 드디어 학습 루프가 나온다. 그런데 이쯤부터 코드 한 줄의 의미는 알면서도 전체 흐름을 놓치기 쉬웠다.

hidden_dim을 왜 인자로 받을까? 그냥 256이라고 쓰면 안 되나?
logits는 확률인가?
model.eval()만 호출하면 gradient도 꺼지나?
batch마다 나온 평균 loss를 왜 다시 batch 크기와 곱할까?

이번 글에서는 MNIST MLP의 입력부터 최종 평가까지를 텐서 shape와 상태 변화 두 축으로 따라간다.

한 줄 요약: 학습은 mini-batch마다 parameter를 바꾸는 과정이고, 평가는 parameter를 고정한 채 모든 샘플의 합계에서 loss와 accuracy를 계산하는 과정이다.

1. 두 개의 은닉층을 가진 MLP

class MLP2Layer(nn.Module):
    def __init__(self, hidden_dim_1=256, hidden_dim_2=256):
        super().__init__()

        self.fc1 = nn.Linear(28 * 28, hidden_dim_1)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_dim_1, hidden_dim_2)
        self.output = nn.Linear(hidden_dim_2, 10)

    def forward(self, x):
        x = torch.flatten(x, start_dim=1)
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        return self.output(x)

MNIST 배치 (B, 1, 28, 28)를 Linear layer에 넣기 위해 한 이미지의 채널·높이·너비를 펼친다.

x = torch.flatten(x, start_dim=1)

start_dim=1이 중요하다. 0번 축인 batch는 보존하고 나머지만 합친다.

\[(B,1,28,28)\rightarrow(B,784)\]

이후 shape 흐름은 다음과 같다.

단계	출력 shape
입력 이미지	`(B, 1, 28, 28)`
`flatten(start_dim=1)`	`(B, 784)`
`fc1 + ReLU`	`(B, 256)`
`fc2 + ReLU`	`(B, 256)`
`output`	`(B, 10)`

2. `hidden_dim`을 인자로 받는 이유

model = MLP2Layer(
    hidden_dim_1=256,
    hidden_dim_2=256,
).to(device)

256을 클래스 안에 직접 적어도 현재 모델은 동작한다. 인자로 받는 이유는 모델 구조와 실험 설정을 분리하기 위해서다.

small_model = MLP2Layer(128, 64)
wide_model = MLP2Layer(512, 512)

클래스 코드를 수정하지 않고도 모델 폭을 바꿀 수 있고, 설정값을 로그에 남기거나 하이퍼파라미터 실험을 자동화하기 쉽다. 기본값 =256이 있으므로 아무 인자도 주지 않으면 원래 구조가 유지된다.

저장된 모델의 parameter는 다음과 같다.

parameter	shape
`fc1.weight`	`(256, 784)`
`fc1.bias`	`(256,)`
`fc2.weight`	`(256, 256)`
`fc2.bias`	`(256,)`
`output.weight`	`(10, 256)`
`output.bias`	`(10,)`

총 학습 가능 parameter는 269,322개다.

3. logits와 CrossEntropyLoss

criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.AdamW(
    model.parameters(),
    lr=0.001,
)

모델 출력 (B, 10)의 각 값은 확률이 아니라 logit, 즉 클래스별 원시 점수다. 음수일 수도 있고 합이 1일 필요도 없다.

CrossEntropyLoss는 logits와 클래스 인덱스 target을 받는다.

입력 logits: (B, 10)의 floating-point tensor
정답 targets: (B,)의 integer tensor, 각 값은 0~9
출력 loss: 기본 평균 reduction이 적용된 scalar tensor

학습 전에 softmax를 직접 적용할 필요가 없다. CrossEntropyLoss가 내부에서 log-softmax와 negative log-likelihood에 해당하는 계산을 안정적으로 결합한다.

확률이 필요한 추론 단계에서만 다음처럼 변환한다.

probabilities = torch.softmax(logits, dim=1)
predictions = logits.argmax(dim=1)

argmax는 softmax 전후에 같은 클래스 인덱스를 반환하므로 예측 클래스만 필요할 때는 logits에 바로 호출할 수 있다.

4. mini-batch 학습 루프

history = {
    "train_loss": [],
    "train_acc": [],
    "test_loss": [],
    "test_acc": [],
}

for epoch in range(1, EPOCHS + 1):
    model.train()

    for images, targets in train_loader:
        images = images.to(
            device,
            non_blocking=(device.type == "cuda"),
        )
        targets = targets.to(
            device,
            non_blocking=(device.type == "cuda"),
        )

        optimizer.zero_grad(set_to_none=True)
        logits = model(images)
        loss = criterion(logits, targets)
        loss.backward()
        optimizer.step()

한 epoch에 60,000장을 모두 사용하지만 parameter update는 60,000장을 한 번에 본 뒤 일어나는 것이 아니다. batch size가 128이라면 대략 469개의 mini-batch마다 update가 한 번씩 일어난다.

데이터 이동 → gradient 초기화 → forward → loss → backward → update가 mini-batch마다 반복된다.

5. 평가 함수는 왜 따로 만들까?

def evaluate(model, data_loader, criterion, device):
    model.eval()

    total_loss = 0.0
    total_correct = 0
    total_samples = 0

    with torch.inference_mode():
        for images, targets in data_loader:
            images = images.to(device)
            targets = targets.to(device)

            logits = model(images)
            loss = criterion(logits, targets)
            predictions = logits.argmax(dim=1)

            batch_size = targets.size(0)
            total_loss += loss.item() * batch_size
            total_correct += (
                predictions == targets
            ).sum().item()
            total_samples += batch_size

    average_loss = total_loss / total_samples
    accuracy = total_correct / total_samples
    return average_loss, accuracy

평가에서는 parameter를 바꾸지 않는다. model.eval()로 layer 동작을 평가 모드로 바꾸고, torch.inference_mode()로 Autograd 기록도 끈다. 둘은 서로 다른 역할이라 함께 사용한다.

6. 평균 loss에 batch 크기를 다시 곱하는 이유

기본 CrossEntropyLoss는 현재 batch의 샘플 loss를 평균낸 값 하나를 반환한다. 모든 batch의 평균을 단순히 다시 평균내면 마지막 batch가 작을 때 각 샘플의 가중치가 달라진다.

예를 들어 전체 샘플 수가 batch size로 나누어떨어지지 않으면 마지막 batch에는 더 적은 샘플이 들어 있다. 그래서 batch 평균을 먼저 합계로 되돌린다.

total_loss += loss.item() * batch_size

모든 합계를 모은 뒤 전체 샘플 수로 나눈다.

average_loss = total_loss / total_samples

이렇게 해야 데이터셋 전체의 샘플당 평균 loss가 된다.

accuracy도 같은 원리로 맞은 개수를 먼저 더한다.

total_correct += (predictions == targets).sum().item()
accuracy = total_correct / total_samples

7. epoch 결과 기록하기

train_loss, train_acc = evaluate(
    model, train_eval_loader, criterion, device
)
test_loss, test_acc = evaluate(
    model, test_loader, criterion, device
)

history["train_loss"].append(train_loss)
history["train_acc"].append(train_acc)
history["test_loss"].append(test_loss)
history["test_acc"].append(test_acc)

저장된 5 epoch 실행 결과는 다음과 같았다.

Epoch	Train loss	Train acc	Test loss	Test acc
1	0.1481	95.75%	0.1515	95.38%
2	0.0780	97.61%	0.0948	96.91%
3	0.0581	98.17%	0.0911	97.14%
4	0.0403	98.76%	0.0776	97.56%
5	0.0335	98.91%	0.0801	97.37%

Train 성능은 마지막까지 좋아졌지만 Test loss와 accuracy는 4 epoch에서 가장 좋고 5 epoch에 소폭 나빠졌다. 한 번의 실행만으로 과적합을 단정할 수는 없지만, 훈련 성능만 보고 마지막 epoch를 무조건 선택하면 안 되는 신호는 확인할 수 있다.

8. 그래프로 확인할 때 생긴 실수

epoch_axis = np.arange(1, len(history["train_loss"]) + 1)

fig, axes = plt.subplots(1, 2, figsize=(12, 4))

axes[0].plot(
    epoch_axis,
    history["train_loss"],
    marker="o",
    label="Train Loss",
)
axes[0].plot(
    epoch_axis,
    history["test_loss"],
    marker="o",
    label="Test Loss",
)
axes[0].legend()

axes[1].plot(
    epoch_axis,
    np.array(history["train_acc"]) * 100,
    marker="o",
    label="Train Accuracy",
)
axes[1].plot(
    epoch_axis,
    np.array(history["test_acc"]) * 100,
    marker="o",
    label="Test Accuracy",
)
axes[1].legend()

plt.tight_layout()
plt.show()

실습 중에는 x축을 256개로 만들고 y값은 5개만 넣어 shape 오류가 났다. x축 길이는 hidden dimension이 아니라 기록한 epoch 수와 같아야 한다.

또 plt.subplots(1, 2)의 axes는 Axes 하나가 아니라 NumPy 배열이다. 따라서 axes.legend()가 아니라 axes[0].legend(), axes[1].legend()처럼 각 subplot에 호출해야 한다.

헷갈리기 쉬운 포인트

logits 10개는 클래스별 확률인가?

아니다. 서로 비교하기 위한 원시 점수다. 확률이 필요하면 softmax(logits, dim=1)을 적용한다.

평가할 때 왜 `model.eval()`과 `inference_mode()`를 둘 다 쓰나?

eval()은 Dropout·BatchNorm 같은 layer의 행동을 바꾸고, inference_mode()는 gradient 기록을 끈다. 하나가 다른 하나를 대신하지 않는다.

`hidden_dim=256`을 인자로 받는 것이 항상 더 좋은가?

한 번만 쓰는 고정 모델이라면 상수로 적어도 된다. 여러 구조를 비교하거나 설정을 재사용할 때 인자로 분리한 장점이 커진다. 중요한 건 숫자를 어디에 적느냐보다 layer 사이의 입력·출력 차원이 일치하도록 연결하는 것이다.

이미지 시각화에서 MNIST 평균과 표준편차를 왜 쓰나?

transform에 Normalize((0.1307,), (0.3081,))를 적용했을 때 원래 밝기로 되돌리기 위해 쓴다. 현재 실습처럼 ToTensor()만 사용했다면 역정규화 없이 바로 그려야 한다.

정리하며

MNIST 학습 코드를 한 문장으로 읽으면 다음과 같다.

DataLoader가 (B,1,28,28) 배치를 제공하고 → MLP가 (B,10) logits를 만들고 → CrossEntropyLoss가 scalar loss를 만들고 → backward가 gradient를 계산하고 → AdamW가 parameter를 바꾸며 → 평가 함수가 전체 샘플 기준 loss와 accuracy를 계산한다.

각 줄의 역할뿐 아니라 shape와 상태가 언제 바뀌는지 함께 보면 긴 학습 루프도 훨씬 덜 복잡해진다.

다음 글에서는 이미지의 공간 구조를 버리고 펼쳐버리는 MLP 대신, Conv2d로 공간 정보를 처리한다. Max Pooling을 strided convolution으로 바꾸는 모델과 depthwise·pointwise convolution을 분리한 모델까지 비교한다.

이전 글: PyTorch 04 - MNIST Dataset과 DataLoader 이해하기 · 다음 글: PyTorch 06 - Strided CNN과 Depthwise Separable CNN

참고

4. PyTorch 04 - MNIST Dataset과 DataLoader 이해하기

Mon, 07 Sep 2026 09:30:00 +0900

들어가며

XOR에서는 데이터 네 개를 직접 텐서로 만들었다. MNIST는 학습 이미지가 60,000장이니 같은 방식으로 관리하기 어렵다. 여기서 Dataset, DataLoader, transform이 한꺼번에 등장한다.

처음 코드를 읽으면서 가장 헷갈렸던 질문은 이것이었다.

train_dataset이 transform을 통해 텐서로 바뀌었는데, 반복문에서는 왜 다시 images라는 변수로 받아도 괜찮지? 그리고 흑백 이미지인데 shape의 채널은 왜 1이지?

답은 Dataset은 전체 데이터를 가진 객체이고, DataLoader가 거기서 꺼낸 텐서 배치를 원하는 변수 이름에 할당한다는 데 있다. 변수 이름은 데이터의 타입을 바꾸지 않는다.

1. Dataset과 transform의 역할

from torchvision import datasets, transforms

mnist_transform = transforms.ToTensor()

train_dataset = datasets.MNIST(
    root="./data",
    train=True,
    download=True,
    transform=mnist_transform,
)

test_dataset = datasets.MNIST(
    root="./data",
    train=False,
    download=True,
    transform=mnist_transform,
)

datasets.MNIST는 이미지와 정답을 보관하고, 인덱스로 샘플을 꺼내는 방법을 정의한 Dataset 객체다.

image, target = train_dataset[0]

print(image.shape)   # torch.Size([1, 28, 28])
print(image.dtype)   # torch.float32
print(type(target))  # int

transform=ToTensor()는 샘플을 꺼내는 순간 PIL 이미지 또는 NumPy 배열을 PyTorch 텐서로 변환한다. 일반적인 8-bit 이미지라면 픽셀값도 0~255 정수에서 0~1 범위의 float32로 바뀐다.

Dataset 자체가 거대한 텐서 한 장으로 변하는 것은 아니다. Dataset이 샘플을 반환할 때 적용할 변환 규칙을 가진다고 보는 편이 정확하다.

2. 흑백 이미지의 채널은 왜 1인가

MNIST 이미지 한 장의 shape은 (1, 28, 28)이다.

축	크기	의미
`C`	1	채널 수
`H`	28	세로 픽셀 수
`W`	28	가로 픽셀 수

흑백에 검정과 흰색 두 상태가 있으니 채널이 2일 것 같았지만, 채널 수는 가능한 색의 개수가 아니다. 흑백 이미지는 각 픽셀의 밝기 값 하나만 있으면 표현할 수 있어 채널이 1개다. 중간 회색까지 포함해도 한 채널의 숫자 크기로 나타낸다.

RGB 이미지는 한 픽셀을 빨강·초록·파랑 값 세 개로 표현하므로 채널이 3개다.

(1, 28, 28)의 1은 “흑백 클래스가 하나”라는 뜻이 아니라 픽셀마다 읽을 feature plane이 밝기 하나라는 뜻이다.

3. DataLoader는 무엇을 더하는가

Dataset이 샘플 하나를 꺼내는 규칙이라면, DataLoader는 여러 샘플을 모아 mini-batch로 공급한다.

from torch.utils.data import DataLoader

BATCH_SIZE = 128

train_loader = DataLoader(
    train_dataset,
    batch_size=BATCH_SIZE,
    shuffle=True,
)

images, targets = next(iter(train_loader))

print(images.shape)   # torch.Size([128, 1, 28, 28])
print(targets.shape)  # torch.Size([128])

iter(train_loader)는 배치를 차례로 꺼내는 iterator를 만들고, next(...)는 그중 첫 배치를 반환한다. 반환값 (images, targets)를 두 변수로 unpacking한 것이다.

images라는 이름 때문에 이미지 객체로 되돌아간 것이 아니다. 변수 이름은 마음대로 정할 수 있고, 실제 값은 이미 transform을 거친 torch.Tensor다.

4. 배치 shape `(B, 1, 28, 28)` 읽기

DataLoader는 샘플 128개의 이미지 텐서를 새로운 batch 축에 쌓는다.

\[(1,28,28)\times128\ \text{samples} \longrightarrow (128,1,28,28)\]

일반적으로 이미지 배치는 (B, C, H, W) 순서를 사용한다.

B: 한 번에 모델로 보내는 샘플 수
C: 이미지 채널 수
H, W: 높이와 너비

target은 이미지마다 숫자 정답 하나이므로 (B,), 즉 (128,)이다. 10개 클래스라고 해서 target shape이 (128, 10)인 것은 아니다. CrossEntropyLoss는 각 샘플의 클래스 인덱스 하나를 정답으로 받는다.

5. 학습용 loader와 평가용 loader를 나누는 이유

실습 코드에서는 같은 train Dataset으로 두 loader를 만들었다.

train_loader = DataLoader(
    train_dataset,
    batch_size=128,
    shuffle=True,
)

train_eval_loader = DataLoader(
    train_dataset,
    batch_size=128,
    shuffle=False,
)

test_loader = DataLoader(
    test_dataset,
    batch_size=128,
    shuffle=False,
)

train_loader는 학습할 때 매 epoch 샘플 순서를 섞는다. 모델이 우연한 데이터 순서에 의존하는 것을 줄이고 mini-batch 구성을 바꾼다.

train_eval_loader는 학습 데이터 전체의 loss와 accuracy를 일정한 순서로 측정한다. 평가 값 자체는 순서와 무관하지만, 섞을 필요가 없다는 의도가 분명해지고 결과를 재현하기 쉽다. test_loader도 같은 이유로 shuffle=False를 사용한다.

6. shuffle도 재현하려면 Generator가 필요하다

SEED = 42

random.seed(SEED)
np.random.seed(SEED)
torch.manual_seed(SEED)

if torch.cuda.is_available():
    torch.cuda.manual_seed_all(SEED)

train_generator = torch.Generator()
train_generator.manual_seed(SEED)

train_loader = DataLoader(
    train_dataset,
    batch_size=128,
    shuffle=True,
    generator=train_generator,
)

모델 초기 가중치만 고정해도 완전한 재현이 되지는 않는다. shuffle=True가 만드는 샘플 순서도 학습 결과에 영향을 주므로 DataLoader가 사용할 난수 생성기를 함께 고정한다.

CUDA의 완전한 결정론은 사용 연산과 환경에 따라 추가 설정이 필요하고 성능이 느려질 수도 있다. seed를 적었다고 모든 환경에서 bit 단위로 같은 결과가 보장되는 것은 아니라는 점도 기억해야 한다.

7. `num_workers`, `pin_memory`, `non_blocking`

GPU 학습 예제에서 자주 보이는 옵션들이다.

use_pin_memory = device.type == "cuda"

train_loader = DataLoader(
    train_dataset,
    batch_size=128,
    shuffle=True,
    num_workers=2,
    pin_memory=use_pin_memory,
    generator=train_generator,
)

옵션	역할
`num_workers`	Dataset에서 샘플을 읽고 transform하는 별도 worker process 수
`pin_memory=True`	CPU batch를 page-locked memory에 준비해 CUDA 전송을 효율화
`non_blocking=True`	조건이 맞으면 CPU→GPU 복사를 비동기적으로 요청

images = images.to(
    device,
    non_blocking=(device.type == "cuda"),
)

worker 수가 많다고 항상 빠른 것은 아니다. CPU core 수, 저장장치, transform 비용, 운영체제에 따라 적정값이 다르다. 노트북 환경에서 worker 생성이 멈추거나 느리다면 0 또는 2부터 확인하는 편이 안전하다.

8. 모델에 넣기 전에 shape 확인하기

학습을 시작하기 전에 배치 하나를 통과시켜 보면 shape 오류를 빠르게 발견할 수 있다.

check_images, check_targets = next(iter(train_eval_loader))
check_images_device = check_images.to(device)

model.eval()

with torch.inference_mode():
    check_logits = model(check_images_device)

print("Input shape :", check_images.shape)
print("Logits shape:", check_logits.shape)
print("Target shape:", check_targets.shape)

저장된 실습 결과는 다음과 같았다.

Input shape : torch.Size([128, 1, 28, 28])
Logits shape: torch.Size([128, 10])
Target shape: torch.Size([128])

이미지 128장이 들어가고, 각 이미지마다 숫자 0~9의 점수 10개가 나온다. 정답은 이미지마다 클래스 인덱스 하나다.

헷갈리기 쉬운 포인트

`images`로 받으면 tensor가 이미지 타입으로 바뀌나?

아니다. images는 변수 이름일 뿐이고, 값은 torch.Tensor다. batch_images나 x라고 이름을 바꿔도 동작은 같다.

Dataset에 transform을 넣으면 전체 60,000장이 즉시 변환되나?

일반적인 torchvision Dataset에서는 샘플을 dataset[index]로 꺼낼 때 transform이 적용된다. DataLoader는 필요한 인덱스의 샘플을 불러와 batch로 묶는다.

`ToTensor()`를 썼는데 MNIST 평균·표준편차로 다시 복원해야 하나?

ToTensor()만 사용했다면 이미지는 단순히 0~1 범위로 변환됐으므로 그대로 시각화하면 된다.

image = images[0].squeeze(0)
plt.imshow(image.numpy(), cmap="gray")

Normalize((0.1307,), (0.3081,))까지 적용했을 때만 image * 0.3081 + 0.1307로 역정규화한다. 실습 코드처럼 ToTensor()만 적용한 뒤 역정규화를 한 번 더 하면 픽셀값이 달라진다.

정리하며

MNIST 데이터 흐름은 다음과 같다.

원본 이미지 → Dataset이 인덱스로 샘플 선택 → transform이 (1,28,28) 텐서 생성 → DataLoader가 128개를 (128,1,28,28)로 묶음 → 학습 루프가 images, targets로 unpacking → device로 이동

이제 for images, targets in train_loader: 한 줄 안에서 무엇이 나오는지 알 수 있다. 다음 글에서는 이 배치가 MLP를 통과하고, loss와 accuracy가 계산되는 전체 학습·평가 루프를 이어서 본다.

이전 글: PyTorch 03 - backward부터 detach까지, Autograd 흐름 읽기 · 다음 글: PyTorch 05 - MNIST 학습과 평가 루프 완성하기

참고

3. PyTorch 03 - backward부터 detach까지, Autograd 흐름 읽기

Mon, 07 Sep 2026 09:20:00 +0900

들어가며

XOR 모델을 만들고 나니 더 큰 의문이 생겼다.

loss.backward()에는 모델을 전달하지 않는데, 어떻게 hidden layer와 output layer의 가중치를 전부 찾아가서 gradient를 계산하지?

처음에는 Python 코드가 위에서 아래로 실행되니 각 줄은 계산이 끝난 숫자만 다음 줄에 넘긴다고 생각했다. 하지만 PyTorch 텐서는 값만 저장하지 않는다. gradient가 필요한 연산에서는 그 값이 어떤 연산을 거쳐 만들어졌는지도 계산 그래프로 연결한다.

이 글은 XOR 학습 루프를 기준으로 zero_grad → forward → loss → backward → step을 따라가며 Autograd의 역할을 정리한 기록이다.

1. 학습 루프 전체부터 보기

for epoch in range(1, 2001):
    model.train()

    optimizer.zero_grad()
    logits = model(X)
    loss = criterion(logits, y)
    loss.backward()
    optimizer.step()

다섯 줄의 역할은 명확히 분리되어 있다.

단계	코드	일어나는 일
1	`zero_grad()`	이전 step에서 parameter의 `.grad`에 누적된 gradient 제거
2	`model(X)`	현재 parameter로 logits 계산, 계산 그래프 생성
3	`criterion(logits, y)`	logits에서 scalar loss까지 그래프 연결
4	`loss.backward()`	그래프를 역방향으로 따라 parameter의 `.grad` 계산
5	`optimizer.step()`	`.grad`를 읽어 parameter 값 갱신

backward()가 gradient를 계산하고, step()이 그 gradient를 사용해 실제 parameter를 바꾼다. 둘을 한 동작으로 생각하면 학습 코드가 자꾸 헷갈린다.

2. `loss.backward()`는 모델을 어떻게 아는가

forward 과정은 다음처럼 연결되어 있다.

\[X \rightarrow \text{Linear}_1 \rightarrow \tanh \rightarrow \text{Linear}_2 \rightarrow \text{logits} \rightarrow \text{BCEWithLogitsLoss} \rightarrow \text{loss}\]

logits = model(X)가 실행될 때, logits 텐서에는 output layer의 연산이 연결된다. 다시 output layer의 입력은 Tanh 결과와 연결되고, Tanh 결과는 hidden layer와 연결된다. 마지막에 만든 loss에서 출발해 이 연결을 거꾸로 따라가면 모든 parameter에 도달한다.

loss.backward()

그래서 backward()에 모델을 다시 전달할 필요가 없다. loss가 이미 모델의 연산 그래프 끝에 있기 때문이다.

loss.backward()는 “이 모델을 미분해”라는 명령이 아니라 “이 loss가 만들어진 경로를 역추적해, 도달 가능한 leaf parameter들의 gradient를 계산해”라는 명령에 가깝다.

3. gradient는 어디에 저장될까?

backward()가 parameter 값을 직접 바꾸지는 않는다. 각 parameter의 .grad 속성에 미분값을 저장한다.

loss.backward()

print(model.hidden.weight.grad.shape)  # (4, 2)
print(model.output.weight.grad.shape)  # (1, 4)

gradient의 shape은 해당 parameter와 같다. optimizer는 생성될 때 받은 parameter들을 기억하고 있다.

optimizer = torch.optim.Adam(model.parameters(), lr=0.05)

따라서 optimizer.step()은 등록된 각 parameter의 .grad를 읽어 Adam 규칙으로 값을 갱신할 수 있다.

4. 왜 매번 `zero_grad()`를 호출할까?

PyTorch는 backward()를 호출할 때 기존 .grad를 덮어쓰지 않고 더한다.

optimizer.zero_grad()
loss.backward()
optimizer.step()

이 누적 방식은 여러 mini-batch의 gradient를 모으는 gradient accumulation에서 유용하다. 하지만 일반적인 학습 루프에서는 지난 step의 gradient가 섞이면 안 되므로 forward 전에 초기화한다.

zero_grad(set_to_none=True)를 쓰면 0으로 채운 텐서를 유지하는 대신 .grad를 None으로 돌려 메모리 작업을 줄일 수 있다. 다음 backward()에서 필요한 gradient가 새로 생성된다.

5. `detach()`는 무엇을 끊는가

학습 도중 parameter 값을 기록한다고 하자.

snapshot = parameter.detach()

detach()는 현재 텐서와 같은 값을 바라보지만, 반환된 텐서를 기존 계산 그래프에서 분리한다. 이 텐서를 사용한 이후 연산은 원래 parameter 쪽으로 gradient를 보내지 않는다.

하지만 한 가지 함정이 있다. detach() 결과는 원본과 storage를 공유한다. optimizer가 원본 parameter를 갱신하면 “과거 값을 저장했다”고 생각한 snapshot도 함께 달라질 수 있다.

그래서 독립적인 과거 값을 보관하려면 clone()까지 필요하다.

previous_params = [
    parameter.detach().clone()
    for parameter in model.parameters()
]

표현	그래프 연결	원본과 storage 공유	과거 값 보관에 적합
`parameter`	O	원본	X
`parameter.detach()`	X	O	X
`parameter.clone()`	O	X	X
`parameter.detach().clone()`	X	X	O

clone()을 먼저 하고 detach()해도 최종 결과는 그래프에서 분리된 독립 복사본이지만, detach().clone()이 “그래프를 끊고 값을 복사한다”는 의도를 읽기 쉽다.

6. `no_grad()`와 `detach()`의 차이

detach()는 특정 텐서 하나를 그래프에서 분리한다. torch.no_grad()는 context 안에서 실행되는 연산 전체에 대해 gradient 기록을 끈다.

with torch.no_grad():
    squared_change = sum(
        ((parameter - previous) ** 2).sum()
        for parameter, previous in zip(
            model.parameters(), previous_params
        )
    )

    delta_history.append(torch.sqrt(squared_change).item())

가중치 변화량은 학습을 관찰하기 위한 통계일 뿐, 다음 loss를 만드는 데 쓰이지 않는다. 이 계산까지 그래프에 기록하면 메모리와 계산을 낭비한다.

with는 이 설정을 해당 블록에만 임시로 적용하는 Python context manager 문법이다. 블록을 빠져나오면 gradient 기록 설정은 원래대로 돌아온다.

7. gradient가 흐르는 경로와 막히는 경로

XOR 코드의 변수들을 기준으로 정리하면 다음과 같다.

대상	loss에서 도달 가능?	이유
`output.weight`, `output.bias`	reachable	logits를 직접 만드는 parameter
`hidden.weight`, `hidden.bias`	reachable	Tanh와 output layer를 거쳐 loss에 연결
`previous_params`	blocked by `detach`	관찰용 복사본이며 그래프에서 분리
`delta_history` 계산	blocked by `no_grad`	parameter 변화량 기록용
`loss.item()` 결과	not involved	Python 숫자로 꺼내 기록만 함
`prediction = probability >= 0.5`	not involved	평가용 이산 예측, 학습 loss에 사용하지 않음

학습에 필요한 경로는 loss까지 끊기지 않고 이어져야 한다. 반대로 로그·그래프·평가를 위한 계산은 의도적으로 그래프 밖에서 수행한다.

8. 실제 변화량을 기록해보니

실습에서는 매 epoch 이후 현재 parameter와 직전 parameter 사이의 L2 거리를 계산했다.

\[\|\theta_t-\theta_{t-1}\|_2 =\sqrt{\sum_i(\theta_{t,i}-\theta_{t-1,i})^2}\]

저장된 실행 결과 일부는 다음과 같다.

Epoch	Loss	parameter 변화량
1	0.75977838	0.20615497
10	0.67387134	0.12946829
100	0.02529514	0.02763611
500	0.00228525	0.00497251
1000	0.00076190	0.00263150
2000	0.00022706	0.00149049

loss가 줄어드는 동안 parameter 변화량도 함께 작아졌다. “학습이 안정된다”는 말을 막연하게 쓰는 대신, 실제 update 크기를 기록해 확인한 셈이다.

헷갈리기 쉬운 포인트

학습 중간에 `loss.detach()`를 하면 어떻게 될까?

detached_loss = loss.detach()
detached_loss.backward()

detached_loss는 계산 그래프와 끊어져 있고 requires_grad=False이므로 정상적인 역전파를 할 수 없다. 숫자 기록은 loss.item()이나 loss.detach()로 해도 되지만, backward()는 연결된 원래 loss에 호출해야 한다.

`model.eval()`이 gradient를 꺼주나?

아니다. eval()은 Dropout과 BatchNorm 같은 layer의 동작 모드를 바꾼다. gradient 기록을 끄려면 torch.no_grad() 또는 torch.inference_mode()가 별도로 필요하다.

`torch.inference_mode()`는 `no_grad()`와 같은가?

둘 다 평가 시 gradient 기록을 막는다. inference_mode()는 추론 전용으로 더 많은 Autograd 추적을 비활성화해 추가 최적화가 가능하지만, 그 안에서 만든 텐서를 이후 gradient 계산에 섞는 용도에는 제약이 더 크다. 순수 평가라면 inference_mode()가 의도를 잘 드러낸다.

정리하며

학습 루프는 한 덩어리의 마법이 아니었다.

forward가 그래프를 만들고 → loss가 그래프의 끝이 되고 → backward가 gradient를 .grad에 저장하고 → optimizer가 parameter를 갱신한다.

그리고 detach, clone, no_grad는 모두 “값을 보관하거나 관찰하되 학습 그래프에는 넣지 않기 위한 도구”였다. 셋의 역할을 구분하고 나니 왜 학습 코드와 기록 코드가 다른 방식으로 작성되는지 이해할 수 있었다.

다음 글에서는 작은 XOR 텐서에서 벗어나 MNIST 60,000장을 Dataset과 DataLoader로 공급하는 과정을 따라간다.

이전 글: PyTorch 02 - XOR로 이해하는 신경망 구조와 순전파 · 다음 글: PyTorch 04 - MNIST Dataset과 DataLoader 이해하기

2. PyTorch 02 - XOR로 이해하는 신경망 구조와 순전파

Mon, 07 Sep 2026 09:10:00 +0900

들어가며

PyTorch 예제는 흔히 class Model(nn.Module)로 시작한다. 처음에는 클래스를 왜 만들어야 하는지도 낯설었고, nn.Linear(2, 4)를 보고 입력이 4개인데 왜 weight가 (4, 2)인지도 헷갈렸다.

XOR은 이 질문들을 확인하기 좋은 작은 문제다. 데이터는 네 개뿐이지만 직선 하나로 분리할 수 없어서 은닉층과 비선형 활성화 함수가 꼭 필요하다.

한 줄 요약: XOR의 네 샘플을 한 번에 넣으면 Linear(2,4)가 각 샘플의 feature 2개를 은닉 feature 4개로 바꾸고, Tanh가 선형 모델로는 만들 수 없는 결정경계를 만든다.

1. XOR은 왜 직선 하나로 풀리지 않을까?

X = torch.tensor(
    [[0, 0],
     [1, 0],
     [0, 1],
     [1, 1]],
    dtype=torch.float32,
    device=device,
)

y = torch.tensor(
    [0, 1, 1, 0],
    dtype=torch.float32,
    device=device,
).reshape(-1, 1)

입력	정답
`(0, 0)`	0
`(1, 0)`	1
`(0, 1)`	1
`(1, 1)`	0

대각선으로 마주 보는 두 점끼리 같은 클래스다. 아무리 직선을 움직여도 한쪽에 0 두 개, 반대쪽에 1 두 개만 남길 수 없다. 그래서 입력을 새로운 feature 공간으로 옮긴 뒤 그 공간에서 분리해야 한다.

2. `nn.Module`로 모델 만들기

import torch.nn as nn


class XOR(nn.Module):
    def __init__(self):
        super().__init__()
        self.hidden = nn.Linear(2, 4)
        self.output = nn.Linear(4, 1)

    def forward(self, x):
        hidden_output = torch.tanh(self.hidden(x))
        logits = self.output(hidden_output)
        return logits


model = XOR().to(device)

nn.Module은 PyTorch 모델의 기본 클래스다. 이를 상속하면 내부에 등록한 layer와 parameter를 PyTorch가 추적할 수 있다.

super().__init__()은 부모인 nn.Module의 초기화를 실행한다. 이 호출이 있어야 self.hidden, self.output에 넣는 layer들이 하위 모듈로 정상 등록되고, 이후 model.parameters(), model.to(device), state_dict() 같은 기능이 작동한다.

3. `nn.Linear(2, 4)`가 만드는 것

nn.Linear(in_features=2, out_features=4)는 다음 연산을 수행한다.

\[h=XW^\top+b\]

PyTorch가 저장하는 parameter shape은 다음과 같다.

parameter	shape	의미
`hidden.weight`	`(4, 2)`	은닉 unit 4개가 각각 입력 feature 2개를 읽음
`hidden.bias`	`(4,)`	은닉 unit마다 bias 하나
`output.weight`	`(1, 4)`	출력 unit 1개가 은닉 feature 4개를 읽음
`output.bias`	`(1,)`	출력 unit의 bias

입력 배치 X가 (4, 2)인 이유는 샘플 4개 × 샘플당 feature 2개이기 때문이다. 여기서 앞의 4와 hidden.weight 앞의 4는 같은 숫자지만 의미가 전혀 다르다.

\[(4,2)@(2,4)+(4,)=(4,4)\]

첫 번째 4: batch에 들어 있는 샘플 수
두 번째 4: 각 샘플에서 만들어낸 은닉 feature 수

그래서 hidden.weight가 (4, 4)일 필요는 없다. batch 크기는 parameter의 shape을 결정하지 않는다.

4. `forward`를 shape로 읽기

def forward(self, x):
    hidden_output = torch.tanh(self.hidden(x))
    logits = self.output(hidden_output)
    return logits

단계	shape
입력 `x`	`(4, 2)`
`self.hidden(x)`	`(4, 4)`
`torch.tanh(...)`	`(4, 4)`
`self.output(...)`	`(4, 1)`
반환 `logits`	`(4, 1)`

모델 인스턴스를 model(X)처럼 호출하면 PyTorch의 nn.Module.__call__()이 내부에서 forward(X)를 실행한다. 사용자가 직접 model.forward(X)를 호출할 수도 있지만, hook과 같은 nn.Module 기능이 적용되는 model(X) 방식이 일반적이다.

5. Tanh가 필요한 이유

은닉층 두 개를 쌓았더라도 사이에 활성화 함수가 없다면 전체는 여전히 하나의 선형변환이다.

\[W_2(W_1X+b_1)+b_2=(W_2W_1)X+(W_2b_1+b_2)\]

층을 여러 개 둔 의미가 사라진다. torch.tanh는 원소별 비선형 변환을 넣어 입력을 휘어진 feature 공간으로 보낸다. 그 결과 출력층의 직선 하나가 원래 입력 공간에서는 XOR을 가르는 비선형 경계가 된다.

“은닉층이 있어서 XOR을 푼다”보다 “은닉층 사이에 비선형성이 있어서 XOR을 푼다”가 더 정확한 표현이다.

6. 왜 출력에 Sigmoid가 없을까?

모델은 마지막 layer의 원시 점수인 logits를 그대로 반환한다.

criterion = nn.BCEWithLogitsLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.05)

BCEWithLogitsLoss는 Sigmoid와 Binary Cross Entropy를 하나로 합친 손실함수다. 모델 안에서 Sigmoid를 먼저 적용한 뒤 이 손실에 넣으면 Sigmoid를 두 번 적용하는 셈이 된다.

학습할 때는 logits를 손실함수에 바로 넣고, 확률이 필요한 평가 단계에서만 Sigmoid를 적용한다.

model.eval()

with torch.inference_mode():
    logits = model(X)
    probability = torch.sigmoid(logits)
    prediction = (probability >= 0.5).to(torch.int64)

값	shape	범위·의미
`logits`	`(4, 1)`	제한 없는 원시 점수
`probability`	`(4, 1)`	0~1 사이 클래스 1 확률
`prediction`	`(4, 1)`	0 또는 1
`loss`	`()`	기본 `reduction="mean"`으로 평균낸 스칼라

여기서 loss의 shape이 (4, 1)이라고 생각하기 쉽다. 개별 원소의 손실은 네 개지만, 기본 설정에서 평균을 내므로 최종 loss는 0차원 스칼라 텐서다.

7. 실제 학습 결과

2000 epoch 학습한 노트북에서는 다음 결과가 저장되었다.

Input         Target     Probability     Prediction
[0, 0]             0       0.000003             0
[1, 0]             1       0.999754             1
[0, 1]             1       0.999753             1
[1, 1]             0       0.000412             0

Accuracy: 100.00%

출력 확률이 네 점을 모두 정확히 구분했다. 중요한 건 이 결과를 외운 것이 아니라, 입력 (4,2)가 은닉 표현 (4,4)를 거쳐 logits (4,1)로 바뀌는 과정을 읽을 수 있게 된 것이다.

헷갈리기 쉬운 포인트

`in_features`, `out_features`를 안 써도 되나?

nn.Linear(2, 4)
nn.Linear(in_features=2, out_features=4)

두 코드는 같다. 앞의 코드는 위치 인자로 전달하고, 뒤의 코드는 키워드 인자로 전달한다. 처음 구조를 읽을 때는 키워드를 쓰면 의미가 더 분명하다.

흑백 분류라 출력이 두 개여야 하나?

XOR은 이진분류이므로 logit 하나만 출력해도 된다. Sigmoid를 통과한 값 하나가 클래스 1일 확률이고, 클래스 0의 확률은 1 - p다. 서로 배타적인 두 클래스에 logits 두 개와 CrossEntropyLoss를 쓰는 방식도 가능하지만, 현재 코드는 logit 하나와 BCEWithLogitsLoss를 택했다.

`model.train()`과 `model.eval()`이 XOR에서도 결과를 바꾸나?

현재 모델에는 Dropout이나 BatchNorm이 없어서 두 모드의 forward 계산은 같다. 그래도 학습·평가 단계의 의도를 명시하고, 나중에 그런 layer가 추가됐을 때 코드가 올바르게 동작하도록 모드를 전환한다.

정리하며

XOR 모델은 작지만 PyTorch 모델의 기본 골격을 모두 갖고 있다.

nn.Module 상속 → __init__에서 layer 등록 → forward에서 데이터 흐름 정의 → logits 반환 → 손실함수로 학습 → 평가에서 확률로 변환

다음 글에서는 이 모델이 어떻게 스스로 가중치를 바꾸는지 살펴본다. 특히 loss.backward()에 모델을 전달하지 않았는데도 어떻게 모든 layer의 gradient를 찾는지, detach()와 no_grad()는 왜 필요한지 정리한다.

이전 글: PyTorch 01 - 텐서로 선형회귀를 직접 풀어보기 · 다음 글: PyTorch 03 - backward부터 detach까지, Autograd 흐름 읽기

1. PyTorch 01 - 텐서로 선형회귀를 직접 풀어보기

Mon, 07 Sep 2026 09:00:00 +0900

들어가며

PyTorch를 처음 보면 torch.tensor, reshape, cat, item처럼 짧은 메소드가 계속 등장한다. 각각의 정의는 금방 찾을 수 있었지만, 정작 코드를 읽을 때는 왜 여기서 텐서 모양을 바꾸고, 왜 1로 채운 열을 붙이는지가 잘 이어지지 않았다.

이번 실습에서는 신경망부터 만들지 않고, 10개의 점에 가장 잘 맞는 직선을 최소제곱법으로 구했다. 덕분에 PyTorch 코드의 기본 문법이 결국 하나의 행렬식으로 모이는 과정을 볼 수 있었다.

한 줄 요약: 입력 벡터를 설계행렬 $X=[1,x]$로 만들면, torch.linalg.lstsq와 행렬곱만으로 선형회귀를 구현할 수 있다.

1. 데이터를 열벡터로 만들기

먼저 10개의 $x$, $y$ 값을 GPU의 float64 텐서로 만든다.

import torch

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

x = torch.tensor(
    [0.8147, 0.9058, 0.1270, 0.9134, 0.6324,
     0.0975, 0.2785, 0.5469, 0.9575, 0.9649],
    dtype=torch.float64,
    device=device,
).reshape(-1, 1)

y = torch.tensor(
    [0.8576, 0.9706, 0.2572, 0.8854, 0.8003,
     0.1419, 0.4218, 0.9157, 0.7922, 0.9595],
    dtype=torch.float64,
    device=device,
).reshape(-1, 1)

torch.tensor()에는 행이나 열을 정하는 dim 인자가 없다. 먼저 데이터로 1차원 텐서를 만든 뒤 reshape(-1, 1)로 열벡터를 만든다.

코드	shape	의미
`torch.tensor([...])`	`(10,)`	원소 10개인 1차원 텐서
`.reshape(-1, 1)`	`(10, 1)`	10행 1열의 열벡터

여기서 -1은 “이 축의 크기는 전체 원소 수에 맞춰 자동으로 계산해 달라”는 뜻이다. 열을 1개로 고정했으므로 행은 자동으로 10이 된다.

2. 왜 1로 채운 열을 붙일까?

구하려는 직선은 다음과 같다.

\[\hat y = b + wx\]

모든 샘플을 한 번에 계산하려면 이를 행렬곱으로 바꿔야 한다.

\[\begin{bmatrix} \hat y_1 \\ \hat y_2 \\ \vdots \\ \hat y_{10} \end{bmatrix} = \begin{bmatrix} 1 & x_1 \\ 1 & x_2 \\ \vdots & \vdots \\ 1 & x_{10} \end{bmatrix} \begin{bmatrix} b \\ w \end{bmatrix}\]

첫 번째 열의 1이 절편 $b$와 곱해지고, 두 번째 열의 $x$가 기울기 $w$와 곱해진다. 코드에서는 ones_like와 cat으로 이 설계행렬을 만든다.

X = torch.cat([torch.ones_like(x), x], dim=1)

torch.ones_like(x)는 x와 shape, dtype, device가 같은 1 텐서를 만든다.
dim=1은 두 텐서를 열 방향으로 붙인다.
따라서 X.shape은 (10, 2)가 된다.

처음에는 feat = [ones, x] 같은 리스트만으로도 계산할 수 있을 것 같았다. 하지만 리스트는 텐서 두 개를 담은 Python 컨테이너일 뿐이다. lstsq에 넣으려면 열들이 결합된 하나의 2차원 텐서가 필요하다.

3. 최소제곱해 구하기

관측값이 직선 위에 정확히 놓이지 않으므로 $X\theta=y$를 완벽하게 만족하는 해는 없다. 대신 잔차 제곱합을 가장 작게 만드는 $ heta=[b,w]^\top$를 구한다.

\[\theta^*=\underset{\theta}{\arg\min}\;\|X\theta-y\|_2^2\]

weight = torch.linalg.lstsq(X, y).solution

intercept = weight[0].item()
slope = weight[1].item()
y_pred = X @ weight

shape만 따라가도 연산이 보인다.

\[(10,2)@(2,1)=(10,1)\]

weight는 (2, 1) 텐서이고, 첫 번째 원소가 절편, 두 번째 원소가 기울기다. X @ weight는 10개 입력의 예측값을 한 번에 계산한다.

lstsq가 차원을 알아서 만들어준다고 생각하기보다, 입력 X의 열 개수가 구해야 할 계수의 개수를 결정한다고 이해하는 편이 정확하다.

4. `item()`은 언제 쓰는가

weight[0]
# tensor([0.1941], device='cuda:0', dtype=torch.float64)

weight[0].item()
# 0.194080159812...

weight[0]은 원소가 하나여도 여전히 텐서다. .item()은 원소가 하나인 텐서를 Python 숫자로 바꾼다. 출력 문자열에 넣거나 일반 Python 값이 필요한 순간에 유용하다.

반대로 이후 계산을 계속 PyTorch에서 수행한다면 굳이 일찍 item()을 호출할 필요가 없다. 텐서에서 Python 숫자로 나오는 순간 autograd 연결과 device 정보도 함께 사라지기 때문이다.

5. 예측 결과 평가하기

실습에서는 RMSE와 결정계수 $R^2$도 텐서 연산으로 직접 계산했다.

rmse = torch.sqrt(torch.mean((y - y_pred) ** 2)).item()

ss_res = torch.sum((y - y_pred) ** 2)
ss_tot = torch.sum((y - torch.mean(y)) ** 2)
r2 = (1 - ss_res / ss_tot).item()

print(f"회귀식: y = {slope:.6f}x {intercept:+.6f}")
print(f"R2 = {r2:.6f}")
print(f"RMSE = {rmse:.6f}")

저장된 노트북의 실행 결과는 다음과 같았다.

회귀식: y = 0.811304x +0.194080
R2 = 0.833847
RMSE = 0.118827

6. 다항회귀로 확장해보니

직선의 설계행렬이 [1, x]였다면 $d$차 다항회귀는 [1, x, x², ..., xᵈ]로 확장하면 된다.

def make_poly_features(input_x, degree):
    features = [torch.ones_like(input_x)]

    for power in range(1, degree + 1):
        features.append(input_x ** power)

    return torch.cat(features, dim=1)


def fit_poly(input_x, target, degree):
    X_poly = make_poly_features(input_x, degree)
    return torch.linalg.lstsq(X_poly, target).solution

차수가 $d$이면 설계행렬은 (10, d+1), 가중치는 (d+1, 1)이다. 이 실험에서 차수를 1부터 8까지 높이자 훈련 RMSE는 계속 줄었지만, LOOCV RMSE는 2차 이후 다시 커졌다.

차수	Train RMSE	LOOCV RMSE
1	0.118827	0.144755
2	0.066986	0.097774
4	0.063891	0.162496
6	0.052451	0.357053
8	0.002012	23.941179

8차식은 훈련점 10개를 거의 완벽하게 통과하지만, 한 점을 빼고 다시 맞추면 오차가 폭발했다. 훈련 오차가 작다는 사실만으로 좋은 모델이라고 말할 수 없는 이유가 숫자로 드러난다.

헷갈리기 쉬운 포인트

`torch.tensor([...], dim=1)`로 열벡터를 만들 수 있나?

그렇게 쓸 수 없다. torch.tensor는 데이터를 받아 텐서를 생성하고, 축 모양은 reshape, unsqueeze 등으로 바꾼다.

`weight`의 크기는 PyTorch가 임의로 정하나?

X가 (N, P), y가 (N, K)라면 해의 shape은 (P, K)다. 이 실습에서는 입력 열이 [1, x] 두 개이므로 계수도 절편과 기울기 두 개다.

CUDA 텐서를 바로 Matplotlib에 넣어도 되나?

Matplotlib은 CUDA 텐서를 직접 처리하지 못한다. 그래프를 그릴 때만 다음처럼 CPU의 NumPy 배열로 옮긴다.

x_plot = x.detach().cpu().squeeze(1).numpy()

정리하며

이번 실습에서 가장 중요했던 것은 메소드 이름보다 shape였다.

열벡터 (10,1) → 1열을 붙인 설계행렬 (10,2) → 최소제곱 계수 (2,1) → 행렬곱으로 예측 (10,1)

이 흐름이 보이기 시작하면 reshape, cat, ones_like, lstsq, @, item()이 따로 놀지 않는다. 모두 $X\theta=\hat y$를 코드로 옮기기 위한 단계였다.

다음 글에서는 선형 경계 하나로 풀 수 없는 XOR 문제를 nn.Module로 구현한다.

다음 글: PyTorch 02 - XOR로 이해하는 신경망 구조와 순전파

1. OcclusionGateNet 개발기 1 — 선글라스를 쓰면 운전자 모니터링은 어떻게 될까?

Mon, 07 Sep 2026 00:00:00 +0900

들어가며

TabPFN 글에서 캡스톤 프로젝트가 우수상을 받았다고 잠깐 언급했었다. 이번에는 그 프로젝트 이야기를 해보려고 한다. 이름은 OcclusionGateNet이다.

운전자 모니터링 시스템, 흔히 DMS(Driver Monitoring System) 라고 부르는 것을 만들었다. 운전자가 어떤 행동을 하는지, 어디를 보는지, 손은 어떻게 두고 있는지, 대화하고 있는지를 영상으로 분류하는 프로젝트다.

여기까지만 보면 얼굴과 자세를 추출해서 분류기에 넣으면 될 것 같다. 그런데 운전자는 항상 카메라를 향해 얼굴을 드러내고 있지 않는다. 선글라스를 쓰기도 하고, 손으로 입을 가리기도 한다. 밤에는 조명 조건도 달라진다. 잘 보이는 얼굴을 잘 분류하는 것과, 얼굴이 가려져도 판단을 유지하는 것은 다른 문제였다.

우리가 집중한 것은 두 번째였다. 한 줄로 설명하면 이렇다.

가려진 얼굴의 랜드마크를 복원하고, 얼굴이 얼마나 보이는지를 이용해 얼굴·자세 정보를 섞는 운전자 모니터링 시스템.

나는 팀에서 얼굴 랜드마크 복원 파트를 맡았고, 융합 모델과 ablation 실험에도 함께 참여했다. 그래서 이 개발기는 완성된 구조를 소개하는 데서 끝내지 않고, 복원 모델을 가져와 학습시키면서 어디서 막혔는지까지 담으려고 한다. 데이터와 학습 기록까지 함께 정리하려니 나눠 쓸 이야기가 꽤 많아졌다.

Part 1. 어두운 것과 가려진 것은 어떻게 다를까?

NIR 카메라를 쓰면 해결되는 문제

프로젝트에서는 근적외선(Near-Infrared, NIR) 영상을 사용했다. 야간 운전자 영상을 다루기 위한 선택이다. 다만 여기서 바로 구분해야 하는 것이 있다. 카메라가 어두운 환경에서 영상을 얻을 수 있다는 것과, 가려진 부위의 정보를 얻을 수 있다는 것은 같지 않다.

예를 들어 손으로 입을 가린 장면을 생각해보자. 화면을 더 밝게 만든다고 손 뒤의 입 모양이 관측되지는 않는다. 모델 입장에서는 입력이 어두운 경우와 관측해야 할 정보 자체가 빠진 경우를 다르게 다뤄야 한다.

문제	프로젝트에서 대응한 부분	남는 문제
야간·조명 변화	NIR 영상 사용, NIR 데이터로 모델 조정	센서와 촬영 환경이 달라질 때의 일반화
눈·입 등의 가림	가시성 추정, 랜드마크 복원	가린 영역의 실제 움직임은 직접 관측되지 않음
손상된 얼굴 정보가 분류에 들어감	가시성을 조건으로 한 얼굴·자세 융합	복원이 그럴듯해도 분류에 항상 도움이 되는 것은 아님

이 마지막 줄이 중요하다. 얼굴 점을 예쁘게 복원하는 것만으로 최종 운전자 행동 분류가 좋아졌다고 말할 수는 없다. 복원된 정보가 실제 판단에 도움이 되는지를 따로 확인해야 한다.

처음의 Eye-Pose에서 Face-Pose-Occ로

초기 구상은 눈과 몸의 자세를 함께 보는 Eye-Pose였다. 눈은 시선과 관련이 있고, 몸의 자세는 휴대전화 사용이나 물건을 집는 행동을 설명할 수 있다.

그런데 눈을 주요 단서로 사용하는 구조라면, 눈이 가려지는 순간 가장 중요한 입력부터 흔들린다. 그래서 최종 구조에서는 얼굴 전체 랜드마크를 사용하고, 여기에 부위별 가시성을 별도의 입력으로 추가했다. 보고서에서 Face-Pose-Occ로 정리한 방향이다.

단순히 입력 하나를 더 붙인 것은 아니다. 가시성 정보는 두 군데에서 쓰인다. 앞에서는 어느 좌표를 복원 좌표로 바꿀지 결정하고, 뒤에서는 어떤 얼굴 부위와 모달리티를 얼마나 참고할지 조절한다.

Part 2. 전체 구조를 먼저 한 번 보자

저장소의 아키텍처 그림을 바탕으로, 이 글에서는 구조 설명에 집중하도록 개별 모델의 성능 숫자를 제외했다. 실제 추론 경로는 full_system 구현을 기준으로 설명한다.

왼쪽에서 오른쪽으로 따라가면 다음과 같다.

① 얼굴과 몸에서 서로 다른 단서를 얻는다

얼굴 영상에서는 YOLO 얼굴 검출기로 crop을 만들고, MediaPipe FaceMesh로 478개 얼굴 랜드마크를 추출한다. 별도의 가시성 CNN은 왼쪽 눈·오른쪽 눈·코·입이 얼마나 보이는지 추정한다.

몸 영상에서는 YOLO-Pose로 17개 관절점을 추출한다. 얼굴이 눈과 입의 세부 변화를 제공한다면, 자세는 팔과 상체의 큰 움직임을 제공하는 식이다.

여기서 랜드마크는 이미지 자체가 아니라 점의 위치다. 픽셀 전체를 최종 분류기에 넣는 대신, 얼굴과 몸의 구조를 좌표 시퀀스로 전달한다.

② 가려졌다고 판단한 얼굴 부위를 복원한다

복원 경로에는 ORFormer와 HGNet이 들어간다. ORFormer가 얼굴 구조를 나타내는 reference heatmap을 만들고, HGNet이 이를 얼굴 영상과 함께 받아 랜드마크를 예측한다.

이때 복원하는 것은 선글라스를 지운 얼굴 사진이 아니다. 뒤에서 사용할 얼굴 구조와 좌표다. 복원 이미지가 사람 눈에 자연스러운지보다, 필요한 위치 정보를 얼마나 유지하는지가 문제다.

그리고 MediaPipe 좌표를 전부 버리지 않는다. 관측 가능한 부위는 기존 좌표를 유지하고, 가림으로 판정한 부위만 정렬된 복원 좌표로 바꾼다. 이 좌표 교체와 뒤의 feature fusion은 이름에 gate가 들어가더라도 서로 다른 연산이다.

③ 여러 프레임을 모아 네 가지 출력을 낸다

최종 분류기는 48프레임 창의 얼굴·자세·가시성 정보를 받아 네 가지 과제를 함께 수행한다.

출력	현재 분류 코드의 클래스 수	예시
Action	11	정상 운전, 문자 입력, 통화, 물 마시기 등
Gaze	9	전방, 좌우 방향, 미러, 인포테인먼트 등
Hands	4	운전대에 둔 손: 양손, 왼손만, 오른손만, 없음
Talk	2	대화 여부

자료를 정리하면서 가장 먼저 확인한 것 중 하나가 이 클래스 수였다. 발표에서는 이해를 돕기 위해 과제를 간단히 묶어 표현한 부분이 있지만, 실제 학습의 정답 공간은 위와 같다. 특히 gaze를 단순한 ‘전방/비전방’ 이진 분류로 읽으면 결과를 잘못 해석하게 된다.

Part 3. 이 프로젝트에서 확인하고 싶었던 것

모델을 만들고 숫자 하나를 얻는 것보다 중요한 질문이 있었다.

첫째, 얼굴이 가려져도 기존 성능을 얼마나 유지하는가? 같은 클립의 clean/masked 조건을 비교해야 가림으로 인해 무엇이 달라졌는지 보기 쉽다.

둘째, 복원 모듈이 실제로 필요한가? MediaPipe만으로 분류했을 때와 복원 좌표까지 사용했을 때를 비교해야 한다. 복원 결과 그림만으로는 답할 수 없는 질문이다.

셋째, 가시성을 알려주는 것이 단순 결합보다 나은가? 얼굴과 자세를 이어 붙이는 것에서 끝내지 않고, 가시성을 입력으로 주었을 때와 gate를 제거했을 때를 나눠 봐야 한다.

실험에서는 이 차이가 특히 gaze에 나타났다. 다만 모든 과제에서 모든 모듈이 이긴 것은 아니다. 예를 들어 얼굴을 제거한 모델이 action에서 더 높은 점수를 낸 결과도 있다. 이 부분까지 포함해야 ‘어떤 정보가 어느 과제에 도움이 되었는가’를 이야기할 수 있다. 구체적인 수치와 해석은 6편에서 다룬다.

앞으로 쓸 이야기

이 시리즈는 다음 흐름으로 구성했다.

편	중심 질문
1. 문제와 전체 구조	왜 가림을 별도로 다뤄야 했을까?
2. 데이터	보이지 않는 얼굴의 정답은 어디서 얻을까?
3. 복원 모델	ORFormer의 codebook과 messenger는 무엇을 할까?
4. 학습 기록	왜 학습을 돌려도 같은 code만 사용했을까?
5. 융합 모델	복원한 얼굴을 얼마나 믿어야 할까?
6. 실험	어떤 모듈이 실제로 도움이 되었을까?
7. 데모와 회고	모델들을 연결하면 바로 시스템이 될까?

마지막에는 영종도에서 야간 영상을 촬영한 기록과 실제 통합 코드의 실패 처리도 다룰 예정이다. 여기서 소개하는 시스템은 캡스톤에서 구현하고 실험한 프로토타입이다. 영상 데모, 저장된 평가 결과, 실제 차량에서 요구하는 검증은 구분해서 읽으면 좋겠다.

다음 편에서는 모델보다 먼저 데이터부터 살펴본다. 가려진 얼굴을 복원하라고 학습시키려면, 가려지기 전 얼굴의 좌표를 어떻게 준비해야 할까?

참고한 자료

이 시리즈의 코드 설명은 17d4211 커밋을 기준으로 한다. 학습 당시 기록과 현재 구현이 다른 곳은 해당 편에서 구분했다.

yg log --graph --oneline --all

2. CIGPose 구현 해설 - 관절 벡터 하나를 바꾸면 어디까지 학습될까?

들어가며

Part 1. 전체 텐서 지도부터

Part 2. Keypoint Encoder — 이미지가 관절 토큰이 되기까지

CSPNeXt와 7×7 convolution

ScaleNorm과 Linear는 다른 일을 한다

GAU는 관절 사이에서 정보를 섞는다

Part 3. CIM — 점수를 계산하고, 고르고, 바꾼다

초기 SimCC는 선택용이다

Top-k는 배치 전체가 아니라 사람별로 고른다

정준 임베딩은 공유하지만, 선택은 이미지마다 다르다

코드에서 추가로 확인해야 했던 부분

Part 4. HGNN — 관절과 부위를 번갈아 본다

① 입력 투영과 국소 EdgeConv

② 관절을 의미 그룹으로 묶기

③ 그룹 gate를 다시 관절로 돌려주기

Part 5. 마지막 SimCC head — 이제 좌표를 만든다

Part 6. 두 손실을 실제 학습 경로에 연결하기

Keypoint loss는 교체된 관절에만 걸리지 않는다

Consistency loss는 멀쩡한 관절의 예측을 기준에 묶는다

같은 GNN인데 한쪽만 고정할 수 있나?

결국 어느 파라미터까지 gradient가 가는가?

Part 7. 코드까지 읽고 나면 설명이 조금 달라진다

참고 자료와 코드 위치

1. CIGPose 논문 리뷰 - 가려진 관절을 문맥에 맡겨도 될까?

들어가며

Part 1. Why CIGPose? — 사람 대신 의자를 보고 있었다면

관절 133개를 한꺼번에 찾는 문제

문맥은 도움이 되지만, 지름길이 되기도 한다

Part 2. 관찰 분포와 개입 분포 — 문맥의 가중치가 달라진다

관찰한 상관관계와 알고 싶은 효과

그런데 배경의 모든 경우를 어떻게 더하지?

Part 3. CIGPose는 실제로 무엇을 바꾸는가

전체 구조부터 보기

CIM ① 어느 관절을 덜 믿을 것인가

CIM ② 정준 임베딩은 정답 좌표인가?

HGNN — 가까운 관절에서 전신 관계까지

Part 4. 바꾸면서도 멀쩡한 관절은 지켜야 한다

Part 5. 실험 결과 — GNN과 CIM의 기여

같은 크기의 모델끼리 비교하기

GNN만 넣어도 꽤 오르는데?

숫자로 보기 어려운 변화

Part 6. 읽고 나서 남은 질문

특징 치환은 backdoor 평균과 같은 계산인가?

불확실한데 맞는 자세, 확신하는데 틀린 자세

내 생각

참고 자료

2. FFDP 수식과 학습 구조 - 좌표가 복원되는 과정을 따라가기

들어가며

1. 한 관절의 좌표를 평균과 차이로 나눈다

더 깊은 level은 더 넓은 구간을 본다

2. 한 줄 좌표가 프레임과 관절의 행렬이 된다

$m,n$이 움직이는 두 축

stride 2가 입력을 두 칸씩 묶는다

3. 계수를 만든 뒤 모델이 배율을 학습한다

4. 가우시안은 좌표를 고치는 장치가 아니라 출발점이다

5. forward 식은 정답에서 검출 좌표 쪽으로 이동한다

6. 36프레임과 DDIM 5 step은 다른 축이다

7. 현재 입력과 깨끗한 좌표 예측을 DDIM 식에 넣는다

8. Stage 1은 2D 복원 규칙을 학습한다

9. Stage 2는 고정한 prior를 3D 복원에 사용한다

10. 고정된 iDWT를 지나도 gradient는 흐른다

계산을 끝내고 다시 보는 전체 경로

참고 자료

6. PyTorch 06 - Strided CNN과 Depthwise Separable CNN

들어가며

1. Conv2d에서 먼저 볼 네 가지

2. StridedCNN: downsampling도 학습시키기

3. Depthwise Separable Convolution

4. dilation을 넣은 DepthwiseCNN

5. Depthwise를 썼는데 왜 전체 모델은 더 클까?

6. 저장된 학습 결과 비교

7. weight 변화량 추적하기

헷갈리기 쉬운 포인트

MaxPool2d에 input size와 output size를 적지 않는 이유는?

groups는 채널을 groups개씩 묶는다는 뜻인가?

padding=1이면 항상 크기가 유지되나?

logits에 softmax를 넣고 CrossEntropyLoss를 써야 하나?

정리하며

1. `Conv2d`에서 먼저 볼 네 가지

`MaxPool2d`에 input size와 output size를 적지 않는 이유는?

`groups`는 채널을 groups개씩 묶는다는 뜻인가?

`padding=1`이면 항상 크기가 유지되나?

2. `hidden_dim`을 인자로 받는 이유

평가할 때 왜 `model.eval()`과 `inference_mode()`를 둘 다 쓰나?

`hidden_dim=256`을 인자로 받는 것이 항상 더 좋은가?

4. 배치 shape `(B, 1, 28, 28)` 읽기

7. `num_workers`, `pin_memory`, `non_blocking`

`images`로 받으면 tensor가 이미지 타입으로 바뀌나?

`ToTensor()`를 썼는데 MNIST 평균·표준편차로 다시 복원해야 하나?

2. `loss.backward()`는 모델을 어떻게 아는가

4. 왜 매번 `zero_grad()`를 호출할까?

5. `detach()`는 무엇을 끊는가

6. `no_grad()`와 `detach()`의 차이

학습 중간에 `loss.detach()`를 하면 어떻게 될까?

`model.eval()`이 gradient를 꺼주나?

`torch.inference_mode()`는 `no_grad()`와 같은가?

2. `nn.Module`로 모델 만들기

3. `nn.Linear(2, 4)`가 만드는 것

4. `forward`를 shape로 읽기

`in_features`, `out_features`를 안 써도 되나?

`model.train()`과 `model.eval()`이 XOR에서도 결과를 바꾸나?

4. `item()`은 언제 쓰는가