과연 나는 열심히 할까..?

[Paper Review] LLaVA : Visual Instruction Tuning

cooling0 — Tue, 30 Sep 2025 13:26:22 +0900

Abstract

machine이 생성한 instruction-following data를 사용한 instruction tuning LLM들은 새로운 task에서 zero-shot 성능 향상을 보여줌
- 하지만, 이러한 아이디어는 멀티모달 분야에서는 덜 탐구됨
본 연구는 language-only GPT-4를 사용하여 multimodal language-image instruction-following data를 생성하기 위한 첫 번째 시도를 제시
이렇게 생성된 데이터에 대한 instruction tuning을 통해, 범용적인 visual and language 이해를 위한 vision encoder와 LLM을 연결한 end-to-end로 훈련된 large multimodal model인 LLaVA(Large Language and Vision Assistant)를 소개
instruction-following data : 모델이 특정한 지시나 명령을 이해하고 따를 수 있도록 설계된 데이터.
- 이 데이터는 instruction(질문이나 요청)과 이에 대한 following(답변이나 설명)으로 구성되며 모델이 지시 사항에 맞춰 task를 수행할 수 있도록 훈련하는 데 사용.
- 이렇게 구성된 데이터는 모델이 다양한 유형의 질문이나 요청을 이해하고 요구사항을 충족하는 방식으로 답변하도록 훈련.

Introduction

멀티모달 vision-and-language instruction을 효과적으로 따르며 인간의 의도에 맞춰 다양한 real-world task를 수행할 수 있는 범용적인 assistant를 개발
본 연구에서는 visual instruction-tuning을 제안하는데, 이는 language-image multimodal 공간으로 instruction-tuning을 확장하려는 첫 번째 시도로, 범용적인 visual assistant를 구축하는 길을 열기 위함이다
한 가지 주요 과제는 vision-language instruction-following 데이터 부족
- 그래서 본 논문은 ChatGPT/GPT-4를 이용하여 image-text 쌍을 적절한 instruction-following 형식으로 변환하기 위한 데이터 재구성 관점 및 파이프라인을 제시
CLIP의 visual encoder를 language decoder Vicuna와 연결하고 생성된 instructional vision-language data를 end-to-end로 fine-tuning하여 large multimodal model (LMM)을 개발

GPT-assisted Visual Instruction Data Generation

multimodal instruction-following data에 있어서는 이용가능한 양이 제한적
최근 text-annotation task에서 GPT 모델들의 성공에 영감받아, 기존에 존재하는 image 쌍 데이터를 기반으로 multimodal instruction-following data 수집을 위해 ChatGPT/GPT-4를 활용할 것을 제안
기존 CC에서 LAION 같은 데이터셋은 단순한 Image 캡셔닝에 그침
- 그래서 LLaVA 를 학습하기 위한 instruction-following Dataset 생성이 필요
- 직접 작성 → cost 높은, human crowd-sourcing → 데이터 정의가 잘안됨.

Multimodal instruction-following Dataset 생성

image $X_v$ 와 해당하는 Caption $X_c$ 가 있는 경우 이미지를 서술해 달라는 내용을 질문 $X_q$ 로한 데이터셋 생성

$$ \text{Human : } X_qX_v \text{ <STOP>} \text{Assistant : } X_c \text{ <STOP>} $$

하지만 다양성 부족 / 심도 있는 Reasoning 부족
이를 해결하기 위하여 GPT 사용
- ChatGPT/ GPT-4 가 visual content 를 이지 못함 → Symbolic Representations 으로 해결
- instruction-following Dataset 의 형태 → Conversation, Detailed description, Complex reasoning

Symbolic Representations

language-only GPT-4 또는 ChatGPT 가 visual content를 포함한 instruction following 데이터를 생성하기 위해 화용
- Captions 을 시각적으로 다양한 관점에서 바라본 image Scence 에 대해 설명
- 즉 language-only 가 이해할수 있게 encode
Bounding Boxes
- Scence 에서 특정 물체가 어디에 위치했는지 설명

instruction-following Dataset 의 형태

Conversation : 이미지에 대해 질문하는 사람과 assistant 사이의 대화형식으로 디자인한다.
- 답변은 마치 assistant가 이미지를 보고 질문에 답하는 듯한 톤으로 되어있다. 객체 유형, 객체 수, 객체 동작, 객체 위치, 객체 간의 상대적 위치를 포함하여 이미지의 시각적 내용에 대해 다양한 질문을 한다. 명확한 답변이 있는 질문만 고려한다.
Detailed description : 이미지에 대한 풍부하고 포괄적인 설명을 포함하기 위해 질문 목록을 만든다.
- 각 이미지에 대해 질문 목록에서 하나의 질문을 무작위로 샘플링하여 GPT-4에 상세한 설명을 생성하도록 요청한다.
- 답변은 일반적으로 엄격한 논리를 따르는 step-by-step reasoning process를 필요로한다.Complex reasoning : 위의 두 가지 유형은 content에 중점을 두며 이를 기반으로 심층 추론 질문을 추가로 생성한다.

Methodologies

Training

training data

각 image $X_v$ 에 대해 multi-turn conversation data $(X^1_q , X^1_a , · · · , X^T_q , X^T_a )$ 확보
각 conversation 의 답변을 assistant 의 답변으로 정의
t 번째 instruction은 아래와 같이 지정

Stage 1: Pre-training for Feature Alignment

image 에 대한 간ㄷ단한 요약을 요청하는 질문을 설정 후 GT 는 원 그림의 캡션으로 정의
이때는 linear 레이어만 학습함
question Xq가 무작위로 샘플링되는데 이는 assistant에게 이미지를 간단히 설명하도록 요청하는 language instruction이다.
ground-truth prediction answer Xa는 original caption이다. 학습에서, visual encoder와 LLM 가중치들을 frozen한 상태로 두고 학습 가능한 파라미터 θ = projection matrix W만을 사용하여 식 (3)의 likelihood를 최대화한다.
이렇게 함으로써 image feature Hv는 pre-trained LLM word embedding과 align된다. 이 stage는 frozen LLM에 대해 호환 가능한 visual tokenizer를 학습하는 것으로 이해할 수 있다.

Stage 2: Fine-tuning End-to-End

visual encoder weight를 계속 frozen 상태로 유지하고 projection layer와 LLM의 사전학습된 가중치를 업데이트한다. 즉, 학습 가능한 파라미터 식 (3)에서 θ = {W, φ} 이다. 본 논문은 두 가지 특정 사례에 대해 고려
- Multimodal Chatbot : Section 3에서 설명된 158K language-image instruction-following data에 대해 chatbot을 finetuning하여 개발한다. 세 가지 유형중에서 conversation은 multi-turn 형식이고 나머지 두 개는 single-turn 형식이다. 학습 시 이들 응답 유형은 균일하게 샘플링된다.
- Science QA : ScienceQA benchmark에서 본 논문의 방법을 연구한다. ScienceQA는 상세한 강의와 설명으로 답변에 주석을 다는 최초의 대규모 multimodal science question dataset이다. 각 질문은 자연어 혹은 이미지 context로 제공되된다. assistant는 자연어로 추론 과정을 제공하고 객관식에서 대답을 선택한다. 식 (2)에서 학습 시, 데이터를 single turn conversation 형태로 구성하며, question & context를 Xinstruct로 reasoning & answer를 Xa로 설정한다.

[Paper Review] Flamingo: a Visual Language Model for Few-Shot Learning

cooling0 — Tue, 30 Sep 2025 11:10:48 +0900

Abstract

소수의 주석이 달린 예제만으로 새로운 작업에 신속하게 적응할 수 있는 모델을 구축하는 것은 멀티모달 머신 러닝 연구의 미해결 과제
본 연구에서는 이러한 기능을 갖춘 시각 언어 모델(VLM) 제품군인 Flamingo를 소개
(i) 강력한 사전 학습된 vision-only and language-only models 을 연결
(ii) 임의로 삽입된 visual and textual data 시퀀스를 처리
(iii) 이미지 또는 비디오를 입력으로 원활하게 처리

1. Introduction

Recently, multimodal vision-language models trained with a contrastive objective have enabled zero-shot adaptation to novel tasks, without the need for fine-tuning.
이러한 모델은 단순히 텍스트와 이미지 간의 유사도 점수만 제공하기 때문에, 사전에 유한한 결과 집합이 제공되는 분류와 같은 제한적인 사용 사례에만 적용될 수 있음
이러한 모델은 언어 생성 능력이 매우 부족하여 캡션 작성이나 시각적 질의응답과 같은 보다 개방적인 작업에는 적합하지 않음
A single large LM은 텍스트 인터페이스만으로도 여러 과제에서 뛰어난 성능을 달성
- 과제 예시 몇 가지가 모델에 프롬프트 형태로 제공 → 쿼리 입력과 함께 모델이 해당 쿼리에 대한 예측 출력을 생성하는 연속적인 구문을 생성
분류, 캡션, 질의응답과 같은 이미지 및 비디오 이해 과제에도 동일한 작업이 가능함을 보여줍니다. 이러한 과제는 시각적 입력 조건화를 통해 텍스트 예측 문제로 변환될 수 있

