Lim's Technology

생성 모델 정리하기 (MLE · VAE · GAN · Diffusion · Language Model)

임승택 — Sat, 22 Nov 2025 01:14:07 +0900

1. 생성(Generation) vs 판별(Discrimination) & 왜 VAE가 중요한가

생성(Generation): 데이터 분포 자체를 배워서, 거기서 새 샘플을 뽑아내는 모델을 만드는 것.
판별(Discrimination): 주어진 입력 x에 대해 라벨/클래스 y를 맞히는 문제 (분류, 검출, 세그멘테이션 등).
- Variational Autoencoder(VAE), 즉 Variational 방법론

VAE를 이해하고, 그 안에 들어있는 최대우도추정(MLE, Maximum Likelihood Estimation),
변분추론(Variational Inference), KL Divergence, ELBO, Reparameterization Trick을 이해하는 것이
생성·확률·베이즈·디퓨전 등으로 넘어가는 핵심

https://wikidocs.net/228770

01. 생성모델 (Generative Models) 이란?

세상에 실제로 존재하는 객체는 확률 분포 $p(x)$로 나타낼 수 없습니다. 하지만 어떤 객체, 예를 들어 강아지의 모습이 담긴 학습 데이터셋 $D = [x_1, x_2, …

wikidocs.net

2. 최대우도추정(MLE)와 'Likelihood'

2.1 Bayes Rule과 관측변수 vs 미지수 구분:

관측 가능한 것: 데이터 x
- 이미 하드에 저장된 값, 내 눈에 보이는 값.
구하고 싶은 것(미지수, 파라미터): θ
- 신경망의 weight, bias 같은 학습해야 할 파라미터들.

Base Rule:

여기서:

2.2 생성적 관점: 데이터는 ‘어딘가의 분포’에서 샘플링된 것

현실 세계에서 우리가 관측하는 데이터 x들은,
어딘가 미지의 세계에 있는 진짜 분포 에서 샘플링되어 하드에 저장된 것이라고 가정.
우리는 진짜 분포 p(x)를 알 수 없지만,
- 어떤 파라미터 θ를 가지는 모델 를 만들어
- 실제 분포 p(x)를 최대한 흉내내고 싶다.

https://angeloyeo.github.io/2020/07/17/MLE.html

최대우도법(MLE) - 공돌이의 수학정리노트 (Angelo's Math Notes)

angeloyeo.github.io

2.3 MLE의 목표: 가장 ‘그럴싸한’ 찾기

Likelihood = “그럴싸한 정도”
→ “이 θ라면, 지금 내가 가진 데이터가 나올 법해 보이나?”
→ 그 ‘정도’를 최대화하는 θ를 찾는게 MLE.

2.4 Likelihood는 “확률분포”가 아니라 “함수”

일반적으로는 가 주어져 있고, x가 변하는 함수 → 확률분포 함수.
그런데 MLE에서는 상황이 거꾸로:
- 우리는 관측된 x들을 알고 있고,
- 라는 미지수(θ)를 찾고 싶다.
즉:
- x는 고정, μ,σ가 변수인 함수 → 이것이 Likelihood 함수.
- 이 함수값이 1이 될 필요도 없고, 1을 넘을 수도 있음.
그래서:
- Likelihood는 ‘확률(probability)’라고 부르지 않고, ‘함수(function)’라고 부른다.
- “내가 가진 데이터가 주어졌을 때, 파라미터 θ가 얼마나 그럴싸한지”를 나타내는 값.

3. 생성 모델링 = 데이터 분포에 대한 MLE

3.1 생성 문제의 목적식

생성 모델링의 핵심

여기에서 pθ(x)가 무엇인지에 따라:
- 판별 문제(분류, 세그멘테이션)도
- 이미지 생성, 텍스트 생성 등도
- “결국 MLE 관점에서 동일한 틀” 안에서 설명 가능.

3.2 판별 테스크(Classification)와의 연결

분류 문제:
- 입력 를 넣었을 때, 정답 라벨 y가 나올 확률 pθ(y∣x)의 로그를 최대화하는 문제.
  - 이때 pθ(y∣x)를:
    - Bernoulli 분포로 두면 → 이진 분류 (Binary Cross Entropy)
    - Multinomial 분포로 두면 → 다중 분류 (Softmax + Cross Entropy)
즉,
- 분류 문제도 “로그 우도 최대화”의 특수 케이스.

3.3 생성 테스크

생성에서는:
- 클래스 y가 아니라,
- 데이터 x 자체의 분포 pθ(x) 를 배우고 싶다.
그래서 생성 모델의 목적도 똑같이:max⁡θ log⁡pθ(x)
다만 이 를 구현하는 방식에 따라:

명시적 생성 모델 (Explicit Generative Model)
암묵적 생성 모델 (Implicit Generative Model)

https://minsuksung-ai.tistory.com/12

생성모델(Generative model)이란 무엇일까?

내일이 기말고사라서 간단하게 강의 정리도 해야해서, 오늘은 비지도학습(Unsupervised learning) 중에서 클러스터링(Clustering)과 함께 가장 대표적인 예시 중 하나인 생성모델(Generative model)에 관련해

minsuksung-ai.tistory.com

4. 명시적(Explicit) vs 암묵적(Implicit) 생성 모델

4.1 명시적 생성 모델 (Explicit)

확률 분포 pθ(x) 를 수식으로 명시적으로 정의하는 모델

즉 모델이 데이터의 likelihood를 계산할 수 있도록 설계된다.

- 예시 분포

Gaussian
Bernoulli
Multinomial
VAE의 일부 구성

여기서 두 분류:
(1) Tractable Explicit Model (정확 계산 가능)
- 데이터의 정확한 확률값
- pθ(x)를 직접 계산할 수 있는 모델
- 대표 예: Autoregressive Model

전체 문장의 확률을
각 토큰의 조건부 확률의 곱으로 분해

각 단계의 확률을 Cross Entropy로 바로 학습 가능하다.

대표 모델

Language Model (Transformer LM)
GPT
PixelCNN

특징

likelihood 정확 계산 가능
학습 안정적
샘플 생성은 순차적이라 느릴 수 있음

(2) Intractable Explicit Model (계산 불가능 → 근사 필요)

여기서는 pθ(x) 를 수식으로는 정의하지만, 실제로 계산하려고 하면 적분 때문에 계산이 불가능해진다.

이 적분이 high dimensional이라 계산 불가.

그래서 다음 방법을 사용한다.

ELBO (Evidence Lower Bound)
Variational Inference

즉 likelihood를 직접 계산하는 대신 하한(lower bound) 을 최대화

대표 모델

VAE (Variational Autoencoder)
Diffusion Model (변분적 해석에서)

특징

확률 모델은 존재
하지만 likelihood 직접 계산 불가
대신 근사 학습

4.2 암묵적 생성 모델 (Implicit Generative Model)

여기서는 아예 pθ(x)를 명시적으로 정의하지 않는다
- likelihood 없음
- 확률식 없음
대신:
- 신경망에 모든 걸 맡기고, 그 네트워크가 데이터 샘플을 만들어내도록 학습.
대표 예: GAN(Generative Adversarial Network)
- Generator가 정의하는 분포가 암묵적으로 데이터 분포를 흉내내도록 학습.
- “Likelihood를 명시적으로 계산하지 않고도” 생성 모델을 학습하는 방식.
  - Generator G(z)
  - Discriminator D(x)

5. GAN 암묵적(Implicit) 생성 모델 대표

5.1 구조: Generator vs Discriminator

Generator G(z):
- 랜덤 노이즈 (레이턴트 스페이스에서 샘플) → 가짜 데이터 x 생성.
- 예: 소리/이미지/음성 등을 생성한다고 가정.
Discriminator D(x):
- 입력 x가 진짜(real) 인지 가짜(fake) 인지 구분하는 이진 분류기.
- CNN, Transformer 등 어떤 구조든 상관없음.

Generator = 위조지폐범
- 진짜 돈과 구분 안 될 정도로 정교한 위조지폐를 만들려고 노력.
Discriminator = 경찰관
- 입력된 돈이 진짜인지 가짜인지 판별하는 역할.
학습 과정:
- 진짜 데이터 x → Discriminator는 1(Real) 이라고 맞히도록 훈련.
- Generator가 만든 가짜 데이터 x → Discriminator는 0(Fake) 라고 맞히도록 훈련.
- 동시에 Generator는 Discriminator를 속여서,
  - 가짜 x~를 넣었을 때 Discriminator가 1(Real) 이라고 착각하도록 학습.
이 관계를 미니맥스 게임(minimax game)으로 표현:
- Discriminator는 정확도를 올리려고 하고,
- Generator는 Discriminator의 정확도를 떨어뜨리려고 함.

5.2 학습 종료 시점: D의 정확도 ≈ 50%

Generator가 충분히 잘 학습되면:
- Discriminator는 진짜 vs 가짜를 거의 구분 못 해서 50% 확률로 찍게 됨.
그 시점에서:
- Generator가 이미 데이터 분포를 잘 흉내내는 모델이 된 것.
- 이후에는 Discriminator는 버리고, Generator만 사용해서 샘플 생성.

5.4 GAN은 “모델 이름”이라기보다 “로스 구조”

실제로는 Adversarial Loss를 붙인 어떤 구조도 다 “GAN류”.
- 특정 모듈에 Discriminator 역할을 하는 신경망을 붙여서,
- 둘을 적대적으로 학습시키는 구조 전체를 어드버서리얼(Adversarial) 하다고 부름.

6. VAE(Variational Autoencoder): 명시적 + 근사(Variational) 기법

- VAE는 이름은 오토인코더지만, 사실 일반적인 ‘Autoencoder’랑은 완전히 다른 기술

- 일반적인 Autoencoder와 달리 확률 기반 생성 모델이다

6.1 목표: pθ(x)를 직접 모델링

생성 모델링의 목적은 같음

하지만 직접 모델링하기 어렵기 때문에 잠재 변수 (latent variable) z를 도입한다.
- 데이터 를 생성하는 숨은 원인
- 저차원 표현 (latent representation)

확률 모델은 다음과 같이 표현된다. 이 적분은 보통 고차원이라 계산 불가능 (intractable) 이다.
우리가 진짜 알고 싶은 건 후분포 pθ(z∣x) 즉 posterior distribution인데 이것도 직접 계산하기 어렵다.

6.2 Variational Inference와 ELBO

posterior를 직접 계산할 수 없기 때문에 근사 분포를 정의한다.

Encoder
posterior pθ(z∣x를 근사

여기서:
- ELBO : Evidence Lower Bound
- KL : Kullback–Leibler divergence
KL 항은 항상 ≥ 0이므로:

ELBO는 log⁡pθ(x) 의 하한(lower bound)

VAE의 아이디어:

6.3 ELBO의 두 항: Reconstruction Loss + KL Regularization

ELBO는 두 항으로 분해된다.

1. Reconstruction Term

latent z 로부터 원래 데이터 x를 얼마나 잘 복원하는가

MSE
Binary Cross Entropy

등의 reconstruction loss로 사용한다.

2. KL Regularization

실제 구현에서는 Encoder가 다음을 출력한다.

Gaussian과 N(0, I) 사이의 KL divergence를 계산해 loss에 추가한다.

재구성 성능 + latent 공간 정규화

6.4 Reparameterization Trick (리파라미터라이제이션 트릭)

문제:

하지만:

샘플링은 미분 불가능한 연산.
gradient가 encoder로 전달되지 않음.

해결:

표준정규 분포에서 샘플링한 ϵ을 이용해 재매개변수화:

이렇게 하면:
- 샘플링은 에서만 발생
- 나머지는 선형 연산

즉:

“평균이 μ, 분산이 σ인 Gaussian에서 샘플링”을
“표준정규 분포에서 샘플링 + 선형변환” 으로 바꾸는 트릭.
이것이 Reparameterization Trick.

따라서 backpropagation 가능, 이 트릭이 중요한 이유:

VAE뿐 아니라,
Diffusion 모델에서도 평균·분산을 계속 다루기 때문에
이 아이디어가 반복적으로 사용됨.

6.5 학습 후 사용

학습이 끝나면:
- 인코더 는 버릴 수 있음.
- z∼N(0,I) (또는 적절한 선형변환)으로 본 뒤
- 디코더 x∼pθ(x∣z) 에 넣어 새로운 생성.

7. 언어 모델 (Autoregressive Model)

- 명시적(Explicit) + Tractable 생성 모델

언어 모델은 오토리그레시브 분해(autoregressive factorization) 를 사용해 문장 전체의 확률을 계산한다.

7.1 오토리그레시브 분해

문장 예시:

입력: “넌 누구야?”
출력: “나는 챗GPT야”

문장을 토큰으로 보면

[x1, x2, x3]

언어 모델은 문장의 확률을 다음처럼 분해한다.

각각의 조건부 분포:
- “나는”이 나올 확률
- “나는” 다음에 “챗”이 나올 확률
- “나는 챗” 다음에 “GPT야”가 나올 확률
이걸 모두 Cross Entropy로 학습:
- 결국 분류 문제의 연속처럼 푸는 것.
- 각 단계는 Vocabulary 전체에 대한 softmax 분류 문제

pθ(x1) => pθ(x2∣x1) => pθ(x3∣x1,x2)

7.2 Tractable 모델인 이유

오토리그레시브 모델은 각 step에서:
- Vocabulary에 대한 softmax 확률을 내기 때문에,
- 그 문장/토큰 시퀀스가 나올 정확한 확률을 계산할 수 있음.

이걸 이용해서:
- “GPT 스타일 텍스트인지, 사람이 쓴 텍스트인지” 구분하는 GPT Detector 같은 것도 만들 수 있음:
  - 어떤 문장이 주어졌을 때,
  - 언어모델이 부여하는 확률이 너무 높다 → AI가 쓴 걸로 의심.
  - 특정 구간에서 확률이 이상하게 낮다 → 사람이 쓴 흔적일 수도.

Explicit + Tractable 생성 모델

8. Diffusion Model

노이즈 → 데이터로 복원하는 과정을 학습하는 생성 모델이다.

8.1 Forward Process: 깨부수기(노이즈 추가)

원본 이미지 x0가 있을 때,
- 매 스텝마다 Gaussian 노이즈를 조금씩 더해
- xT가 되면 원본을 전혀 알아볼 수 없는 순수 노이즈가 됨.

이 과정은:
- 각 step의 변환이 정규분포 수식으로 명시되어 있어
  코드로 쉽게 구현 가능 (Randn + 계수 조합).

8.2 Reverse Process: 정리하기(노이즈 제거)

우리가 원하는 것은 반대 방향

즉, 순수 노이즈에서 시작해 데이터로 가는 과정을 학습
문제:
- p(xt−1∣xt) 같은 역전달 분포는 직접 알 수 없음.
- 그래서 여기에 신경망을 써서:
  - 각 step에서 제거해야 할 노이즈를 예측하도록 학습시킨다.

8.3 ‘아이 방 어질러 놓기’

Forward:
- 아이가 방에서 장난쳐서 물건을 마구 어질러서 쓰레기장(노이즈) 상태가 됨.
Reverse:
- 부모(모델)는 “원래 방이 어땠는지 한 번 본 적이 있다”고 가정.
- 그 기억(트레이닝 데이터)을 활용해서:
  - 현재 쓰레기장 상태에서 조금씩 정리해 나가며 원래 방처럼 만들어감.
완벽히 똑같은 방이 아니라:
- 원래 방과는 다르지만 그럴싸한 새로운 방이 되는 것.
- 즉, train set과는 다르지만 같은 분포에서 나온 새로운 샘플 생성.

8.4 Diffusion과 VAE/Variational의 연결

Diffusion의 목적도 결국: max⁡log⁡pθ(x)
이 목표에서 출발해 Variational 방식으로 유도하면,
- VAE 때처럼 ELBO 형태의 학습 목적이 나온다.
이 유도 과정에서:
- Forward process(노이즈 추가)는 명시적인 Gaussian 수식.
- Reverse process는 신경망이 “얼마나 노이즈를 지워야 하는지”를 예측하도록 학습.
그래서:
- Reparameterization Trick, Gaussian 평균·분산 다루기 등이
  Diffusion에서도 핵심.

9. 정리

생성 vs 판별
- 판별 (Discriminative Model) : pθ(y∣x)를 학습 → 분류/검출/세그멘테이션.
  - 입력 xx가 주어졌을 때 라벨 yy 의 확률을 학습
  - 사용 분야
    - 분류 (classification)
    - 객체 검출 (detection)
    - 세그멘테이션 (segmentation)
    예시 모델
    - Logistic Regression
    - CNN classifier
- 생성 (Generative Model) : pθ(x)를 학습 → 데이터 분포 자체를 모델링.
MLE & Likelihood
- 생성 모델의 기본 목표는 데이터가 나올 “ Likelihood ”을 최대화하는 파라미터 θ를 찾는 것.
- 데이터가 생성될 확률이 가장 높아지도록 파라미터를 찾는다
- Likelihood는 확률분포가 아니라, 파라미터에 대한 함수.
  - x : 고정된 데이터
  - : 변수
명시적 vs 암묵적 생성 모델
- 명시적 (Explicit) : pθ(x를 수식으로 명시 (Gaussian, 오토리그레시브 LM, VAE, Diffusion 등).
  - Tractable: 언어모델처럼 정확한 likelihood 계산 가능. (GPT)
  - Approximate: Likelihood 계산 불가능 → 근사 , VAE, Diffusion처럼 ELBO/Variational로 근사.
- 암묵적 (Implicit) : GAN처럼 모델이 정의하는 분포를 수식으로 직접 쓰지 않음.
  - 샘플 생성 과정만 학습 (GAN)
GAN
- Generator vs Discriminator의 적대적 학습.
- Discriminator 정확도 ≈ 50%가 되면 Generator가 분포를 잘 흉내내고 있다고 볼 수 있음.
- Adversarial Loss 구조 자체가 핵심.
VAE
- log⁡pθ(x를 직접 최적화하기 어렵기 때문에 ELBO를 최대화.
- ELBO = 재구성 손실 + KL 정규화.
- Reparameterization Trick으로 샘플링 과정까지 미분 가능하게 만들어 backprop.
Diffusion
- Forward: 데이터에 점점 노이즈 추가 → pure noise.
- Reverse: 노이즈에서 출발해 노이즈를 조금씩 지워가며 데이터를 복원하는 과정을 신경망이 학습.
- Variational 관점에서 유도하면, VAE와 비슷한 형태의 목적식(ELBO)이 나온다.

생성 모델링, 특히 VAE·Diffusion을 제대로 이해하려면:

- MLE, Likelihood, Bayes, Variational Inference, KL, Reparameterization 등을
  연결해서 보는 관점이 필수.

[Object Tracking] Visual Object Tracking (VOT) 알아보기 (Distance Learning)

임승택 — Thu, 25 Sep 2025 17:45:09 +0900

이번 포스팅에서는 Visual Object Tracking (VOT)에 대해 다뤄보았다

Visual Object Tracking (VOT)

Visual Object Tracking (VOT)은 비디오 상에서 특정 객체(Target Object)의 움직임을 지속적으로 추적하는 기술이다.
즉, 비디오의 각 프레임에서 목표 객체의 위치를 지속적으로 예측하고, 시간의 흐름에 따라 그 궤적을 추적한다.

Single Object Tracking (SOT) : 하나의 객체를 추적
Multi Object Tracking (MOT) : 여러 객체를 동시에 추적

이번 포스팅에서는 Single Object Tracking을 중심으로 다룬다.

2. Object Detection vs Object Tracking

	Object Detection	Object Tracking
목적	한 장의 이미지 내에서 객체의 위치와 클래스 식별	비디오에서 객체의 시간적 변화와 일관성 유지
입력 단위	Single Frame (정적인 이미지)	Video (연속된 Frame)
출력	Bounding Box + Class Label	연속된 Frame 상의 객체 ID + Bounding Box 궤적
학습 내용	객체의 시멘틱 정보 (의미) 학습	객체 간 관계(Correspondence) 학습
Temporal Context	없음	있음 (시간적 문맥 고려)
관심 포인트	정확도(Accuracy) & 효율성(Efficiency)	ID 일관성, Occlusion(가림), 이동 추적
응용 분야	정적인 이미지 분석	비디오 기반 궤적 추적 및 행동 분석

Object Detection은 “무엇이 어디에 있는가”를, Object Tracking은 “이전 프레임의 객체가 다음 프레임에서 어디로 이동했는가”를 다룬다.

Object Tracking의 개념

비디오가 진행될 때, 동일한 객체를 시간적으로 연결(Association) 해야 한다. 즉, 프레임 간 객체의 Identity(정체성) 를 유지하는 것이 핵심이다.

Tracking은 매 프레임마다 새롭게 검출된 객체들이 이전 프레임의 어떤 객체와 동일한지를 판단하는 과정이다.

이때 중요한 구성요소는 다음 두 가지이다:

Appearance Representation (외형 표현)
- 객체의 외형 정보를 어떤 방식으로 표현할 것인가
- RGB, Histogram, Feature Descriptor 등 사용
Data Association (데이터 연관성)
- 이전 프레임의 객체와 현재 프레임의 객체를 매칭하는 과정
- 유사도, 거리, 확률 기반 매칭 수행

1. Appearance Representation (외형 표현)

Tracking의 주요 난제 (Challenges)

Deformation (형태 변화)	객체의 포즈나 모습이 계속 바뀜
Occlusion (가림)	객체가 다른 물체에 의해 일시적으로 가려짐
Fast Motion (급격한 이동)	짧은 시간에 큰 이동 발생
Illumination Change (조명 변화)	빛의 세기와 색 변화로 Appearance 변화
Scale / Rotation Variation	크기나 방향 변화에 대한 불변성 확보 어려움

이러한 이유로 Object Tracking은 컴퓨터 비전 분야에서 가장 어려운 태스크 중 하나로 꼽힌다.

대표적인 전통적 특징 표현

Histogram (히스토그램)	픽셀 값의 분포를 확률로 표현
HOG (Histogram of Oriented Gradients)	Gradient 방향 분포를 이용한 형태 특징
SIFT (Scale-Invariant Feature Transform)	크기·회전에 불변한 키포인트 기반 특징
Optical Flow (광류)	픽셀의 움직임 벡터를 계산하여 모션 기반 추적 수행

2. Association (연관성 판단)

추적할 객체(Template 또는 Target)가 주어졌을 때, 다음 프레임의 후보 영역(Candidates) 중에서 가장 유사한 객체를 찾는 과정이다.

후보 중 유사도가 가장 높은 영역을 선택
여러 객체 추적 시, 각 객체에 ID를 부여하고 Matching 수행
필요 시 속도, 위치 제약 조건(Constraint) 을 추가할 수 있음

또한, 배경(Background)과의 차이를 계산하여 타겟과 배경의 Appearance 차이를 활용한 Matching도 가능하다.

전통적인 방법 vs 딥러닝 방법

1. 전통적 방법: Histogram Back Projection + Mean Shift

(1) Histogram Back Projection

첫 번째 프레임에서 타겟 객체를 선택하여 픽셀 값 히스토그램을 구함
각 픽셀의 값에 해당하는 확률로 영상을 다시 매핑 → “확률 맵” 생성
이 확률 맵에서 밝을수록(확률이 높을수록) 객체가 존재할 가능성이 큼

즉, 타겟의 색 분포를 기반으로 비디오 전체에서 유사 영역을 찾는 방법.

(2) Mean Shift (모드 시킹, Mode Seeking)

히스토그램 백프로젝션 결과에서 확률 밀도가 높은 영역으로 윈도우를 이동
프레임마다 밝은 영역(확률이 높은 영역)으로 이동하며 객체를 추적
“모드(최빈값)”를 향해 이동하므로 클러스터링 기반 최적화로 볼 수 있음

Mean Shift Tracking (CamShift 포함)
Appearance = 히스토그램, Association = Mean Shift 이동 → 대표적인 전통적 Visual Object Tracking 방법

2. 딥러닝 기반 Visual Object Tracking

전통적 방식은 Appearance 변화에 취약하다. 그래서 Neural Network를 사용하여 Feature Representation(표현 학습) 을 수행한다.

Color Intensity 대신 Feature Embedding을 학습하여 구분력 향상
유사 객체가 많은 장면에서도 올바른 타겟 구분 가능
Object의 시멘틱 의미보다는 “일관된 표현 유지”에 초점

즉, 딥러닝 기반 Tracker는 객체 간 일관성 있는 표현을 학습하여 강건한 추적을 수행한다.

Distance Learning / Similarity Learning

딥러닝을 활용한 object Tracking 방법에는 거리 유사도를 활용하는 방법이 있다.

Distance Learning (거리 학습) 혹은 Similarity Learning (유사도 학습)
- 두 데이터 간의 거리(distance) 또는 유사도(similarity) 를 학습하는 개념.
- 사도와 거리는 서로 역수 관계로 이해할 수 있다.
단순히 “이 데이터가 어떤 클래스에 속하는가?”를 학습하는 classification 문제가 아니라, 두 데이터가 얼마나 유사한가를 학습하는 문제다.

원샷 러닝 (One-Shot Learning)

클래스마다 단 한 장의 이미지만 존재하는 학습 문제.
기존 분류기(classifier)는 다수의 데이터를 요구하므로, 학습이 어렵다.
예시: Omniglot Dataset
- 여러 고대 문자들로 구성됨.
- 20-way one-shot → 클래스가 20개이고, 클래스마다 이미지 1장만 존재.
인간은 별도의 학습 없이도 유사도 계산을 통해 원샷 러닝을 수행한다. 즉, 유사도 판단 능력을 자연스럽게 수행한다.
원 샷 러닝은 인간처럼 “이거랑 이게 비슷하다”를 AI가 학습하도록 만드는 것이 목표이다.

AI는 시각적 외형이 아니라, 뉴럴 네트워크를 통해 latent space (잠재 공간) 에 데이터를 매핑한다.
이 공간에서는 유사한 데이터끼리 가깝게, 다른 데이터끼리는 멀게 위치하도록 학습한다.

Latent Space와 Feature Embedding

입력 데이터는 공유된 파라미터를 가진 모델(shared weights)을 통해 잠재공간에 매핑된다.
모델은 입력 데이터를 받아 유사도 계산이 용이한 벡터(feature vector) 로 변환한다.
이 공간에서 가까운 벡터 = 유사한 데이터, 먼 벡터 = 다른 데이터를 의미한다.
즉, Classification이 아니라 Embedding + Similarity 계산 문제이다.

Siamese Network 구조

두 개의 동일한 네트워크가 파라미터를 공유하는 구조이다.

- F: 동일한 뉴럴 네트워크 (CNN, MLP 등)
- h1, h2: 두 입력의 임베딩 벡터
두 벡터 간의 유사도(distance) 를 계산해, positive/negative 관계를 학습한다.

Contrastive Learning (대조 학습)

Positive pair: 같은 클래스 (유사한 두 데이터)
Negative pair: 다른 클래스 (비유사한 두 데이터)
목표:
- Positive pair는 가깝게,
- Negative pair는 멀게.

Positive pair → 타깃 1, Negative pair → 타깃 0으로 하여 Binary Cross Entropy (BCE)를 사용하는 방법이 있겠고 그게 아니라면 Contrastive Loss를 사용하는 방법이 있다.

Contrastive Loss

Positive pair: → 두 벡터 거리를 최소화 (Pull together)
Negative pair: → 두 벡터를 ε 이상 떨어뜨림 (Push apart)
반복:
- Positive pair → 가까워지도록 loss 감소
- Negative pair → ε 이상 멀어질 때까지 loss 유지
- 이후 거리가 충분히 벌어지면 gradient가 0 → 업데이트 중단.

Face Recognition 예제

얼굴 인식을 classification 문제로 학습하면,

새로운 사람이 추가될 때마다 모델 재학습 필요.
실용성이 떨어짐.

- Distance Learning 기반으로 극복

DB에는 각 사람의 대표 얼굴 한 장만 저장.
새 입력 이미지가 들어오면:
- CNN을 통해 임베딩 벡터로 변환.
- DB에 저장된 임베딩 벡터들과 거리 계산.
- 가장 가까운 벡터 = 동일 인물.
새로운 인물이 추가되면 다시 학습할 필요 없이 DB에 벡터만 추가하면 됨.

Triplet 구조

세 개의 입력 (Anchor, Positive, Negative)
세 개의 동일한 CNN을 통해 각각 임베딩 벡터로 변환.

Anchor → CNN → f(A)
Positive → CNN → f(P)
Negative → CNN → f(N)

α: margin
목적:
- A-P 거리는 작게,
- A-N 거리는 크게.
- 단, (A,P) 거리가 (A,N) 거리보다 α 이상 작게 되도록 학습.

마진 α는 “최소한 이 정도 차이는 나야 한다”는 거리 기준.

Contrastive Learning 학습 시 고려사항

(1) Data Augmentation

같은 이미지에서 다양한 변형을 만들어 Positive pair 생성
(예: 채도 제거, 회전, 크롭 등)
변형된 두 이미지는 같은 객체로 간주한다.

(2) Large Batch Size

한 배치 내에서 다양한 Positive / Negative pair 를 구성해야 함.
배치가 클수록 contrastive loss가 안정적으로 계산됨.
GPU 메모리 요구량이 크다.

(3) Hard Negative Mining

학습을 잘 시키려면 어려운 Negative Sample 이 필요하다.
예: 비슷하게 생겼지만 실제로는 다른 클래스의 이미지.
쉬운 Negative보다 어려운 Negative를 사용해야 모델이 더 정교하게 학습된다.

[Segmentation] DeepLab, Mask R-CNN, PanopticFPN

임승택 — Thu, 25 Sep 2025 17:27:55 +0900

이번 포스팅에서는 시멘틱 세그멘테이션(Semantic Segmentation) 에 대해 저번 포스팅에 이어서, 보다 세밀한 픽셀 단위의 인식 과정을 이해하기 위해 Dilated Convolution(또는 Atrous Convolution) 과 이를 기반으로 한 대표 모델인 DeepLab 시리즈를 살펴보고, 이어지는 Mask R-CNN 과 Panoptic FPN 으로 확장되는 세그멘테이션 계열 모델들을 함께 알아보겠다.

Recap) 시멘틱 세그멘테이션(Semantic Segmentation)의 개념

시멘틱 세그멘테이션이란 영상의 각 픽셀이 어떤 클래스(의미)에 속하는지를 구분하는 문제이다. 즉, 입력 이미지의 모든 픽셀마다 “이 픽셀이 하늘인가? 도로인가? 사람인가?”를 예측하는 과정이다.

이를 수행하기 위해서는 각 픽셀의 정보뿐 아니라 주변 영역의 문맥(Context) 을 함께 고려해야 한다.
→ 이러한 “픽셀이 주변을 얼마나 넓게 보는가”를 설명하는 개념이 바로 Receptive Field(수용 영역) 이다.

Receptive Field

정의: 특정 Feature를 형성하기 위해 필요한 입력 이미지의 영역 크기.

즉, 한 Feature가 “얼마만큼의 입력 픽셀을 기반으로 만들어졌는가”를 나타낸다.
Receptive Field가 넓을수록 → 더 넓은 문맥 정보를 반영한 Feature를 학습 가능.

Receptive Field를 키우는 기존 접근

Pooling (Max/Average Pooling)
- Feature Map 크기를 줄여서 Receptive Field를 간접적으로 확장.
- 단점: 해상도 손실로 인해 디테일 정보가 사라짐.
Strided Convolution
- Convolution의 stride를 키워 feature를 압축하면서 Receptive Field 확장.
- 단점: 정보 손실 존재.
Filter Size를 직접 키우기 (예: 3×3 → 7×7)
- 파라미터 수와 연산량이 급격히 증가.
- 계산비용과 과적합 위험 증가.

- Dilated (Atrous) Convolution

필터 커널 사이에 “구멍(hole)”을 뚫어 간격을 띄운 형태의 컨볼루션. 즉, 같은 수의 파라미터(같은 3×3 필터) 를 사용하면서 더 넓은 영역을 커버하도록 설계한 기법.

D = 1: 일반적인 Convolution (연속된 픽셀 관찰)
D = 2: 한 칸씩 건너뛰며 관찰 (구멍이 하나씩 생김)
D = 3: 두 칸을 띄워 관찰 → 중간 픽셀은 보지 않지만, Receptive Field가 넓어짐.

3×3 필터는 여전히 9개의 파라미터를 사용하지만 실제로는 5×5, 7×7 수준의 넓은 영역을 관찰하는 효과를 냄. 연산량 증가 없이 Receptive Field 확장 가능.

픽셀 단위 분류(Semantic Segmentation)는 디테일 정보와 전역 정보 모두 필요함. Pooling으로 해상도를 줄이는 대신 Dilated Convolution을 사용해 세밀한 픽셀 정보는 유지하면서 전역 문맥 정보까지 확보 가능.

DeepLab

Dilated Convolution을 도입한 대표적 시멘틱 세그멘테이션 모델
Google이 제안, 버전별로 진화:
- DeepLab v1 → v2 → v3 → v3+
기본 철학: Receptive Field를 넓히되, 공간 해상도 손실 없이 픽셀 단위 분류 정밀도를 높이자.

(1) Encoder-Decoder 구조

Encoder: CNN 기반 (예: ResNet)
Decoder: Bilinear Upsampling 또는 Transposed Convolution으로 크기 복원

(2) 핵심: Atrous (Dilated) Convolution 도입

Receptive Field를 확장하면서 Feature의 공간적 크기는 유지.

(3) 결과적 문제점

Upsampling만으로 복원하면 경계가 흐릿하고 Coarse한 결과 발생.→ 후처리(Post-processing) 필요.

DeepLab의 후처리: Fully Connected Conditional Random Field (CRF)

- egmentation 결과를 정제(Refine) 하기 위한 별도의 후처리 단계. 신경망 학습과는 별개로 수행되며, 예측된 확률 맵(Logit Map)을 입력으로 받는다.

입력 이미지와 예측된 Segmentation Score Map을 기반으로, 픽셀 간 유사도(색상·위치)를 고려해 경계선을 부드럽게 맞춤.
Belief Propagation, MCMC, Bilateral Filter 등 확률 그래프 기반 알고리즘 사용.

(2) Loss ( Unary Term + Pairwise Term )

Unary Term:
각 픽셀의 예측 확률(딥러닝 결과값). Cross Entropy Loss와 유사한 단일 픽셀 기반 정보.
Pairwise Term:
인접 픽셀 간의 관계(색상 차이, 거리 등) 고려. 가까우면서 색상 유사한 픽셀은 같은 클래스로 유도.

Atrous Spatial Pyramid Pooling (ASPP)

서로 다른 dilation factor를 병렬로 적용해 다양한 스케일의 정보 취합. 다양한 스케일의 문맥 정보를 통합.

DeepLab v3+에서 ASPP와 전체 아키텍쳐

1×1 Conv	-	채널 축소
3×3 Conv	6	좁은 Receptive Field
3×3 Conv	12	중간 Receptive Field
3×3 Conv	18	넓은 Receptive Field
Image Pooling	-	전역 문맥(Global Context) 반영

→ 이 결과들을 Concat → 1×1 Conv → Feature Map 통합.

Encoder: Dilated Conv + ASPP

Decoder: Upsampling + Low-level Feature 병합

입력 해상도가 (H×W)라면, 인코더 출력 Feature는 약 (H/16 × W/16) 수준으로 축소됨.

Decoder는 이를 4배 업샘플링 후, (H/4 × W/4) 레벨의 Feature와 Concat하여 세밀한 복원 수행.

+ 그 후 최종 출력 및 후처리로 구

Softmax를 통과하여 각 픽셀별 클래스 확률 분포 생성.
경계가 흐릿할 경우 CRF로 정제.
반복 적용 시 점차 Ground Truth에 가까운 세그멘테이션 결과 획득.

Probabilistic Graphical Model 확률 그래프 모델 (CRF의 배경)

CRF는 확률 그래프 모델(Probabilistic Graphical Model, PGM)의 한 종류로, 픽셀을 노드, 픽셀 간 관계를 엣지로 하는 그래프 구조로 표현한다.
Fully Connected CRF는 모든 픽셀 쌍이 연결되어 있어,전역적으로 경계 정제를 수행하는 효과를 가진다.

정리

Instance Segmentation

시멘틱 세그멘테이션은 영상의 각 픽셀마다 클래스(의미)를 예측하는 문제이다. 예를 들어 자동차가 여러 대 있는 이미지에서, 모든 자동차 픽셀은 전부 같은 “car” 클래스로 라벨링된다. 따라서 “자동차 1”, “자동차 2”처럼 개별 객체(Instance)를 구분하지 못한다는 한계가 존재한다.

Instance Segmentation은 시멘틱 세그멘테이션 + 객체 인스턴스 구분(Object Instance Identification) 각 픽셀의 클래스뿐 아니라 “어떤 객체에 속하는 픽셀인가” 를 함께 예측한다.

→ 시멘틱 세그멘테이션이 인스턴스를 구분하지 못하므로, Object Detection 기능을 결합하는 것이 핵심 아이디어다. 객체 검출로 얻은 Bounding Box 내부에서 픽셀 분류를 수행하면 각 객체별 마스크가 생성된다.

데이터셋과 첼린지로는 대표적으로 DAVIS Challenge (Densely Annotated Video Segmentation)와 데이터셋이 있는데 각 객체 인스턴스별로 픽셀 단위 마스크가 제공되어 인스턴스 세그멘테이션 학습에 활용 가하고 여러 객체가 프레임마다 개별적으로 라벨링되어 있어 Tracking, Segmentation 연구의 기반이 된다.

Mask R-CNN

Mask R-CNN의 핵심 아이디어

Faster R-CNN에 Segmentation Mask Prediction Branch를 추가.
즉, Object Detection (Faster R-CNN) + Semantic Segmentation = Instance Segmentation

Classification + Bounding Box Regression + Mask Prediction까지 세 가지를 동시에 학습하는 Multi-Task Learning 구조이다. ROIpooling 대신 ROIAlign이 들어간 형태

Multi-Task Learning 효과

서로 관련성 높은 태스크를 함께 학습하면 공유 Feature 표현력이 향상된다.
Mask Branch 추가만으로도 Classification 성능이 향상되는 경우가 있다.
이유: Segmentation Loss 학습 중 추출된 세밀한 Feature가 다른 태스크에도 도움이 되기 때문.

입력 이미지  
   ↓  
Backbone CNN  
   ↓  
Region Proposal Network (RPN)  
   ↓  
ROI Align → Feature Extraction  
   ├── Classification + Bounding Box Regression (Faster R-CNN 기능)  
   └── Mask Head (FCN 기반 Segmentation Branch)

각 ROI마다 14×14×256 Feature Map을 생성한 뒤

Classification + Box Regression → 객체 종류 및 위치 예측
Mask Branch → 픽셀 단위 이진 마스크 예측 (0 = 배경, 1 = 객체)

마스크 예측 (14×14×C 출력)

클래스 수 C 만큼 채널을 두고, 각 채널은 해당 클래스의 Binary Mask (0 또는 1).
예: 사람 → 14×14 Mask, 개 → 14×14 Mask 등.
Upsampling 을 통해 입력 크기 (H×W) 에 맞게 복원.

ROI Pooling vs ROI Align

	ROI Pooling	ROI Align
연산	Feature Map 을 정수 좌표로 강제 맞춤	부동소수점 좌표 보정 및 보간
문제점	정수 좌표 매핑 시 오차 발생	위치 정확도 향상 (Interpolation 사용)
방식	Max Pooling	Bilinear Interpolation → Max Pooling

→ ROI Align 은 Mask R-CNN의 정확도 상승의 요소중 하나

ROI Align은 ROI Pooling에서 발생하는 좌표 quantization(정수 반올림) 오차 문제를 해결하기 위해 제안되었다. 즉, 원래의 feature map 상의 위치를 소수점 단위로 보존하고, 그 지점의 feature 값을 bilinear interpolation을 통해 더 정확히 샘플링한다.

RCNN 계열 정리

Panoptic segmentation

- Segmentation의 발전 과정

Segmentation은 크게 Semantic Segmentation, Instance Segmentation, 그리고 이 두 가지를 결합한 Panoptic Segmentation으로 발전해 왔다.

Semantic Segmentation
입력된 이미지의 각 픽셀을 ‘무엇인지(what)’ 기준으로 구분한다.
예를 들어, 하늘, 건물, 도로, 자동차 등을 분류하지만, 동일 클래스 내 개별 객체 구분(자동차1, 자동차2 등)은 하지 않는다.
Instance Segmentation
Countable한 객체(Things) — 예: 사람, 자동차 등 — 에 대해
각각의 인스턴스에 고유한 ID를 부여하여 구분한다. 하지만, 하늘·풀·도로 같은 Stuff(Count 불가능한 영역)은 다루지 않는다.
Panoptic Segmentation
Semantic과 Instance Segmentation을 통합한 형태이다.
- Things(Countable) → Instance Segmentation 수행 (ID 부여)
- Stuff(Uncountable) → Semantic Segmentation 수행 (클래스 단위)
  따라서 하늘·건물은 하나의 클래스 마스크로, 자동차·사람은 인스턴스별로 구분된다.

Penoptic Segmentation의 대표 모델 – Penoptic FPN

(1) FPN(Feature Pyramid Network) Recap

FPN은 이러한 서로 다른 레벨의 feature들을 multi-scale로 fusion하여,정보 손실 없이 풍부한 feature map을 만드는 구조

2025.09.25 - [분류 전체보기] - [Segmentation] DeepLab, Mask R-CNN, PanopticFPN

(2) Penoptic FPN 구조 개요

- Penoptic FPN은 FPN을 기반으로 두 개의 브랜치로 나뉜다.

상단 브랜치 (Instance Segmentation)

Mask R-CNN 구조 그대로 사용
Region Proposal Network → ROI Align → Mask Head
- Class (분류)
- Bounding Box (좌표 예측)
- Instance Mask (픽셀 단위 마스크)

하단 브랜치 (Semantic Segmentation)

FPN에서 추출한 shared feature를 이용하여 pixel 단위의 segmentation 수행
하늘, 건물, 도로 등 Stuff 클래스에 대한 Semantic Segmentation
CNN decoder를 사용하여 feature map을 upsampling (32분의1 → 4분의1 → 원본 크기)

- Asymmetric Feature Pyramid Network (비대칭 FPN)

Penoptic FPN의 중요한 특징은 비대칭적(asymmetric) FPN 구조이다.

기존 RetinaNet, FPN은 Symmetric 구조를 사용한다. 모든 단계의 feature가 동일한 채널 수(C)로 유지됨.

Penoptic FPN은 Asymmetric 구조를 사용:

백본에서 나온 feature의 채널 수를 1×1 Convolution으로 축소
예: 1024 → 256 채널, 512 → 256 채널 등

이유:
- 연산량(곱셈·덧셈)을 줄이기 위해서
- Memory, computational complexity 절감
- 성능 저하 없이 효율적 연산 가능

- Semantic Segmentation 하부 Branch 세부 구조

하단 브랜치에서 수행되는 시멘틱 세그멘테이션은 다음 조건을 만족해야 한다

High-resolution feature 확보
Multi-level feature 고려
풍부한 semantic 정보 유지

Backbone + Neck(FPN)에서 얻은 feature를 기반으로 함.
각 feature map은 원본 대비 1/32 크기에서 출발.
Convolution → Upsampling(×2) → Convolution → Upsampling(×2) 반복
→ 최종적으로 1/4 크기 feature map 생성.
각 단계에서 채널 수 조정 (예: 256 → 128)
모든 feature map의 크기와 채널이 동일하므로 element-wise sum 가능.
최종적으로 합쳐진 feature를 convolution 후 4배 업샘플링하여 원본 크기로 복원.
출력: Stuff 클래스(예: Grass, Sky, Building 등)에 대한 Semantic Mask

학습 (Training) — Multi-Task Learning

Penoptic FPN은 Instance Segmentation + Semantic Segmentation을 동시에 수행해야 하므로 Multi-Task Learning 구조를 사용한다.

(1) Instance Segmentation Loss

Classification Loss: 객체 분류용 Cross Entropy Loss
Bounding Box Regression Loss: Smooth L1 또는 MSE Loss
Mask Loss: 픽셀 단위 Cross Entropy Loss

(2) Semantic Segmentation Loss

Stuff 클래스용 Pixel-wise Cross Entropy Loss 추가

최근 발전 방향

(1) Transformer 기반 Segmentation

CNN 대신 Transformer를 활용:

SegFormer, MaskFormer 등의 모델이 대표적
장점: Long-range dependency를 학습하여 더 넓은 공간적 관계 인식 가능

(2) 비디오 기반 Segmentation

단일 이미지가 아닌 연속 프레임(video) 단위 세그멘테이션 수행
시간적 일관성을 유지하기 위해 Neural Memory 모듈을 사용
(하드웨어 메모리가 아닌, 뉴럴 네트워크 기반 메모리)

(3) Foundation Model 기반 Segmentation

Segment Anything Model (SAM)
- Meta가 공개한 범용 세그멘테이션 파운데이션 모델
- 방대한 데이터로 학습되어 제로샷(Zero-shot) Segmentation 가능
- 다양한 downstream task에 fine-tuning 가능

(4) 생성 모델 기반 Segmentation (Generative Segmentation)

Segmentation은 전통적으로 판별(discriminative) 태스크였다.
하지만 최근에는 생성(Generative) 모델을 이용한 접근이 연구되고 있다.

Diffusion Model 기반 접근:
- Diffusion 과정에서의 Attention Map을 이용하여
  모델이 "어디를 보고 생성하는가"를 분석 → Segmentation으로 활용
- Attention Map은 곧 시각적 집중 영역(Salient Region)으로
  Segmentation Mask와 동일한 역할 수행 가능
관련 연구: SegRef, Deformer, DiffusionNet 등
→ 생성 모델의 시각적 집중 영역을 세그멘테이션으로 변환

정리

Semantic Segmentation: 클래스별 영역 분류
Instance Segmentation: 개별 객체별 ID 분류
Panoptic Segmentation: 두 가지의 통합 형태
Penoptic FPN: FPN 기반 멀티태스크 학습 구조로 효율적이며,
Stuff와 Things를 동시에 세그멘테이션 수행, Asymmetric FPN 구조를 통해 연산 효율 극대화

[Segmentation] Semantic Segmentation 알아보기 FCN, U-Net

임승택 — Wed, 24 Sep 2025 19:54:31 +0900

이번 포스팅에서는 시멘틱 세그멘테이션(Semantic Segmentation) 에 대해 다뤄보았다

시멘틱 세그멘테이션이란?

Segmentation → 분할, 나누기
Semantic → 의미론적인

우리는 컴퓨터 비전을 배웠기 때문에 Image Segmentation 방법론에 대해 들어봤을 것이다. 의미와 상관없이 비슷한 색, 밝기, 질감 등을 기준으로 영역을 나누는 방법론 등이 있었는데 정리해보자면

Thresholding, Edge Detection / Watershed, Clustering기법, Graph-based Segmentation등이 있었다. 더 나아가서는 Selective Search같은 방법도 배웠다.

오늘 알아볼 Semantic Segmentation은 단순히 색상이나 질감이 아니라, “이 픽셀이 무엇인가?”를 학습 기반으로 분류한다.

Instance Segmentation은 다음에 포스팅 해보겠다.

예를 들어 사람과 고양이가 함께 있는 사진이 있다면, 모델은 모든 픽셀마다 ‘이건 사람’, ‘이건 고양이’, ‘이건 배경’ 이라고 예측한다. 즉, 이미지의 각 픽셀에 클래스 라벨(Class Label) 이 부여됨

하지만 픽셀 하나만 보고는 “이게 뭔지” 알 수 없다. 주변 문맥(Context)이 없으면 사람도, 모델도 구분할 수 없는것이다.

그래서 모델은 보통 주변 영역(윈도우, window) 을 함께 참고하는데

각 픽셀마다 윈도우를 적용하면 겹치는 중복 연산이 너무 많아져 비효율적이다.

이 문제를 해결하기 위해 이미지 전체를 CNN에 통째로 입력하여 사용하는 아이디어가 제시되었다. 하지만 위 사진 처럼 CNN을 사용하게 되면 Low-level Feature들만 사용되는 느낌이 있어 다운샘플링이 필요하다.

Encoder–Decoder 구조

이 한계를 해결하기 위해 등장한 구조가 바로 Encoder–Decoder 구조이다.

- Encoder (인코더):

인코더의 목표는 이미지의 의미를 요약하는 것이다. 원본 이미지를 점점 압축해가며, 중요한 정보만 남기고 나머지는 버린다.

입력 이미지를 여러 단계의 Convolution + Pooling 을 통해 다운샘플링
이미지의 크기(H×W)는 줄어들지만, 채널(Channel, Feature Map)은 많아짐
결과적으로, 전역적인 문맥(Context) 을 담은 압축된 표현(Feature) 을 얻음

- Decoder (디코더):

디코더는 인코더의 반대 역할을 수행한다. 압축된 Feature Map을 다시 원래 이미지 크기로 되돌리면서,
Semantic Segmentation에는 각 픽셀에 “무엇인지”를 예측한다.

Up Sampling, Transpose Convolution, Unpooling 등을 사용
점점 크기를 복원하며, 각 픽셀에 대한 클래스 확률을 출력
최종 출력은 입력 이미지와 동일한 크기의 H×W 마스크

Up Sampling 기법

이것도 영상처리나 비전 공부에서 봤을 것이다. 줄어든 영상의 크기를 다시 늘려줘야 하기 때문에 Up Sampling 기법을 사용해야하는데 가장 가까운 픽셀 값을 그대로 복사해서 확대하는 Nearest Neighbor, 값을 그대로 유지하고 나머지는 0으로 채우는 방법 Bed of Nails, 최댓값의 위치(index) 를 저장해두었다가 사용하는 Max Unpooling 등이 있겠다.

그중에서 디코더의 핵심은 Transpose Convolution (Deconvolution)이다

Transpose Convolution은 일반 Convolution의 “역방향”처럼 작동하며, Feature Map의 크기를 키우는 역할을 한다.

예를 들어

일반 Convolution: 4×4 입력 → 3×3 필터 → 2×2 출력

Transpose Convolution: 2×2 입력 → 3×3 필터 → 4×4 출력

참고

1. 체크보드 패턴(Checkerboard Artifact)

- Transpose Convolution에서는 필터 겹침(Overlap) 구간이 생긴다.

따라서 Transpose Convolution 사용시에는 Stride와 Kernel Size를 적절히 설정 (예: Stride=2, Kernel=2) 하거나 Bilinear / Nearest Neighbor Interpolation 후 일반 Conv로 정제하는 테크닉이 필요하다

2. “Transpose(전치)”라는 이름의 이유

컨볼루션 연산은 실제로 다음과 같은 행렬 곱 형태로 쓸 수 있수 있는데 . y = W × x

x는 입력 이미지(4×4)를 벡터 형태(16×1) 로 펼친 것
W는 필터를 적용하는 역할을 하는 큰 행렬(4×16)
y는 출력(2×2)을 펼친 4×1 벡터

스파스 행렬(Sparse Matrix)

이때의 W는 대부분이 0(Zero) 인 희소행렬(Sparse Matrix) 이 되는데 예를 들어, W의 한 행(row)은 필터가 특정 위치에서 본 3×3 영역의 위치를 반영한다.

그렇게 이제 x' = Wᵀ × y으로 보고 W가 전치된 Wᵀ와 y를 보고 x'를 구할 수 있게 되는것이다.

- 참고로 x'는 예측 값이고 x는 아님

https://excelsior-cjh.tistory.com/130

[코딩더매트릭스]Chap05 - 행렬 The Matrix

깃헙으로 Jupyter Notebook을 볼 경우 LaTex 문법이 깨지는 경우가 있어 되도록 nbviewer로 보는 것을 추천한다. nbviewer에서 보기Chap 05 - 행렬(The Matrix)5.1 행렬이란 무엇인가?5.1.1 전통적인 행렬일반적

excelsior-cjh.tistory.com

시멘틱 세그멘테이션과 Dense Prediction

Dense Prediction의 개념

Dense Prediction은 이미지의 각 픽셀 단위로 예측을 수행하는 작업을 의미한다. 예를 들어 RGB 이미지로부터 깊이(depth)를 추론하거나, 각 픽셀이 어떤 객체에 속하는지를 예측하는 시멘틱 세그멘테이션(Semantic Segmentation)이 대표적인 예다. 이런 Dense한 예측을 위해서는 인코더(Encoder)와 디코더(Decoder)가 연결된 구조가 자주 사용된다.

FCN (Fully Convolutional Network)

FCN은 시멘틱 세그멘테이션 분야에서 인코더–디코더 구조를 처음으로 도입한 모델 중 하나이다.
입력 이미지는 인코더를 거치며 점차 크기가 줄어드는 다운샘플링(Encoding) 과정을 거치고, 이후 디코더에서 업샘플링(Decoding) 되어 픽셀 단위로 분류되는 결과(세그멘테이션 마스크)를 출력한다.

특징

1. Fully Connected Layer 제거

일반적인 CNN 분류(Classification)에서는 마지막에 Flatten 후 FC Layer를 통해 최종 클래스를 예측한다.

하지만 FCN에서는 이를 컨볼루션(Convolution) 으로 대체하여 “Fully Convolutional” 구조를 만들었다.

Fully Connected Layer의 문제점

위치 정보 손실(Location Information Loss)
- FC Layer는 입력을 일렬로 펼치므로 공간적 위치 정보(spatial information)가 사라진다.
- Convolution은 지역적 필터를 사용하므로 위치 정보를 보존하지만, FC Layer는 이를 파괴한다.
입력 크기 고정 문제(Input Size Dependency)
- FC Layer는 입력 Feature의 차원 수가 고정되어 있어, 학습한 입력 크기 이외의 이미지는 처리할 수 없다.
- Convolution으로 대체하면 입력 크기 변화에 유연해지며, 위치 정보도 유지된다.

기존 방식

예: 512×7×7 Feature → 4096차원 벡터로 Flatten
→ 512×7×7 × 4096개의 weight 필요

FCN 방식

동일한 연산을 7×7 Convolution Filter로 구현
필터를 4096개 사용하면 동일한 연산 수행 가능
출력은 1×1×4096 텐서(즉, height=1, width=1, channel=4096)
이후 1×1 Convolution을 적용하여 21개 클래스(파스칼 VOC 기준)로 매핑

이 방식은 FC Layer를 Convolution으로 바꾸어 공간 정보를 유지하면서도 다양한 입력 크기를 처리할 수 있게 한다.

- 1×1 Convolution을 이용한 Class Prediction

4096채널 Feature Map에 대해 1×1 필터를 21개 사용하면, 각 픽셀마다 21개의 클래스 확률을 추론할 수 있다.
즉, 픽셀 단위의 분류(Semantic Segmentation) 가 가능해진다. 이 구조 덕분에 FCN은 Fully Connected Layer 없이도 선형 연산(Linear Transformation)과 같은 효과를 낼 수 있다.

- 업샘플링(Decoding): Transpose Convolution

인코더에서 축소된 Feature Map을 원래 이미지 크기로 복원하기 위해 Transpose Convolution(전치 합성곱) 을 사용한다.
과거에는 Deconvolution이라는 용어를 썼지만, 현재는 잘못된 표현으로 간주된다.

예를 들어, 인코더 출력이 4×4라면 Transpose Convolution으로 32배 확대하여 128×128로 복원할 수 있다.

하지만 한 번에 너무 크게 업샘플링하면 결과가 Coarse(엉성) 해진다.
이를 해결하기 위해 FCN에서는 Multi-Level Feature와 Skip Architecture를 도입했다.

- Skip Architecture (Skip Connection)

중간 Feature를 활용해 여러 단계로 업샘플링하면서 세밀한 정보를 복원한다.

마지막 Feature를 업샘플링하여 중간 Feature와 합친다 (Element-wise Sum)
다시 업샘플링하여 더 낮은 레벨의 Feature와 합친다
마지막으로 전체 크기로 업샘플링하여 Softmax로 픽셀별 분류 수행

이 구조는 Residual Network(ResNet)의 Identity Skip과 유사하며, 중간 Feature를 Refine(정제) 하여 더 파인(Fine)한 결과를 만든다.

정리 : FCN의 주요 기여점 (Contribution)

Fully Convolutional Operation 도입
- FC Layer를 모두 Convolution으로 대체하여
  - 위치 정보 손실 방지
  - 입력 크기 제약 해소
Transpose Convolution을 통한 학습 가능한 업샘플링
- 단순한 보간이 아닌, 학습 가능한 업샘플링 구조로 세밀한 복원 가능
Skip Architecture 도입 (Coarse to Fine)
- Multi-Level Feature 결합을 통해 엉성한 결과를 정제하고,
  세밀한 경계 복원이 가능한 구조 제안

U-Net

U-Net은 네트워크의 모양이 U자 형태를 띠기 때문에 붙여진 이름이다.
구조적으로는 앞서 설명한 FCN(Fully Convolutional Network) 과 유사하지만, 인코더(Encoder)와 디코더(Decoder) 를 연결하는 스킵 커넥션(Skip Connection) 방식에서 차별화된다.

특히 인코더에서 추출된 Feature Map을 디코더로 전달할 때 덧셈(Sum) 이 아닌 Concatenate(채널 방향 결합) 방식을 사용하는 것이 특징이다. 이 구조는 로컬라이제이션(위치 정보)을 보다 정확하게 보존하기 위해 설계되었다.

- 인코더(Contracting Path)

입력: 572×572×1
연산: Convolution(3×3, padding 없음) → Activation → Normalization
결과: 570×570×64 Feature Map 생성
또 한 번 3×3 Convolution → 568×568×64
이후 Pooling(Max Pool, stride=2)을 사용하여
공간 크기를 절반(284×284)으로 줄이면서 채널 수는 2배(128)로 증가시킴
이 과정을 반복하여 점차 공간 크기를 줄이고, 채널 수를 늘림
→ Feature의 추상화 수준이 점점 높아짐

- 디코더(Expanding Path)

디코더는 인코더의 반대 역할을 한다.

Transpose Convolution (UpConv) 사용
- 2×2 필터, stride=2
- Feature Map의 공간 크기를 2배씩 키움
각 단계마다 Convolution(3×3)을 2회 적용하여 Feature를 정제(refine)
인코더의 Feature를 Concatenate하여 결합
- 공간 크기가 맞지 않으면 Crop하여 정렬 후 Concatenate
- Concatenate는 채널 방향(channel-wise) 으로 수행됨

이 과정을 반복하여 Feature Map 크기를 점점 늘리고 채널 수를 절반씩 줄여
최종적으로 입력과 동일한 크기의 출력 이미지를 얻는다.

결과적으로

위치 정보(Localization) 보존
- 인코더 하단부로 갈수록 Feature가 추상화되어 위치 정보가 손실된다.
- 상단부 Feature(공간 크기 큰 Feature)를 직접 전달하여
  세밀한 위치 정보(로컬 정보)를 보존할 수 있다.
Context 정보와의 결합
- 낮은 레벨의 Feature는 위치 정보가 풍부하지만 문맥 정보가 부족하다.
- 깊은 레벨의 Feature는 문맥 정보는 풍부하지만 위치 정보가 손상된다.
- 두 Feature를 Concatenate하여 로컬 + 글로벌 정보를 모두 활용한다.

+ 백프로파게이션 시, 스킵 커넥션은 그래디언트(Gradient)의 흐름을 원활히 해주어 Vanishing Gradient(그래디언트 소실) 문제를 완화한다. 이는 ResNet의 Identity Shortcut이 가지는 이론적 효과와 동일하다.

https://arxiv.org/abs/1505.04597

U-Net: Convolutional Networks for Biomedical Image Segmentation

There is large consent that successful training of deep networks requires many thousand annotated training samples. In this paper, we present a network and training strategy that relies on the strong use of data augmentation to use the available annotated

arxiv.org

https://arxiv.org/abs/1411.4038

Fully Convolutional Networks for Semantic Segmentation

Convolutional networks are powerful visual models that yield hierarchies of features. We show that convolutional networks by themselves, trained end-to-end, pixels-to-pixels, exceed the state-of-the-art in semantic segmentation. Our key insight is to build

arxiv.org

[Deep Learning] Partial Fine-Tuning 해보기

임승택 — Fri, 19 Sep 2025 18:50:43 +0900

Feature Extractor만 활용해보는 ResNet50 전이학습

딥러닝 모델을 학습할 때, 모델 전체를 처음부터 학습(From Scratch) 하는 것은 시간도 오래 걸리고, 많은 데이터가 필요하다.

그래서 우리는 보통 전이학습(Transfer Learning) 을 이용한다. 그중에서도 이번 글에서는 Partial Fine-Tuning, 즉 Feature Extractor만 사용하는 전이학습을 직접 실험해본다.

Fine-Tuning의 세 가지 방식

먼저 개념을 간단히 정리해보자.

From Scratch	랜덤 초기화로 처음부터 학습
Full Fine-Tuning	ImageNet 등 사전학습 가중치로 초기화 후 전체 재학습
Partial Fine-Tuning (Feature Extractor)	사전학습된 백본을 고정(Freeze)하고 마지막 FC 레이어만 학습

Partial Fine-Tuning은 모델이 이미 학습한 일반적인 시각적 특징(feature) 을 그대로 활용하고, 새 데이터셋에 맞게 마지막 분류기(classifier) 만 조정하는 방식이다.

코드 구현

import torch
import torchvision.transforms as transforms
from torchvision.datasets import ImageFolder
from torchvision import models
from torch.utils.data import DataLoader
import torch.nn as nn
import torch.optim as optim
from torch.optim import lr_scheduler
import os, time, copy

# 학습 함수 정의
def train_resnet(model, criterion, optimizer, scheduler, num_epochs=25):
    best_model_wts = copy.deepcopy(model.state_dict())
    best_acc = 0.0
    for epoch in range(num_epochs):
        print(f'-------------- epoch {epoch+1} ----------------')

        for phase in ['train', 'val']:
            model.train() if phase == 'train' else model.eval()
            running_loss, running_corrects = 0.0, 0

            for inputs, labels in dataloaders[phase]:
                inputs, labels = inputs.to(DEVICE), labels.to(DEVICE)
                
                optimizer.zero_grad()

                with torch.set_grad_enabled(phase == 'train'):
                    outputs = model(inputs)
                    _, preds = torch.max(outputs, 1)
                    loss = criterion(outputs, labels)
                    if phase == 'train':
                        loss.backward()
                        optimizer.step()

                running_loss += loss.item() * inputs.size(0)
                running_corrects += torch.sum(preds == labels.data)

            if phase == 'train':
                scheduler.step()

            epoch_loss = running_loss / dataset_sizes[phase]
            epoch_acc = running_corrects.double() / dataset_sizes[phase]
            print(f'{phase} Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}')

            if phase == 'val' and epoch_acc > best_acc:
                best_acc = epoch_acc
                best_model_wts = copy.deepcopy(model.state_dict())

        print(f'Best val Acc so far: {best_acc:.4f}')
    model.load_state_dict(best_model_wts)
    return model

model.train() => train 단계: 모델이 가중치를 업데이트함
model.eval() => val 단계: 학습된 모델의 일반화 성능을 확인함

optimizer.zero_grad() → 이전 배치에서 계산된 gradient 초기화

=> PyTorch는 기본적으로 gradient를 누적하므로 매 step마다 초기화

with torch.set_grad_enabled(phase == 'train'):
    outputs = model(inputs)
    _, preds = torch.max(outputs, 1)
    loss = criterion(outputs, labels)
    if phase == 'train':
        loss.backward()
        optimizer.step()

torch.set_grad_enabled(phase == 'train')
→ 학습 단계(train)에서만 gradient 계산 활성화,
검증(val)에서는 비활성화 → 메모리 절약 및 속도 향상
outputs = model(inputs) → forward propagation 수행
torch.max(outputs, 1) → softmax 결과 중 가장 높은 확률을 가진 클래스의 index를 예측(preds)
criterion(outputs, labels) → CrossEntropyLoss 계산
loss.backward() → gradient 계산 (오차 역전파)
optimizer.step() → 가중치 갱신

if phase == 'train':
    scheduler.step()

학습 단계가 끝날 때마다 StepLR 스케줄러를 한 번 호출
일정 에폭(step_size)마다 학습률을 gamma 비율만큼 줄임

data_transforms = {
    'train': transforms.Compose([
        transforms.Resize([64, 64]),          # 이미지 크기 통일
        transforms.RandomHorizontalFlip(),    # 좌우 반전
        transforms.RandomVerticalFlip(),      # 상하 반전
        transforms.RandomCrop(52),            # 무작위 크롭 (데이터 증강)
        transforms.ToTensor(),                # Tensor로 변환
        transforms.Normalize([0.485, 0.456, 0.406],
                             [0.229, 0.224, 0.225])  # ImageNet 정규화 값
    ]),
    'val': transforms.Compose([
        transforms.Resize([64, 64]),
        transforms.RandomCrop(52),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406],
                             [0.229, 0.224, 0.225])
    ])
}

Normalize()는 ImageNet 데이터셋의 평균, 표준편차로 정규화하여 사전학습된 모델(ResNet50) 의 입력 분포와 맞춰준다.

데이터셋 및 데이터로더 정의

data_dir = './splitted'  # train, val 폴더가 들어있는 상위 폴더
image_datasets = {
    x: ImageFolder(root=os.path.join(data_dir, x),
                   transform=data_transforms[x])
    for x in ['train', 'val']
}

dataloaders = {
    x: DataLoader(image_datasets[x],
                  batch_size=BATCH_SIZE,
                  shuffle=True,
                  num_workers=4)   # CPU 4개로 데이터 병렬 로드
    for x in ['train', 'val']
}

dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}
class_names = image_datasets['train'].classes

ImageFolder : 폴더 구조를 자동으로 라벨링하여 Dataset으로 변환

ResNet50 모델 정의 ( From Scratch, Full Fine-Tuning, Partial Fine-Tuning )

From Scratch

resnet = models.resnet50(pretrained=False)

num_ftrs = resnet.fc.in_features
resnet.fc = nn.Linear(num_ftrs, 33)

resnet = resnet.to(DEVICE)  # GPU로 이동

완전 처음부터 학습

in_features : 기존 fc 레이어의 입력 뉴런 수(in_features) 를 가져오고

resnet.fc : 기존 1000-class 출력을 33-class로 교체한다

Full Fine-Tuning

resnet = models.resnet50(pretrained=True)
num_ftrs = resnet.fc.in_features
resnet.fc = nn.Linear(num_ftrs, 33)

resnet = resnet.to(DEVICE)  # GPU로 이동

pretrained=True로 ImageNet 사전학습 가중치를 불러와서 train

Partial Fine-Tuning

resnet = models.resnet50(pretrained=True)
print(">>> Using Partial Fine-Tuning version (Feature Extractor)")

for param in resnet.parameters():
    param.requires_grad = False  # Feature Extractor 부분 Freeze

num_ftrs = resnet.fc.in_features
resnet.fc = nn.Linear(num_ftrs, 33)

for param in resnet.fc.parameters():
    param.requires_grad = True   # 마지막 FC만 학습

resnet = resnet.to(DEVICE)  # GPU로 이동

pretrained=True로 ImageNet 사전학습 가중치를 불러옵니다.
requires_grad=False → ResNet의 백본(Feature Extractor) 부분을 동결시켜 학습 제외
requires_grad=True : 새로운 FC 레이어만 학습 대상

손실함수 / 옵티마이저 / 스케줄러 설정

criterion = nn.CrossEntropyLoss()  # 다중 클래스 분류용 Loss

optimizer_ft = optim.Adam(
    filter(lambda p: p.requires_grad, resnet.parameters()),
    lr=0.001
)

exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1)

