RAG란 (Retrieval-Augmented Generation = 검색 증강 생성) 이란 뜻으로, 언어모델이 특정 데이터를 검색하여 답변을 생성하는 방식을 말합니다.

RAG의 장점

AI Model 자체 성능에 모든걸 의존하는건 비효율적이고 사실상 AI 자체 메모리(학습내용)가 커지면 커질수록 연산량은 기하급수적으로 증가하기때문에, 모델성능은 필요한 언어를 잘 이해하고 요약이나 생성 할수 있을정도면 충분하고, 답변을 생성할때 필요한 지식부분은 별도의 DATA에 의존하게 함으로써 모델의 성능(속도 퍼포먼스 측면)을 취할수있고 연산량도 최적화시킬수있고, 데이터의 정확성도 높일수있는 즉, 언어모델이 효율적으로 작동하게 할수있는 기법이라고 볼수있음.

Fine-Tuning 과 차이점

Fine-Tuinng은 사전 학습모델을 살짝 변형시키는 구조로, 어떤 기능추가라거나 모델이 참고할 데이터(지식)를 추가해주는것이 가능하지만, 해당 데이터나 기능추가부분이 가중치의 일부로 흡수되는 방식이여서 RAG방식보다 새로운 데이터에 대한 명확성이 떨어질 수 있음.

정리하면..

graph TD;
A[Pretrained Model]
B[Fine Tuning]
C[RAG]

• Pretrained Model(사전학습모델): 언어를 당담. 여러가지 언어를(용도에 필요한) 이해하고 번역이가능하고, 뜻을이해해서 유사문장을 가려낼수있고, 특정 의미를 담는 문장을 생성할수있음.
• Fine Tuning(전이 학습): 사전학습모델이 특정 기능을 더 잘 할수있도록 업데이트함. (optional, 사전학습모델이 원하는기능을 할수 없을때만 하면 됨)
• RAG(검색 증강 생성): 언어모델이 미리 구축된 DATABASE에서 쿼리를통해 필요한 정보를 검색해서 답변을 생성하는 방법.

요약하면 RAG를 적용할경우 언어모델은 지능 역할을 하고, RAG에서 사용되는 데이터는 지식의 역할을함.

여기서 또 고려해야 하는점은 사전학습모델은 지능의 역할을 하는데, 학습방법이 지식을 통해서 지능을 높이기때문에 일정 지능을 갖추려면 지식도 많이 알려줘야 한다는점

RAG 데이터는 지식 역할을 한다지만, 데이터가 RAW 데이터로 다 저장되기때문에 저장 용량을 많이 차지함.

모델의 지능이 낮으면 RAG의 데이터를 활용할수없고 RAG데이터가 너무많아지면 가중치용량보다 더커질수있어서 밸런스를 맞추는게 필요함.

기본 RAG 아키텍쳐

RAG 역사

1. Naive RAG: 위 그림같은 구조로 검색하여 찾은 데이터를 제공함.
2. Advanced RAG: 더 잘 검색하고, 필터링한 후, 정리해서 제공한다.
3. Modular RAG: 검색, 판단, 도구, 재검색, 검증 을 레고처럼 조립힌다.
4. Graph RAG: GraphRAG는 문서를 단순 chunk 목록으로 보지 않고, entity와 relationship 중심의 graph로 바꿔서 검색·요약하는 방식입니다. Microsoft Research는 GraphRAG를 텍스트 추출, 네트워크 분석, LLM prompting/summarization을 결합한 end-to-end 시스템으로 설명합니다.
5. Self-RAG: 모델이 언제 검색할지, 검색 결과를 사용할지, 답변이 근거에 맞는지를 스스로 판단하게 만드는 방향입니다.
6. CRAG (Corrective RAG): CRAG는 검색 결과가 나쁠 때 교정 행동을 넣는 방식입니다. 검색된 문서의 품질을 평가하는 lightweight retrieval evaluator를 두고, confidence에 따라 다른 retrieval action을 실행합니다
7. RAPTOR:
8. Contextual Retrival:
9. Late Chunking:
10. RAFT:
11. Agentic RAG:

4번~11번은 최신 변화중인 RAG 기법들

1. Naive RAG (구현 쉬움, 검색결과가 안좋으면 답변 퀄리티도 안좋음)

사용자가 “회사 휴가 규정 알려줘” 라고 물으면 벡터 DB에서 휴가 관련 chunk를 몇개 가져와서 LLM에게 같이 넣어주는 방식.

문서 준비
→ chunk 분할
→ embedding
→ vector DB 저장
→ 사용자 질문 embedding
→ 유사 chunk 검색 top-k
→ LLM에게 context로 넣기
→ 답변 생성

검색 결과를 그대로 제공하기때문에, 관련 있어 보이지만, 실제로는 도움이 안되는 답변일 경우가 많음.

2. Advanced RAG

Naive RAG과 유사하지만, 검색 전후에 여러 개선 단계를 추가함

예를 들어 “2023년과 2024년 매출 차이와 원인을 알려줘”라는 질문은 한 번의 검색으로는 부족할 수 있습니다. Advanced RAG는 질문을 “2023년 매출”, “2024년 매출”, “매출 변화 원인”처럼 쪼개서 검색한 뒤, 결과를 합쳐 답하게 만들 수 있습니다.

장점

Naive RAG보다 훨씬 실무적입니다.
검색 실패율을 낮출 수 있습니다.
문서가 많아져도 어느 정도 대응 가능합니다.
회사 문서 검색, 기술문서 QA, 법률/계약서 분석 같은 곳에 적합합니다.

단점

구성이 복잡해집니다.
검색, reranking, LLM 호출이 늘어나 비용과 latency가 증가합니다.
잘못 설계하면 “복잡한데 성능은 별로 안 좋아지는” 상태가 됩니다.

3. Modular RAG

Modular RAG는 단순히 “Advanced RAG보다 더 고급”이라기보다는, RAG 시스템을 모듈 단위로 분해해서 필요에 따라 조립하는 구조입니다.

예를들면 이런식 입니다. 핵심은 질문에 따라 다른 경로를 선택한다는 것입니다.

Router
→ Query Analyzer
→ Retriever A: Vector DB
→ Retriever B: SQL DB
→ Retriever C: Web Search
→ Reranker
→ Verifier
→ Generator
→ Citation Checker

장점

확장성이 좋습니다.
문서 검색, DB 조회, API 호출, 웹 검색, 코드 실행 등을 하나의 RAG 시스템 안에 넣을 수 있습니다.
복잡한 업무 자동화에 적합합니다.
Agentic RAG와 결합하기 쉽습니다.

단점

설계 난도가 높습니다.
모듈 간 데이터 형식, 실패 처리, 비용 관리, 평가 시스템이 필요합니다.
작은 프로젝트에는 과할 수 있습니다.

1. Chunking 전략
2. Embedding 모델
3. Vector Database -> Chroma DB Python 한 줄 설치, 디스크에 저장, 학습 프로토타입의 기본 선택
4. Retriever ( Similarity Search vs MMR – Maximal Marginal Relevance )

Deep Dive

PDF 깨지지않게

• OCR
• PDF Parser

저장된 Chunk 는 json

Parent-child Chunking (계층구조)

Query Rewriting

개요: 허깅페이스에서 직접 모델을 다운받아 Fine-Tuning을 시키고, 그동안 배운 테크닉들을 활용하여 모델 성능 (accuracy)를 올린다.

주제는 자유주제로 말씀해주셨지만 2.5일 짧은 프로젝트 기간을 감안해 단순하고 방금전에 배워서 시작하기 쉬운 “언어만 한국어로 바뀐 두문장 관계” 분석을하는 모델로 fine-tuning 해볼생각이다. (두문장 관계 평가란 두 문장이 같은의미를 지닌 문장인지 평가하는것을 말한다.)

모델학습을 통해 성능을 올리는것이 목표지만, 더 중요한것은 성능을 올리기위해 어떤것을 해봤는지 경험하고 어떤차이가 있었는지 비교를통해 fine-tuning 할때 어떤방법으로 어느정도 개선을 했을때 어떤차이를 보이더라 하는 그런 감각을 체득하는것 등 이 더 중요하다고 생각한다. 따라서 가능하면 무언가 수정할때는, 꼭 평가를해보고 가능하면 실제로 문장을 집어 넣어 테스트를 해서 어떤지 비교도 해볼 생각이다.

성능 개선과 더불어 모델 학습속도를 늘려줄수있는 최적화 기법도 중요하다.

루브릭

• klue/bert-base를 NSMC 데이터셋으로 fine-tuning 하여, 모델이 정상적으로 작동하는 것을 확인하였다.
• Preprocessing을 개선하고, Validation accuracy를 90% 이상으로 개선하였다.
• Bucketing을 성공적으로 적용하고, 연산 속도와, 모델 성능간 trade-off 관계가 발생하는지 여부를 확인하였다.

프로젝트 구조

평가기준에 klue/bert-base를 NSMC 데이터셋으로 fine-tuning 하라고 되어있다, 루브릭 크게 신경쓰지 말라는 말씀도 계셨지만 아무튼 나는 한국어 두 문장 관계도를 파악하는 모델로 훈련할 생각이기 때문에, 상관이 없긴하다. (하지만 나중에 모델을 교체할수도 있긴하다)

기본 구조

graph LR;
a[데이터 분석 및 HF Dataset]
b[모델 및 tokenizer]
c[데이터셋 전처리 및 모델 학습]
d[FT로 모델 성능 향상]
e[Bucketing으로 학습 결과분석]
a-->b
b-->c
c-->d
d-->e

고려 사항

프로젝트 할때는 어느정도 리서치를 하면서 머리에 정리를하면서 해보면 좋겠죠?

klue/bert-base 모델 사용시 mecab 사용금지.

리서치중 klue/bert-base는 학습될 때 형태소 분석기를 거치지 않고, 원본 텍스트를 바로 자체 토크나이저(WordPiece)로 쪼개어 학습되었습니다. 만약 억지로 Mecab으로 먼저 쪼갠 뒤 모델에 넣으면, 모델이 한 번도 본 적 없는 이상한 띄어쓰기와 토큰 조합이 입력되어 오히려 성능이 크게 떨어 진다는것을 알게되었음.

STEP 1. 데이터 분석 및 전처리 (EDA & Preprocessing)

• 중복 데이터 제거, pandas나 datasets의 기능을 이용해, 텍스트가 일치하는 중복 아이템 제거
• 정규식(Regex) 정제: *한글, 영문, 숫자, 기본 구두점만 남기고 의미없는 특수문자나 과도한 자음/모음 반복을 축소 (예: ㅋㅋ, ㅎㅎ 등 2개로 제한) 하는 전처리 적용.
• 최적의 max_length 찾기 (EDA 시각화):
  • 리뷰 길의 분포를 히스토그램으로 그려보기. 보통 95%정도 데이터가 특정 길이에 들어옴. max_length를 무조건 크게잡으면 패딩 때문에 연산시간이 크게 나빠짐.

STEP 2&3. 토크나이저 및 학습 초기 설정

• Dynamic Padding (동적 패딩)
  • DataCollatorWithPadding 을 사용하여 배치 내에서 가장 긴 문장을 기준으로만 패딩을 적용 (Step 5의 Bucketing과 결합을 하면 효과가 극대화)

STEP 4. 90% 이상을 위한 하이퍼 파라미터 최적화 (Fine-tuning)