2. Approach

Flamingo: a visual language model that accepts text interleaved with images/videos as input and outputs free-form text

그림 3에 제시된 주요 아키텍처 구성 요소는 pretrained vision and language models 을 활용하고 효과적으로 연결하기 위해 선택
Perceiver Resampler
- Vision Encoder 로부터 시공간적 특징(이미지 또는 비디오에서 획득)을 수신하여 고정된 개수의 visual tokens을 출력
이러한 visual tokens 은 pretrained LM 계층 사이에 인터리빙된 새로 초기화된 cross-attention layers (2.2절)을 사용하여 동결된 LM을 조정하는 데 사용
- 이러한 새로운 레이어는 LM이 다음 토큰 예측 작업에 visual information를 통합할 수 있는 표현적인 방법을 제공
Flamingo는 인터리브된 이미지와 비디오 를 조건으로 텍스트 의 가능성을 다음과 같이 모델링합니다.

$ y_\ell $ 은 입력 텍스트의 $ \ell $번째 언어 토큰을 의미한다.
$ y_{<\ell} $ 은 해당 토큰 이전의 모든 토큰 집합을 나타낸다.
$ x_{\leq \ell} $ 은 인터리브(interleaved)된 시퀀스 내에서 $ y_\ell $ 이전에 등장하는 이미지/비디오들의 집합을 의미한다.
확률 분포 $ p $ 는 Flamingo 모델에 의해 파라미터화된다.
인터리브된 텍스트와 시각적 시퀀스(2.3절 참조)를 처리할 수 있는 기능 덕분에 Flamingo 모델을 맥락 내 퓨샷 학습에 자연스럽게 활용할 수 있습니다

2.1 Visual processing and the Perceiver Resampler

Vision Encoder: from pixels to features

frozen NormalizerFree ResNet(NFNet)[10]을 비전 인코더에 적용

Perceiver Resampler: from varying-size large feature maps to few visual tokens

이 모듈은 그림 3과 같이 비전 인코더를 동결된 언어 모델에 연결
- 비전 인코더에서 가변 개수의 이미지 또는 비디오 특징을 입력으로 받아 고정된 개수의 시각적 출력(64)을 생성하여 vision-text cross-attention 의 계산 복잡도를 줄임.
- Perceiver [48] 및 DETR [13]과 유사하게 Transformer에 공급되고 시각적 특징에 교차 참여하는 미리 정의된 개수의 잠재 입력 쿼리를 학습

2.2 Conditioning frozen language models on visual representations

텍스트 생성은 Transformer decoder에 의해 수행되며, 이는 Perceiver Resampler 에서 생성된 시각적 표현을 기반
사전 학습되고 동결된 텍스트 전용 LM 블록과, Perceiver Resampler 의 시각적 출력에 교차 반응하는 처음부터 학습된 블록을 인터리빙

Interleaving new GATED XATTN-DENSE layers within a frozen pretrained LM.

We freeze the pretrained LM blocks 학습된 원래 계층 사이에 gated cross-attention dense blocks (그림 4)을 삽입

2.3 Multi-visual input support: per-image/video attention masking

방정식 (1)에 도입된 image-causal modelling 은 전체 text-to-image cross-attention matrix 을 마스킹하여 모델이 각 텍스트 토큰에서 보는 시각적 토큰을 제한함으로써 얻어짐.
주어진 텍스트 토큰에서, 모델은 이전 모든 이미지가 아닌 interleaved sequence 에서 바로 앞에 나타난 이미지의 시각적 토큰에 주의를 기울임
Though the model only directly attends to a single image at a time, LM의 self-attn 을 통해 이전 모든 이미지에 대한 종속성은 유지
이 단일 이미지 교차 어텐션 방식은 모델이 훈련 중 사용되는 시각적 입력의 개수에 관계없이 모든 개수의 시각적 입력에 대해 원활하게 일반화할 수 있도록 하는 중요한 역할

[Paper Review] BLIP-2 : Bootstrapping Language-Image Pre-training with Frozen Image Encoders and Large Language Models

cooling0 — Tue, 30 Sep 2025 08:54:10 +0900

Abstract

large-scale models 의 end to end 학습으로 인해 vision-and-language pre-training 의 cost 가 높음
BLIP-2 : a generic and efficient pretraining strategy that bootstraps vision-language pre-training from off-the-shelf frozen pre-trained image encoders and frozen large language models
BLIP-2는 두 단계로 사전 학습되는 경량 쿼리 변환기(Querying Transformer)를 사용하여 모달리티 간 격차를 해소
- 첫 번째 단계는 frozen image encoder 에서 시각-언어 표현 학습을 부트 스트랩
- 두 번째 단계는 frozen language model 에서 시각-언어 생성 학습을 부트 스트랩
BLIP-2는 기존 방법보다 학습 가능한 매개변수가 훨씬 적음에도 불구하고 다양한 시각-언어 작업에서 최고 수준의 성능을 달성
자연어 명령을 따를 수 있는 제로샷 이미지-텍스트 생성이라는 모델의 새로운 기능을 보여줌

Introduction

본 논문에서는 기성품인 사전 훈련된 시각 모델과 언어 모델을 부트스트래핑하여 일반적이고 계산 효율적인 VLP(Virtual Lab Proof) 기법을 제안
사전 훈련된 언어 모델, 특히 대규모 언어 모델(LLM)은 강력한 언어 생성 및 제로샷 전이(zero-shot transfer) 기능을 제공
In order to leverage pre-trained unimodal models for VLP, it is key to facilitate cross-modal alignment.
그러나 LLM은 unimodal 사전 훈련 과정에서 이미지를 접하지 않았기 때문에, 이미지를 고정하는 것은 특히 시각-언어 정렬을 어렵게 만듬
To achieve effective vision-language alignment with frozen unimodal models, we propose a Querying Transformer (QFormer) pre-trained with a new two-stage pre-training strategy.

그림 1에서 볼 수 있듯이, Q-Former는 학습 가능한 쿼리 벡터 집합을 사용하여 Frozen 이미지 인코더에서 시각적 특징을 추출하는 경량 변환기
Q-Former : Frozen 이미지 인코더와 Frozen LLM 사이의 정보 병목 지점 역할을 하며, LLM이 원하는 텍스트를 출력할 수 있도록 가장 유용한 시각적 특징을 제공
첫 번째 사전 학습 단계에서는 시각-언어 표현 학습을 수행하여 Q-Former가 텍스트와 가장 관련성이 높은 시각적 표현을 학습
두 번째 사전 학습 단계에서는 Q-Former의 출력을 Frozen LLM에 연결하여 시각-언어 생성 학습을 수행하고, LLM이 출력 시각적 표현을 해석할 수 있도록 Q-Former를 학습

Method

3.1. Model Architecture

본 연구에서는 고정 이미지 인코더와 고정 LLM 간의 간극을 메우는 학습 가능 모듈로 Q-Former를 제안
Q-Former는 입력 이미지 해상도와 관계없이 이미지 인코더에서 고정된 개수의 출력 특징을 추출
위의 그림에서 볼수 있듯이 Q-Former는 동일한 self-attention layers 를 공유하는 두 개의 transformer 하위 모듈로 구성
- (1) 시각적 특징 추출을 위해 고정 이미지 encoder 와 상호작용 하는 이미지 변환기
- (2) 텍스트 encoder 와 텍스트 decoder 역할을 모두 수행할 수 있는 텍스트 변환기
We create a set number of learnable query embeddings as input to the image transformer
pre-training task에 따라, query-text interaction을 제어하기 위해 다양한 self-attention masks 적용
- Q-Former는 총 18,800만 개의 파라미를 포함합니다. 쿼리는 모델 매개변수로 간주

3.2. Bootstrap Vision-Language Representation Learning from a Frozen Image Encoder

representation learning stage : Q-Former를 Frozen 이미지 인코더에 연결하고 이미지-텍스트 쌍을 사용하여 사전 학습을 수행
- query들이 text의 가장 유익한 visual representation을 추출하기 위해 학습할 수 있도록 Q-Former를 학습하는 것을 목표
- BLIP(Li et al., 2022)에서 영감을 얻어, 동일한 입력 형식과 모델 매개변수를 공유하는 세 가지 사전 학습 목표를 공동으로 최적화.
- Each objective employs a different attention masking strategy between queries and text to control their interaction.

Image-Text Contrastive Learning (ITC)

ITC는 이미지와 텍스트 표현간의 mutual information이 최대화하기 위해 image representation과 text representation을 align하는 방법을 학습
- 이미지와 대응하는 텍스트(positive pair) 간의 유사성은 높이는 동시에, negative pair 간의 유사성은 낮추는 방식으로 mutual information을 최대화
- image transformer로부터 얻은 output query representation $Z$ 를 text transformer로부터 얻은 text representation $t$ 와 align

Image-grounded Text Generation (ITG)