결과

From Scratch는 가중치를 처음부터 학습했음에도 95.61%로 높은 성능을 보였다.

Full Fine-Tuning은 사전학습된 가중치를 기반으로 모든 레이어를 재학습해 99.13%의 최고 정확도를 기록했다.
반면 예상외로 Partial Fine-Tuning은 Feature Extractor를 고정하고 FC 레이어만 학습해 79.19%로 가장 낮은 정확도를 보였다.

데이터셋의 이미지 특성이 ImageNet과 달라서 그런 것 같기도 하고 모델이 새로운 데이터셋의 특성에 충분히 적응하지 못했던 것 같다.

검증 및 결과

import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision.transforms as transforms
from torchvision.datasets import ImageFolder
from torch.utils.data import DataLoader

def evaluate(model, test_loader):
    model.eval()
    test_loss = 0
    correct = 0

    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(DEVICE), target.to(DEVICE)
            output = model(data)

            test_loss += F.cross_entropy(output, target, reduction='sum').item()

            pred = output.max(1, keepdim=True)[1]
            correct += pred.eq(target.view_as(pred)).sum().item()

    test_loss /= len(test_loader.dataset)
    test_accuracy = 100. * correct / len(test_loader.dataset)
    return test_loss, test_accuracy

if __name__ == '__main__':
    USE_CUDA = torch.cuda.is_available()
    DEVICE = torch.device("cuda" if USE_CUDA else "cpu")
    BATCH_SIZE = 256

    transform_resNet = transforms.Compose([
        transforms.Resize([64, 64]),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ])

    # Evaluate model
    test_resNet = ImageFolder(root='./splitted/test', transform=transform_resNet)
    test_loader_resNet = torch.utils.data.DataLoader(test_resNet, batch_size=BATCH_SIZE, shuffle=False, num_workers=4)

    '''
    Compare the transfer-learned model with the learned model from scratch
    '''
    resnet = torch.load('resnet50_from_partial_0.7919.pt', weights_only=False)   # change model
    # resnet = torch.load('resnet50_from_pretrained_0.9913.pt') # change model
    # resnet = torch.load('resnet50_from_scratch_0.9561.pt') # change model
    print(resnet)
    resnet.to(DEVICE)
    test_loss, test_accuracy = evaluate(resnet, test_loader_resNet)

    print('test acc: ', test_accuracy)