• 학습률 스케줄러 변경: 기본값인 linear 대신 cosine_with_restarts 또는 cosine 스케줄러를 사용해 보세요. 모델이 지역 최소점(Local Minima)에 빠지는 것을 방지해 줍니다.
• Weight Decay 조정: 과적합(Overfitting)을 막기 위해 weight_decay 값을 0.01에서 0.1 사이로 미세 조정해 보세요.
• Early Stopping (조기 종료): EarlyStoppingCallback을 적용하여 Validation Loss가 더 이상 안 떨어지면 학습을 멈추고 가장 좋았던 체크포인트로 복원하도록 설정하세요.
• Optuna 융합 (고급): 하이퍼파라미터(Batch size, Learning rate 등)를 수동으로 찾기 힘들다면 Optuna 라이브러리를 Hugging Face Trainer에 연동하여 최적의 조합을 자동으로 찾게 만들 수 있습니다.
• 평가함수 compute_metrics() 를 numpy로직접 구현하는것보다 최적화된 scikit-learn 활용하면 성능잇점이 있다고함 코드에 주석확인.

STEP 5. 성능 vs 훈련 시간 분석 및 고도의 시각화 (결과분석)

• Weights & Biases (W&B) 도입: * pip install wandb를 설치하고 TrainingArguments에 report_to="wandb"를 추가해 보세요.
  • Bucketing을 켰을 때와 껐을 때의 Loss 하락 곡선, GPU 메모리 사용량, 학습 속도(Steps/sec)를 웹 대시보드에서 화려하고 직관적인 그래프로 겹쳐서 비교할 수 있습니다.
• Confusion Matrix (혼동 행렬) 시각화:
  • 단순히 Accuracy 숫자만 내지 말고, Validation 세트의 예측 결과를 뽑아 scikit-learn과 seaborn을 활용해 Confusion Matrix를 그려보세요.
  • “우리 모델은 긍정을 부정으로 착각하는 경우가 더 많을까? 아니면 부정을 긍정으로 착각하는 경우가 더 많을까?” 같은 깊이 있는 인사이트를 도출할 수 있습니다.
• 오답 노트 (Error Analysis):
  • 모델이 틀린 리뷰들만 따로 모아서 데이터프레임으로 출력해 보세요. “아, 비꼬는 반어법 리뷰(예: ‘참~~ 재밌네’)를 모델이 못 맞추는구나!” 같은 정성적인 분석이 가능합니다.

Projects Attempts

(1) 첫 번째 시도

첫번 째 시도는 튜토리얼에서 배운것을 한국어버전으로 만들기 위해 최소한의 수정만 거친 버전이다.

graph LR;
a[1.데이터 분석 및 HF Dataset]
b[2.모델 및 tokenizer]
c[3.데이터셋 전처리 모델학습]
d[4.FT로 모델 성능 향상]
e[5.Bucketing 학습 결과분석]
a-->b
b-->c
c-->d
d-->e

(1)-1. EDA

한국어 두문장 관계 데이터셋인 KLUE-STS 사용

train/evaluation/test 데이터로 분리: train:10501, evaluation:1167, test:519 | test가 STS자체에서 제공한 validation split.

문자열 길이 분포도 확인. (추후 패딩용) 길이가120안에 다 들어가는것을 확인.

(1)-2&3. 토크나이저와 모델

라이브러리: transformer
언어 모델: klue/bert-base
토크나이저: transformer 내장 AutoTokenizer
패딩: 추후 동적패딩과 성능비교를 해보기위해 정적 패딩 사용. EDA에서 확인한 문자열길이를 기준으로 모든 데이터를 커버할수있는 MAX_LENGTH=128
패딩 데이터 직접확인, 레이블도 앞부분 14개 확인해봤는데 1개뺴고 다 맞다고 판단 (신뢰도 90%+)
첫시도 특별한 전처리는 없이 바로 실행

(1)-4. Train/Evaluation과 Test

best checkpoint는 f1 기준으로 선택.

소스코드

https://github.com/ohmanbo/AIFFEL_quest_eng/blob/main/LLM_Application/LLM04/HF_korean_project.ipynb

6. 결과

훈련시간: 196.7s

Validation Accuracy 83.0% < 90% (부적격)

(1) tiral + 동적패딩 적용결과

훈련시간: 126s

Validation Accuracy 81.7% < 90% (부적격)

훈련시간은 늘어나고 정확도는 줄어드는 상콤한 상황!

[최종 평가 지표]

정적 패딩 평가 결과:
{‘eval_loss’: 0.8487739562988281, ‘eval_accuracy’: 0.8304431599229287, ‘eval_precision’: 0.7408759124087592, ‘eval_recall’: 0.9227272727272727, ‘eval_f1’: 0.8218623481781376}
버키팅 동적 패딩 평가 결과:
{‘eval_loss’: 0.9469589591026306, ‘eval_accuracy’: 0.8169556840077071, ‘eval_precision’: 0.7192982456140351, ‘eval_recall’: 0.9318181818181818, ‘eval_f1’: 0.8118811881188119}

확실히 동적패딩이 학습 속도는 눈에띄게 빨라지지만, 정확도는 낮은 문제가 발생 (trade-off 확인)

2번째 시도 – 학습을 위한 전략

A. STS 데이터셋에 label (True or False) 말고, real-label이라고 회귀값이 존재하는데 이걸기준으로 threadhold 조정해서 positive , negative 비율 postive가 좀더 많이 나오도록 조절하기.

 KLUE-STS 점수 회귀 학습 후 threshold로 이진화하는 방식이 더 유력함

• 현재: 문장쌍 -> positive/negative
• 변경: 문장쌍 -> 유사도 점수 -> threshold로 positive/negative

B. 학습데이터가 크지않으니 evaluation으로 빼놨던 나머지 10%도 Train에 사용하기

C. epoch를 3회돌렸는데 10회만 돌리기.

D. 정적패딩 사용하기. 동적패딩이랑 속도차이가 몇배나는게아니고 30%정도만 빨라져서 그정도면 모델 성능을 위해 희생할만한 학습시간이라고 생각됨. 동적패딩 아예 코드도 넣지말기.

E. Learning rate를 2e-5 에서 2e-5 부터 5e-5 4단계로 시도해보고 가장좋은값 사용.

F. batch size 16으로 수정

G. 모델변경 klue/roberta-base

H. wandb.init 에서 name을 2nd trial로 수정

소스코드

https://github.com/ohmanbo/AIFFEL_quest_eng/blob/main/LLM_Application/LLM04/HF_korean_project_v2.ipynb

학습결과

lr=2e-05 accuracy=0.9383 f1=0.9498 threshold=2.25 pred_positive_ratio=0.6185 time=708.07s
lr=3e-05 accuracy=0.9461 f1=0.9560 threshold=2.35 pred_positive_ratio=0.6146 time=788.65s
lr=4e-05 accuracy=0.9383 f1=0.9511 threshold=2.15 pred_positive_ratio=0.6493 time=540.65s
lr=5e-05 accuracy=0.9345 f1=0.9459 threshold=2.45 pred_positive_ratio=0.5992 time=557.46s

선택된 learning rate: 3e-05
선택된 prediction threshold: 2.35
선택된 모델 경로: transformers_klue_sts_regression_roberta_lr_3em05\best_model

테스트셋 결과

{‘eval_loss’: 0.33285850286483765, ‘eval_mse’: 0.3327992324688497, ‘eval_mae’: 0.4282605896357569, ‘eval_accuracy’: 0.9460500963391136, ‘eval_precision’: 0.9529780564263323, ‘eval_recall’: 0.9589905362776026, ‘eval_f1’: 0.9559748427672956, ‘eval_pred_positive_ratio’: 0.6146435452793835}

직접 작성한 예문 테스트

1) 바쁘다 -> 친절하다 로 바뀌면 유사도가 낮아서 negative -> 의도한 대로 작동 GOOD

2) (맥북, 스타벅스) -> (노트북, 카페) 유사도 높음

and

(맥북, 스타벅스) -> (비싼시계, 카페) 유사도 낮음 -> 의도한 대로 작동 GOOD

3) 이건 예시가 좀 많이 바뀌어서 직관적이지 않은데, (AIFFEL 딥러닝) -> (APPLE, 맥북) 유사도낮음.

3번째 (generate paraphrased sentences)

우선 두번째 학습결과가 지표로보나 실제 테스트결과로보나 너무 잘나와서 더 진행하지않아도 될것같다. 무얼 해볼까 계속 고민하던중 유사문장을 구분하는게아닌 유사문장을 만들어주는 기능을 만들어보면 어떨까 싶어서 decoder모델을 fine-tuning하기로 정했다.

모델은 Qwen3.5-4B로 정했는데 추론성능만 생각하고 너무 쉽게 정한게 아닌가싶다 ㅠㅠ 학습시키는데 1epoch에 3시간이 넘게 소요된다. 이런이유로 아직 결과가 나오지않아서 프로젝트 제출은 2번째로 제출하였다.

소스코드

https://github.com/ohmanbo/AIFFEL_quest_eng/blob/main/LLM_Application/LLM04/HF_korean_project_v3.ipynb

커널 재시작후 저장된 모델, lora 파일들을 불러와서 다시 실행할수있도록 만든 standalone 버전 (모델은 용량때문에 못올림)

https://github.com/ohmanbo/AIFFEL_quest_eng/blob/main/LLM_Application/LLM04/HF_korean_project_v3_test.ipynb

프로젝트 구성 (기존방법에서 바뀐부분)

1. KLUE-STS 로드 (1~2번째에서 학습에 사용한 동일한 데이터)
2. real-label >= 4.0 데이터만 paraphrase pair로 변환
3. Qwen3.5-4B LoRA/QLoRA SFT
4. 입력 문장으로 후보 30개 생성
5. 기존 STS regression 모델로 후보 점수 계산
6. top 10 정렬 출력

구성을 보면 알겠지만, 학습한모델로 유사문장을 30개 생성후 top10를 출력해주는 프로젝트이다 아직 학습중인데 결과가 어떤지에따라 추가계획을 생각해볼생각.

학습결과

학습시간 20314초 = 약 5시간 40분 (너무 오래걸려서 2epoch만 돌림)

테스트 1

꽤 자연스스럽게 새로운 문장을 만들어내고, 07번째를 보면, 여자라고 입력하지않았는데도 여자라고 유추를 한건지 아무튼 그렇습니다.

테스트 2

다음에는 복잡한 문장을 해봤는데요

1. 이건 대단한 기술이다
2. 폴란드에는 이미수출했고, 여러나라에서 사고싶어 한다.
3. 그 기술은 대한민국 방산 기술이다.

라는 2개의 단순문장과 1개의 복잡한문장 총 3개를 사용해서 모델이 어떻게 paraphrase하는지 확인해보았더니,

그럴듯 하지만, 대부분 맞지만 여러개의 오류도 쉽게 찾을수 있었습니다. 아무래도 학습한 예문이 복잡한문장이 많이 없어서 그런것 같습니다. 이런걸 개선하려면 더 복잡한 문장 또는 문단단위로 학습을하면 좋아질수도 있지않을까 생각해봅니다.

테스트 3

다시 복잡한 문장 1개만 가지고 해보았더니 정말 자연스럽게 다시 만들어주는걸 확인할 수 있었습니다.

테스트 4

혹시 모델 자체가 성능이 좋아서 그런게 아닐까? 해서 영어문장도 테스트해보았는데,