ITG loss는 텍스트 생성을 위해 주어진 input image를 조건으로 Q-Former를 학습
- Q-Former의 아키텍처는 frozen image encoder와 text token 간의 직접적인 상호작용을 허용하지 않기 때문에, 텍스트 생성에 필요한 정보는 query들에 의해 먼저 추출
- 그 후, self-attention layers를 통해 text token에 전달된다. 그러므로, query들은 텍스트에 관한 모든 정보들을 포착하는 visual feature들을 추출하기 위해 집중
- query-text 상호작용을 제어하기 위해 UniLM에서 사용한 것과 유사하게 multimodal causal self-attention mask를 적용

Image-Text Matching (ITM)

ITM은 이미지와 텍스트 표현 간의 fine-grained alignment를 학습하는 것을 목표
- 이는 binary classification task로 모델은 image-text pair가 positive (일치) 한지 negative (비일치) 한지 예측하도록 요청
- 모든 query들과 텍스트들이 서로 attend할 수 있도록 bi-directional self-attention mask를 사용
- 그러므로 output query embedding Z는 multimodal 정보를 포착
- 로짓값을 얻기위해 각 output query embedding을 two-class linear classifier에 제공한 후, 모든 query들에 대한 로짓값을 평균화하여 output matching score를 계산

3.3 Bootstrap Vision-to-Language Generative Learning from a Frozen LLM

[Paper Review] Sigmoid Loss for Language Image Pre-Training

cooling0 — Fri, 26 Sep 2025 15:14:18 +0900

정리에 앞서 해당에서 VLM 에 관해 잘표현된 그림이 있어 가져왔습니다. 공부하는 입장에서 도움이 많이됨…

https://kyujinpy.tistory.com/166#introduction

[SigLip 논문 리뷰] - Sigmoid Loss for Language Image Pre-Training

*SigLip를 위한 논문 리뷰 글입니다! 궁금하신 점은 댓글로 남겨주세요! SigLip paper: https://arxiv.org/abs/2303.15343 Sigmoid Loss for Language Image Pre-TrainingWe propose a simple pairwise Sigmoid loss for Language-Image Pre-train

kyujinpy.tistory.com

Abstract

We propose a simple pairwise Sigmoid loss for Language-Image Pre-training (SigLIP)
softmax normalization 를 사용하는 표준 대조 학습과 달리, sigmoid loss 은 이미지-텍스트 쌍에만 적용되며 정규화를 위해 쌍별 유사성에 대한 전반적인 관점을 필요로 하지 않음
sigmoid loss은 배치 크기를 더욱 확장할 수 있게 하는 동시에 더 작은 배치 크기에서도 더 나은 성능을 보임
배치 크기와 손실의 분리를 통해 쌍과 샘플의 영향, 그리고 음수 대 양수 비율을 더욱 자세히 연구할 수 있음

Introduction

CLIP 과 ALIGN 이 대조학습을 통해 image-text pairs 의 선구자가 됨.
이러한 모델을 사전 학습하는 표준 방법은 이미지-텍스트 대조 목적 함수를 활용하는 것
- 이는 이미지와 텍스트 임베딩을 정렬하여 일치하는(긍정적인) 이미지-텍스트 쌍을 찾는 동시에, 관련 없는(부정적인) 이미지-텍스트 쌍이 임베딩 공간에서 서로 다르도록 함.
- 이는 batch-level softmax-based contrastive loss 을 통해 달성되며, 모든 이미지와 모든 텍스트에 대한 pairwise 유사도 점수를 정규화하기 위해 두 번 적용
일반적으로 소프트맥스를 적용하기 전에 최대 입력 값을 빼서 안정화하는데[18], 이를 위해서는 전체 배치에 대한 추가 단계가 필요
In this paper, we propose a simpler alternative: the sigmoid loss.
- 전체 배치에 걸쳐 어떠한 연산도 필요하지 않으므로 분산 손실 구현을 크게 단순화하고 효율성을 높임
- 제안된 시그모이드 손실을 여러 설정에서 표준 소프트맥스 손실과 비교
- 특히 이미지-텍스트 학습을 위한 두 가지 주요 접근 방식인 CLIP[36]과 LiT[59]를 사용하여 시그모이드 기반 손실을 조사합니다.
- 이를 각각 시그모이드 언어 이미지 사전 학습(SigLIP)과 시그모이드 LiT(SigLiT)라 정의
- 그러나 소프트맥스와 시그모이드 모두 배치 크기가 증가함에 따라 성능이 포화되는 것을 확인
- 다행히 이미지-텍스트 사전 학습에는 32k의 적절한 배치 크기가 충분

Method

image-text pairs : 미니배치 $B = \{ (I_1, T_1), (I_2, T_2), ...,\}$
미니배치가 주어졌을때 contrastive learning은 pair 가 서로 정렬되도록 유도하는 반면, 일치하지 않은 것은 분리하도록한다.
- 그러나 실제적으로 모든 이미지 i에 대해 다른 이미지 j와 연관된 텍스트는 i와 관련이 없으며, 그 반대의 경우도 마찬가지라고 가정
- 이러한 가정은 일반적으로 노이즈가 많고 불완전합니다.

Softmax loss for language image pre-training

이 목적을 공식화하기 위해 소프트맥스 손실을 사용할 때 이미지 모델 f(·)와 텍스트 모델 g(·)는 다음 목적을 최소화하도록 훈련됩니다.

Sigmoid loss for language image pre-training

softmax-based contrastive loss 대신, 전역 정규화 계수 계산이 필요 없는 더 간단한 대안을 제안
sigmoid-based loss 는 모든 이미지-텍스트 쌍을 독립적으로 처리하여, 학습 문제를 모든 쌍 조합의 데이터셋에 대한 표준 이진 분류로 효과적으로 변환
이때 일치하는 쌍 $(I_i, T_i)$에는 양의 레이블을, 다른 모든 쌍 $(I_i, T_{i \neq j})$에는 음의 레이블을 지정

Sigmoid loss for language image pre-training

softmax-based contrastive loss 대신, 전역 정규화 계수 계산이 필요 없는 더 간단한 대안을 제안
sigmoid-based loss 는 모든 이미지-텍스트 쌍을 독립적으로 처리하여, 학습 문제를 모든 쌍 조합의 데이터셋에 대한 표준 이진 분류로 효과적으로 변환
이때 일치하는 쌍 $(I_i, T_i)$에는 양의 레이블을, 다른 모든 쌍 $(I_i, T_{i \neq j})$에는 음의 레이블을 지정

[Paper review] EVA: Exploring the Limits of Masked Visual Representation Learning at Scale

cooling0 — Fri, 26 Sep 2025 14:43:42 +0900

Abstract

EVA는 visible image patches 를 조건으로 마스크 처리된 이미지-텍스트 정렬 vision features 을 재구성하도록 사전 학습된 vanilla ViT 모델
pretext task 을 통해 EVA를 10억 개의 매개변수로 효율적으로 확장하고, image recognition, video action recognition, object detection, instance segmentation and semantic segmentation 과 같은 광범위한 대표적 시각 하위 작업에서 고강도 지도 학습 없이 새로운 기록을 세울 수 있음
Moreover, we observe quantitative changes in scaling EVA result in qualitative changes in transfer learning performance that are not present in other models
- 예를 들어, EVA는 까다로운 대규모 어휘 인스턴스 분할 작업에서 큰 도약을 이룹니다. 저희 모델은 1,000개 이상의 범주를 가진 LVISv1.0 데이터셋과 80개만 있는 COCO 데이터셋에서 거의 동일한 최첨단 성능을 달성
- EVA는 단순한 시각 인코더를 넘어 이미지와 텍스트를 연결하는 시각 중심의 다중 모달 피벗 역할도 수행

Introduction

사전 학습된 언어 모델(PLM)의 확장은 지난 몇 년 동안 자연어 처리(NLP)에 혁명을 일으켰습니다
이를 통해 Transformer 모델[101]은 거의 무제한의 레이블이 지정되지 않은 데이터를 사용하여 수십억 개의 매개변수로 확장될 수 있었고, 거의 튜닝 없이 다양한 하위 작업으로 일반화
그러나 가장 경쟁력 있는 10억 개 규모의 비전 사전 학습 모델[33, 64, 71, 123]은 여전히 수억 개의(종종 공개적으로 접근 불가능한) 레이블이 지정된 데이터를 사용하는 지도 학습 또는 약 지도 학습에 크게 의존
masked image modeling (MIM) 은 heavily supervised pre-training 이전의 초기화 단계로만 채택되거나, 순수한 MIM 사전 학습 모델은 10억 개 규모의 모델 크기에서 유리한 성능을 달성할 수 없음.
우리는 이러한 격차가 자연 이미지가 원시적이고 정보가 희소하다는 사실에서 비롯된다고 생각
이상적인 비전 사전 텍스트 작업에는 저수준 기하학 및 구조 정보뿐만 아니라 고수준 의미론의 추상화가 필요한데, 이는 픽셀 수준 복구 작업에서는 거의 포착되지 않음
In this work,
- 대규모 비전 표현 학습에 적합한 MIM pretext task을 찾고, 수천만 개의 레이블이 지정되지 않은 데이터가 있는 10억 개의 매개변수 규모에서 그 한계를 탐구
- (i) 토큰화된 semantic features 이 비전에서 마스크된 모델링을 위한 더 나은 supervision signal 를 제공할 수 있다는 점
- (ii) 마스크된 예측 작업 없이 간단한 사후 증류 과정을 통해서도 좋은 성능을 얻을 수 있다는 점
- 파일럿 경험 연구를 통해 MIM에서 예측 대상으로 이미지-텍스트 정렬(즉, CLIP[73]) 비전 특징만 사용하면 확장성이 뛰어나고 광범위한 다운스트림 벤치마크에서 만족스러운 성능을 달성한다는 것을 발견