ResNet50 Train과 Test 데이터셋으로 검증 결과

From Scratch	랜덤 초기화	전체 레이어	약 95%	89.5%
Full Fine-Tuning	ImageNet pretrained	전체 레이어 재학습	약 99%	98.5%
Partial Fine-Tuning	ImageNet pretrained	FC layer만 재학습 (feature extractor 고정)	약 79%	73.3%

Full Fine-Tuning은 사전학습된 가중치를 기반으로 전체를 재학습하여 가장 높은 정확도를 기록했다.
→ 사전학습 모델의 일반적 시각 특징을 유지하면서, 새로운 도메인에 맞게 최적화되었기 때문.
From Scratch는 ImageNet 사전학습을 사용하지 않고도 약 89%의 테스트 정확도를 달성했지만,
수렴 속도가 느리고 많은 데이터가 필요했다.
Partial Fine-Tuning은 Feature Extractor를 고정했기 때문에
새로운 도메인의 세부적인 질감이나 색상 패턴을 학습하지 못해 성능이 20% 이상 낮게 나타났다.
즉, 사전학습된 일반적인 특성만으로는 도메인 적응이 어렵다는 한계가 드러났다.

참고자료

https://hi-ai0913.tistory.com/32

[딥러닝] 전이학습(Transfer learning)과 파인튜닝(Fine tuning)