영어문장은 자연스럽지 않고, 한국어로 번역을 하려고하는걸봐서 확실히 모델도 좋지만, fine-tuning 영향이 적지않다는걸 느꼇습니다. 애초에 qwen 한국어보다 영어를 더 잘하는데 이런결과가 나온걸 보면요.

• 병렬처리
• 모든 시퀀스를 한번에 처리

Self-Attention Layer

• 하나의 정보를 처리할 때 input sequence의 다른 정보들의 영향력을 계산

Feed Forward Neural Network

모델의 비선형성 추가

Input Embedding

• Input -> embedding algorithm -> 토큰 벡터화

Positional Encoding

• 추론시 필요한 순서정보를 보존하기 위해 (번역, 생성, 문맥 이해 등에 필요)
• 병렬처리를 가능하게함.

• RNN은 토큰을 하나씩 입력하지만 Transformer는 한번에 모든 단어를 처리
  • 위치 정보를 보존해야 할 필요성이 있다.
• Sin & Cos 사용하는 이유
  • 같은 위치 정보에 해당하는 위치 벡터 값이 같아야 한다. (주기성)
  • 위치 벡터의 값이 너무 커지면 안된다. (-1 ~ 1)

Self-Attention

• 하나의 정보를 처리할 때 input sequence의 다른 정보들의 영향력을 계산 -> Dependency가 존재한다.
• Feed Forward Network에는 dependency가 존재하지 않는다.

Q, K, V

• 3개의 vector 생성 -> Encoder의 input vector
  • Query : 현재 단어의 표현, “나는 지금 무엇을 찾고 있나?”
  • Key : 각 토큰이 “나는 이런 특징으로 검색될 수 있다”고 내놓는 검색용 특징
  • Value : 실제 단어의 표현 즉 실제 값, “쿼리와 키를 비교해서 나온 score”

Value 벡터가 softmax 결과값과 곱해져서 Attention 벡터가됨

원래 임베딩 테이블에는 “tower”라는 단어 하나에 벡터 하나만 있어. 이건 “타워”의 평균적인 의미라서, 건축물인지 중장비인지 구분되지 않아.

임베딩 테이블의 "tower":
[0.5, -0.2, 0.8, ...]  ← 어떤 tower인지 모름

Self-Attention을 거치면 같은 “tower”라도 주변 단어에 따라 다른 벡터가 돼.

"Eiffel tower"에서의 tower:
α(Eiffel)=0.7, α(tower)=0.3
→ 새 벡터 = 0.7·V(Eiffel) + 0.3·V(tower)
→ 건축물/파리/높음 의미 쪽으로 이동

"crane tower"에서의 tower:
α(crane)=0.7, α(tower)=0.3
→ 새 벡터 = 0.7·V(crane) + 0.3·V(tower)
→ 중장비/건설/금속 의미 쪽으로 이동

Self Attention 재 정리

Step 1: q, k, v 생성

Residual Connection

Layer Normalization

https://www.youtube.com/watch?v=Ub3GoFaUcds

Transformer의 등장 배경, 특징등이 궁금하다면 이전 글을 참조해주세요.

1. 강의 소개

강의 목표

1. Transformer가 어떻게 작동하고, LLM과 어떤 연관성이 있는지 이해하기.
2. LLMs 이 어떻게 훈련되고 어떤 다양한 용도로 사용되는지 배운다.

강의 대상

• 머신러닝 기본을 이해 하는 자
• 선형 대수학을 이해 하는 자
• LLM에 관심있는 자

Textbook

Super Study Guide

강의 링크

https://cme295.stanford.edu

치트 시트

출처: https://github.com/afshinea/stanford-cme-295-transformers-large-language-models

2. NLP tasks overview (자연어 처리 3가지 작업)

Classification (분류)

graph LR;
    A(Input Text) --> B[Model];
    B --> C(3);

• Sentiment extraction (감정 추출): 스토리를 읽고, 슬픈지 기쁜지 등 감정을 추출함.
• Intent detection(목적 감지): 프롬프트가 “6시에 알람 맞춰줘” 라면 알람을 설정하는게 목적인것을 파악해냄.
• Language detection(언어 감지): 영어인지 한국어인지 판별.
• Topic modeling

“Multi”-classification (다중분류)

graph LR;
    A(Input Text) --> B[Model];
    B --> C(3:Input, 5:text);

• Part of speech tagging
• Named entity recognition (NER): 장소, 시간, 사물등 알려진 entity를 인식함.
• Dependency parsing
• Constituency parsing

Generation (생성)

graph LR;
    A(Input text) --> B[Model];
    B --> C(Out text);

• 머신 번역 (언어 번역, 영어 -> 한국어)
• 질문에 답변
• 요약
• 텍스트 생성 (소설, code 등)

Sentiment extraction (감정 추출)

graph LR;
A>This teddy bear is SO CUTE!] --> B[Model]
B --> C('+')

3. Tokenization (토큰화)

모델은 (컴퓨터는) text를 이해할수없어서 문자를 숫자데이터로 바꿔줘야한다.

A cute teddy bear is reading.

text는 복잡하고 무한이 많은 조합이 가능하기때문에 문장단위로 토큰화하는건 무한히 많은 메모리를 요구하므로 불가능하고 문장을 토큰단위로 쪼개어 컴퓨터가 이해할수 있도록 만들어야한다.

토큰화 방식은 다양 한방법이 존재한다

arbitrary (문법/띄어쓰기)

graph TD;
A[A]
B[cute]
c[teddy bear]
d[is]
e[reading]
f[.]

word (단어)

graph TD;
A[A]
B[cute]
c[teddy]
d[bear]
e[is]
f[reading]
g[.]

sub-word (하위 단어)

sub-word 는 하위단어 토큰화방식인데 한마디로 단어뿌리기반으로 분리해서 의미를 word 기반보다 더 작게 쪼개는것입니다.
car 와 cars 라는 단어가 있을때 이 둘은 비슷하지만 다릅니다 car는 a car, the car, your car 이런식으로만 등장이 가능하지만 cars는 a나 the 같은 관사 없이도 사용이 가능합니다.
이걸 분리해주지 않으면, 모델은 이부분을 학습하기가 매우 어려울것입니다. a cars 같은 틀린 문법이 번역 결과로 출력이 될수도 있겠죠.