Fly EVA to the Moon

먼저 §2.1에서 이상적인 vision pretext task 을 선택하기 위한 일련의 파일럿 실험을 수행하고, §2.2에서 선택된 사전 학습 목표를 통해 EVA 사전 학습을 확장

2.1. The Feature Instrumentality Project

(i) recovering the masked out tokenized semantic vision features

(ii) feature distillation from strong pre-trained representation

(i) 의미적 특징 양자화/토큰화[5, 70] 및 (ii) BEiT-3[104]에서처럼 이미지-텍스트 쌍 사전 학습 데이터와 대규모 코퍼스를 명시적으로 사용하지 않고도 비전 중심 표현 학습을 위해 최대 10억 규모의 매개변수와 수천만 개의 레이블이 지정되지 않은 이미지까지 확장될 수 있음을 보여줌
추가적인 CLIP feature 토큰화나 증류나 다 필요 없음.
그냥 단순히 마스크 된 CLIP vision feature를 재구성하면 좋은 성능이 나온다.

2.2. Pre-training

EVA는 1.0B 매개변수를 갖는 바닐라 ViT[33]입니다. 그녀의 모양은 ViT 거대[123]와 BEiT-3[104]의 비전 인코더를 따릅니다.
사전 학습 중에는 상대 위치 임베딩[89] 및 레이어 스케일[99]을 사용하지 않습니다.

Pre-training objective

EVA is pre-trained to reconstruct the masked out image-text aligned vision features conditioned on visible image patches. (마스크 처리된 이미지-텍스트 정렬 비전 특징을 재구성하도록 사전 학습)
입력 패치를 [MASK] 토큰으로 손상시키고에 따라 40%의 마스킹 비율을 갖는 블록별 마스킹을 사용
MIM 사전 학습의 대상은 224×224 픽셀 이미지에서 학습된 공개 OpenAI CLIP-L/14 비전 타워
EVA의 출력 특징은 먼저 정규화되고[3] 선형 계층을 통해 CLIP 특징과 동일한 차원으로 투영됩니다. 손실 함수로 음수 코사인 유사도를 사용합니다.

1주차 : clip performance tuning (part 1)

cooling0 — Fri, 26 Sep 2025 11:03:05 +0900

지난 포스트에서

https://cooling0.tistory.com/11

1주차: CLIP & Contrastive Learning 맛보기

clip 논문에 관한 paper reivew 는 아래에서 볼 수 있습니다.https://cooling0.tistory.com/8이미지→카테고리 매칭 코드 설명 (CLIP, ViT-B/32)아래 코드는 이미지 10장과 카테고리별 텍스트 동의어를 CLIP의 공통

cooling0.tistory.com

해당 카테고리들을 정확히 맞추지만 확률이 미미한것을 해결하기 위한 방법을 찾아서 적용

해당 결과에 대한 코드는

https://github.com/cooling-0/VLM-SIDE-PROJECT/blob/main/notebooks/01_01_clip_advance_part1.ipynb

VLM-SIDE-PROJECT/notebooks/01_01_clip_advance_part1.ipynb at main · cooling-0/VLM-SIDE-PROJECT

Contribute to cooling-0/VLM-SIDE-PROJECT development by creating an account on GitHub.

github.com

그중 첫번째는

Prompt Ensemble and Negative Prompting 입니다.

- **Radford et al. (2021), *Learning Transferable Visual Models From Natural Language Supervision (CLIP)***

CLIP 원 논문에서도 단일 텍스트 대신 여러 템플릿(예: *“a photo of a {label}”, “a picture of a {label}”*)을 평균해서 class prototype을 만듦. **핵심**: 단일 표현 대신 프롬프트 앙상블이 성능을 안정화/개선.

- **Zhou et al. (2022), *Learning to Prompt for Vision-Language Models (CoOp)***

수동 템플릿 대신 *learnable prompt*를 제안. 하지만 아이디어의 뿌리는 **다양한 프롬프트 조합 → 임베딩 평균**. - **Zhou et al. (2022), *Conditional Prompt Learning for Vision-Language Models (CoCoOp)***

카테고리마다 다르게 조정되는 프롬프트를 학습. **핵심**: 다양한 텍스트 표현으로 프로토타입을 풍부하게 만드는 것이 중요.

- **Shen et al. (2022), *How Much Can CLIP Benefit Vision-and-Language Tasks?***

단순히 긍정 프롬프트만 쓰지 않고, 혼동되는 다른 class를 **음성 프로토타입**으로 추가해 차이를 강조하는 기법 소개.

- **Kim et al. (2023), *DeBiasing CLIP via Prompt Regularization***

잘못된/헷갈리는 프롬프트를 넣어 감점하는 방식이 **bias 완화**와 **decision sharpening**에 유효함을 보임.

CATEGORIES: Dict[str, List[str]] = {
    "white_dress_shirt": [
        "a photo of a white dress shirt", "a white button-up shirt", "a white long-sleeve shirt"
    ],
    "hat": [
        "a photo of a baseball cap", "a photo of a hat", "a black cap"
    ],
    "denim_shirt": [
        "a photo of a denim shirt", "a blue denim shirt"
    ],
    "jeans": [
        "a photo of blue jeans", "a photo of denim pants"
    ],
    "white_tshirt": [
        "a photo of a white t-shirt", "a plain white tee"
    ],
    "pants" : [
        "a photo of a pants"
    ]
}

기존의 prompt 의 다양성을 향상하기 위해 아래와 같은 templates, Attribution, negative prompts 를 진행

# -----------------------------------------
# 1) 속성 사전 (전역 기본 + 카테고리별 오버라이드 가능)
#    * 영어 위주 권장 (CLIP 영문 최적화)
# -----------------------------------------
ATTR_LEXICON_GLOBAL = {
    "color":  ["white", "blue", "black", "navy", "beige", "grey"],
    "material":["cotton", "denim", "linen", "polyester"],
    "fit":    ["slim-fit", "regular", "oversized"],
    "detail": ["with collar", "with buttons", "with chest pocket"]
}

# 카테고리별 특화 속성 (없으면 전역 사용)
ATTR_LEXICON_PER_CATEGORY = {
    "white_dress_shirt": {
        "color": ["white"],
        "material": ["cotton", "poplin"],
        "fit": ["slim-fit", "regular", "oversized"],
        "detail": ["with collar", "with buttons"]
    },
    "denim_shirt": {
        "color": ["blue", "light blue", "dark blue"],
        "material": ["denim"],
        "fit": ["regular", "oversized"],
        "detail": ["with chest pocket", "with snap buttons"]
    },
    "jeans": {
        "color": ["blue", "light blue", "dark blue", "black"],
        "material": ["denim"],
        "fit": ["slim-fit", "regular", "straight"],
        "detail": ["with five pockets"]
    },
    "white_tshirt": {
        "color": ["white"],
        "material": ["cotton"],
        "fit": ["regular", "oversized"],
        "detail": ["crew neck", "round neck"]
    },
    "pants": {
        "color": ["black", "navy", "beige", "grey"],
        "material": ["cotton", "wool", "polyester"],
        "fit": ["slim-fit", "regular", "tapered"],
        "detail": ["with belt loops", "with side pockets"]
    },
    "hat": {
        "color": ["black", "navy", "white"],
        "material": ["cotton", "wool"],
        "fit": ["adjustable"],
        "detail": ["with curved brim", "with strapback"]
    }
}

# -----------------------------------------
# 2) 프롬프트 템플릿
#    * 간단·중간·풍부형 혼합
# -----------------------------------------
TEMPLATES = [
    "{color} {material} {fit} {category} {detail}",
    "{fit} {color} {category}",
    "{color} {category}",
    "a {color} {category} {detail}",
    "a photo of a {color} {category}",
]

# -----------------------------------------
# 3) 음성(negative) 카테고리 매핑 (헷갈리는 이웃)
#    * 필요 시 자유롭게 수정
# -----------------------------------------
NEG_NEIGHBORS = {
    "white_dress_shirt": ["white_tshirt", "denim_shirt", "hat"],
    "denim_shirt": ["white_dress_shirt", "white_tshirt"],
    "jeans": ["pants"],
    "pants": ["jeans"],
    "white_tshirt": ["white_dress_shirt"],
    "hat": ["white_tshirt", "denim_shirt"]
}