전이 학습(Transfer Learning)과 파인 튜닝(Fine-Tuning)은 현대 딥러닝 연구와 실용화에서 핵심적인 역할을 하는 전략입니다. 이들은 특히 데이터가 제한적이거나 특정 작업에 대한 사전 지식이 필요한

hi-ai0913.tistory.com

2025.06.14 - [Technology Notes] - [Deep Learning] Transfer Learning과 Knowledge distillation

[Deep Learning] Transfer Learning과 Knowledge distillation

Pre-trained Model 개념 Pre-trained Model (사전 학습 모델)은 대규모 데이터셋으로 이미 학습이 끝난 모델.이 모델은 특정 문제를 풀기 위해서 처음부터 학습한 것이 아니라, 충분히 크고 일반적인 데이

c0mputermaster.tistory.com

[Object Detection] One-Stage Object Detection - YOLO, SSD, RetinaNet

임승택 — Fri, 12 Sep 2025 00:15:29 +0900

One-Stage Object Detection 개요

우리는 이전까지 Two-Stage Object Detection을 리뷰하였고 이번에는 Region Proposal 과정을 생략하고 Bounding Box Regression + Classification 동시에 수행하는 One-Stage Detector를 살펴보겠다.

YOLO

YOLO = You Only Look Once.

Region Proposal을 생략하고 한 번의 Forward Pass로 Detection 수행.