graph TD;
A[A]
B[cute]
c
d[##dy] 
e[bear]
f[is]
g[read]
h[##ing]
i[.]

이 예제에서도 read 와 read+ing인 reading은 전혀 다른의미가 되는데, 이런식으로 분리해주면 모델이 prefix suffix개념도 이해 할수있게 된다.

character-level (자소단위)

자소단위는 오타나, 대소문자 (영어의경우) 오류, 에 강해지는 장점이 있지만, 비현실적인 vocab(단어장) 사이즈에 처리속도가 매우느리고, 자소단위는 의미가없어서 모델이 의미를 이해하는게 거의 불가능하다. 물론 짧고 간단한 문장은 처리가 가능하기도 하지만. 현재 실제로는 쓰이지않는다.

한국어의 subword

한국어도, 띄어쓰기, 단어, 글자, 자소, 하위단어 등 여러기준으로 토큰을 나눌수있고 현재 가장 많이 쓰이는건 “하위단어 기반 토크나이저” 이다.

다시한번 강조하지만 토큰화를 시키는 이유는 메모리 한계 때문이기도 하지만, 의미 단위로 쪼개져야 AI 모델이 토큰을 재조합해 새로운 글을 작성할수 있다.

Word representation (단어 표현)

One hot encoding (OHE)

사람들이 주로 쓰는 유사도 측정방식으로는 Cosine Similarity가 존재하는데, 이 방식은 토큰마다 축을 따로만들어야함. 이렇게되면 vocab 수만큼 축이 생기는데, 모든토큰이 다른토큰벡터들로부터 직교를하게되어서 유사도 측정이 불가능함.

사실 이런이유가 아니어도 LLM을만들기 위해서는 무수히 많은 단어를 여러언어로 학습시켜야하는데, 이 방식은 가중치 용량이 너무커져서 사실상 안씀. 못씀.

Embedding 도입

임베딩은 토큰마다 축을 만드는게아님

Lecture 2 – Transformer-Based Models & Tricks

https://www.youtube.com/watch?v=yT84Y5zCnaA&list=PLoROMvodv4rOCXd21gf0CF4xr35yINeOy&index=2

Transformer 전체 흐름을 정검

아래 플로우 차트에서 왼쪽은 Encoder 오른쪽은 Decoder Component이다.

이 형태가 기본형인 이유는 Transformer가 처음에 머신러닝을 활용한 번역모델로 개발되었기 때문이다.

Multi-Head Attention Layer

이곳이 바로 self-attention 매커니즘이 작동하는 위치이다. 이 그림에서 Scaled Dot-Product Attention 부분에서 h의 갯수가 head의 갯수다. 이 갯수만큼 attention 매커니즘을 반복한다.

Attention Map

각 토큰(단어, Q)와 K를 내적해서 큰 값 (= 코사인 유사도가 큰값)에 매칭 시켜준다.
이 후 위에있는 softmax 함수처럼 Root dk로 나눠준다. (값이 너무 커지거나 작아지는걸 방지)

스탠포드 교수는 각 header마다 서로다른 시각으로 단어가 무슨 의미를 갖는지 이해 할거라고(may) 한다

Masked vs unmasked 차이 – 미래를 볼 수 있는지 차이

Decoder에서 masked & unmasked 2중으로 처리하는 이유

두 Attention의 역할 분담

이렇게 비유해볼게. 통역사가 한국어로 통역할 때 머릿속에서 두 가지를 동시에 해야 해.

Masked Self-Attention의 역할 — “내가 방금까지 한국어로 뭐라고 말했더라?”

지금까지 만든 한국어 문장의 흐름을 파악하는 거야. “나는 학교에서”까지 말했으면 다음에 동사가 와야 자연스럽다는 걸 한국어 문법 차원에서 판단해. 이건 영어 원문과는 무관한, 출력 언어 자체의 일관성을 챙기는 단계.

Encoder-Decoder Attention의 역할 — “그런데 영어 원문은 뭐였지?”

이제 영어 원문을 다시 들여다봐. “school” 다음 위치에 해당하는 의미를 찾아야 한다고 판단하면, 인코더 출력에서 “study” 토큰에 높은 가중치를 줘. 이건 소스 언어와 타겟 언어를 연결하는 단계.

Positional Embeddings

RNN에서는 단어를 순차적으로 처리했지만 트랜스포머는 그렇지 않다. 심지어병렬처리까지 한다.

따라서 임베딩된 토큰에 해당 토큰의 위치정보를 주입시켜주는데 그게 바로 positional embedding 이라고 한다

(위치정보를 가진 임베딩 이라고 이해하면 쉽다.)

Are the position embeddings static? or learned?

스탠포드 학생이 질문했다, 위치 임베딩이 고정되어있냐? 아니면 학습된거냐? 라는 질문이다.

static (고정형) – sin/cos 방식

위치 벡터를 수학 공식으로 미리 계산해서 고정해놓는 방식이야. 우리가 앞서 얘기했던 sin/cos 방식이 바로 이거야.

학습이 시작되기 전에 모든 위치의 벡터값이 이미 결정되어 있어. 학습 과정에서 이 값은 절대 바뀌지 않아. 모델이 만져볼 수 없는 “상수표”야.

PE(pos, 2i)   = sin(pos / 10000^(2i/d_model))
PE(pos, 2i+1) = cos(pos / 10000^(2i/d_model))

Learned (학습형) — 임베딩 테이블 방식

위치 벡터도 단어 임베딩처럼 학습 가능한 파라미터로 두는 방식이야.

처음에는 랜덤 값으로 시작하고, 학습이 진행되면서 모델이 스스로 “각 위치를 어떻게 표현하는 게 좋을지” 를 데이터로부터 배우는 거야.

position_embedding = nn.Embedding(max_len, d_model)
# 위치 0, 1, 2, ... 마다 d_model 차원 벡터를 랜덤 초기화
# 학습하면서 backprop으로 업데이트됨

Answer

고정으로 시작하고, 학습하면서 수정되니까 둘 다임.

Hardcoded Position Embeddings

임베딩에 더해야 하므로, Position m 벡터는 d차원의 크기를 가지고있음.

벡터의 각 인덱스는 위에 해당하는 방정식을 사용해서 계산된다.

m과 n 사이의 상대 거리에 대한 함수인 코사인 값들의 합.

= m과 n의 상대거리 함수

코사인 유사도 = 내적 / normalized 된 각 embeddings

RoPE (Rotary Positional Embedding)

핵심 아이디어: 회전 행렬을 사용하여 Q, V 벡터를 회전시킴

기존 PE는 위치 정보를 임베딩에 더했어. RoPE는 다르게 접근해 — 벡터를 회전시켜서 위치를 표현해.

작동 방식 — 어디에 적용되나?

기존 PE는 입력 임베딩 단계에서 한 번 더해지고 끝이야. RoPE는 다른 곳에 적용돼.

RoPE는 Attention 계산 직전, Q와 K에만 회전을 적용
V에는 적용 안 함

위치 m에 있는 Q와 위치 n에 있는 K가 있을 때, Q를 m각도만큼, K를 n각도만큼 회전시켜. 그 다음 내적(Q·Kᵀ)을 하면, 신기하게도 결과값이 두 위치의 차이 (m-n)에만 의존하는 형태가 돼.

이게 RoPE의 진짜 마법이야. 절대 위치를 인코딩했는데도 내적 결과는 상대 위치만 반영하는 거야.

벡터를 회전행렬로 회전시키지 않아도 두 벡터의 상대좌표는 구할 수 있지 않니?

네 의문이 맞아 — 좌표만 빼면 거리는 그냥 구해져

그냥 두 토큰의 위치 인덱스(예: pos_q=3, pos_k=5)를 빼면 거리가 나와. 그 자체로는 회전이 필요 없지.

그럼 왜 회전을 쓰냐?

답은 — RoPE의 목표가 단순히 “거리를 구하는 것”이 아니라 **”Attention 점수에 거리 정보가 자동으로 녹아들게 하는 것”**이기 때문이야.

핵심: Attention은 내적(Q·K)으로 작동한다는 점이 결정적

Transformer가 이미 정해놓은 연산 흐름이 있어.

score = Q · K (두 벡터의 내적)

이 연산은 절대 안 바꿔. Attention의 본질이니까. 그래서 위치 정보를 이 내적 결과 안에 어떻게든 녹여 넣어야 해.

여기서 두 가지 선택지가 생겨.

선택지 A — Attention 외부에서 거리를 따로 계산해서 score에 더하기

score = Q · K + f(pos_q - pos_k)

이게 실제로 존재하는 방식이고, 이름이 있어. “상대 위치 편향(relative position bias)” 또는 ALiBi 같은 방법들이야. 네가 말한 “그냥 좌표 빼서 쓰면 되잖아”가 정확히 이 방식이야.

선택지 B — Q와 K 자체를 회전시켜서, 내적 결과에 거리가 자동으로 들어가게 하기

이게 RoPE야.

그럼 왜 굳이 B(RoPE)를 택했나?

회전이 가진 수학적으로 아름다운 성질 때문이야. 회전 행렬의 특성상,

(R_m · Q) · (R_n · K)  =  Q · R_(n-m) · K

위치 m으로 회전된 Q와 위치 n으로 회전된 K를 내적하면, 결과가 자동으로 (n-m), 즉 상대 위치만의 함수가 돼. 절대 위치 m, n은 사라지고 차이만 남아.

이게 가능한 이유는 회전 행렬이 직교 행렬이라는 특별한 성질을 가지기 때문이야. 더하기로는 이런 성질이 안 나와.

A방식 (편향 더하기) vs B방식 (RoPE)

RoPE 방식이 추가 연산이 필요 없는 이유? (증명)

Step 1 — 회전이 정확히 무슨 일을 하는지

위치 m에 있는 Q를 회전한다는 건 이런 뜻이야.

원래 Q = [a, b]                  (2D 예시)
회전된 Q = R(mθ) · Q
       = [a·cos(mθ) - b·sin(mθ), a·sin(mθ) + b·cos(mθ)]

여기서 R(mθ)는 각도 mθ만큼 돌리는 회전 행렬이야. 위치 m이 클수록 더 많이 돌아가.

K도 마찬가지로 위치 n에서 R(nθ)만큼 회전돼.

Step 2 — 마법이 일어나는 지점: 내적

이제 회전된 Q와 K를 내적해봐.

회전된 Q · 회전된 K
= (R(mθ)·Q) · (R(nθ)·K)

여기서 회전 행렬의 수학적 특성이 발동해. 회전 행렬은 직교 행렬이라 다음이 성립해.

R(mθ)ᵀ · R(nθ) = R((n-m)θ)

Layer normalization

LN은 한마디로 Vector의 각 component (인덱스 값) 들을 임의의 값으로 정규화 시키는것. (예: -1.0 ~ 1.0 )

벡터에서 계산된 평균값을 뺴주고 standard deviation으로 normalize 시킨다.

감마: re-scailing factor

베타: (앞으로 배울것 -_-)

Post-Norm

2017년 트랜스포머 기본형태

Pre-Norm

요즘 사용하는 방식, Layer Norm이 실행되는 위치가 다름.

Pre-Norm + RMSNorm

완전 최근 사용하는방식은 RMSNorm을 섞여주는건데, 기본적으로 빠름.

Attention approximation

기본적으로 Self-Attention 과정은 각각의 토큰이 다른 모든토큰과 상호작용을 하게 되어있습니다. 그러니까 입력된 문장에 토큰이 10개면 10의 제곱인 100번의 상호작용이 일어나고 토큰이 100개면 1만번의 상호작용이 일어납니다. 입력된 문장이 길면 길수록 연산량이 엄청나게 커집니다.

2020년에 Longformer라는 논문이 발표되었는데, 토큰이 모든토큰과 상호 작용하는대신 창문을 제어하여 이웃들하고만 상호작용하도록 효율을 높힌 방식이다.

(아래 사진에서는 흰색부분이 연산에서 제외된것으로 보면 됨.)

Leveraging local and global attention

SWA = Sliding Window Attention

최신에는 일부 layer는 global attention을 적용하고 나머지는 local attention을 적용하는 추세인데, 다양한 조합을 시도하고있음.

그리고 이미지에서는 윈도우가 5×5로 매우 작지만 실제로 local attention window를 이렇게 작게 쪼개는건아니고 수천x수천 단위로 엄청큼. 수만x수만 or 수십만x수십만 을 수천단위로 줄이는것임.

CV과정을 공부할떄 convulution 벡터 layer가 보고있는 일부인 receptive field와 같은개념이라고 보면 이해하기 쉬움.

Sharing attention heads

head마다 각각의 projection matrix를 갖지않고 몇개의 축소된 행렬들을 공유하는개념

variation A: full attention 대신 그때 그때 local attention을 사용하는것

variation B: (행렬) orthogonal to all of this heads

왜 Projection matrix를 share하는데 V K만 쉐어하고 Q는 쉐어하지않을까?

KV cache : saves values of K and V.

KV cache가있는데 이게 너무 커지지않도록하기위해 필요한 알고리즘.

Sharing Matrcies to share

아래 그림에서 G는 Group의 수

MQA

하나의 projection 행렬을 모든 head에 적용

GQA

그룹을 나눠 각각 그룹에맞는 projection 행렬을 적용.

MHA

각 Head가 Query projection, key projection, and value projection 이 존재하는 standard방식.

3가지 케이스를보면 GQA가 가장 좋아보이지만, GQA가 모든 모델에 사용되는건 아니다. 라는것 기억하고 넘어가기 다른것도 필요하니까.

Transformer-based models

Encoder-decoder 모델

T5 = Transformer의 like 바닐라 모델 (text to text)

mT5 (m=multilingual) =

ByT5 (By=Byte) = 바이트레벨 토크나이저 사용으로 사전크기가 작아짐.

sentinel tokens in T5 family = a span of corrupted tokens

Encoder-Only

decoder가 없어서 분류용으로 사용됨.

왜 요즘 모델은 Decoder-only인데 번역을 잘하지?

첫째, 번역도 결국 “다음 토큰 예측” 문제로 환원될 수 있어. Decoder-only 모델한테 "Translate to Korean: Hello world →" 같은 입력을 주면, 그 다음에 자연스럽게 올 토큰은 “안녕”이지. 즉 번역이라는 별도의 작업이 아니라, 조건부로 다음 토큰을 예측하는 일반 문제의 특수한 경우가 되는 거야. 이게 GPT 계열의 핵심 철학이기도 해 — “모든 NLP 태스크는 결국 다음 토큰 예측”이라는 관점.

둘째, 스케일과 다국어 데이터의 힘이 커. GPT-4, Claude 같은 모델은 인터넷에 있는 어마어마한 양의 다국어 코퍼스 — 번역서, 위키피디아, 자막, 이중언어 웹사이트 등 — 로 학습돼. 데이터와 파라미터가 충분히 커지면, 아키텍처 차이가 만드는 이론적 우위는 점점 줄어들어. “scale은 모든 걸 이긴다”는 격언이 어느 정도 들어맞는 영역이지.

셋째, Instruction tuning과 RLHF가 결정적이야. 사후 학습 단계에서 “사용자 지시를 따르도록” 훈련받기 때문에 “이걸 한국어로 번역해줘” 같은 자연어 명령을 이해하고 수행할 수 있어.

그럼 encoder-decoder는 이제 안 쓰이냐? 그건 아니야. 순수 번역 전문 모델인 Meta의 NLLB, Google의 M2M-100, T5 같은 건 여전히 encoder-decoder를 써. 이론적 장점이 있거든:

• Encoder는 소스 문장을 양방향(bidirectional) 으로 한 번에 처리할 수 있어. “I saw the bank” 같은 문장에서 “bank”의 의미가 뒤에 나오는 단어로 정해질 때, 양방향이 유리해.
• Decoder-only는 인과적(causal) 어텐션 이라 왼쪽에서 오른쪽으로만 봐. 그래서 소스를 읽을 때도 단방향이고, 같은 표현력을 얻으려면 더 많은 파라미터가 필요해.
• 순수 번역 태스크에서는 encoder-decoder가 같은 성능을 더 적은 파라미터로 낼 수 있는 경우가 많아.

정리하자면, 강의의 분류는 “원래 무엇을 위해 설계됐나“에 대한 답이고, 실제로 GPT/Claude가 번역을 잘하는 건 “충분히 크고 잘 학습된 decoder-only 모델은 거의 모든 NLP 태스크를 다음 토큰 예측이라는 하나의 형식으로 풀어낼 수 있다“는 사실 때문이야. 가장 효율적인 구조가 아닐 수는 있어도, 불가능한 건 전혀 아니지. 오히려 단순함과 범용성이라는 큰 장점이 있어서 범용 LLM의 주류가 된 거고.

BERT deep dive

트랜스포머 마스터 카드 (20장)

카드를 클릭해 답을 확인하세요. 답을 본 후 “쉬움/보통/어려움”으로 평가하면 진도가 기록돼요.

1단계 · 등장 배경

카드 1-5

2단계 · 핵심 개념

카드 6-14

3단계 · 구조와 응용

카드 15-20

1 / 20

쉬움 0 보통 0 어려움 0

← 이전

쉬움 보통 어려움

다음 →

Self-Attention 깊이 보기 RNN과 비교 복습 계획 만들기

Transformer의 등장 배경.

Attention으로 해결하지 못한것

• 장기 의존성 문제 (Long-term Dependency Problem): RNN의 순차적 정보 전달 구조, 문장이 길어질수록 앞쪽 정보가 뒤로 전달되는 과정에서 소실됨. LSTM으로 개선되었기는하나 여전히 이전 정보가 희석되고 한계가 있음. Attention은 디코더가 인코더의 모든 hidden state를 참조할수 있게 해주지만, hidden state 자체가 이미 RNN을 통해 만든 값들임.
• 병렬 처리의 어려움 (Parallelization Difficulty): RNN은 구조적으로 현재 스텝의 계산이 이전 스텝의 결과에 의존적임. Hidden state에서 h2를 계산하려면 h1이 필요하고 h3를 계산하려면 h2가 필요함. Attention 자체는 병렬계산이 가능한 알고리즘이지만, Transformer 이전의 attention은 RNN 위에서 쓰는 부가기능이었기때문에 한계가 존재했음.

Transformer의 핵심 개념들.

• Positional Encoding
• Attention
  • Scaled dot product Attention
  • Multihead Attention
• FFNN
• Add&Norm

Positional Encoding (PE): 위치기반 인코딩

PE가 없다면 아래 두 문장을 구분할수 있을까?

나는 학생 이다 / 이다 학생 나는

[답변] Transformer는 모든 토큰을 동시에 처리해. RNN처럼 순서대로 읽지 않기 때문에, Positional Encoding이 없으면 아래 두 문장은 완전히 동일하게 인식돼.

"나는 학생 이다"   →  {나는, 학생, 이다}  ← 그냥 단어 집합
"이다 학생 나는"   →  {이다, 학생, 나는}  ← 똑같은 단어 집합

PE가 하는 일: 각 토큰의 임베딩 벡터에 위치 정보를 담은 벡터를 더해줘.

입력 = 단어 임베딩 + 위치 임베딩

예를 들면 이렇게 돼:

"나는 학생 이다"
나는  →  [단어벡터] + [위치1 벡터]
학생  →  [단어벡터] + [위치2 벡터]
이다  →  [단어벡터] + [위치3 벡터]

"이다 학생 나는"
이다  →  [단어벡터] + [위치1 벡터]  ← !!
학생  →  [단어벡터] + [위치2 벡터]
나는  →  [단어벡터] + [위치3 벡터]  ← !!

핵심 원리 한 줄 요약

같은 단어라도 위치가 다르면 → 더해지는 벡터가 다르고 → 최종 입력값이 달라진다

그래서 모델은 단순히 “어떤 단어가 있냐”가 아니라 “어떤 단어가 몇 번째에 있냐” 를 함께 인식할 수 있어.

PE 설계에 반영된 전제들과 해소 방법

전제가 왜 필요한가?

위치 벡터를 단어 임베딩에 더하는(+) 방식을 쓰기 때문에, 잘못 설계하면 위치 정보가 단어 의미 정보를 덮어쓰거나 방해할 수 있어. 그래서 PE는 아래 3가지 전제를 만족해야 해.

전제 1. 위치마다 고유한 값이어야 한다 (Unique)

문제: 위치 벡터가 중복되면 모델이 두 위치를 구별할 수 없어.

1번 위치 PE = 3번 위치 PE → 모델 입장에서 두 토큰이 같은 위치

해소: sin/cos 함수를 다양한 주파수로 조합해서 사용해. 각 차원마다 진동 속도가 다른 sin/cos 값을 쌓으면, 모든 위치가 고유한 벡터 패턴을 가지게 돼. 이진수에서 각 자릿수가 다른 속도로 바뀌는 것과 같은 원리야.

PE(pos, 2i)   = sin(pos / 10000^(2i/d_model))
PE(pos, 2i+1) = cos(pos / 10000^(2i/d_model))

전제 2. 값이 너무 커지면 안 된다 (Bounded)

문제: 위치 벡터의 값이 단어 임베딩보다 훨씬 크면, 모델은 위치 정보만 보고 단어 의미는 무시하게 돼.

단어 임베딩 값: 0.3, 0.7, -0.2 … 위치 벡터 값: 1000, 5000, 3000 … → 임베딩 정보가 묻혀버림

해소: sin/cos 함수는 모든 값이 [-1, 1] 범위 안에 있어서, 위치 신호가 단어 임베딩을 압도하지 않아. 반면 단순히 위치 인덱스(1, 2, 3…)를 그대로 더하면 문장이 길어질수록 위치 값이 무한히 커지는 문제가 생겨. Mesuvash

전제 3. 가까운 위치는 비슷한 벡터여야 한다 (Smooth)

문제: 인접한 위치의 PE가 완전히 다른 값이라면, 모델이 “1번과 2번 위치는 가깝다”는 것을 학습하기 어려워.

해소: sin/cos의 주기적 특성 덕분에 가까운 위치는 비슷한 인코딩 값을 가지게 되어, 모델이 자연스럽게 위치 간 근접성을 학습할 수 있어. 또한 삼각함수의 덧셈정리 덕분에, 임의의 위치 k만큼 떨어진 관계를 선형 변환으로 표현할 수 있어서 상대적 위치 관계도 파악 가능해. Mesuvash

정리

이 세 조건을 동시에 만족하는 함수로 sin/cos가 선택된 거야. 실제로 Transformer 논문에서 learnable한 PE도 시도해봤지만 성능이 거의 동일했고, 입력 길이에 대한 일반화 측면에서 sinusoidal을 최종 선택했다고 해.

Attention

트랜스포머 이전의 Dot proudct Attention의 과정.

전체 흐름을 3단계로 나눠서 보면 이해하기 쉬워.

① 인코더 — 입력 문장의 각 토큰을 RNN이 순서대로 처리해서 hidden state(h₁, h₂, h₃)를 생성해. 각 hᵢ는 해당 토큰까지의 문맥 정보를 담고 있어.

② Attention — 디코더의 현재 상태(s)와 인코더의 각 hᵢ를 비교해서 점수를 계산하고, Softmax로 가중치(α)를 뽑아. 그 가중치로 hᵢ들을 가중합해서 context vector(c) 를 만들어. 선 굵기가 attention 가중치를 나타내는데, h₂가 가장 관련 있다고 판단된 예시야.

③ 디코더 — context vector와 이전 decoder state를 합쳐서 RNN이 다음 출력 토큰을 생성해.

오른쪽 하단 점선 박스가 핵심인데, Attention을 썼어도 RNN 구조 자체는 그대로라서 순차 처리와 h₁ 손상 문제가 남아있는 게 Transformer 등장의 배경이야.

Q, K, V가 뭔지 — 도서관 비유로 먼저 이해하기

Attention을 도서관 검색 시스템으로 생각해봐.

• Q (Query) — “내가 지금 찾고 싶은 것”. 검색창에 입력하는 검색어야. 현재 처리 중인 토큰이 “나는 무엇에 집중해야 하지?”라고 던지는 질문.
• K (Key) — “각 책의 색인 태그”. 모든 토큰이 자신을 설명하는 라벨을 달고 있어. Query가 어떤 Key와 잘 맞는지를 비교해.
• V (Value) — “책의 실제 내용”. Key가 매칭됐을 때 실제로 가져오는 정보야.

그리고 Q · Kᵀ는 Query와 모든 Key를 내적(dot product)해서 유사도 점수를 계산하는 것이야. 두 벡터의 내적이 크다 = 방향이 비슷하다 = 관련이 높다는 뜻이야.

공식 맨 아래 / √dk가 있는데, 이건 벡터 차원이 커질수록 내적값이 폭발적으로 커져서 Softmax가 한 값으로 쏠리는 걸 방지하기 위한 정규화야.

Scaled dot product Attention (기존 attention과의 차이)

기존 Attention은 Q, K, V가 이렇게 나옴

• Q = 디코더의 현재 hidden state
• K = 인코더의 각 hidden state
• V = 인코더의 각 hidden state (K와 동일한 값)

즉 Q, K, V가 RNN이 만들어낸 hidden state 그 자체였어. 별도의 변환 없이 바로 사용한 거야.

Scaled Dot-Product Attention(Transformer)에서는 근본적으로 달라져. 입력 토큰의 임베딩 벡터 하나에서 Wq, Wk, Wv 세 개의 별도 가중치 행렬을 곱해서 Q, K, V를 각각 따로 만들어. 같은 토큰이라도 Q로 쓸 때와 K로 쓸 때, V로 쓸 때 서로 다른 벡터가 되는 거야.

2. 하나의 토큰이 3개로 나뉜다는 의미

토큰 임베딩 벡터 x가 있을 때:

Q = x · Wq   ← "나는 무엇을 찾고 있나?"  (질문자 역할)
K = x · Wk   ← "나는 어떤 정보를 갖고 있나?" (색인 역할)
V = x · Wv   ← "나의 실제 내용은 무엇인가?" (정보 역할)

같은 토큰 x에서 세 가지 역할이 분리되는 거야. Wq, Wk, Wv는 학습으로 최적화되는 파라미터이기 때문에, 모델이 "어떤 방식으로 질문하고, 어떤 방식으로 매칭하고, 어떤 정보를 전달할지"를 스스로 학습하게 돼.

3. Self-Attention vs Encoder-Decoder Attention

도식에서 핵심 차이가 보이지? Self-Attention은 Q, K, V가 전부 같은 시퀀스에서 나와서 "자기 문장 내부의 단어들이 서로를 참조"하는 거고, Encoder-Decoder Attention은 Q만 디코더에서, K와 V는 인코더에서 나와서 "번역 대상 문장을 보면서 출력을 생성"하는 구조야.

4. Scaling(√dk로 나누기)의 의미

Scaling의 원리는 이래. 벡터의 차원(dk)이 커질수록 Q와 K의 내적값이 자연히 커지는데, 이 큰 값이 그대로 Softmax에 들어가면 지수함수 특성상 가장 큰 값 쪽으로 확률이 거의 1로 쏠려버려. 이 상태에서 역전파를 하면 기울기가 거의 0이 되어서(기울기 소실) 학습이 제대로 안 돼.

√dk로 나누는 건 이 폭발적인 스케일을 내적 차원에 맞게 정규화해주는 거야. 예를 들어 dk=64이면 √64 = 8로 나눠서 점수를 안정된 범위로 가져오는 거지.

전체를 한 줄로 정리하면

self attention 하고, Encoder-Decoder Attention 둘다 transformer에서 사용하는거같은데, self attention 은 decoder only or encoder only 중에 하나인가?

Single-Head Attention vs Multi-Head Attention

Self-Attention은 "무엇을", Multi-Head Attention은 "어떻게 더 잘" 하는지에 대한 개념이야.

Self-Attention은 Q, K, V를 사용해서 토큰 간 관계를 계산하는 연산 방식 자체고, Multi-Head Attention은 그 Self-Attention을 h개의 헤드로 나눠서 병렬로 여러 번 돌린 뒤 결과를 합치는 구조적 확장이야.

헤드를 여러 개 쓰는 이유는, 하나의 Attention만으로는 한 가지 관점밖에 못 배우기 때문이야. 예를 들어 "나는 어제 학교에서 공부했다"라는 문장에서 단 하나의 Attention은 문법 관계에 집중하거나 의미 관계에 집중하거나 둘 중 하나밖에 못 해. 헤드를 8개, 16개로 늘리면 각 헤드가 서로 다른 Wq, Wk, Wv를 학습해서 각자 다른 언어적 패턴을 담당하게 돼.

그래서 Transformer에서 실제로 쓰이는 건 Multi-Head Self-Attention이야. Self-Attention(연산 방식) + Multi-Head(구조)가 합쳐진 형태인 거지.

단일 토큰 벡터를 multihead로 구성하는 방법

차원 분할 방식(d_model -> h개로 나누기)

d

독립적 학습 파라미터 방식 (각 head가 독립적 가중치 학습)

각 헤드가 원본 d_model 전체 차원에 접근하는 독립적인 Wq, Wk, Wv를 가져. 헤드가 h개면 파라미터 행렬도 h세트가 따로 존재.

입력 x (d_model=512)
  ↓
Head 1: x · Wq¹(512×512), x · Wk¹(512×512), x · Wv¹(512×512)
Head 2: x · Wq²(512×512), x · Wk²(512×512), x · Wv²(512×512)
...
Head 8: x · Wq⁸(512×512), x · Wk⁸(512×512), x · Wv⁸(512×512)

각 헤드가 전체 벡터를 보고 독립적으로 뭘 집중할지 결정해. 파라미터 수는 h × 3 × d_model²으로 헤드 수에 비례해서 증가해.

차원 분할 방식 (Transformer 논문의 실제 선택)

d_model을 헤드 수로 쪼개서 각 헤드에 할당해. d_model=512, h=8이면 각 헤드는 dk=64 차원만 담당해.

입력 x (d_model=512)
  ↓
Head 1: x · Wq¹(512×64), x · Wk¹(512×64), x · Wv¹(512×64)
Head 2: x · Wq²(512×64), x · Wk²(512×64), x · Wv²(512×64)
...
Head 8: x · Wq⁸(512×64), x · Wk⁸(512×64), x · Wv⁸(512×64)

각 헤드가 더 작은 부분 공간에서 작동해. 파라미터 수는 h × 3 × d_model × dk = 3 × d_model²로 헤드 수에 무관하게 일정해.

핵심 차이를 한 문장으로 요약하면, 독립 파라미터 방식은 헤드마다 각자 512차원 전체를 보고, 차원 분할 방식은 512차원을 헤드 수로 나눠서 각자 64차원씩 담당하는 것이야.

Transformer 논문("Attention is All You Need")이 차원 분할을 선택한 이유는 파라미터 수가 헤드 수에 상관없이 일정하게 유지되기 때문이야. 독립 파라미터 방식으로 헤드를 8개 쓰면 파라미터가 8배로 늘어나지만, 차원 분할 방식은 헤드가 몇 개든 3 × d_model²로 고정돼. 계산량과 메모리를 효율적으로 유지하면서 다양한 관점을 동시에 학습할 수 있는 거지.

다만 차원 분할도 완전히 독립적인 파라미터를 가지긴 해. 각 헤드의 Wq, Wk, Wv가 서로 다른 별개의 행렬이야. 차이는 그 행렬의 크기가 d_model × dk(작은 부분공간)냐, d_model × d_model(전체 공간)이냐인 거야.

N21, N2N, N2M 정리

N21 — 문장 전체를 보고 답 하나를 내는 것. "이 리뷰가 긍정이야 부정이야?" 처럼 전체 입력을 하나의 결론으로 압축하는 태스크야.

N2N — 토큰 하나하나에 대응하는 답을 내는 것. "각 단어가 무슨 품사야?" 처럼 입력과 출력 개수가 딱 맞아. Transformer 인코더 내부의 Self-Attention이 이 방식이야.

N2M — 입력과 출력 길이가 서로 달라도 되는 것. 번역이 대표적인 예야. 한국어 3단어를 넣었는데 영어로는 4단어가 나올 수도 있잖아. Transformer 전체 구조(인코더 + 디코더)가 이걸 가능하게 하는 거야.

Transformer가 이전 RNN 기반 모델들보다 혁신적이었던 이유 중 하나가 N2M을 훨씬 잘 처리할 수 있게 된 거야. RNN은 길이가 길어질수록 앞쪽 정보가 흐려졌지만, Transformer는 Self-Attention으로 거리와 상관없이 모든 토큰을 직접 참조할 수 있으니까.

트랜스포머 관련 링크 (3 가지)

https://wikidocs.net/31379

https://cpm0722.github.io/pytorch-implementation/transformer

찾아봐야할 내용

PCA, 공분산 행렬

이 수식을 기억하시나요?

$p(y_1,\dots ,y_{T^{\mathrm{\prime }}}\mid x_1,\dots ,x_T)={\mathrm{\Pi }}_{t=1}^{T^{\mathrm{\prime }}}p(y_t\mid v,y_1,\dots ,y_{t-1})$p(y1​,…,yT′​∣x1​,…,xT​)=Πt=1T′​p(yt​∣v,y1​,…,yt−1​)

Encoder가 생성한 컨텍스트 벡터 v 를 Embedding 레이어를 거친 y 값에 Concatnate하여 위 수식을 비로소 만족하게 됩니다. 우리가 Seq2seq를 완성한 거죠!

LSTM Encoder

import torch.nn as nn

class Encoder(nn.Module):
    def __init__(self, input_dim, emb_dim, hidden_dim):
        super().__init__()

        self.embedding = nn.Embedding(input_dim, emb_dim)
        self.rnn = nn.LSTM(emb_dim, hidden_dim, batch_first=True)

    def forward(self, src):
        print("입력 Shape:", src.size())

        embedded = self.embedding(src)
        print("Embedding Layer를 거친 Shape:", embedded.size())

        outputs, (h_0, c_0) = self.rnn(embedded)
        print("LSTM Layer의 Output Shape:", outputs.size())
        print("LSTM Layer의 Hidden State Shape:", h_0.size())
        print("LSTM Layer의 Cell State Shape:", c_0.size())

        return outputs, h_0, c_0

Embedding 레이어를 단어 사이즈와 Embedding 차원에 대해 선언을 한 후, 논문에서 소개한 대로 torch.nn.LSTM(enc_units)으로 LSTM을 정의합니다. Pytorch 속 LSTM 모듈의 기본 반환 값은 최종 State 값이므로 return_sequences 나 return_state 값은 따로 조정하지 않습니다 (기본: False). 즉, 우리가 정의해 준 Encoder 클래스의 반환 값이 곧 컨텍스트 벡터(Context Vector) 가 되는 겁니다. 추가적인 옵션이 궁금하시다면 아래의 Pytorch LSTM 공식 문서를 참조하시면 좋습니다.

vocab_size = 30000
emb_size = 256
lstm_size = 512
batch_size = 1
sample_seq_len = 3

print("Vocab Size: {0}".format(vocab_size))
print("Embedidng Size: {0}".format(emb_size))
print("LSTM Size: {0}".format(lstm_size))
print("Batch Size: {0}".format(batch_size))
print("Sample Sequence Length: {0}\n".format(sample_seq_len))

Vocab Size: 30000
Embedidng Size: 256
LSTM Size: 512
Batch Size: 1
Sample Sequence Length: 3

import torch

encoder = Encoder(vocab_size, emb_size, lstm_size)
sample_input = torch.randint(0, vocab_size, (batch_size, sample_seq_len))

sample_output, hidden, cell = encoder(sample_input)

LSTM Decoder

class Decoder(nn.Module):
def init(self, vocab_size, embedding_dim, hidden_dim):
super(Decoder, self).init()
self.embedding = nn.Embedding(vocab_size, embedding_dim)
self.lstm = nn.LSTM(embedding_dim + hidden_dim, hidden_dim, batch_first=True)
self.fc = nn.Linear(hidden_dim, vocab_size)

def forward(self, x, hidden, cell, context):
    print("입력 Shape:", x.size())

    embedded = self.embedding(x)
    print("Embedding Layer를 거친 Shape:", embedded.size())

    embedded = torch.cat((embedded, context), dim=2)
    print("Context Vector가 더해진 Shape:", embedded.size())

    output, (hidden, cell) = self.lstm(embedded, (hidden, cell))
    print("LSTM Layer의 Output Shape:", output.size())

    output = self.fc(output)
    print("Decoder 최종 Output Shape:", output.size())

    return output, hidden, cell

Decoder는 Encoder와 구조적으로 유사하지만 결과물을 생성해야 하므로 Fully Connected 레이어가 추가되었고, 출력값을 확률로 변환해 주는 Softmax 함수도 추가되었습니다 (Softmax는 모델 내부에 포함시키지 않아도 훈련 과정에서 포함시키는 방법도 있습니다). 그리고 Decoder가 매 스텝 생성하는 출력은 우리가 원하는 번역 결과에 해당하므로 LSTM 레이어의 return_sequences 변수를 True로 설정하여 State 값이 아닌 Sequence 값을 출력으로 받습니다.

print("Vocab Size: {0}".format(vocab_size))
print("Embedidng Size: {0}".format(emb_size))
print("LSTM Size: {0}".format(lstm_size))
print("Batch Size: {0}".format(batch_size))
print("Sample Sequence Length: {0}\n".format(sample_seq_len))

decoder_input = torch.randint(0, vocab_size, (batch_size, sample_seq_len))  # (batch_size, seq_length)

decoder = Decoder(vocab_size, emb_size, lstm_size)

dec_output, hidden, cell = decoder(decoder_input, hidden, cell, sample_output)

AI 토큰 소모를 60% 이상 절약하는 무료 방법 10가지를 모았습니다

Claude Code를 본격적으로 쓰기 시작하면 진짜 병목은 토큰 리밋입니다.
세션 한 번에 리밋이 절반 이상 차는 경험도 부지기수입니다.

대부분의 Github repo 를 직접 살펴봤습니다.
하지만 주목할만한 건 아래 10가지 방법뿐이었어요:
이 방법만으로도 같은 작업에서 AI 지출을 확 줄일 수 있습니다:

• RTK – 터미널 출력을 컨텍스트에 넣기 전에 필터링하는 CLI 프록시 → https://lnkd.in/gstbVEKb

• Context Mode – Playwright·GitHub·로그 등 raw 출력을 SQLite에 샌드박싱해서 깨끗한 요약만 대화에 넣어주는 Claude Code 플러그인 → https://lnkd.in/gHX7CJqS

• code-review-graph – Tree-sitter로 코드베이스를 로컬 지식 그래프로 매핑해서 필요한 부분만 읽게 해주는 MCP 서버 → https://lnkd.in/gQqUpqr2

• Token Savior – 파일 전체 대신 심볼 단위로 코드를 탐색하는 MCP 서버. 69개 도구에 세션 간 메모리도 유지되고, 토큰 소모도 확 줄어듭니다 → https://lnkd.in/gMFTd2du

• Caveman Claude – Claude 를 원시인처럼 말하게 해서 출력 토큰만 65-75% 깎아주는 스킬. 한 줄 설치에 결과물 정확도는 그대로입니다 → https://lnkd.in/gChQPymJ

• claude-token-efficient – CLAUDE.md 파일 하나로 응답을 간결하게 잡아주는 드롭인 설정. 코드 변경도 필요 없습니다 → https://lnkd.in/g5VajJAG

• token-optimizer-mcp – 캐싱·압축·스마트 도구 인텔리전스를 결합한 MCP 서버. 반복 출력을 압축해서 토큰을 절감해줍니다 → https://lnkd.in/g5zQNeye

• claude-token-optimizer – 어떤 프로젝트든 5분이면 적용 가능한 셋업 프롬프트 모음. 문서 토큰 소모가 대폭 줄어듭니다 → https://lnkd.in/gwd3MV9Y

• token-optimizer – 컨텍스트를 조용히 잡아먹는 고스트 토큰을 찾아내는 도구. 컴팩션 후에도 품질이 유지됩니다 → https://lnkd.in/gfnj3m2Z

• claude-context by Zilliz – BM25 + 벡터 하이브리드 검색으로 코드베이스 전체를 컨텍스트로 만들어주는 코드 검색 MCP. → https://lnkd.in/gFJGE3_C

10개를 다 설치하실 필요는 없습니다.
워크플로에 맞게 선택하세요:

터미널 출력이 많다면 → RTK
큰 코드베이스라면 → code-review-graph + Token Savior
MCP 서버가 많다면 → Context Mode
당장 리밋을 아끼고 싶다면 → Caveman + claude-token-efficient

10가지 방법 전부 무료입니다.
지금 Claude code 나 Codex 에 적용해보세요.
즉시 여러분의 지갑을 지킬 수 있습니다.

출처: https://www.linkedin.com/feed/update/urn:li:activity:7452105881321725953/?utm_source=share&utm_medium=member_desktop&rcm=ACoAADN6qvkBoCpZ2mDg6u0HK-Zg_GDF1ifPyc8

오늘은 일기로 글을 쓰기 시작 하겠다.

나는 C언어를 처음 배운게 2004년, 컴퓨터공학을 공부하고 게임개발 위해 투자한 시간만 2만시간이 넘는다. 비록 게임개발자로 일한것은 1년밖에 되지 않지만, 다른일 을 하면서도 중간 중간 코딩하는것을 잊은적이 없다. 코딩 실력을 유지하기위해서? 아니다 코딩자체가 재밌고, 무언가 만들었을때 사람들이 좋아해주면 그것으로 뿌듯하고 기분이 좋은일이라 계속 했던것 같다.

본격 AI시대에 들어서면서 머신러닝 딥러닝을 공부한지 벌써 한달이 지났다. 정신없게 만드는 새로운 용어들이 하루에도 몇 개씩 계속 나타난다. 이제 딥러닝이 왜 딥러닝 인지 뉴럴네트워크는 왜 그렇게 불리는지 머신러닝, 딥러닝 모델 십여개를 학습시켜보면서 감이 오기 시작한다. 최근에는 CV를 배우면서 상용 모델을 몇가지 써보면서 문득 이런 고민에 빠졌다.

• “이렇게 많은 모델들 구조를 다 알아야 하나?”
• “이 모델들의 특징을 모르면, 내가 필요한 모델이 뭔지 알고 사용할수 있을까?”
• “연구를 해봐야한다면 논문을 다 읽어봐야하나? 구현만 해보면 충분한가?”

모든 사람이 알겠지만, AI의 발전은 미친듯이 빠르다. 그만큼 AI 머신러닝 관련 논문이 수도없이 나오고 있다. 그동안 인기있던 모델들을 100% 다 이해하면, 내가 스스로 모델을 만들어낼때 도움이 되겠지만, 너무나 시간이 많이 걸릴것 같다. 따라서 분야별로 논문을봐서 특징이나 사용기술에대한 개념을 이해하기위한 모델들을 정리하고 순서대로 공부를 해야겠다는 전략을 세우게 됨.

공부법은 아래처럼 하고 매주 1-2개씩 모델을 깊게 공부하는 시간을 가져야할것같다.

1. 각 모델이 어떤 문제를 해결하려 했는지를 이해하기. (이전 모델에서는 어떤 방법을 썼고, 왜 부족했는지 30분정도 알아보기)
2. 전체를 한번에 이해하려 하지말고 특징이 뭔지 살펴보기 (논문의 Abstract, Figure, Experiment 순으로 읽어 전체 그림을 잡기)
3. 수식은 나중에 완벽히 분석하고, 특징파악 끝났으면 PyTorch 사용해서 핵심 모듈만 구현부터 해보기 (전체모듈 다 안해봐도 됨, 반복이라서)
4. 공개된 코드를 읽고 논문과 대조해보기.
5. 해당 모델을 인용한 논문 2-3개 찾아보고 어느 부분이 한계라고 지적했는지 보기
6. 코드 구현 끝났으면 실제로 사용해서 대충 학습시간이나 추론시간등 감을 익혀보고 다른 모델과 비교해보기
7. 70%만 이해한다는 생각으로 논문을 빠르게 습득하고 넘어가기 나머지 30%는 다른 모델을 공부하거나 실제 프로젝트를 진행하면서 채워나가기

분야 간 연결도 중요합니다. Transformer는 NLP에서 나왔지만 ViT(CV), Whisper(음성), DiT(이미지 생성)로 그대로 흘러들어갔습니다. CLIP은 이미지-텍스트 정렬이고 Stable Diffusion의 핵심 부품입니다. 분야를 별개로 공부하다 보면 이런 연결이 안 보이는데, “이 개념이 다른 분야에서는 어떻게 쓰이지?”라는 질문을 항상 갖고 있는 것만으로 이해의 깊이가 달라집니다

논문 읽기 전에 필요한 수학 기초로는 선형대수(행렬 곱, 고유값), 확률·통계(베이즈 정리, KL divergence, 가우시안 분포), 미적분(편미분, 체인룰), 정보이론(엔트로피, cross-entropy)이 있습니다. 이걸 미리 다 공부하려 하지 말고, 논문 읽다가 막히는 수식이 나올 때 그 개념만 찾아보는 방식이 훨씬 효율적입니다.

각 분야별로 공부해야 할 것들

딥러닝·CV·NLP·음성 분야별 뼈대 모델 공부 순서 로드맵

먼저 이걸 잡아야 모든 분야가 열립니다. 아래 개념들은 분야를 불문하고 모든 논문에서 당연한 것으로 전제합니다. 모델보다 개념 순서로 접근하세요.

개념 레이어 1 — 학습 원리

1986역전파 (Backpropagation)필수

Rumelhart et al. 모든 딥러닝의 학습 엔진. 체인룰로 gradient를 역방향 전파. 이걸 수식으로 직접 유도해보는 것이 가장 중요한 첫 단계.

핵심 개념: Chain rule, computational graph, gradient flow

자세히 물어보기

2012~SGD / Adam / 최적화기필수

SGD, Momentum, RMSProp, Adam. 단순 경사하강법부터 적응형 학습률까지. Adam이 왜 대부분의 상황에서 기본값인지 이해.

핵심 개념: Learning rate, momentum, adaptive LR, weight decay

자세히 물어보기

개념 레이어 2 — 안정화 기법

2015Batch Normalization필수

Ioffe & Szegedy. 레이어 입력 분포를 정규화해 학습을 안정화. 왜 없으면 깊은 네트워크가 학습이 안 되는지 이해가 핵심.

핵심 개념: Internal covariate shift, running stats, train vs inference 차이

자세히 물어보기

2015Residual Connection (ResNet)필수

He et al. F(x)+x 형태의 skip connection으로 gradient vanishing 해결. 이게 없으면 100층 이상 학습 불가. 현재 거의 모든 딥러닝 구조의 근간.

핵심 개념: Gradient highway, identity mapping, depth scalability

자세히 물어보기

2017Attention / Transformer필수

Vaswani et al. “Attention is All You Need”. Query-Key-Value attention 메커니즘. NLP뿐 아니라 이후 CV, 음성, 이미지생성 모두의 기반. 논문 전체를 수식까지 이해하는 것을 목표로.

핵심 개념: Scaled dot-product attention, multi-head, positional encoding

자세히 물어보기

공부 순서 원칙: 역전파 → 최적화기 → BatchNorm/Dropout → ResNet → Attention. 이 순서가 무너지면 이후 모든 논문이 맥락 없이 읽힙니다. 각 개념마다 PyTorch로 미니 구현을 해보세요.

CV 공부 순서: 분류 → 검출 → 분할 → Transformer 순으로. 각 단계가 이전 단계의 아이디어를 확장합니다.

1단계 — CNN 분류 기초

2012AlexNet뼈대

Krizhevsky et al. ImageNet을 처음 정복한 딥 CNN. ReLU, Dropout, GPU 학습을 도입. “딥러닝 르네상스”의 시작점.

핵심 개념: ReLU 활성화, Dropout, GPU 병렬 학습, Data augmentation

자세히 물어보기

2015ResNet뼈대

He et al. Residual block으로 152층까지 안정 학습. 현재까지도 CV 백본의 표준. ResNet-50/101은 수백 개 논문의 baseline.

핵심 개념: Residual block, bottleneck, depth vs width tradeoff

자세히 물어보기

2019EfficientNet

Tan & Le. 깊이·너비·해상도를 동시에 스케일하는 compound scaling. 같은 연산량에서 최고 정확도.

핵심 개념: Compound scaling, NAS, MobileNet 계열

자세히 물어보기

2단계 — 객체 검출

2015Faster R-CNN뼈대

Ren et al. Region Proposal Network(RPN)으로 detection을 완전 end-to-end화. Two-stage detection의 표준 구조.

핵심 개념: RPN, anchor box, RoI Pooling, two-stage pipeline

자세히 물어보기

2016YOLO (v1~)뼈대

Redmon et al. 이미지를 한 번에 처리하는 one-stage detection. 속도와 정확도의 트레이드오프를 이해하는 핵심 모델.

핵심 개념: Grid cell, confidence score, one-stage vs two-stage

자세히 물어보기

2017FPN (Feature Pyramid Network)

Lin et al. 다중 스케일 feature map을 계층적으로 결합. 작은 객체 검출 성능을 크게 향상. 거의 모든 최신 detector의 neck 구조.

핵심 개념: Top-down pathway, lateral connection, multi-scale feature

자세히 물어보기

3단계 — Vision Transformer

2020ViT (Vision Transformer)뼈대

Dosovitskiy et al. 이미지를 패치로 나눠 Transformer에 입력. “CNN 없이도 된다”는 것을 증명. 이후 CV Transformer의 원조.

핵심 개념: Patch embedding, positional encoding, class token

자세히 물어보기

2021Swin Transformer

Liu et al. 계층적 구조 + shifted window attention으로 ViT의 고해상도 한계를 극복. 현재 CV Transformer 백본 표준.

핵심 개념: Shifted window, hierarchical feature, linear complexity

자세히 물어보기

NLP 공부 순서: RNN의 한계 이해 → Attention 등장 배경 → Transformer → Pre-training 패러다임으로. 이 흐름이 “왜”를 설명합니다.

1단계 — 시퀀스 모델의 기원

2014Seq2Seq + LSTM뼈대

Sutskever et al. 인코더-디코더 구조로 기계번역. LSTM이 왜 vanilla RNN보다 장기 의존성을 잘 처리하는지가 핵심.

핵심 개념: LSTM gate (input/forget/output), hidden state, teacher forcing

자세히 물어보기

2015Attention (Bahdanau)뼈대

Bahdanau et al. RNN의 bottleneck(context vector)을 깨는 attention. Transformer attention의 직접적 전신. 이 논문을 이해해야 Transformer가 왜 나왔는지 보인다.

핵심 개념: Alignment score, soft attention, context vector per step

자세히 물어보기

2단계 — Transformer 시대

2017Transformer필수

Vaswani et al. “Attention is All You Need”. 이 논문 하나가 NLP, CV, 음성, 이미지생성을 전부 바꿨다. 수식 하나하나를 직접 구현해보는 게 목표.

핵심 개념: Multi-head attention, FFN, positional encoding, encoder-decoder

자세히 물어보기

2018BERT뼈대

Devlin et al. (Google). Masked Language Model로 대규모 사전학습 후 fine-tuning. “Pre-train → Fine-tune” 패러다임의 정립.

핵심 개념: MLM, NSP, bidirectional context, fine-tuning

자세히 물어보기

2018~GPT 시리즈뼈대

Radford et al. (OpenAI). Decoder-only, causal language modeling. GPT-1→2→3→4로 스케일이 곧 성능임을 증명. 현재 LLM의 주류 구조.

핵심 개념: Causal masking, in-context learning, scaling law

자세히 물어보기

2022InstructGPT / RLHF

Ouyang et al. Reinforcement Learning from Human Feedback. 언어모델을 인간 의도에 align. ChatGPT의 직접 전신.

핵심 개념: SFT, reward model, PPO, alignment

자세히 물어보기

Diffusion 공부 순서: VAE로 latent space 개념 → GAN으로 생성 학습 이해 → DDPM으로 diffusion 원리 → Stable Diffusion으로 실용화 흐름.

1단계 — 생성 모델 기초

2013VAE (Variational Autoencoder)뼈대

Kingma & Welling. Encoder가 latent distribution을 출력하고 sampling으로 생성. ELBO, reparameterization trick이 핵심. Latent diffusion의 latent space 개념의 직접 전신.

핵심 개념: ELBO, KL divergence, reparameterization trick, latent space

자세히 물어보기

2014GAN뼈대

Goodfellow et al. Generator vs Discriminator의 minimax 게임. 이미지 생성 패러다임을 열었고, diffusion 이전까지 SOTA. 학습 불안정성이 왜 생기는지 이해 필수.

핵심 개념: Minimax game, mode collapse, Wasserstein distance (WGAN)

자세히 물어보기

2단계 — Diffusion 본류

2020DDPM필수

Ho et al. Forward(노이즈 추가) → Reverse(노이즈 제거) 과정으로 이미지 생성. Diffusion의 수학적 기반. 이 논문의 수식을 이해하는 것이 이 분야 진입의 관문.

핵심 개념: Forward/reverse process, noise schedule, ELBO 유도, epsilon prediction

자세히 물어보기

2021CLIP뼈대

Radford et al. (OpenAI). 이미지-텍스트 쌍을 contrastive learning으로 학습. “텍스트로 이미지 검색/생성”의 기반. Stable Diffusion의 text encoder가 CLIP.

핵심 개념: Contrastive learning, zero-shot transfer, image-text alignment

자세히 물어보기

2022Stable Diffusion (LDM)뼈대

Rombach et al. VAE의 latent space에서 diffusion을 수행해 연산량을 획기적으로 절감. CLIP text encoder + U-Net denoiser + VAE 구조. 현재 이미지 생성 표준.

핵심 개념: Latent diffusion, cross-attention for text conditioning, CFG

자세히 물어보기

2023DiT (Diffusion Transformer)

Peebles & Xie. U-Net 대신 Transformer를 denoiser로 사용. 스케일 법칙이 잘 적용됨. Sora 등 최신 video generation의 기반.

핵심 개념: Patch-based latent, adaLN conditioning, scalable diffusion

자세히 물어보기

OCR 공부 순서: CNN으로 feature 추출 → RNN/CTC로 시퀀스 인식 → Attention 기반 → Transformer 통합. OCR은 CV + NLP의 교차점입니다.

1단계 — 시퀀스 인식 기초

2015CRNN + CTC뼈대

Shi et al. CNN(특징 추출) + RNN(시퀀스 모델링) + CTC(정렬 없는 학습). 문자 위치 어노테이션 없이 end-to-end 학습. OCR의 사실상 첫 딥러닝 표준.

핵심 개념: CTC loss, blank token, 문자 정렬 문제, feature map to sequence

자세히 물어보기

2단계 — Attention 기반

2016Attention OCR뼈대

Baek et al. 계열. Attention으로 어느 위치를 볼지 학습. CTC 대비 불규칙 레이아웃, 곡선 텍스트에 강함. STN(공간 변환 네트워크)과 조합되는 경우 많음.

핵심 개념: Spatial attention, STN, irregular text recognition

자세히 물어보기

2019CRAFT (텍스트 검출)

Baek et al. 문자 단위 affinity로 텍스트 영역 검출. 곡선, 다방향 텍스트 검출에 강함. OCR 파이프라인의 검출(detection) 단계.

핵심 개념: Character region score, affinity map, weakly supervised

자세히 물어보기

3단계 — Transformer 통합

2021TrOCR현대 표준

Li et al. (Microsoft). ViT encoder + BART decoder. 사전학습된 Transformer를 OCR에 적용. 현재 문서 OCR 최고 성능 수준. Handwriting에도 강함.

핵심 개념: Pre-trained ViT encoder, autoregressive decoding, transfer learning for OCR

자세히 물어보기

음성 인식 공부 순서: 음성 신호 기초(MFCC) → HMM-GMM 이해(딥러닝 왜 필요한지) → CTC 기반 → Attention → Whisper.

1단계 — 신호 처리 기초

기초MFCC / Spectrogram필수 개념

모델이 아니지만 반드시 먼저 이해해야 하는 전처리. 음성 파형을 어떻게 주파수 표현으로 바꾸는지. 현재 mel spectrogram이 사실상 표준 입력 형식.

핵심 개념: FFT, mel filterbank, MFCC, log mel spectrogram

자세히 물어보기

2단계 — 딥러닝 ASR

2014DeepSpeech (Baidu)뼈대

Hannun et al. End-to-end 음성 인식의 선구자. RNN + CTC로 음소-문자 정렬 없이 학습. HMM 없이 딥러닝만으로 ASR 가능성을 증명.

핵심 개념: End-to-end ASR, CTC loss, bidirectional RNN

자세히 물어보기

2015Listen, Attend and Spell (LAS)뼈대

Chan et al. Attention 기반 seq2seq ASR. 입력 음성의 어느 부분을 볼지 attention으로 결정. CTC의 조건부 독립 가정을 깸.

핵심 개념: Listener encoder, speller decoder, content-based attention

자세히 물어보기

2020wav2vec 2.0뼈대

Baevski et al. (Meta). 음성 자기지도학습(self-supervised). 대량의 레이블 없는 음성으로 사전학습 후 소량 레이블로 fine-tuning. ASR의 BERT.

핵심 개념: Contrastive loss, quantized speech representations, self-supervised pretraining

자세히 물어보기

2022Whisper현재 표준

Radford et al. (OpenAI). 68만 시간 웹 데이터 대규모 학습. Encoder-decoder Transformer. 99개 언어 다국어, 번역 동시 지원. 현재 가장 널리 쓰이는 ASR.

핵심 개념: Multitask training, log-mel input, timestamp prediction

자세히 물어보기

음성 생성 공부 순서: Autoregressive(WaveNet) → non-autoregressive(FastSpeech) → Diffusion 기반(DiffWave) → 최신 대형 모델(VALL-E). 속도와 품질의 트레이드오프가 발전의 축입니다.

1단계 — Autoregressive TTS

2016WaveNet뼈대

van den Oord et al. (DeepMind). Dilated causal convolution으로 고품질 음성 파형 생성. 처음으로 사람 수준 TTS 달성. 느리지만 품질의 기준을 세움.

핵심 개념: Dilated causal conv, autoregressive waveform, μ-law encoding

자세히 물어보기

2018Tacotron 2뼈대

Wang et al. (Google). 텍스트 → mel spectrogram (seq2seq) + WaveNet vocoder 구조. 자연스러운 억양·리듬 학습. 현대 TTS 2단계 파이프라인의 표준.

핵심 개념: Location-sensitive attention, stop token, mel 2단계 구조

자세히 물어보기

2단계 — Non-autoregressive / 빠른 생성

2020FastSpeech 2뼈대

Ren et al. (Microsoft). 병렬 생성으로 Tacotron 대비 수십 배 빠름. Duration, pitch, energy predictor로 운율 명시적 제어. 실용적 TTS의 기준.

핵심 개념: Non-autoregressive, duration predictor, pitch/energy control

자세히 물어보기

2021VITS

Kim et al. Variational Inference + GAN + flow 결합. 텍스트 → waveform 1단계 end-to-end. 고품질 + 실시간 속도 달성.

핵심 개념: Normalizing flow, GAN discriminator, end-to-end TTS

자세히 물어보기

3단계 — 대형 모델 / 음성 복제

2023VALL-E최신 패러다임

Wang et al. (Microsoft). 3초 음성 샘플만으로 화자 음성 복제. 언어모델처럼 audio codec token을 예측. 음성 생성의 GPT-3 모멘트.

핵심 개념: Neural audio codec, in-context learning for speech, zero-shot voice cloning

자세히 물어보기

• Semantic Segmentation: 이미지에서, 사람, 자전거, 동물 등 class 분류 만 하는것.
• Instance Segmentation: 이미지에서 사람, 자전거, 동물을 분류하는것 뿐만아니라, 사람마다, 자전거마다, 동물마다 서로 다른 Instance인지 아닌지를 구분하는것

Class Segmentation

Semantic Segmentation 주요 모델 요약 및 Instance Segmentation 추천 모델

모델 한눈에 비교

Instance Segmentation

Instance Segmentation — 현재 많이 쓰는 모델

• Class Activation Map (CAM): 딥러닝 모델에서 특정 클래스와 관련된 입력 이미지 영역을 시각화.
  GAP을 통해 각 채널의 정보를 하나의 값으로 요약함.
  FC Layer를 통해 어떤채널이 중요했는지 판단함.
• Grad-CAM:
  GAP 구조가 없이 미분을 통해 어떤채널이 결정적이었는지 역으로 계산함.

CAM vs Grad-CAM 장단점 비교

Global Average Pooling(GAP, 전역 평균 풀링)

하나의 Feature Map(채널) 전체를 평균내어 하나의 숫자로 만드는 기술.각 픽셀에 대한 정보를 1차원으로 펴고 이를 출력으로 사용.

FC Layer (완전 연결 계층)

CAM에서 FC는 1차원 정보 (예: 512개의 특징을 얼마나 강하게 나타내는지 숫자로 나타낸다면. 512길이의 1차원배열)를 가지고 그래서 이게 뭔데?

고양이인가 강아지인가 판단하는 분류기(Classifier) 역할을 함.