그러나 프롬포트 를 하나하나 작성하는건 매우 비효율적이므로 자동 생성을 진행하기 위하여 아래 코드 작성

class Weights:
    cat: float = 0.5
    color: float = 0.2
    fit: float = 0.15
    detail: float = 0.15
    material: float = 0.0  

def get_attr_lexicon(category: str):
    base = ATTR_LEXICON_GLOBAL
    over = ATTR_LEXICON_PER_CATEGORY.get(category, {})
    merged = {k: over.get(k, base.get(k, [])) for k in ["color", "material", "fit", "detail"]}
    return merged
    
 def sample_prompts_for_category(category: str, n: int = 30) -> List[str]:
    attrs = get_attr_lexicon(category)
    bag = set()
    for _ in range(n * 2):  # 여유롭게 뽑고 중복 제거
        t = random.choice(TEMPLATES)
        s = t.format(
            color=random.choice(attrs["color"]) if attrs["color"] else "",
            material=random.choice(attrs["material"]) if attrs["material"] else "",
            fit=random.choice(attrs["fit"]) if attrs["fit"] else "",
            detail=random.choice(attrs["detail"]) if attrs["detail"] else "",
            category=category.replace("_", " ")
        ).replace("  ", " ").strip()
        bag.add(s)
        if len(bag) >= n:
            break
    return list(bag)
    
 def make_attribute_phrases(category: str) -> Dict[str, List[str]]:
    attrs = get_attr_lexicon(category)
    phrases = {
        "color":  [f"{c} {category.replace('_',' ')}" for c in attrs["color"]],
        "fit":    [f"{f} {category.replace('_',' ')}" for f in attrs["fit"]],
        "detail": [f"{category.replace('_',' ')} {d}" for d in attrs["detail"]],
        "material":[f"{m} {category.replace('_',' ')}" for m in attrs["material"]],
    }
    # 간단한 기본 카테고리 문장
    phrases["category"] = [f"a photo of a {category.replace('_',' ')}", f"a {category.replace('_',' ')}"]
    return phrases

def build_negative_prototype(category: str, prototypes: Dict[str, torch.Tensor]) -> Optional[torch.Tensor]:
    neg_cands = NEG_NEIGHBORS.get(category, [])
    if not neg_cands:
        return None
    negs = [prototypes[c] for c in neg_cands if c in prototypes]
    if not negs:
        return None
    neg = torch.stack([t.squeeze(0) for t in negs], dim=0).mean(dim=0, keepdim=True)
    neg = neg / neg.norm(dim=-1, keepdim=True)
    return neg
    
 def build_all_prototypes(categories: Dict[str, List[str]], n_samples:int=30) -> Tuple[Dict[str, torch.Tensor], TextEmbedder]:
    embedder = TextEmbedder()
    prototypes = {}
    for cat in categories.keys():
        prototypes[cat] = build_prototype_for_category(cat, embedder, n_samples=n_samples)
    return prototypes, embedder

해당을 기반으로 앙상블 속성 가중 평균 진행

def build_prototype_for_category(category: str, embedder: TextEmbedder, n_samples:int=30) -> torch.Tensor:
    # (a) 템플릿×속성 자동 확장
    prompts = sample_prompts_for_category(category, n=n_samples)
    emb_a = embedder.embed_texts(prompts).mean(dim=0, keepdim=True)
    # (b) 속성 가중 평균
    phrases = make_attribute_phrases(category)
    cat_e = embedder.embed_texts(phrases["category"]).mean(0, keepdim=True)
    color_e = embedder.embed_texts(phrases["color"]).mean(0, keepdim=True) if phrases["color"] else 0
    fit_e = embedder.embed_texts(phrases["fit"]).mean(0, keepdim=True) if phrases["fit"] else 0
    detail_e = embedder.embed_texts(phrases["detail"]).mean(0, keepdim=True) if phrases["detail"] else 0
    material_e = embedder.embed_texts(phrases["material"]).mean(0, keepdim=True) if phrases["material"] else 0

    weighted = (
        WEIGHTS.cat * cat_e +
        (WEIGHTS.color * color_e if isinstance(color_e, torch.Tensor) else 0) +
        (WEIGHTS.fit * fit_e if isinstance(fit_e, torch.Tensor) else 0) +
        (WEIGHTS.detail * detail_e if isinstance(detail_e, torch.Tensor) else 0) +
        (WEIGHTS.material * material_e if isinstance(material_e, torch.Tensor) else 0)
    )

    proto = (emb_a + weighted) / 2.0
    proto = proto / proto.norm(dim=-1, keepdim=True)
    return proto  # shape: (1, d)

위의 과정 코드들을 기반으로 이전 포스팅과 비슷하게 이미지에 대한 매칭 확률을 구해보았습니다.

@torch.no_grad()
def score_images(
    image_paths: List[str],
    prototypes: Dict[str, torch.Tensor],
    embedder: TextEmbedder,
    beta: float = 0.2,
    temperature: float = 0.7,
    zscore_per_image: bool = True
):
    imgs = [Image.open(p).convert("RGB") for p in image_paths]
    inputs = embedder.proc(images=imgs, return_tensors="pt").to(embedder.device)
    img_feats = embedder.model.get_image_features(**inputs)
    img_feats = img_feats / img_feats.norm(dim=-1, keepdim=True)  # (B, d)

    cat_names = list(prototypes.keys())
    P = torch.cat([prototypes[c] for c in cat_names], dim=0)  # (K, d)

    neg_map = {c: build_negative_prototype(c, prototypes) for c in cat_names}

    pos_scores = img_feats @ P.T
    neg_scores = torch.zeros_like(pos_scores)
    for j, c in enumerate(cat_names):
        nproto = neg_map[c]
        if nproto is not None:
            neg_scores[:, j] = (img_feats @ nproto.T).squeeze(-1)

    scores = pos_scores - beta * neg_scores

    if zscore_per_image:
        mu = scores.mean(dim=1, keepdim=True)
        std = scores.std(dim=1, keepdim=True).clamp_min(1e-6)
        scores = (scores - mu) / std

    logits = scores / max(1e-6, temperature)
    probs = torch.softmax(logits, dim=-1)  # (B, K)
    return probs, cat_names

해본 결과 성능이 말도 안되게 좋아진 것을 느끼며... 마무리하겠습니다.

기존에 저는 time series 를 기반으로 직접 모델링을 진행하거나 SOTA 모델을 가져와 구조를 변경하여 처음부터 학습을 진행시키며 업무를 진행했는데

VLM 의 성능에 한번더 놀라고 갑니다...

1주차: CLIP & Contrastive Learning 맛보기

cooling0 — Fri, 26 Sep 2025 08:28:11 +0900

clip 논문에 관한 paper reivew 는 아래에서 볼 수 있습니다.

https://cooling0.tistory.com/8

[Paper Review]Learning Transferable Visual Models From Natural Language Supervision

Abstract제한된 형태의 지도 학습은 다른 시각적 개념을 명시하기 위해 추가적인 레이블링된 데이터가 필요하기 때문에 일반성과 유용성을 제한함.이미지에 대한 원시 텍스트로부터 직접 학습하

cooling0.tistory.com

이미지→카테고리 매칭 코드 설명 (CLIP, ViT-B/32)

아래 코드는 이미지 10장과 카테고리별 텍스트 동의어를 CLIP의 공통 임베딩 공간으로 투영한 뒤,
이미지마다 Top-3 카테고리를 예측하는 파이프라인

목적

이미지와 텍스트(카테고리 설명)를 같은 차원 의 임베딩으로 변환
임베딩을 L2 정규화하여 내적 = 코사인 유사도
카테고리마다 여러 표현(동의어)을 평균해 프로토타입 임베딩 생성
각 이미지가 어떤 카테고리에 가장 가까운지 Top-K 매칭 산출

코드는

https://github.com/cooling-0/VLM-SIDE-PROJECT/blob/main/notebooks/01_clip_intro.ipynb

VLM-SIDE-PROJECT/notebooks/01_clip_intro.ipynb at main · cooling-0/VLM-SIDE-PROJECT

Contribute to cooling-0/VLM-SIDE-PROJECT development by creating an account on GitHub.

github.com

Model

- CLIP 모델/프로세서 로드: ViT-B/32 백본의 CLIP을 불러와 평가 모드로 올림.

- processor는 이미지 리사이즈/정규화, 토큰화 등 전처리를 자동 수행(기본 224×224).

# 환경

# syntax=docker/dockerfile:1
ARG PYTHON_VERSION=3.11
FROM python:${PYTHON_VERSION}-slim

# --- basic envs ---
ENV PYTHONDONTWRITEBYTECODE=1     PYTHONUNBUFFERED=1     PIP_NO_CACHE_DIR=1     MPLBACKEND=Agg     DEBIAN_FRONTEND=noninteractive

WORKDIR /workspace