YOLOv1 → v2 → v3 → … → v5, v8, v10까지 지속 개발 되어 요즘도 널리 쓰이는 대표적인 One-Stage Detector이다.

우선 YOLO는 입력 이미지를 S×S Grid로 나눔. (YOLO v1에서는 7×7)

단순히 이미지를 잘라내는 전처리가 아님.
Feature Map의 한 픽셀이 원본 이미지의 일정 영역(64×64)을 담당하는 개념.

각 Grid Cell은 B개의 Bounding Box를 예측한다. (YOLO v1에서는 B=2).

각 Box는 (x, y, w, h, confidence) 5개 값 출력.

따라서 한 Grid Cell 출력 차원: 5*B + C. ( 예: B=2, C=20 → 30차원. )

전체 7×7=49개의 Grid Cell → 총 98개의 Box 후보 생성.

448×448×3 RGB 이미지 =>

Backbone: GoogLeNet 기반 Convolution Network.

Fully Connected Layer를 통해 4096차원 벡터 → 1470차원 벡터로 변환하는데 이걸 다시 7×7×30 Feature로 변환

7×7 Grid 기준, 각 픽셀은 원본 이미지의 64×64 영역 담당.
각 Grid Cell 출력 벡터(30차원):
- 첫 5개: Box1 (x, y, w, h, confidence).
- 다음 5개: Box2 (x, y, w, h, confidence).
- 나머지 20개: Class Probabilities.

최종 Confidence × Class Probability = Class-specific Score을 구함

데이터셋 클래스 수(C)에 따라 마지막 출력 차원 변경이 필요하

Loss Function

Bounding Box Regression Loss
- (x, y, w, h) 예측값과 Ground Truth 차이 최소화.
- 모든 Grid Cell × Box에 대해 계산.
- λ (lambda)라는 하이퍼파라미터로 가중치 조절.
Confidence Loss
- Object 존재 시: Confidence → 1 근접.
- No Object 시: Confidence → 0 근접.
- Indicator Function(지시 함수) 사용.
Classification Loss
- 클래스별 예측 확률 분포가 Ground Truth One-hot 벡터와 가까워지도록 학습.

- YOLO의 장단점

Faster R-CNN 대비 6배 빠르고 Background Error가 적음

Two-Stage Detector (예: Faster R-CNN)
- RPN(Region Proposal Network)이 수많은 후보 영역(anchors)을 생성.
- 이 중 많은 영역이 사실상 배경인데도 객체 후보로 전달됨.
- Classification 단계에서 배경을 걸러내야 하므로 FP가 증가하는 경향.
One-Stage Detector (YOLO)
- 이미지 전체를 고정된 Grid Cell로 나눔.
- 각 Grid Cell은 자신이 담당하는 영역 안에 객체가 있으면 예측, 없으면 “배경”으로 처리.
- 불필요한 수천 개의 후보 영역을 만들지 않음.
- 따라서 배경을 객체로 잘못 잡는 경우(Background Error)가 구조적으로 줄어듦.

하지만 한 Grid Cell은 사실상 하나의 객체만 예측 가능하고 여러 객체가 겹치면 성능 저하 문제가 존재하고, 작은 객체 Localization 한계, 입력 크기 고정.

YOLO v1은 최종 7×7 Feature만 사용
CNN의 뒤쪽 Feature는 시맨틱 정보(무엇인지)는 잘 잡지만, 공간 정보(어디에 있는지)는 손실됨

YOLOv2~v3 이후에는 Multi-Scale Feature Map(FPN), Anchor Box, Stride 축소 등을 도입해 작은 객체도 잘 잡도록 개선됨.

SSD

SSD = Single Shot MultiBox Detector
이름 그대로 한 번(Shot)에 Detection을 끝내는 구조.
YOLO와 마찬가지로 Region Proposal 과정 없음.

하지만 YOLO와 차별점은 Multiple Feature Map을 활용한다는 것이다.

- YOLO: 마지막 하나의 Feature Map만 사용 (7×7).

- SSD: 여러 층에서 나온 Feature Map을 동시에 사용 → 작은 물체부터 큰 물체까지 다양한 크기 탐지 가능.

YOLO v1: 448×448 입력 → CNN → 마지막 7×7 Feature Map 사용.
- 단점: 해상도(7×7)가 너무 작아서 작은 물체 검출에 한계.
SSD: 300×300 입력 이미지 → CNN(VGG16) → 중간 Feature Map들을 여러 개 사용.
- 예: 38×38, 19×19, 10×10, 5×5, 3×3, 1×1 등.
- 각각의 Feature Map에서 Classification + Bounding Box Regression 수행.
- 따라서 다양한 스케일의 객체를 탐지할 수 있음

SSD의 핵심 특징

(1) Multiple Feature Map

다양한 크기의 Feature Map을 모두 활용.

(2) Default Box (Anchor Box)

Faster R-CNN의 Anchor 개념을 차용.
각 Grid Cell에 여러 개의 Default Box(미리 정의된 크기와 비율) 설정.
예: 한 Cell에 4~6개의 Default Box.
네트워크는 이 Default Box를 기준으로 좌표(x, y, w, h) 보정값을 학습.
즉, Ground Truth와 가까워지도록 Default Box → 실제 객체 박스로 변환.

SSD 구조

입력: 300×300 (SSD300) / 512×512 (SSD512).

각 Layer 마다 Feature Map을 구함 (빨간색은 엥커박스 수)

Classification: C개의 클래스 확률.
Regression: Default Box 좌표 보정값 (Δx, Δy, Δw, Δh).

최종적으로 8732개의 Box 예측(SSD300 기준).

YOLO v1: 98개만 예측 → SSD는 훨씬 많은 후보.

하지만 작은 객체 탐지 여전히 약하고 Box 개수 너무 많아서 느려짐 (8732개)

앞쪽 Feature Map(큰 해상도)을 사용하지만,
CNN 앞단 Feature는 Low-level Feature라 충분히 "영글지 못한 정보" → 예측 성능 낮음.
실제로 작은 비행기, 자전거, 새 등 검출률 낮음.

Loss Function

Faster R-CNN과 거의 동일한 Loss 사용.:
1. Classification Loss: Cross-Entropy (Softmax 기반).
  - 객체 클래스 예측 정확도.
2. Bounding Box Regression Loss: Smooth L1 Loss.
  - Default Box → Ground Truth 박스로의 좌표 보정.

하지만 SSD도 작은 객체 검출력이 올라가긴 했으나 큰 객체 검출에 비해 낮은 성능을 보였다.

RetinaNet

Retina = 망막(눈), Net = 신경망 → 눈처럼 이미지에서 객체를 잘 잡아내고자 함.
One-Stage Detector의 문제를 해결하기 위해 제안됨.
- Two-Stage(Faster R-CNN 등): Region Proposal로 배경 대부분을 걸러냄 → FP 줄어듦.
- One-Stage(YOLO, SSD 등): Region Proposal 없음 → Negative(배경) 샘플이 너무 많아 Class Imbalance 발생.

Class Imbalance

Foreground vs Background 불균형
- 이미지 대부분은 배경, 객체는 소수 → 배경 Anchor가 수천~수만 개.
- 예: COCO dataset → 객체 < 1%, 배경 > 99%.
Foreground 내부 불균형
- "사람" 클래스는 수십만 개, "드문 객체(예: 산삼..?)"는 몇 개.
- 데이터셋 내 클래스 분포가 극도로 불균형.

결과적으로 One-Stage Detector는 쉽고 많은 Negative 샘플에 학습이 끌려 성능이 떨어진다고 생각

RetinaNet의 핵심 아이디어

(1) Focal Loss

기본 Cross-Entropy에 가중치(감마) 추가.
잘 분류되는 “쉬운 예제”(특히 배경)에 대해서는 Loss를 줄이고,
어려운 예제(희소 클래스, 작은 객체)에는 Loss를 집중(focus).
Negative 샘플 억제, Positive 샘플 강조 → Class Imbalance 완화.

(2) Feature Pyramid Network (FPN, Neck 구조)

멀티 스케일 객체 검출 성능 개선을 목표로 Backbone(ResNet)과 Head 사이에 Neck = FPN 삽입

Neck?

Backbone에서 뽑은 Feature Map을 가공·변환·융합하는 중간 처리 단계.

여러 스케일의 Feature를 결합해서 멀티스케일 특징을 강화.

FPN

Scale Invariant 달성 방법에는 여러가지가 있다

A. Multi-scale Input (이미지 피라미드)

입력 이미지를 여러 크기로 줄이거나 키워서 CNN에 각각 넣음.
각각에서 Detection을 수행 후 결과를 합침.
장점: 단순하고 효과적.
단점: 입력마다 CNN을 돌려야 하므로 속도가 매우 느림.

B. Single Feature Map (YOLO v1 방식)

입력 이미지를 CNN에 넣고, 마지막 Feature Map 하나만 사용.
예: YOLO v1 → 7×7 Feature Map 기반 예측.
장점: 빠름.
단점:
- 해상도가 너무 낮아 작은 객체 탐지에 취약.
- 겹쳐 있는 객체 탐지 어려움.

C. Multi-Feature Map (SSD 방식)

CNN의 중간 Feature Map과 마지막 Feature Map을 모두 사용.
작은 Feature Map → 큰 객체 탐지
큰 Feature Map → 작은 객체 탐지
장점: 다양한 크기의 객체 처리 가능.
단점: 앞단 Feature는 아직 영글지 않은 Low-level Feature라서 작은 객체 탐지 성능이 떨어짐.

D. Feature Fusion (FPN, RetinaNet 방식)

SSD의 단점을 보완.
Higher-level Feature (의미 풍부, 공간 해상도 낮음)
Lower-level Feature (공간 해상도 큼, 의미 정보 적음)
→ 업샘플링 + 1x1 Conv으로 크기와 채널 맞춰서 합성(Fusion)
결과적으로 작은 객체와 큰 객체 모두 탐지가 가능.
RetinaNet은 이 구조를 Neck(FPN)으로 채택.

Bilinear Interpolation을 사용해서 이미지 크기를 늘려서 맞추고 채널은 1X1 Conv로 맞춰서 Feature를 같은 위치 (x,y) 픽셀별, 채널별로 더함.

Performance

기존 One-Stage Detector(YOLO, SSD)보다 AP(정확도) 크게 향상

최근 연구 동향

1. Backbone의 다양화

기존 ResNet 대신 EfficientNet 계열을 Backbone으로 활용한 Object Detection 기법 등장
효율성과 정확도를 동시에 추구하는 흐름

2. Transformer 기반 Detection

DETR (Detection Transformer) 등장
이후 다양한 변형 모델들이 개발되어 성능 개선
CNN 기반 한계를 넘어선 Transformer 기반 검출 구조가 활발히 연구됨

3. Anchor 문제와 Anchor-free 기법

Faster R-CNN, SSD, RetinaNet 등은 Anchor Box를 사전 정의해야 했음 → 사람이 개입 필요, Hyperparameter 의존적
단점: 사전 정의 크기·비율에 따라 성능이 달라짐
해결책: Anchor-free Detector 개발 (대표: FCOS)
- 객체 중심점(center point) + 크기 비율을 직접 학습 → Anchor 사전 정의 불필요

4. 3D Object Detection

기존: 2D 이미지 입력 → 2D Bounding Box 출력
최근: LiDAR 등 3D 센서를 활용 → 입체적 Bounding Box (육면체) 출력
자율주행, 로보틱스 등에서 필수 기술로 발전
대표적 기법: Point-based 3D Detection, CVF, 3D DETR 계열

5. 멀티모달 Object Detection

단순히 이미지 속 모든 객체를 찾는 것이 아니라, 텍스트 Prompt 기반 검출 연구 확산
- 예: “사람만 찾아줘”, “자전거만 찾아줘” 같은 요청 수행
대표 사례: GLIP (Grounded Language-Image Pretraining)
- 대규모 Foundation Model 기반, 텍스트와 이미지 융합

[Generative AI] Flow Matching for Generative Modeling

임승택 — Thu, 11 Sep 2025 22:49:51 +0900

이 리뷰는 오직 학습과 참고 목적으로 작성되었으며, 해당 논문을 통해 얻은 통찰력과 지식을 공유하고자 하는 의도에서 작성된 것입니다. 본 리뷰를 통해 수익을 창출하는 것이 아니라, 제 학습과 연구를 위한 공부의 일환으로 작성되었음을 미리 알려드립니다.

이 논문은 Continuous Normalizing Flows(CNF)를 시뮬레이션 없이 효율적으로 학습할 수 있는 방법으로 Flow Matching(FM)을 제안한다. 최근 생성 모델에서 Flow Matching 관심을 끌고 있는 만큼, 논문을 리뷰해 보게 되었다.

https://arxiv.org/abs/2210.02747

Flow Matching for Generative Modeling

We introduce a new paradigm for generative modeling built on Continuous Normalizing Flows (CNFs), allowing us to train CNFs at unprecedented scale. Specifically, we present the notion of Flow Matching (FM), a simulation-free approach for training CNFs base

arxiv.org

1. Introduction

최근 몇 년간 생성 모델 분야에서 디퓨전(diffusion) 계열 모델은 탁월한 성능을 보여주며 사실상 주류로 자리 잡았다. 여러 단계에 걸친 반복적 샘플링을 통해 고품질의 이미지를 생성할 수 있다는 점은 큰 장점이지만, 동시에 이러한 과정은 추론 속도를 심각하게 저하시킨다는 한계를 지닌다.

본 논문은 Continuous Normalizing Flows(CNF)를 시뮬레이션 없이(simulation-free) 효율적으로 학습할 수 있는 새로운 훈련 방법으로서 Flow Matching(FM)을 제안한다. 이 글에서는 해당 논문을 중심으로 Flow Matching의 핵심 아이디어와 기여점을 정리하고자 한다.

Simulation-Free? CNF? 하나씩 알아보자

2. Continuous Normalizing Flows

Recap) 우선 이전 생성모델의 구조를 살펴보자

생성모델 : 데이터의 분포를 학습 ( Source(p0) 분포에서 Target(p1) 분포로 변화되는 과정을 학습 )

- GAN, VAE

대부분의 생성 모델은 샘플링이 쉬운 분포(예: 가우시안 분포) z에서 데이터 분포 x로의 변환을 학습한다.
GAN: z → x 변환을 적대적 학습(Adversarial Training)을 통해 학습한다.
VAE: z → x 생성과 x → z 인코딩을 동시에 학습해 잠재공간을 정규화한다.

=> GAN, VAE 같은 모델은 Source(p0) 분포에서 Target(p1) 분포를 한번에 mapping하는 방식

- Diffusion model

Diffusion model: x → z 방향으로 점진적으로 노이즈를 주입하는 과정을 학습하고, 반대로 z → x 방향으로 노이즈 제거(Denoising) 과정을 통해 데이터를 생성한다. => 노이즈 제거 함수를 학습
복잡한 데이터 분포 학습 가능, 학습이 효율적 But 생성속도가 느림
하지만 생성속도가 느림 ( 여러번의 model forward )

=> Diffusion model Source(p0)분포에서Target(p1)분포로 단계적으로 변화

- Normalizing flow ( Flow 모델 , NICE )

Normalizing flow : x → z로의 가역적 변환(flow)을 학습하고, 역변환을 통해 z → x 생성을 수행한다.
Likelihood를 계산 가능하다는 장점이 있음 => 확률추정이 가능

Normalizing flow 모델은 역변환이 가능한 모델 구조(Jacobian determinant 계산 가능)가 필요하고, 학습이 비효율적이다 ( 역변환을 계속 해야하기 때문에 ).

https://angeloyeo.github.io/2020/07/24/Jacobian.html

자코비안(Jacobian) 행렬의 기하학적 의미 - 공돌이의 수학정리노트 (Angelo's Math Notes)

angeloyeo.github.io

Flow model?

Source(p0)를 Target(p1)로 변환하는 Flow를 찾는 모델

Flow model: source 분포 0를 target 분포 1으로 변환해주는 flow( )를 찾는 모델 싸이t
Flow? 0를 로 Mapping해주는 함수 (Diffeomorphism <= 특징 [미분가능 / 역함수 존재])
하지만 Continuous time(중간중간 샘플이 없는) 상황에서 flow를 직접적으로 학습하기는 어려움

이해를 돕자면 Flow는 데이터 분포와 간단한 분포(보통 정규분포)를 연결하는 변환이며

자체를 학습해서 데이터 분포를 얻음, 즉 Flow 자체를 파라미터화해서 학습

그래서 Flow model에서는 vector field를 통해 flow를 간접적으로 계산

- Velocity Field (vector field)

Flow를 간접적으로 계산하는 과정, 간단하게 (X) = Flow를 t에 대해 미분하는 것

- 한마디로 Velocity Field는 각각의 포인트에서 화살표 방향이다. 어디로 갈지, 즉 각각의 점에서 어디로 움직여야 소스에서 타겟으로 옮겨갈 수 있나를 알려주는것을 Velocity Field라고 한다. ODE로 정의됨

Flow의 미분을 통해 Velocity filed를 구하고 Solver를 통해 다시 Flow를 구할 수 있음

스탭h를 지정한뒤 Velocity Field와 Solver 를 통해 t일 떄 타겟분포 Xt를 구할 수 있다.

+ Probability Paths

Probability Paths(pt) = 그렇게 source 분포 0에서 target 분포 1로 가는 과정의 t시점의 분포를 말함

Normalizing Flow(NF):
- x → z (데이터 분포 → 잠재 분포)로 가는 가역적인 변환 f를 뉴럴 네트워크가 학습한다.
- 학습 후에는 z0 ~ N(0, I)를 샘플링한 뒤 f⁻¹(z0)을 통해 데이터를 생성할 수 있다.
- 쉽게 말하자면 데이터 분포인 $x$ 에서 $z$ 로의 역변환이 가능한 함수(Flow)를 학습하는 모델
Continuous Normalizing Flow(CNF):
- 변환 함수 자체를 학습하는 대신, vector field를 학습한다.
- 시간축 t ∈ [0, 1]을 따라 정의된 흐름(flow)에서,
  - t=0일 때 분포는 z,
  - t=1일 때 분포는 x가 된다.
- 따라서, z에서 출발해 ODE Solver로 적분하면 최종적으로 데이터 분포 샘플을 생성할 수 있다.
장점: 역변환 가능해야 한다는 제약 해소.
단점: 학습과 샘플링 과정에서 ODE Solver(수치적분)을 반복적으로 호출해야 하므로 비용이 크다. → Diffusion의 느린 샘플링 문제와 유사, "ODE의 적분에는 많은 시간이 걸린다

NF가 복잡한 분포에 맞게 함수 파라미터 최적화 한다면 CNF는 시간에 따라 분포가 맞게 흘러가도록 vector field 최적화

정리:

Data: d차원 벡터 공간에 존재하는 포인트

Flow(ϕ): 데이터를 시간에 따라 연속적으로 변환하는 함수. ODE(미분 방정식)

Vector Field: 데이터 공간의 각 위치에서 어떤 방향으로 얼마나 이동할지를 나타내는 정보

Probability density path(p): 시간에 따라 변화하는 확률 밀도 함수

Continuous Normalizing Flow(CNF): 위의 vector field를 neural network로 나타낸 모델, 연속적인 시간 변화에 따른 데이터 변환을 모델링. 즉, 간단한 데이터 분포에서 복잡한 분포로 변환하는 역할

Flow Matching (FM)

Flow mathcing은 적분 없이 Velocity Field를 학습, 즉 Flow Matching은 CNF를 학습하기 위한 새로운 목적 함수로 vector field를 학습하도록 하는 것

CNF는 굉장히 강력한 프레임워크이지만 많은 데이터셋에 대해서 학습하기가 굉장히 어렵다. 학습 과정 중에 적분을 수행해야 하기 때문에 ODE Solver를 통해서 여러번의 forward가 필요하기 때문이다. 간단하게 말해서, Diffusion 모델의 느린 샘플링 과정을 매 학습마다 수행해야 하는 것이다. 목표인 Flow Matching이 어떻게 simulation-free, 즉 실제 적분 과정 없이 CNF를 학습 가능하게 하는지를 알아보자.

CNF처럼 vector field를 학습하지만 직접 밀도를 계산하지 않고 학습해야한다. x1는 우리가 알지 못하는 q(x1)데이터의 분포 에서 얻은 샘플들로, 생성 모델을 훈련하고자 하는 데이터셋이다. pt를 정의할 것인데, 는 우리가 알고 있는 쉬운 분포p가 p0이고, p1 되도록 하고 싶다.

데이터 샘플을 갖고 있지만, 데이터 분포 함수 자체는 알지 못한 상태에서 목표 u와 v가 같아지도록 regression, 손실 함수가 0에 가까워지면 CNF 모델이 probability path p를 생성할 수 있다. 하지만 우리는 p와 u를 모르기 때문에 Flow Matching은 probability path에 대한 supervision을 사용하여 로스를 사용할 수 있게 한다. 우리가 직접 p와 u를 만들어주는 것이다. 당연히 전체 분포에 대한 것을 임의로 만들 수는 없고 샘플 별로 p와 u를 디자인해주는데 어떻게 하는지 살펴보자.

Conditional Flow Matching (CFM)

1. pt와 ut를 정의

- Conditional probability path(조건부 확률 경로, )

t=0일 때 는 간단한 초기 분포 p(x).
t=1일 때 는 평균이 이고, 작은 표준편차를 가지는 정규분포

- Marginal probability path(주변 확률 경로, ): 여러 조건부 확률 경로를 합친 결과

Marginal Vector field(주변 벡터 필드, )

조건부 벡터 필드()는 각 조건부 확률 경로 를 생성하는 벡터 필드

조건부 벡터 필드들을 모두 합친 것이 주변 벡터 필드

위의 수식에서 은 특정 샘플 에 대해서 간단한 분포의 x가 어떻게 이동해야 하는지 나타내고 는 가중치로, 각 데이터 샘플에 대한 conditional vector field()가 marginal vector field()에 얼마나 기여하는지를 결정한다.

Theorem1: 조건부 문제들을 잘 정의하고 이를 마진화하여 합치면 전체적인 분포를 생성할 수 있는 유효한 벡터 필드를 얻을 수 있다는 것을 보장합니다.

2. Conditional flow matching

이전 단락에서 설명한 marginal probability path와 vector field는 적분 계산이 복잡하고 직접 계산하기 어려운 난해한 수식을 포함함. 따라서 Flow mathcing 목표를 계산하는 것은 비현실적이다. 이에 따라 Conditional flow matching loss이라는 더 간단한 목표를 제안한다.

t∼U[0,1]은 균등 분포를 따르는 시간
은 데이터 분포에서 샘플링한 데이터.
은 조건부 확률 경로에서 샘플링한 데이터

Theorem2:

그리고 여기서 두 로스가 같다는 증명이 등장한다. 즉, sample 별로 최적화를 수행하고 expectation을 구하는 식으로 최적화를 진행해도 된다는 뜻이다. 증명은 논문의 Appendix에 있다. 이걸로 적당한 supervision을 통해 ode solver 필요 없이 CNF를 학습하는 방법을 알았다. 이제 필요한 것은 적절한 p, u를 정의하는 것이다.

probability path $p$ 를 실제로 정의하여 conditional path (우리의 “label” 이 될 대상) 을 구체화시켜보자.

(1) Probability path p 정의

논문에서는 probability path로 gaussian distribution을 사용한다.

x1에대한 평균과 표준편차를 사용하여 정규분포로 가정, $μ_{t}$ 와 $σ_{t}$ 에 대한 조건을 아래와 같이 사용한다.

t=0일 때 평균은 0, 표준편차를 1, t=1일 때 평균을 x, 표준편차를 충분히 작은값으로 설정하였을 때 다음과 같은 Flow를 얻을 수 있다.

그리고 앞에서와 같은 flow를 시점 t에 대하여 미분하여 vector 필드를 구할 수 있다.

Theorem3: 최종적으로 백터필드는 위와같은 수식으로 구할 수 있다.

정리하자면 Continuous Normalizing Flows(CNF)는 데이터 분포를 학습하기 위해 ODE 적분을 사용하였음. 그러나 이러한 적분 과정은 계산량이 많고 시간이 오래 걸리는 문제가 있었다. 이를 개선하기 위해 augmentation이나 regularization을 추가하는 방식의 연구들이 진행되었으나, 이는 ODE를 정규화한 것에 불과하고 학습 알고리즘 자체를 변화시키지는 못했다.

CNF 학습 속도를 높이기 위해 simulation-free CNF training frameworks가 개발되었다. 하지만 이러한 방식 역시 여전히 적분 계산의 부담이 있었고, Flow Matching은 이러한 한계를 극복하기 위해 제안된 방법으로, 시뮬레이션 과정조차 필요 없이 CNF를 학습할 수 있도록 하였다. 이로써 단순하고 빠른 학습이 가능해졌다

Flow Matching의 Conditional Flow Matching(CFM)은 diffusion 기반 설계에서 출발하였으나, 벡터 필드를 직접 매칭하는 접근 방식을 일반화하였음. 따라서 Flow Matching은 처음으로 diffusion 과정 없이 확률 경로를 직접 학습할 수 있음을 보여주었으며, CNF 학습의 새로운 가능성을 제시하였다.

- 참고자료

https://arxiv.org/abs/2210.02747

Flow Matching for Generative Modeling

arxiv.org

https://youtu.be/YFZbFr3cjpA?si=K4yX3xw-CTp1Y3wv

https://seastar105.tistory.com/176

Flow Matching 설명

Introduction 디퓨전 계열이 생성 모델에서 엄청난 성능을 보여주며 주류가 되어 버린지는 한참 되었다. 그러나 여러 번에 걸친 샘플링이 디퓨전 모델의 좋은 성능을 만들어 주는 것처럼 보이지만

seastar105.tistory.com

[ILSVRC 논문 정리해 보기] DenseNet, SENet과 대회 그 이후

임승택 — Fri, 5 Sep 2025 13:34:47 +0900

2025.09.05 - [분류 전체보기] - [ILSVRC 논문 정리해 보기] VGGNet, GoogleNet, ResNet

[ILSVRC 논문 정리해 보기] VGGNet, GoogleNet, ResNet

이전 논문 리뷰에 이어서 ILSVRC논문을 정리해보았다.2025.05.07 - [Computer Vision1/Paper reviews] - [ILSVRC 논문 정리해 보기] AlexNet (ImageNet Classification with Deep Convolutional Neural Networks) [ILSVRC 논문 정리해 보기]

c0mputermaster.tistory.com

DenseNet

ResNet의 Residual Block에서는

하지만 Concat을 해버리면 기존의 피처가 그대로 뒤로 전달되면서 작은 파라미터로 풍부한 피처를 활용가능하지만 채널 수 증가 문제가 발생함 => 중간에 Transition Layer( conv + pooling ) 넣어서 해결

Bottleneck 구조

ResNet과 DenseNet 모두 병목(bottleneck) 아이디어를 씀. 하지만 동작은 다름

CNN에서 3×3 convolution을 채널이 많을 때 그대로 쓰면 연산량이 너무 크니까 좁은 병목 구간(bottleneck)을 거쳐 연산을 줄이자

1×1 conv: 채널 축소 (예: 256 → 64)
3×3 conv: 실제 feature extraction (64 채널만 사용)
1×1 conv: 채널 복원 (다시 256)

근데 DenseNet에서는 어차피 채널이 길어지기 때문에 ResNet처럼 1×1 conv해서 늘린다음 더하는게 아니라 3x3 conv후 Concat

여기서 k = Growth rate

SENet ( Squeeze-and-Excitation Networks )

Squeeze-and-Excitation Networks, 마지막 ILSVRC의 우승작

기존 ILSVRC에 CNN 모델들이 전반적으로 모델의 설계 구조를 제안하였다면 SENet은 모델에 하나의 플러그인 모듈을 제안함 (SE block) =>

Feature recalibrarion을 제안 플러그인처럼 붙여서(global 정보를 보정)

Squeeze와 Excitation 하나씩 살펴보자

Squeeze

압축 => 각 채널의 평균을 구함 = GAP

(H x W x C) => Global average pooling을 통해 백터로 만듬, 백터화 => 그럼 C만큼의 1x1 사이즈의 백터가 생성됨 ( 채널별 특징 )

Excitation

재조정 => FC1 - ReLU - FC2 - Softmax를 통과 그럼 결과적으로 출력값이 확률로 변화됨

결론적으로 이 출력값을 가중치로 사용하여 원래 채널에 곱해줌 즉 채널별의 중요도를 찾아주는 과정

Squeeze-and-Excitation과정 = Attention

https://codingopera.tistory.com/41

3. Attention [초등학생도 이해하는 자연어처리]

안녕하세요 '코딩 오페라'블로그를 운영하고 있는 저는 'Master.M'입니다. 현재 저는 '초등학생도 이해하는 자연어 처리'라는 주제로 자연어 처리(NLP)에 대해 포스팅을 하고 있습니다. 제목처럼

codingopera.tistory.com

이런식으로 모델에 모듈을 달 수 있는데 그냥 사용하는 것은 아니고 global한 정보를 다루는 부분에 붙였을 떄 큰 효과가 있었다고 한다.

After ILSVRC

성능 최적화 중심 → 경량화 중심

초기에는 정확도를 높이는 게 목표였음. (AlexNet → VGG → ResNet 같은 흐름)
이후에는 모바일·임베디드 환경에서도 쓸 수 있게 경량화(라이트웨이트) 모델 연구가 활발해짐.
대표: MobileNet, ShuffleNet, EfficientNet

ResNeXt: 그룹 컨볼루션으로 연산량 줄이면서 성능 유지

- 채널별로 그룹을 나눠서 필터링 => 연산량이 줄어듦

MobileNet: Xception 아이디어

Xception?: Depthwise + Pointwise Convolution (연산량 대폭 절감)

공간 정보는 채널별로 따로 보고, 채널 정보는 1x1 컨볼루션으로 합쳐서 연산을 대폭 줄인 컨볼루션

Depthwise: 각 채널을 따로 3×3 같은 필터로 처리 → 공간 정보만 학습
Pointwise (1×1): 채널끼리 정보를 합쳐서 출력 채널 생성 → 채널 정보 학습

일반적인 3x3 컨볼루션 = FLOPs(연산량) = H×W×Cin×Cout×K×K

ShuffleNet: MobileNet의 구조를 기본적으로 사용하고 grouped convolution을 통해 채널 전체를 다 고려하는 것이 아니라 일부만 고려하고 모든 채널을 다 고려하기 위하여 중간중간에 채널들을 섞어줘서 연산량 부분에서 이득을 봄

NAS (Nerual Architrcture Search)

NAS(Neural Architecture Search): 네트워크 구조 설계를 사람이 아니라 AI가 자동으로 탐색
예: NASNet, AmoebaNet, FBNet

Generalize Network Design

자동화를 하는 것도 좋은데 사람이 그래도 좀 손을 타야 더 성능이 좋아지더라 하는 아이디어서 나온 아키텍쳐

NAS(Neural Architecture Search)로 CNN 구조를 자동으로 설계 가능
하지만 완전히 자동화만으로는 최적 성능이 나오지 않을 때가 있음
사람의 직관을 적절히 개입하면 성능 향상 가능

RegNet

디자인 스페이스를 정의하고 제한된 선택지 내에서 탐색
- Width(W): 채널 수
- Depth: 레이어 수
- Bottleneck 비율: 채널 축 축소 정도
- Group Convolution 수: 그룹 수
NAS가 모든 것을 탐색하는 대신 제한된 범위 내에서 탐색 → 효율적

EfficientNet

사람이 설계한 규칙 + 컴퓨터 탐색
주요 요소:
- Width(W): 채널 수
- Depth: 레이어 수
- Resolution: 피처 맵 H×W
컴파운드 스케일링(Compound Scaling)
- Width, Depth, Resolution의 균형을 공식으로 결정
- 예: Width 2배 → Depth는 1/2배, Resolution 적절히 조절

ILSVRC 논문을 정리하고 난뒤

LSVRC 기반의 다양한 CNN 아키텍처를 살펴본 이후, 단순히 구조를 아는 것보다 CNN을 어떤 역할로 활용할 것인지가 더 중요함을 강조한다.

CNN 구조 자체(레이어 수, 필터 크기, Residual/ Inception 등)는 도구일 뿐
입력 x를 받아 출력 를 생성하는 하나의 함수로 이해
핵심은 CNN을 어떤 역할로 사용할지와 어떤 테스크에 적용할지 결정하는 것이다

아키텍쳐 보다는 CNN을 통해 어떤 특징(feature)을 추출할지, 학습 목표(loss function)과 데이터 특성에 맞게 CNN을 설계/활용하는것이 중요하다.

CNN 활용 예시 참고

이미지 분류(Classification): 유용한 피처 추출 후 분류
객체 검출(Object Detection): 관심 객체를 잘 표현하는 피처 추출
생성 AI(Generative AI): 데이터를 이해하기 쉬운 latent space로 매핑

https://newitlec.com/entry/5%ED%8E%B8-%ED%95%A9%EC%84%B1%EA%B3%B1-%EC%8B%A0%EA%B2%BD%EB%A7%9DCNN-%EA%B0%9C%EC%9A%94%EC%99%80-%EB%8F%99%EC%9E%91-%EB%A7%A4%EC%BB%A4%EB%8B%88%EC%A6%98-%EB%B0%8F-%EC%9D%91%EC%9A%A9%EB%B6%84%EC%95%BC

[5편] 합성곱 신경망(CNN) 개요와 동작 매커니즘 및 응용분야

목 차합성곱 신경망, CNN(Convolution Neural Network) 알고리즘 개요CNN(Convolution Neural Network) 동작 개념도 및 동작 메커니즘 세부 설명CNN(Convolution Neural Network) 응용분야마무리본 편에서는 합성곱 신경망,

newitlec.com

[ILSVRC 논문 정리해 보기] VGGNet, GoogleNet, ResNet

임승택 — Fri, 5 Sep 2025 13:34:36 +0900

이전 논문 리뷰에 이어서 ILSVRC논문을 정리해보았다.

2025.05.07 - [Computer Vision1/Paper reviews] - [ILSVRC 논문 정리해 보기] AlexNet (ImageNet Classification with Deep Convolutional Neural Networks)

[ILSVRC 논문 정리해 보기] AlexNet (ImageNet Classification with Deep Convolutional Neural Networks)

ILSVRC(ImageNet Large-Scale Visual Recognition Challenge)이란?- 2010년 ~ 2017년 매년 개최된 국제 컴퓨터 비전 경진대회로 대규모 데이터셋(ImageNet)을 기반으로 이미지 인식 성능을 겨루었던 역사적인 대회- 2012

c0mputermaster.tistory.com

VGGNet

제안자: 옥스포드 대학의 Visual Geometry Group (VGG).
등장: ILSVRC 2014 이미지넷 대회에서 분류(Classification) 2등, 위치(Localization) 1등.
의의: 구조가 단순하면서도 강력하여, 이후 컴퓨터 비전 모델의 백본(Feature Extractor) 으로 널리 사용됨.

VGG-16 / VGG-19: 학습되는 층(Convolution + Fully Connected)을 각각 16개, 19개 사용.
특징:
- 3×3 Convolution 필터를 일관적으로 사용.
- 2×2 Max Pooling으로 다운샘플링.
- Fully Connected Layer 3개 + Softmax 출력.
성능:
- Top-5 Accuracy: 92.7%.
- 단순하고 규칙적인 구조 → 재사용성, 전이학습(Transfer Learning)에서 높은 활용도.

핵심 아이디어

기존: AlexNet 등에서는 11×11, 5×5 등 다양한 크기의 필터 사용.
VGG: 모든 Conv Layer를 3×3 필터로 통일.

비선형성(Non-linearity) 증가
- 7×7 한 번 = ReLU 1번
- 3×3 세 번 = ReLU 3번
  → 같은 수용영역(Receptive Field)을 가지면서도 더 많은 비선형성 확보 → 표현력이 강해짐.
파라미터 수 감소
- 7×7 필터 1개 = 49개의 파라미터.
- 3×3 필터 3개 = 27개의 파라미터.
  → 같은 리셉티브 필드지만 더 적은 파라미터 → 과적합 위험 감소.
표현력과 성능의 균형
- 더 깊은 네트워크 구조 가능.
- 작은 필터를 여러 번 쌓음으로써 복잡한 패턴을 더 효과적으로 학습.

구조가 단순하고 성능이 좋아 오늘날에도 Object Detection, Segmentation 등 다양한 CV 작업에서 백본(Feature Extractor)으로 쓰이고, 이미지 스타일 변환, 초해상화 등에서 손실 계산용 네트워크( Perceptual Loss)로 자주 활용됨.

GoogleNet

(Inception v1)

배경

발표: ILSVRC 2014 ImageNet 대회 1등 모델.
명칭: GoogLeNet, 혹은 Inception v1. (LeNet을 오마주한 이름)
의의: “더 깊게 쌓되, 효율적으로 설계할 방법”을 제안.

기본 구조

Stem: 입력 이미지를 다운샘플링하여 작은 크기의 feature map으로 변환.
Inception Module: GoogLeNet의 핵심 블록.
- 1×1 Conv
- 3×3 Conv
- 5×5 Conv
- 3×3 Max Pooling
  → 모두 병렬 실행 후 Concatenation으로 합침.
Inception 모듈 개수: 9개 쌓아서 전체 네트워크 형성.
Auxiliary Classifier (보조 분류기): 중간에 2개 삽입, 학습 시에만 사용하여 vanishing gradient 방지. (추론 시에는 제거)

1×1 Convolution의 의미

공간적 정보는 거의 보지 않음 (픽셀 단위).
채널 축을 압축/확장하는 역할 → 파라미터 수와 연산량 감소.
예: 192채널 입력 → 1×1 Conv(64 filters) → 64채널 출력.
효과:
1. 연산량 줄임 (3×3이나 5×5 Conv 앞단에 사용).
2. 채널 간 조합을 통해 더 다양한 feature 표현 가능.

1x1 conv랑 FC랑 효과가 같다?

Fully Connected Layer (FC)는 입력 벡터의 모든 요소와 출력 노드가 전부 연결됨. 예를 들어, 입력이 크기 N이고 출력이 크기 M이라면, 가중치 행렬 으로 곱한 후 bias를 더해서 출력 계산.

1×1 Convolution은? 한 픽셀 위치에서, 입력 채널들을 모두 받아서 선형 결합 후 출력 채널을 만듦. (h,w)에서 채널 백터에 가중치 행렬을 곱함

채널 축에서의 선형 변환이라는 점에서 수학적으로 동일하고 1×1 Conv는 픽셀 위치별로 독립적으로 FC를 적용하는 것과 같다.

성능/특징

AlexNet: 8개의 레이어, 파라미터 수 60M.

GoogLeNet: 훨씬 깊은 구조(22층)이지만 파라미터 수 5M.

연산량 최적화, 성능 우수하지만 구조가 복잡하여 구현/변형 난이도가 높음. 이후 Inception v2, v3, v4에서 개선되어 계속 사용됨.

ResNet

이미지 인식 능력이 사람을 뛰어 넘음 152개의

기존 Degradation 문제

층을 계속 쌓으면 표현력은 늘지만, 실제 학습은 더 어려워져 오히려 훈련/테스트 오류가 커지는 현상(= degradation).
학습과 최적화 난이도가 높아지고 오버피팅, vanishing gradient 등의 문제가 생김

CIFAR-10와 Unseen data에 대해 56레이어와 20레이어에 대해 테스트 결과 레이어가 많은 신경망이 오버피팅, vanishing gradient 문제로 인해 Train error가 더 높았음 = 층이 무조건 많다고 좋은 신경망이 아니였다.

잔차 학습(Residual Learning, Block)

블록 출력 H(x)를 직접 학습하지 않고 차이 F(x)=H(x) 를 학습 = 출력과 입력의 차이를 학
입력 x를 지름길(Shortcut)로 더해 아이덴티티 경로를 유지 → 정보/그라디언트가 막힘없이 흐름 → 깊게 쌓아도 학습 용이.

레지듀얼 블록 형태

CBR? BRC? ResNet에 후속 논문에서는 순서가 바뀜

Basic Block 3×3 Conv → BN → ReLU → 3×3 Conv → BN + skip add → ReLU

Batch Normalization?

정규화를 하는 이유? → 빠른 수렴과 정규화 효과. ( 오버피팅과 기울기 소실 문제 완화 )

https://velog.io/@cbkyeong/ML%EC%A0%95%EA%B7%9C%ED%99%94normalization%EC%99%80-%ED%91%9C%EC%A4%80%ED%99%94standardization%EB%8A%94-%EC%99%9C-%ED%95%98%EB%8A%94%EA%B1%B8%EA%B9%8C

[ML]정규화(normalization)와 표준화(standardization)는 왜 하는걸까?

exploration을 진행하다보니 **인공지능 모델을 훈련시키고 사용할 때, 일반적으로 입력은 0 ~ 1 사이의 값으로 정규화 시켜주는 것이 좋습니다.** 라는 말을 봤는데, 그 말에대한 설명이 없어 개인적

velog.io

모든 Conv 뒤에 BN을 넣어 내부 공변량 변화(Internal Covariate Shift) 완화 → 빠른 수렴과 정규화

Conv 경로에서는 보통 Dropout의 효과가 있어 불필요
학습 시 배치 통계 사용, 추론 시 이동평균(러닝 스탯) 사용.

Batch Normalization은 학습 과정에서 각 배치 단위 별 다양한 분포를 가진 데이터를 각 배치별(채널)로 평균과 분산을 이용해 정규화하는 것이다.
Batch Normalization는 별도의 과정으로 있는 것이 아닌, 신경망 안에 포함되어 학습시 평균과 분산으로 조정하는 과정이다.

Batch Normalization도 중요한 것은 Dropout 처럼 학습 단계와 추론 단계에서 다르게 적용되어야 한다. 왜?

train은 배치 단위로 들어오니까

여기서 x를 통해 평균과 분산을 구할 수 있지만 test에서는 배치가 없어서 평균과 분산의 개념이 없음

그래서 train 과정에서 평균과 분산을 메모리에 저장해놓은뒤 사용되도록 사용하기 때문에 학습과 추론이 다르게 적용된다.

정리하자면 “어떤 CNN을 쓸지 모르겠다면 ResNet부터”라는 말이 나올 정도로 범용 백본이다.

대표 구성 ResNet-152(152층).
깊이가 깊어질수록(34 → 50 → 101 → 152) 오류 감소 그럼에도 연산 효율은 VGG 대비 우수
분류뿐 아니라 Detection/Segmentation/재식별/Metric Learning/Perceptual Loss 등 거의 모든 CV 작업의 기본 뼈대.

다른 논문들은 이어서 다음 포스팅에서 알아보겠다.

2025.09.05 - [분류 전체보기] - [ILSVRC 논문 정리해 보기] DenseNet, SENet과 대회 그 이후

[ILSVRC 논문 정리해 보기] DenseNet, SENet과 대회 그 이후

2025.06.14 - [Computer Vision1/Paper reviews] - [ILSVRC 논문 정리해 보기] VGGNet, GoogleNet, ResNet [ILSVRC 논문 정리해 보기] VGGNet, GoogleNet, ResNetVGGNet 제안자: 옥스포드 대학의 Visual Geometry Group (VGG).등장: ILSVRC 2014

c0mputermaster.tistory.com

[Project] Classification Model 구현해보기 (ResNet)

임승택 — Tue, 12 Aug 2025 09:06:28 +0900

Classification 모델을 구현해보자 먼저 Train과 Test 구조를 정의

Import

import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
import torchvision.transforms as transforms
import torch.optim as optim

import os
import matplotlib.pyplot as plt

torch.nn as nn

신경망 레이어와 모델 구축을 위한 모듈.
예: nn.Conv2d, nn.Linear, nn.BatchNorm2d 등을 사용해 레이어 정의.

torch.nn.functional as F

활성화 함수나 pooling 같은 연산을 함수형(functional)으로 제공.
예: F.relu(x), F.max_pool2d(x, 2).

torch.optim as optim

- SGD, Adam, RMSprop 등 다양한 Optimizer 제공.

torchvision

- CIFAR-10, ImageNet 등 유명 데이터셋과 미리 정의된 모델들(ResNet, VGG 등) 제공.

def accuracy(output, target, topk=(1, )):
    with torch.no_grad():
        maxk = max(topk)
        batch_size = target.size(0)

        _, pred = output.topk(maxk, 1, True, True)
        pred = pred.t()
        correct = pred.eq(target.view(1, -1).expand_as(pred))

        acc = []
        num_cor = []
        for k in topk:
            correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)
            num_cor.append(correct_k.clone())
            acc.append(correct_k.mul_(1 / batch_size))
    return acc, num_cor