# --- system deps (minimal, headless) ---
RUN apt-get update && apt-get install -y --no-install-recommends     git ca-certificates curl     && rm -rf /var/lib/apt/lists/*

# --- python deps ---
COPY requirements.txt /tmp/requirements.txt
RUN python -m pip install --upgrade pip &&     pip install -r /tmp/requirements.txt

# for notebooks & outputs
RUN mkdir -p /workspace/notebooks /workspace/data/images /workspace/out

# Default command: Jupyter Lab (no token; local dev)
EXPOSE 8888
CMD ["bash", "-lc", "jupyter lab --ip=0.0.0.0 --port=8888 --no-browser --NotebookApp.token='' --NotebookApp.password=''"]

- 환경은 다음과 같이 docker 컨테이너를 구성

데이터의 경우 다음과 같이 웹 사이트에서 이미지를 가져왔습니다.

데님 셔츠 2장, 흰 티셔츠 2장, 모자 2장, 바지 2장 , 흰 셔츠 2장으로 총 10장으로 구성.

입력/출력 개념

입력

$\texttt{imgs}$: 이미지 경로 리스트 $(N\ \text{장})$
$\texttt{CATEGORIES}$: ${\ \text{카테고리명} : [\text{동의어 문장들}]\ }$ $(K\ \text{개})$

출력 (주요 변수)

$\mathbf{F}_{\text{img}} \in \mathbb{R}^{N \times D}$: 이미지 임베딩 (정규화)
$\mathbf{F}_{\text{txt}}^{\text{proto}} \in \mathbb{R}^{K \times D}$: 카테고리 프로토타입 임베딩 (정규화)
$\mathbf{S}{\text{ic}} = \mathbf{F}{\text{img}}\ \mathbf{F}_{\text{txt}}^{\text{proto}\top} \in \mathbb{R}^{N \times K}$: 이미지–카테고리 코사인 유사도 행렬
$\texttt{mapping}$: 각 이미지의 Top-3 카테고리와 유사도 점수 리스트

보통 $D=512$. 예: $N=10$, $K=5$ 이면
$\mathbf{F}{\text{img}} \in \mathbb{R}^{10 \times 512}$, $\mathbf{F}{\text{txt}}^{\text{proto}} \in \mathbb{R}^{5 \times 512}$, $\mathbf{S}_{\text{ic}} \in \mathbb{R}^{10 \times 5}$.

테스트

# === 3) 임베딩 ===
@torch.no_grad()
def get_image_features(paths):
    ims=[Image.open(p).convert("RGB") for p in paths]
    x=processor(images=ims, return_tensors="pt").to(device)
    f=model.get_image_features(**x); f=f/f.norm(dim=-1, keepdim=True)
    return f

@torch.no_grad()
def text_feats(texts):
    x=processor(text=texts, return_tensors="pt", padding=True, truncation=True).to(device)
    f=model.get_text_features(**x); f=f/f.norm(dim=-1, keepdim=True)
    return f

get_image_features(...)로 이미지 임베딩 $\mathbf{F}_{\text{img}} \in \mathbb{R}^{N\times D}$ 추출
text_feats(...)로 텍스트 임베딩을 뽑고, 동의어 평균으로 카테고리 프로토타입 $\mathbf{F}_{\text{txt}}^{\text{proto}} \in \mathbb{R}^{K\times D} $ 생성
둘 다 L2 정규화 → 내적이 코사인 유사도랑 같아짐
유사도 행렬 $\mathbf{S}{\text{ic}} = \mathbf{F}{\text{img}}\ \mathbf{F}_{\text{txt}}^{\text{proto}\top} \in \mathbb{R}^{N\times K} $ 계산
각 이미지별로 Top-K 카테고리(예: Top-3) 뽑아서 mapping에 저장

F_img = get_image_features(imgs)

# 카테고리별 텍스트 프로토타입(동의어 평균)
cat_names = list(CATEGORIES.keys())
proto = []
for name in cat_names:
    F_t = text_feats(CATEGORIES[name])
    proto.append(F_t.mean(dim=0, keepdim=True))
F_txt_proto = torch.cat(proto, dim=0)              # [K, D]
F_txt_proto = F_txt_proto / F_txt_proto.norm(dim=-1, keepdim=True)

# === 4) 이미지→카테고리 매칭 (Top-3) ===
S_ic = (F_img @ F_txt_proto.T).cpu().numpy()       # [N_img, K]
idx_top = np.argsort(-S_ic, axis=1)[:, :3]

mapping = []
for i in range(len(imgs)):
    top3 = [(cat_names[j], float(S_ic[i, j])) for j in idx_top[i]]
    mapping.append({
        "image_idx": i+1, "image_file": imgs[i].name,
        "pred1": top3[0][0], "score1": round(top3[0][1], 4),
        "pred2": top3[1][0], "score2": round(top3[1][1], 4),
        "pred3": top3[2][0], "score3": round(top3[2][1], 4),
    })

위의 과정을 통해 Clip 을 통해 image feature 와 text feats 에 embedding 을 추출하여
코사인 유사도를 구한 결과 아래와 같이 모두 원하는 결과를 도출 하였지만
예측 확률의 차이가 크지 않은 것을 발견했다.

------------------------------------------------------------------------------------------------------------------------------------------------------------

1주차의 경우 CLIP 에 대한 이해와 활용을 목표로 하였지만 VLM 의 성능이 이정도 일줄은 몰랐다.

그럼에도 해당 카테고리들의 확률의 차이가 없어

추가적으로 다음에는 이를 방법들을 공부해 볼 생각이다.

12주차 VLM × 반대추천 프로젝트 로드맵

cooling0 — Wed, 24 Sep 2025 09:08:59 +0900

computer vision 을 공부하고 싶어 퇴근 후 사이드 프로젝트 해보기로 결정하였습니다.

아래와 같이 계획을 세워서 진행해볼 예정입니다......

과연 할 수 있을까?

해당 프로젝트의 코드는 아래 github 에 등록할 예정입니다

https://github.com/cooling-0/VLM-SIDE-PROJECT

GitHub - cooling-0/VLM-SIDE-PROJECT

Contribute to cooling-0/VLM-SIDE-PROJECT development by creating an account on GitHub.

github.com

1주차: CLIP & Contrastive Learning 맛보기

공부

CLIP 논문 [fig.1,2] 읽기: contrastive loss, temperature 역할
“이미지 인코더 + 텍스트 인코더 → 공통 latent space” 구조

프로젝트

HuggingFace openai/clip-vit-base-patch32 실행
옷 이미지 10장, 문장 10개로 임베딩 뽑기 → 매칭
matplotlib으로 매칭 결과 시각화

산출물

notebooks/01_clip_intro.ipynb
결과 캡처 + 개념 메모

2주차: Vision Encoder & 리뷰 텍스트 임베딩

공부

ViT, EVA-CLIP, SigLIP 구조 비교
BLIP-2 그림(프로젝터 Q-Former) 확인
Aspect-based Sentiment Analysis(ABSA) 개념 이해

프로젝트

리뷰 샘플 50–100개 모으기
multilingual-e5-large 또는 bge-m3로 문장 임베딩
규칙 기반 aspect-opposites.json 작성
샘플 리뷰에 (aspect, sentiment) 태깅 함수 작성

산출물

notebooks/02_text_embeddings.ipynb
src/nlp/aspect_rules.py, data/aspect_opposites.json

3주차: 데이터 수집·정제

공부

VLM 학습 데이터셋 구성 방식(CLIP의 WIT, LAION) 참고
데이터 전처리(이미지 resize, 텍스트 정규화) 기초

프로젝트

아마존 공개 데이터셋에서 상의 카테고리 1–3k 상품 + 리뷰 5–20k 수집
스키마 확정: products.jsonl, reviews.jsonl
이미지 로컬 캐싱 / 텍스트 정규화

산출물

data/bronze/products.jsonl, reviews.jsonl
src/ingest/loader.py

4주차: 임베딩·인덱스 구축

공부

FAISS 기본 구조 (IndexFlatIP, IndexIVF, HNSW)
검색 효율화 기초(코사인 유사도)

프로젝트

CLIP으로 상품 대표 이미지 임베딩 → FAISS 인덱스 구축
텍스트 임베딩도 저장(선택)
Top-K 유사 이미지 검색 실험

산출물

src/embeddings/image_embed.py
src/index/faiss_image.py
artifacts/faiss.index

5주차: 반대추천 로직 v0

공부

InfoNCE loss = softmax with temperature → contrastive ranking
Retrieval & Ranking 개념 (BM25, embedding ranking 비교)

프로젝트

입력: A상품 + 불평 리뷰(“작다”)
단계:
1. Top-K 유사 이미지 검색
2. 후보 B에서 반대 sentiment(“크다”) 리뷰 수 집계
3. 품질 가중치(평점/리뷰수) 반영
가중합 점수 함수 구현

산출물

src/reco/opposite_recommender.py
CLI로 추천 Top-10 출력

6주차: UI 데모 v1

공부

Streamlit 기본 사용법
Explainability: 추천 이유 표시 방법

프로젝트

Streamlit UI → 입력(A상품, 불평문장) → 추천 리스트 출력
추천된 상품마다 근거 리뷰 문장 하이라이트

산출물

app/demo_streamlit.py
데모 스크린샷 & GIF

7주차: 반대성 검증(NLI)

공부

자연어추론(NLI) 개념: entailment vs contradiction
MNLI 데이터셋, 사전학습된 모델(deberta-v3-large-mnli)

프로젝트

불평문 vs 후보 리뷰 문장 → NLI 추론
contradiction 확률로 opp_sent 점수 보정

산출물

src/nlp/contradiction.py
notebooks/07_nli_eval.ipynb

8주차: 품질·룰 튜닝

공부

Aspect term expansion: 동의어/표현 다양성 처리
데이터 클리닝 기법(스팸 리뷰 필터링)

프로젝트

오버핏/루즈핏/타이트/와이드 등 용어 사전 보강
리뷰 스팸 필터 추가(짧은 반복문, URL, 과한 이모지)
품질 점수 계산 개선(별점 보정, 리뷰 helpful 가중치)

산출물

data/dicts/aspect_terms.txt
정규화 파이프라인 업데이트

9주차: 성능 평가(오프라인)

공부

IR 평가 지표: Precision@K, Recall@K, nDCG
추천 시스템 평가 기초

프로젝트

인력 라벨링 100–200샘플: 반대성 정확도, 유사성 만족도
다양성, 커버리지 지표 계산

산출물

reports/offline_eval.md
문제 사례 분석 표

10주차: 경량 튜닝(LoRA)

공부

LoRA, QLoRA 원리(어댑터 기반 미세조정)
Instruction tuning과의 차이

프로젝트

소량 라벨(수백–수천)로 ABSA 분류기 LoRA 튜닝
zero-shot vs fine-tune 비교

산출물

src/train/lora_absa.py
artifacts/absa_lora.bin

11주차: 서빙 & 최적화

공부

FastAPI 기본 API 설계
모델 양자화(4bit/8bit) 원리

프로젝트

/recommend API 구현 (입력: product_id, complaint)
Dockerfile 작성, 메모리 최적화

산출물

app/server.py
deploy/Dockerfile
간단 부하테스트 결과

12주차: 마무리 & 문서화

공부

벤치마크 관리(MMBench/MMMU 참고)
프로젝트 문서화/모델카드 작성법

프로젝트

최종 README + 설치 가이드 + 데모 영상
CHANGELOG, 다음 단계 로드맵(다국어 확장, 카테고리 확장 등)

산출물

README.md, CHANGELOG.md, reports/final_report.md
데모 GIF/영상

[Paper Review] AN IMAGE IS WORTH 16X16 WORDS:TRANSFORMERS FOR IMAGE RECOGNITION AT SCALE

cooling0 — Wed, 24 Sep 2025 08:42:40 +0900

Abstract

비전 분야에서 어텐션은 합성곱 신경망과 함께 적용되거나, 합성곱 신경망의 전체 구조는 그대로 유지하면서 특정 구성 요소를 대체하는 데 사용
본 연구에서는 CNN에 대한 이러한 의존성이 불필요하며, 이미지 패치 시퀀스에 직접 적용된 순수 트랜스포머가 이미지 분류 작업에서 매우 우수한 성능을 발휘할 수 있음을 보여줌
대량의 데이터로 사전 학습된 Vision Transformer(ViT)는 학습에 필요한 연산 리소스를 크게 줄이면서도 최첨단 합성곱 신경망에 비해 탁월한 결과를 제공

Introduction

Self-attention-based architectures 특히 트랜스포머(Transformers, Vaswani et al., 2017)는 자연어 처리(NLP) 분야에서 선호되는 모델이 되었음
주된 접근 방식은 large text corpus 를 pre-train 한 후, 더 작은 작업별 데이터셋을 사용하여 fine-tune 하는 것
자연어 처리(NLP)의 성공 사례에 영감을 받아, 여러 연구에서 CNN 유사 아키텍처와 셀프 어텐션(self-attention)을 결합하는 시도가 이루어지고 있으며, 일부는 합성곱을 완전히 대체하기도 합니다
후자의 모델은 이론적으로는 효율적이지만, 특수 어텐션 패턴을 사용하기 때문에 최신 하드웨어 가속기에서 효과적으로 확장되지는 못함.
따라서 대규모 이미지 인식 분야에서는 고전적인 ResNet 유사 아키텍처가 여전히 최첨단 기술로 남아 있음
자연어 처리(NLP)에서 트랜스포머 확장 성공 사례에서 영감을 받아, 최소한의 수정만으로 표준 트랜스포머를 이미지에 직접 적용하는 실험을 진행
- 이미지를 패치로 분할하고, 각 패치의 선형 임베딩 시퀀스를 트랜스포머에 입력으로 제공
- 이미지 패치는 자연어 처리 애플리케이션에서 tokens (words) 과 동일한 방식으로 처리
저희의 Vision Transformer(ViT)는 충분한 규모로 pre-trained 하고 데이터 포인트가 더 적은 작업에 적용했을 때 탁월한 결과를 얻음
- 공개 ImageNet-21k 데이터 세트 또는 자체 JFT-300M 데이터 세트로 사전 학습했을 때, ViT는 여러 이미지 인식 벤치마크에서 최첨단 수준에 근접하거나 이를 능가
- 최고 모델은 ImageNet에서 88.55%, ImageNet-ReaL에서 90.72%, CIFAR-100에서 94.55%, 그리고 VTAB 19개 작업 세트에서 77.63%의 정확도를 달성

METHOD

모델 설계에서는 기존 Transformer 를 최대한 충실히 따랐습니다. 의도적으로 단순하게 설계된 이 모델의 장점은 확장 가능한 NLP Transformer 아키텍처와 효율적인 구현을 거의 즉시 사용할 수 있다는 것입니다.

VISION TRANSFORMER (VIT)

Standard Transformer 는 1D sequence of token embeddings 를 받음
- 이를 위하여 2D images → reshape $\mathbf{x} \in \mathbb{R}^{H \times W \times C}$ → $\mathbf{x}_p \in \mathbb{R}^{N \times (P^2 C)}$
- where (H, W) is the resolution of the original image, C is the number of channels, (P, P) is the resolution of each image patch, and $N = HW/P^2$ is the resulting number of patches, which also serves as the effective input sequence length for the Transformer

Transformer는 모든 레이어에 걸쳐 일정한 latent vector 크기 $D$ 를 사용하므로, 패치를 평탄화하고 학습 가능한 linear projection(식 1)을 사용하여 D 차원으로 매핑
BERT의 [class] 토큰과 유사하게, learnable embedding 을 sequence of embedded patches ( $\mathbf{z}0^0 = \mathbf{x}{class}$ ) 에 추가합니다. 이 임베딩의 트랜스포머 인코더 출력 상태 ( $\mathbf{z}_L^0$ ) 는 이미지 표현 y (식 4)로 사용
pre-training and fine-tuning 모두에서 classification head 가 $\mathbf{z}_L^0$ 에 연결됩니다. 분류 헤드는 사전 학습 시 하나의 은닉층을 갖는 MLP(Multiple Layer)로 구현되고, 미세 조정 시 하나의 선형층으로 구현
Position embeddings 유지하기 위해 패치 임베딩에 위치 임베딩을 추가 (1D 임베딩 사용 → 2D 도 의미 없었음)
The Transformer encoder consists of alternating layers of multiheaded self-attention and MLP blocks (Eq. 2, 3). Layernorm (LN) is applied before every block, and residual connections after every block.
The MLP contains two layers with a GELU non-linearity

Inductive bias

Vision Transformer는 CNN보다 이미지별 귀납적 편향이 훨씬 적습니다.
- CNN에서는 지역성, 2차원 이웃 구조, 그리고 이동 등가성이 모델 전체에 걸쳐 각 계층에 내장되어 있습니다.
- ViT에서는 MLP 계층만 지역적이고 이동 등가성을 가지며, 셀프 어텐션 계층은 전역적이다.

Hybrid Architecture

As an alternative to raw image patches, the input sequence can be formed from feature maps of a CNN
이 하이브리드 모델에서는 패치 임베딩 투영 E(식 1)가 CNN 특징 맵에서 추출된 패치에 적용
특별한 경우로, 패치의 공간 크기가 1x1일 수 있는데, 이는 특징 맵의 공간 차원을 평탄화하고 변환기 차원으로 투영하여 입력 시퀀스를 얻는다는 것을 의미

FINE-TUNING AND HIGHER RESOLUTION

일반적으로 ViT는 대용량 데이터셋을 사용하여 pre-train 하고, (더 작은) downstream tasks 에 맞춰 fine-tune 합니다.
For this, we remove the pre-trained prediction head and attach a zero-initialized D × K feedforward layer, where K is the number of downstream classes.
사전 학습보다 고해상도에서 미세 조정하는 것이 종종 유용
고해상도 이미지를 입력할 때는 패치 크기를 동일하게 유지하여 유효 시퀀스 길이를 늘림.
Vision Transformer는 메모리 제약 조건 내에서 임의의 시퀀스 길이를 처리할 수 있지만, 사전 학습된 위치 임베딩은 더 이상 의미가 없을 수 있습니다. 따라서 원본 이미지에서의 위치에 따라 사전 학습된 위치 임베딩의 2D 보간을 수행합니다.

[Paper Review]Learning Transferable Visual Models From Natural Language Supervision

cooling0 — Tue, 23 Sep 2025 14:28:27 +0900

Abstract

제한된 형태의 지도 학습은 다른 시각적 개념을 명시하기 위해 추가적인 레이블링된 데이터가 필요하기 때문에 일반성과 유용성을 제한함.
이미지에 대한 원시 텍스트로부터 직접 학습하는 것은 훨씬 더 광범위한 지도 학습 소스를 활용하는 유망한 대안
인터넷에서 수집된 4억 개의 (이미지, 텍스트) 쌍으로 구성된 데이터셋을 기반으로 어떤 캡션이 어떤 이미지에 속하는지 예측하는 간단한 사전 학습 작업이 SOTA 이미지 표현을 처음부터 학습하는 효율적
사전 학습 후, 자연어를 사용하여 학습된 visual concepts 을 참조하거나 새로운 개념을 설명함으로써 모델을 후속 작업으로 즉시 이전할 수 있음 (zero-shot transfer of the model to downstream tasks)

1. Introduction and Motivating Work

Task-agnostic objectives such as autoregressive and masked language modeling have scaled across many orders of magnitude in compute, model capacity, and data, steadily improving capabilities
그러나 컴퓨터 비전과 같은 다른 분야에서는 ImageNet과 같은 crowd-labeled 데이터셋을 사용하여 모델을 사전 학습하는 것이 여전히 표준 관행
최근의 아키텍처와 사전 학습 방식을 채택한 VirTex, ICMLM 및 ConVIRT는 최근 transformer-based language modeling, masked language modeling 및 contrastive objectives 텍스트에서 이미지 표현을 학습하는 잠재력을 입증
본 연구에서는 이러한 차이를 줄이고 자연어 지도 학습을 통해 대규모로 학습된 이미지 분류기의 동작을 연구
인터넷에서 이러한 형태의 방대한 공개 데이터를 활용하여 4억 개의 (이미지, 텍스트) 쌍으로 구성된 새로운 데이터 세트를 생성하고, 처음부터 학습된 ConVIRT의 단순화된 버전인 CLIP(Contrastive Language-Image Pre-training)이 자연어 지도 학습을 위한 효율적인 방법임을 보여줌.
우리는 거의 두 자릿수의 연산량에 걸쳐 8개의 모델을 학습시켜 CLIP의 확장성을 연구했으며, 전이 성능이 연산 능력의 함수로서 원활하게 예측 가능함을 확인
GPT 계열과 유사하게 CLIP은 사전 학습 과정에서 OCR, 지리적 위치 인식, 동작 인식 등 다양한 작업을 수행하도록 학습

2. Approach

2.1. Natural Language Supervision

At the core of our approach is the idea of learning perception from supervision contained in natural language. → natural language supervision
초기 연구에서는 주제 모델과 n-gram 표현을 사용할 때 자연어의 복잡성을 해결해야 했지만, deep contextual representation learning 의 개선을 통해 이제는 풍부한 감독 소스를 효과적으로 활용할 수 있는 도구가 있음을 알 수 있음.
자연어 학습은 다른 학습 방법에 비해 여러 가지 잠재적인 장점을 가지고 있음.
- 이미지 분류를 위한 표준 크라우드소싱 레이블링에 비해 자연어 지도 학습을 확장하기가 훨씬 쉬움
- 자연어를 기반으로 하는 방법은 인터넷에 있는 방대한 양의 텍스트에 포함된 지도 학습을 통해 수동적으로 학습할 수 있음
- 자연어 학습은 대부분의 비지도 학습 또는 자기 지도 학습 방식보다 중요한 이점을 가지고 있는데, 단순히 표현을 학습하는 것이 아니라 해당 표현을 언어에 연결하여 유연한 제로샷 전이를 가능

2.2. Creating a Sufficiently Large Dataset

natural language supervision 의 주요 동기는 인터넷에 공개적으로 이용 가능한 이러한 형태의 방대한 데이터이다.
인터넷에서 공개적으로 이용 가능한 다양한 출처에서 수집한 4억 개의 (이미지, 텍스트) 쌍으로 구성된 새로운 데이터셋을 구축
To attempt to cover as broad a set of visual concepts as possible, we search for (image, text) pairs as part of the construction process whose text includes one of a set of 500,000 queries.

2.3. Selecting an Efficient Pre-Training Method

VirTex와 유사한 초기 접근법은 이미지 CNN과 텍스트 변환기를 처음부터 공동 학습하여 이미지 캡션을 예측하는 것
그림 2는 ResNet-50 이미지 인코더보다 두 배 더 많은 계산량을 사용하는 6,300만 개의 매개변수를 가진 변환기 언어 모델이 동일한 텍스트의 Bag-of-Words 인코딩을 예측하는 훨씬 더 간단한 기준선보다 세 배 더 느리게 ImageNet 클래스를 인식하는 것을 보여줌
Both these approaches share a key similarity → 각 이미지에 수반되는 텍스트의 정확한 단어를 예측하려고 시도
- 이는 이미지와 함께 나타나는 다양한 설명, 주석 및 관련 텍스트로 인해 어려운 작업
- 이미지에 대한 contrastive representation learning 에 대한 최근 연구에서는 contrastive objectives 가 equivalent predictive objective 보다 더 나은 표현을 학습할 수 있음을 발견
we explored training a system to solve the potentially easier proxy task of predicting only which text as a whole is paired with which image and not the exact words of that text.
- 동일한 단어 묶음 인코딩 기준선을 시작으로, 그림 2에서 예측 목적을 대조 목적으로 바꾸었고 ImageNet으로의 제로샷 전송 속도에서 효율성이 4배 더 향상되는 것을 관찰

N개의 (이미지, 텍스트) 쌍으로 구성된 배치가 주어지면, CLIP은 배치 전체에서 가능한 N × N개의 (이미지, 텍스트) 쌍 중 실제로 발생한 쌍을 예측하도록 학습
이를 위해 CLIP은 이미지 인코더와 텍스트 인코더를 공동으로 학습하여 배치 내 N개의 실수 쌍의 이미지 및 텍스트 임베딩의 코사인 유사도를 최대화하는 동시에 $N^2 - N$ 개의 잘못된 쌍의 임베딩의 코사인 유사도를 최소화함으로써 다중 모달 임베딩 공간을 학습
- 이러한 유사도 점수에 대한 대칭적 교차 엔트로피 손실을 최적화

mageNet 가중치로 이미지 인코더를 초기화하거나 사전 학습된 가중치로 텍스트 인코더를 초기화하지 않고 처음부터 CLIP을 학습
표현과 대조 임베딩 공간 사이의 비선형 투영을 사용하지 않음
- 대신 각 인코더의 표현에서 다중 모달 임베딩 공간으로 매핑하기 위해 선형 투영만 사용
이미지 transformation function 을 단순화
- 학습 과정에서는 크기가 조정된 이미지에서 무작위로 정사각형을 잘라내는 것만 데이터 증강에 사용
- 소프트맥스에서 로짓의 범위를 제어하는 temperature parameter τ는 하이퍼파라미터로 변환되는 것을 방지하기 위해 학습 과정에서 log-parameterized multiplicative scalar 로 직접 최적화

2.4. Choosing and Scaling a Model

이미지 인코더를 위해 두 가지 아키텍처를 고려
- 첫 번째 아키텍처는 널리 채택되고 성능이 검증된 ResNet-50
- 두 번째 아키텍처에서는 최근 도입된 비전 트랜스포머(Vision Transformer, ViT)(Dosovitskiy et al., 2020)를 실험
텍스트 인코더는 Radford et al.(2019)에서 설명한 아키텍처 수정을 적용한 Transformer
- 기본 크기로 8개의 어텐션 헤드가 있는 63M 매개변수 12계층 512폭 모델을 사용
- Transformer는 49,152개의 어휘 크기를 갖는 텍스트의 소문자 바이트 쌍 인코딩(BPE) 표현에서 작동
- 계산 효율성을 위해 최대 시퀀스 길이는 76으로 제한
- 텍스트 시퀀스는 [SOS] 및 [EOS] 토큰으로 괄호로 묶이고 [EOS] 토큰에서 Transformer의 최상위 계층의 활성화는 계층 정규화된 다음 다중 모달 임베딩 공간으로 선형 투영되는 텍스트의 특징 표현으로 처리
- 사전 훈련된 언어 모델로 초기화하거나 언어 모델링을 보조 목표로 추가하는 기능을 유지하기 위해 텍스트 인코더에서 마스크된 자기 주의가 사용되었지만, 이에 대한 탐구는 향후 작업으로 남겨둠.

3. 실험

여기서는 그냥 좋은 아이디어를 정리하면
1. embedding ensemble
2. Prompt engineering (up acc)