top-k 분류 정확도를 계산

topk=(1,) → 일반적인 top-1 정확도.
topk=(1,5) → top-1 정확도와 top-5 정확도를 동시에 계산 가능.

def initialize_weights(module):
    if isinstance(module, nn.Conv2d):
        nn.init.kaiming_normal_(module.weight.data, mode='fan_out')
    elif isinstance(module, nn.BatchNorm2d):
        module.weight.data.fill_(1)
        module.bias.data.zero_()
    elif isinstance(module, nn.Linear):
        module.bias.data.zero_()

만약 레이어가 합성곱(Conv2D) 레이어라면 He(Kaiming) 초기화 [각 층의 가중치를 입력 노드 수의 역수에 비례하는 분산을 가진 분포에서 무작위로 선택하여 초기화]

https://resultofeffort.tistory.com/114

[Deep learning] 가중치 초기화(weight initialization) (feat. Xavier, He,normal, uniform)

0. 딥러닝 모델 학습 / 모델 훈련 프로세스1. 모델 초기화(Initialization): 최초 가중치(weight) 값을 설정합니다.2. 예측(Prediction): 설정된 가중치와 입력 feature(X) 값을 사용하여 예측 값을 계산합니다.

resultofeffort.tistory.com

fan_out 모드: 출력 채널 기준으로 분산을 맞춤.

만약 레이어가 배치 정규화(BatchNorm2D) 라면 배치 정규화 레이어의 scale(γ)은 1로, shift(β)는 0으로 초기화. = 정규화된 출력 그대로 weight=1, bias=0.

만약 레이어가 완전연결층(FC, Linear) 라면 bias 항을 0으로 초기화.

정규화된 이미지를 다시 원래 값으로 되돌리는 함수

def inverse_normalize(tensor, mean=(0.4914, 0.4822, 0.4465), std=(0.2023, 0.1994, 0.2010)):
    for t, m, s in zip(tensor, mean, std):
        t.mul_(s).add_(m)
    return tensor

tensor: 정규화된 이미지 텐서 (C, H, W 형태).
mean: 정규화 시 사용한 평균값 (CIFAR-10 채널 평균).
std: 정규화 시 사용한 표준편차 (CIFAR-10 채널 표준편차).

일반적으로 학습 전에 이미지를 Normalize(mean, std)로 변환함

이렇게 되면 픽셀 값이 -1~1 근처의 값으로 바뀌어서 시각화할 때 원본 이미지와 다르게 보임 따라서 다시 원래 값으로 돌려줄 필요가 있기 때문에 정의

Train

def train(epochs):
    best_acc = 0.0
    print('[*] start training')
    for epoch in range(1, epochs):
        model.train() #입력과 출력이 다를 댸
        for step, (data, targets) in enumerate(trainloader): # trainloader에서 데이터(batch) 꺼내오기.
            data = data.to(device, dtype=torch.float)
            targets = targets.to(device)
            optimizer.zero_grad() # optimizer.zero_grad() → 이전 배치에서 계산된 gradient 초기화.

            outputs = model(data) # 모델에 입력 넣고 예측값 outputs
            loss = nn.CrossEntropyLoss(reduction='mean')(outputs, targets) # 손실 함수

            loss.backward() # gradient 계산 (backpropagation).
            optimizer.step() # Adam optimizer로 가중치 업데이트.

            loss = loss.item()
            acc, _ = accuracy(outputs, targets)
            acc = acc[0].item()

            if step % 10 == 0: # 중간 학습 상황 출력.
                print(f'[Epoch {epoch}/{epochs}, Step {step}/{len(trainloader)}] Loss {loss:.4f}, Accuracy {acc:.4f}')
        scheduler.step() # 에폭이 끝날 때마다 학습률(learning rate) 조정


        model.eval() # 평가 모드 전환 (Dropout 비활성화, BatchNorm 고정).
        total_cor = 0
        total_samples = 0

        with torch.no_grad():
            for step, (data, targets) in enumerate(testloader):
                data = data.to(device, dtype=torch.float)
                targets = targets.to(device)
                outputs = model(data)
                _, num_cor = accuracy(outputs, targets)
                num_cor = num_cor[0].item()
                total_samples += data.size(0)
                total_cor += num_cor
            acc = total_cor / total_samples
            print(f'Epoch {epoch} : Test Accuracy {acc:.4f}')

        if acc > best_acc: # 모델 저장 새로운 최고 정확도 달성 시 → 모델 저장.
            print('[*] model saving...')
            state = {
                'model': model.state_dict(),#모델 가중치만 저장
                'acc': acc,
                'epoch': epoch,
            }
            if not os.path.isdir('ckpt_0'):
                os.mkdir('ckpt_0')

            path = f'ckpt_0/model_{model.__class__.__name__}_state_{epoch:03d}_{acc:.4f}.st'
            torch.save(state, path)
            best_acc = acc
    print(f'Best Test Accuracy {best_acc:.4f}')

best_acc = 최고 test accuracy 저장

model.train() → 학습 모드 전환. (Dropout, BatchNorm 등 학습용 동작 활성화)

def test(ckpt_path):
    print(f'[*] load {ckpt_path}')
    model.eval() #평가 모드 전환
    state_dict = torch.load(ckpt_path) # 학습된 모델 checkpoint 파일 불러오기.
    model.load_state_dict(state_dict['model'], strict=True) # 저장된 가중치 불러오기.
    # (strict=True → 저장된 키와 모델 구조가 정확히 일치해야 함)

    total_cor = 0
    total_samples = 0
    with torch.no_grad():
        for step, (data, targets) in enumerate(testloader):
            data = data.to(device, dtype=torch.float)
            targets = targets.to(device)
            outputs = model(data)
            _, num_cor = accuracy(outputs, targets)
            num_cor = num_cor[0].item()
            total_samples += data.size(0)
            total_cor += num_cor
        acc = total_cor / total_samples # 전체 정답 수 ÷ 전체 샘플 수 → 최종 Test Accuracy 출력.
        print(f'Test Accuracy {acc:.4f} of Loaded Model {model.__class__.__name__}')

        # Visualize
        images = []
        pred_classes = []
        labels = []
        pred = outputs.topk(1, dim=1, largest=True, sorted=True) # 각 샘플의 예측 클래스(Top-1) 뽑기
        fig, axes = plt.subplots(3, 3, figsize=(15, 5))  # 3 row, 3 columns
        axes = axes.flatten()
        for k in range(9):  # check only the first 9 images
            images.append(inverse_normalize(data[k, :, :, :]).detach().cpu().permute(1, 2, 0).numpy())
            pred_classes.append(classes[pred[1][k].item()])
            labels.append(classes[targets[k].item()])
        for k, image in enumerate(images):
            axes[k].imshow(image)
            axes[k].axis('off')
            axes[k].set_title(f'label: {labels[k]}, pred: {pred_classes[k]}', fontsize=10)
        plt.tight_layout()
        plt.show()

저장된 모델 checkpoint 로드
전체 test dataset에 대해 정확도 계산
일부 이미지를 예측 결과 vs 실제 라벨로 시각화

Main - train

if __name__ == '__main__':
    # 학습에 사용할 디바이스 설정 (CUDA가 있으면 GPU, 없으면 CPU)
    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    print(device)

    # --------------------
    # 1. 데이터 준비
    # --------------------
    print('[*] preparing data')
    # 학습 데이터 변환 (데이터 증강 포함)
    transform_train = transforms.Compose([
        transforms.RandomCrop(32, padding=4),         # 랜덤 크롭 (여백 포함)
        transforms.RandomHorizontalFlip(),            # 랜덤 좌우 반전
        transforms.ToTensor(),                        # 텐서 변환
        transforms.Normalize((0.4914, 0.4822, 0.4465),# 채널별 평균 정규화
                             (0.2023, 0.1994, 0.2010))# 채널별 표준편차 정규화
    ])

    # 테스트 데이터 변환 (증강 X, 정규화만 적용)
    transform_test = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.4914, 0.4822, 0.4465),
                             (0.2023, 0.1994, 0.2010))
    ])

    # CIFAR-10 학습 데이터셋 (5만 장)
    trainset = torchvision.datasets.CIFAR10(
        root='./data', train=True, download=True, transform=transform_train)
    # 학습 데이터 로더
    trainloader = torch.utils.data.DataLoader(
        trainset, batch_size=128, shuffle=True, num_workers=2)

    # CIFAR-10 테스트 데이터셋 (1만 장)
    testset = torchvision.datasets.CIFAR10(
        root='./data', train=False, download=True, transform=transform_test)
    # 테스트 데이터 로더
    testloader = torch.utils.data.DataLoader(
        testset, batch_size=100, shuffle=False, num_workers=2)

    # CIFAR-10 클래스 이름
    classes = ('plane', 'car', 'bird', 'cat', 'deer',
               'dog', 'frog', 'horse', 'ship', 'truck')

    # --------------------
    # 2. 모델 정의
    # --------------------
    print('[*] building model')
    # model = ToyNetwork()   # 간단한 CNN (연습용)
    model = ResNet50()       # 실제 학습에 사용할 ResNet50 모델
    model.to(device)         # GPU/CPU 디바이스에 올리기

    # --------------------
    # 3. 손실 함수
    # --------------------
    criterion = nn.CrossEntropyLoss(reduction='mean') # 다중 분류용 손실 함수

    # --------------------
    # 4. 최적화 도구 & 학습률 스케줄러
    # --------------------
    epochs = 100
    params = model.parameters()
    optimizer = optim.Adam(params, lr=1e-3) # Adam Optimizer (lr=0.001)
    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
        optimizer, T_max=epochs)             # Cosine Annealing 학습률 스케줄러

    # --------------------
    # 5. 학습 시작
    # --------------------
    train(epochs)  # 학습 루프 실행

Test

    directory = './ckpt_0'
    ckpt_list = os.listdir(directory) # ckpt_0 폴더 안의 모든 파일 목록 불러오기.
    ckpt_list = [f for f in ckpt_list if os.path.isfile(os.path.join(directory, f)) and model.__class__.__name__ in f]
    # 리스트 컴프리헨션으로 필터링 파일 이름에 현재 모델 이름 포함된 것만 선택
    ckpt_list.sort()
    ckpt_path = os.path.join(directory, ckpt_list[-1]) # 가장 최신 checkpoint 파일 경로 얻기.
    print(ckpt_path)
    test(ckpt_path=ckpt_path)

Model ( ResNet50 )

2025.09.05 - [Computer Vision1/Paper reviews] - [ILSVRC 논문 정리해 보기] VGGNet, GoogleNet, ResNet

[ILSVRC 논문 정리해 보기] VGGNet, GoogleNet, ResNet

c0mputermaster.tistory.com

ResNet을 구성하는 기본 단위 블록

class BasicBlock(nn.Module):
    expansion = 1

    def __init__(self, in_planes, planes, stride=1):
        super(BasicBlock, self).__init__()
        self.conv1 = nn.Conv2d(
            in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(planes)
        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3,
                               stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(planes)

        self.shortcut = nn.Sequential()
        if stride != 1 or in_planes != self.expansion*planes:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_planes, self.expansion*planes,
                          kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(self.expansion*planes)
            )

    def forward(self, x):
        out = F.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        out += self.shortcut(x)
        out = F.relu(out)
        return out


class Bottleneck(nn.Module):
    expansion = 4

    def __init__(self, in_planes, planes, stride=1):
        super(Bottleneck, self).__init__()
        self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=1, bias=False)
        self.bn1 = nn.BatchNorm2d(planes)
        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3,
                               stride=stride, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(planes)
        self.conv3 = nn.Conv2d(planes, self.expansion *
                               planes, kernel_size=1, bias=False)
        self.bn3 = nn.BatchNorm2d(self.expansion*planes)

        self.shortcut = nn.Sequential()
        if stride != 1 or in_planes != self.expansion*planes:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_planes, self.expansion*planes,
                          kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(self.expansion*planes)
            )

    def forward(self, x):
        out = F.relu(self.bn1(self.conv1(x)))
        out = F.relu(self.bn2(self.conv2(out)))
        out = self.bn3(self.conv3(out))
        out += self.shortcut(x)
        out = F.relu(out)
        return out

- BasicBlock

class BasicBlock(nn.Module):
    expansion = 1

conv1: 3×3 Conv, stride는 입력에 따라 다름.
bn1: BatchNorm → 학습 안정화.
conv2: 또 다른 3×3 Conv.
bn2: BatchNorm.
shortcut: 잔차 연결(residual connection).
- 기본은 단순히 identity 연결.
- 하지만 stride가 바뀌거나(in_planes ≠ planes) 차원이 달라지면 →
  1×1 Conv + BatchNorm으로 차원 맞춰줌.

forward()

out = F.relu(self.bn1(self.conv1(x)))
out = self.bn2(self.conv2(out))
out += self.shortcut(x)     # 입력 + 변환된 출력 → skip connection
out = F.relu(out)

입력을 그대로 더하는 skip connection(잔차 연결)

- Bottleneck

class Bottleneck(nn.Module):
    expansion = 4

ResNet-50 이상에서 사용하는 블록.
expansion=4 → 출력 채널 수가 입력보다 4배 확장.
conv1: 1×1 Conv → 채널 축소 (차원 줄여 연산량 감소).
conv2: 3×3 Conv → 실제 feature 추출.
conv3: 1×1 Conv → 채널 확장 (planes → planes×4).
각 conv 뒤에 BatchNorm.
shortcut: 마찬가지로 stride나 채널이 다르면 1×1 Conv로 매핑.

forward()

out = F.relu(self.bn1(self.conv1(x)))  # 채널 축소
out = F.relu(self.bn2(self.conv2(out)))# 3×3 conv
out = self.bn3(self.conv3(out))        # 채널 확장
out += self.shortcut(x)                # skip connection
out = F.relu(out)

BasicBlock: 2개의 3×3 Conv → ResNet-18, ResNet-34에 사용.
Bottleneck: 1×1 → 3×3 → 1×1 Conv 구조 → ResNet-50 이상에서 사용.

class ResNet(nn.Module):
    def __init__(self, block, num_blocks, num_classes=10):
        super(ResNet, self).__init__()
        self.in_planes = 64

        self.conv1 = nn.Conv2d(3, 64, kernel_size=3,
                               stride=1, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1)
        self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2)
        self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2)
        self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2)
        self.linear = nn.Linear(512*block.expansion, num_classes)

    def _make_layer(self, block, planes, num_blocks, stride):
        strides = [stride] + [1]*(num_blocks-1)
        layers = []
        for stride in strides:
            layers.append(block(self.in_planes, planes, stride))
            self.in_planes = planes * block.expansion
        return nn.Sequential(*layers)

    def forward(self, x):
        out = F.relu(self.bn1(self.conv1(x)))
        out = self.layer1(out)
        out = self.layer2(out)
        out = self.layer3(out)
        out = self.layer4(out)
        out = F.avg_pool2d(out, 4)
        out = out.view(out.size(0), -1)
        out = self.linear(out)
        return out


def ResNet18():
    return ResNet(BasicBlock, [2, 2, 2, 2])


def ResNet34():
    return ResNet(BasicBlock, [3, 4, 6, 3])


def ResNet50():
    return ResNet(Bottleneck, [3, 4, 6, 3])


def ResNet101():
    return ResNet(Bottleneck, [3, 4, 23, 3])


def ResNet152():
    return ResNet(Bottleneck, [3, 8, 36, 3])


def test():
    net = ResNet18()
    y = net(torch.randn(1, 3, 32, 32))
    print(y.size())

class ResNet(nn.Module):

def __init__(self, block, num_blocks, num_classes=10):

super(ResNet, self).__init__()

self.in_planes = 64

block: 어떤 블록을 쓸지 (BasicBlock or Bottleneck).
num_blocks: 각 레이어에 몇 개의 블록을 쌓을지 지정.
num_classes: 분류할 클래스 수 (CIFAR-10 → 10).

수치 표현과 데이터 전처리

딥러닝 프레임워크의 기본 자료형은 float32 (32비트 부동소수점).
일부 최적화/압축 기법으로 int4, float16 같은 quantization을 적용할 수 있음.
데이터 정규화(Normalize):
- 각 채널(R, G, B)의 평균과 표준편차로 정규화.
- 보통 ImageNet의 통계값(예: 평균 [0.4914, 0.4822, 0.4465], 표준편차 [0.2023, 0.1994, 0.2010])을 많이 사용.
학습(train) 때는 데이터 어그멘테이션(RandomCrop, Flip 등)을 적용하지만, 테스트(test) 시에는 동일한 Normalize만 적용.

데이터셋 & 데이터로더

데이터셋 클래스 작성법:
- torch.utils.data.Dataset 상속.
- 필수 구현 메서드:
  - __init__: 경로/데이터/라벨 로드 및 초기화.
  - __getitem__: 인덱스로 데이터와 레이블을 반환.
  - __len__: 전체 데이터 크기 반환.
데이터로더(DataLoader):
- 배치 단위로 데이터를 꺼내 학습 파이프라인에 전달.
- 인자: dataset, batch_size, shuffle, num_workers.
- num_workers: CPU가 GPU 학습 중에도 병렬로 데이터를 전처리해서 성능 향상.

모델 구조 (PyTorch)

커스텀 네트워크는 nn.Module 상속.
- __init__에 레이어 정의.
- forward()에서 순전파 정의 (연산 그래프 구성).
학습 가능한 텐서(requires_grad=True)는 **파라미터(필터, 가중치)**이고, 입력 데이터는 보통 requires_grad=False.
Convolution Layer 예시:
- Conv2d(3, 32, kernel_size=7) → 파라미터 크기: (32, 3, 7, 7).
1x1 Convolution은 Fully Connected Layer와 동일한 효과.

미분 그래프(Autograd)

PyTorch 핵심: 자동 미분(Autograd).
각 텐서는 다음 3개 멤버를 가짐:
1. requires_grad: 학습 여부 (True/False).
2. grad_fn: 어떤 연산을 거쳤는지(미분 함수 추적).
3. grad: 역전파 시 계산된 기울기 값.
Forward Pass = 그래프 구성, Backward Pass = 기울기 전파 및 파라미터 업데이트.

학습 과정

데이터 로더에서 배치 꺼냄.
모델 forward → 출력값 계산.
손실함수(loss) 계산 (CrossEntropyLoss 등).
loss.backward() → gradient 계산.
옵티마이저(Adam, SGD)가 파라미터 업데이트.
루프: (배치 → 옵티마이저 step) × (에폭 수 만큼 반복).

학습 & 추론 모드

model.train(): 드롭아웃/배치정규화가 학습 모드로 동작.
model.eval(): 추론 모드 (드롭아웃 비활성화, 배치정규화는 EMA 값 사용).

학습률(Learning Rate) 제어

기본: 일정한 lr (예: 0.001).
고급 기법:
- Cosine Annealing: 코사인 함수 곡선 형태로 lr 감소.
- Warm-up: 초기에 작은 lr로 시작해 점차 증가시킨 뒤 감소.

결과 시각화

모델의 더 자세한 정보는 이전에 정리한 포스팅을 참고하면 좋겠다.

2025.09.05 - [Computer Vision1/Paper reviews] - [ILSVRC 논문 정리해 보기] VGGNet, GoogleNet, ResNet

[ILSVRC 논문 정리해 보기] VGGNet, GoogleNet, ResNet

c0mputermaster.tistory.com

Lim's Technology

생성 모델 정리하기 (MLE · VAE · GAN · Diffusion · Language Model)

1. 생성(Generation) vs 판별(Discrimination) & 왜 VAE가 중요한가

2. 최대우도추정(MLE)와 'Likelihood'

2.1 Bayes Rule과 관측변수 vs 미지수 구분:

2.2 생성적 관점: 데이터는 ‘어딘가의 분포’에서 샘플링된 것

2.3 MLE의 목표: 가장 ‘그럴싸한’ θ 찾기

2.4 Likelihood는 “확률분포”가 아니라 “함수”

3. 생성 모델링 = 데이터 분포에 대한 MLE

3.1 생성 문제의 목적식

3.2 판별 테스크(Classification)와의 연결

3.3 생성 테스크

4. 명시적(Explicit) vs 암묵적(Implicit) 생성 모델

4.1 명시적 생성 모델 (Explicit)

4.2 암묵적 생성 모델 (Implicit Generative Model)

5. GAN 암묵적(Implicit) 생성 모델 대표

5.1 구조: Generator vs Discriminator

5.2 학습 종료 시점: D의 정확도 ≈ 50%

5.4 GAN은 “모델 이름”이라기보다 “로스 구조”

6. VAE(Variational Autoencoder): 명시적 + 근사(Variational) 기법

6.1 목표: pθ(x)를 직접 모델링

6.2 Variational Inference와 ELBO

6.3 ELBO의 두 항: Reconstruction Loss + KL Regularization

6.4 Reparameterization Trick (리파라미터라이제이션 트릭)

6.5 학습 후 사용

7. 언어 모델 (Autoregressive Model)

7.1 오토리그레시브 분해

7.2 Tractable 모델인 이유

8. Diffusion Model

8.1 Forward Process: 깨부수기(노이즈 추가)

8.2 Reverse Process: 정리하기(노이즈 제거)

8.3 ‘아이 방 어질러 놓기’

8.4 Diffusion과 VAE/Variational의 연결

9. 정리

[Object Tracking] Visual Object Tracking (VOT) 알아보기 (Distance Learning)

Visual Object Tracking (VOT)

2. Object Detection vs Object Tracking

Object Tracking의 개념

1. Appearance Representation (외형 표현)

대표적인 전통적 특징 표현

2. Association (연관성 판단)

전통적인 방법 vs 딥러닝 방법

1. 전통적 방법: Histogram Back Projection + Mean Shift

(1) Histogram Back Projection

(2) Mean Shift (모드 시킹, Mode Seeking)

2. 딥러닝 기반 Visual Object Tracking

Distance Learning / Similarity Learning

Latent Space와 Feature Embedding

Siamese Network 구조

Triplet 구조

Contrastive Learning 학습 시 고려사항

[Segmentation] DeepLab, Mask R-CNN, PanopticFPN

Receptive Field

DeepLab

Instance Segmentation

Mask R-CNN

Panoptic segmentation

Penoptic Segmentation의 대표 모델 – Penoptic FPN

[Segmentation] Semantic Segmentation 알아보기 FCN, U-Net

시멘틱 세그멘테이션과 Dense Prediction

FCN (Fully Convolutional Network)

기존 방식

FCN 방식

U-Net

[Deep Learning] Partial Fine-Tuning 해보기

Fine-Tuning의 세 가지 방식

데이터셋 및 데이터로더 정의

ResNet50 모델 정의 ( From Scratch, Full Fine-Tuning, Partial Fine-Tuning )

[Object Detection] One-Stage Object Detection - YOLO, SSD, RetinaNet

YOLO

SSD

RetinaNet

Class Imbalance

A. Multi-scale Input (이미지 피라미드)

B. Single Feature Map (YOLO v1 방식)

C. Multi-Feature Map (SSD 방식)

D. Feature Fusion (FPN, RetinaNet 방식)

1. Backbone의 다양화

2. Transformer 기반 Detection

3. Anchor 문제와 Anchor-free 기법

2.3 MLE의 목표: 가장 ‘그럴싸한’ 찾기