[논문리뷰] 기계 번역 모델의 발전방향 및 비교

Transformer는 GPT나 BERT보다도 더 먼저 등장했고, 사실 이 두 모델의 출발점이자 핵심 구조야.
GPT와 BERT는 Transformer를 기반으로 각각 다른 목적에 맞게 커스터마이징된 후속 모델

Transformer의 탄생과 핵심

발표 시기

2017년, Google의 논문
→ "Attention Is All You Need" (Vaswani et al.)

목표

기존의 RNN, LSTM 기반 번역 모델보다 빠르고 더 정확한 기계 번역 모델을 만들기 위해

Transformer의 핵심 아이디어

핵심 요소설명

Self-Attention	문장 내 단어들이 서로 어떤 관계를 맺고 있는지를 학습하여 문맥을 반영
병렬 처리	RNN은 순차적으로 학습해야 하지만, Transformer는 동시에 학습 가능
Position Encoding	순서를 알 수 없기 때문에, 위치 정보를 추가적으로 인코딩
Encoder-Decoder 구조	입력(Encoder) → 중간 표현 → 출력(Decoder) 로 이어지는 구조

✅ 1. Self-Attention: 핵심 중의 핵심

입력된 문장의 모든 단어들이 서로를 바라보며 얼마나 중요한 관계인지 점수를 매김

🧠 어떻게 작동하냐면...

Transformer는 각 단어 벡터를 다음의 세 가지로 분리해서 계산해:

Query (질문)
Key (특징의 열쇠)
Value (정보 자체)

한 단어가 다른 단어들과의 관련성을 파악하려면,
→ Query · Key 를 내적해서 중요도(Attention Score) 를 계산하고
→ 이걸 기준으로 Value 들을 가중합해서 그 단어의 문맥적 표현을 만듦.

💡 왜 중요해?

문장 안의 문맥적 관계를 동시에 학습 가능
문장의 길이와 상관없이, 전 단어를 동시에 고려
기존 RNN이나 CNN보다 훨씬 직관적이고 빠름

✅ 2. Position Encoding: 순서 정보를 넣는 장치

Transformer는 입력 순서를 몰라. 왜냐면 RNN처럼 순차적으로 처리하지 않기 때문이지.
그래서 입력 벡터에 **"이 단어가 몇 번째 위치인가"**라는 정보도 넣어줘야 해.

보통 사용하는 방식은?

사인·코사인 함수 기반의 고정된 위치 인코딩
혹은 학습 가능한 위치 임베딩
→ 입력 토큰 벡터에 위치 벡터를 더하거나 Concatenate 해서 사용

중요성?

없으면 Transformer는 단어들의 순서를 모름
문장 의미가 뒤바뀔 수 있음

✅ 3. 병렬 연산 구조: GPU 친화적

기존 RNN 계열 모델들은 단어를 순차적으로 처리했어.
Transformer는 각 단어가 동시에 Self-Attention 계산을 하므로,
→ 병렬 처리 가능 → GPU에서 훨씬 빠름

결과적으로?

학습 속도 ↑, 성능 ↑
문장 길이에 구애받지 않고 긴 문장도 잘 처리

🚀 이 3가지를 통해 Transformer가 가능하게 된 것들:

기존 RNN의 한계Transformer의 극복 방식

순차 처리 → 느림	병렬 처리 가능
장기 의존성 약함	전 범위 Self-Attention
문장 내 관계 제한적	전 단어 쌍 간 상호작용 학습 가능
순서 정보 없음	위치 인코딩으로 보완

발전 흐름 요약

1. Transformer (2017)

최초의 self-attention 기반 구조
기계번역에서 큰 성능 향상
이후 모든 NLP의 판을 바꿈

2. GPT 시리즈 (2018~)

Transformer의 Decoder 부분만 활용
왼쪽에서 오른쪽으로 단어를 생성하는 Auto-regressive 모델
목적: 언어 생성

3. BERT (2018)

Transformer의 Encoder 부분만 활용
양방향 문맥 이해가 가능한 Masked Language Modeling
목적: 언어 이해

4. T5, BART (2019~)

Transformer의 전체 구조 (Encoder + Decoder) 사용
입력과 출력을 모두 "텍스트"로 통합하는 방식
목적: 번역, 요약, QA 등 텍스트-텍스트 변환

BERT와 GPT는 각각 Transformer의 Encoder와 Decoder를 활용한 파생 모델

BERT와 GPT의 발전 배경과 그 차이점, 그리고 서로 다른 방향으로 어떻게 발전해왔는지를 구조적으로 정리해줄게.
이 두 모델은 자연어 처리(NLP)에서 Transformer 아키텍처를 기반으로 하고 있지만, 철학, 학습 방식, 목적, 진화 방향에서 큰 차이가 있어.

🔹 BERT vs GPT: 발전 배경과 발전 방향 비교

제안 시기	2018년 10월 (Google)	2018년 6월 (OpenAI GPT-1)
핵심 아이디어	깊은 양방향 문맥 이해 (Bidirectional)	왼쪽→오른쪽 방향성 기반 언어 생성 (Autoregressive)
사전 학습 목표	MLM (Masked Language Model) + NSP (Next Sentence Prediction)	LM (Language Modeling, 다음 단어 예측)
입력 구조	문장의 양쪽 문맥을 동시에 고려	왼쪽 문맥만 보고 다음 단어 예측
주 목적	언어 이해 (QA, NER, 분류 등)	언어 생성 (문장 생성, 대화 등)
파인튜닝 방식	특정 태스크에 맞춰 모델 전체 fine-tuning	전체 또는 부분 fine-tuning, 혹은 zero-shot 사용
대표 모델	BERT, RoBERTa, ALBERT, ELECTRA 등	GPT-1, GPT-2, GPT-3, GPT-4 등

1. BERT의 발전 배경과 방향

배경

이전 모델(E.g., Word2Vec, GloVe, ELMo)은 문맥이 정적인 임베딩이거나 부분적 문맥만 고려함.
ELMo는 양방향 LSTM을 썼지만, 완전한 양방향성(deep bidirectionality) 을 가진 건 아니었음.
그래서 BERT는 Transformer 기반의 구조에 masked language modeling (MLM) 을 도입해서
문장의 앞뒤를 동시에 고려해 단어를 예측하게 함.

발전 방향

다양한 변형 모델 등장:
- RoBERTa: NSP 제거, 더 많은 데이터로 학습, 성능 향상
- ALBERT: 파라미터 공유로 경량화
- ELECTRA: MLM 대신 Replaced Token Detection 사용으로 학습 효율 향상
대부분은 fine-tuning 기반의 다운스트림 적용을 전제로 한 구조
주로 QA, 문서 분류, 개체명 인식, 문장 유사도 판단 등 언어 이해 중심의 태스크에 특화

✍️ 2. GPT의 발전 배경과 방향

배경

자연어 생성 분야에서 좌측 문맥만으로도 충분한 생성 능력 확보가 목적
Transformer Decoder 구조만 사용하여, 왼쪽→오른쪽 예측만 수행
다음 단어 예측이라는 단순한 사전 학습 목적을 바탕으로 언어의 통계적 구조를 깊이 학습

발전 방향

GPT-2: 파라미터 수 확장 (1.5B), zero-shot learning 성능 실현
GPT-3: (175B 파라미터) 대규모 few-shot, zero-shot 학습의 실질적 성공
GPT-4: 멀티모달 이해, 논리 추론, 대화형 AI, 코딩 능력 등으로 AGI(범용 인공지능) 영역으로 확장

특징

문맥을 길게 기억하며 자연스러운 문장 생성
명시적 fine-tuning 없이 프롬프트 기반 학습(prompt learning) 으로 다양한 태스크 수행 가능
점점 언어 이해 + 생성 능력을 통합하는 방향으로 진화 중

🚀 최근 추세: BERT와 GPT의 경계가 허물어짐

방향설명

BERT 기반 생성 모델 등장	T5, BART: BERT의 인코더 디코더 구조를 응용해 텍스트 생성까지 가능하게 함
GPT의 이해 능력 강화	GPT-3 이후 프롬프트 설계 및 instruction tuning으로 이해 기반 태스크도 높은 성능
Unified 모델 추세	FLAN-T5, PaLM 등은 이해와 생성 모두 수행하는 모델로 발전
Multi-modal 대응	GPT-4, Gemini 등은 텍스트+이미지+음성 통합 이해로 확장

🧭 결론

BERT는 이해에 최적화된 구조로 시작해, 효율적이고 강력한 파인튜닝 기반 모델로 성장했어.
GPT는 생성에 최적화된 구조에서 시작했지만, prompt 중심으로 이해까지 장악했지.
최근은 둘의 강점을 융합한 멀티태스크 + 멀티모달 + 대규모 프롬프트 기반 통합 모델의 시대야.

"Transformer의 Encoder만 활용한다"는 말은,
Transformer 전체 구조(Encoder + Decoder) 중 "입력을 이해하는 부분"만 사용한다는 뜻이야.

BERT처럼 텍스트 이해에 집중하는 모델들은 Decoder가 필요 없기 때문에 Encoder만 따로 떼서 사용하는 거야.

✅ Transformer 전체 구조는 이렇게 생겼어

css

복사편집

[Encoder] --> [중간 표현] --> [Decoder] 입력 문장 벡터 표현 출력 문장

🔹 Encoder: 입력 문장을 이해함

문장을 토큰 단위로 잘게 쪼갠 후,
Self-Attention을 통해 단어 간 관계를 파악해서
문장의 의미를 벡터로 압축

🔹 Decoder: 새로운 문장을 생성함

위에서 받은 중간 표현을 이용해
단어를 한 글자씩 왼쪽에서 오른쪽으로 생성

✅ Encoder만 쓴다는 건 어떤 구조일까?

BERT의 경우

입력: 하나 혹은 두 개의 문장
Encoder만 사용하여 문장 전체를 동시에 이해
출력: 각 단어 혹은 전체 문장에 대한 이해된 벡터 표현
예시 작업: 문장 분류, 질문에 대한 문맥 이해, 개체명 인식 등

css

복사편집

[입력] --> [Encoder (Self-Attention)] --> [출력: 이해된 표현]

Decoder는 아예 없음!
생성은 하지 않음. 오직 이해만.

🔁 GPT는 왜 Decoder만 쓸까?

GPT는 "생성" 중심 모델이라서,

이전 단어들을 보고 다음 단어를 한 글자씩 예측하는 게 중요해.
그래서 Decoder만 단독으로 쓰고, Encoder는 사용하지 않아.

이때 사용되는 Decoder는:

"미래 단어"를 못 보게 막은 Masked Self-Attention 사용
예측할 단어의 왼쪽 정보만 보고 한 글자씩 생성

css

복사편집

[앞쪽 단어] --> [Decoder] --> [다음 단어 예측]

✅ 다시 정리: Encoder만 사용한다는 것의 의미

항목의미

구조적 의미	Transformer 전체 중 Encoder 블록만 떼어 사용
목적	문장의 의미를 벡터로 정확히 이해하는 데 집중
대표 모델	BERT, RoBERTa, DistilBERT 등
장점	문맥을 양방향으로 보며 정확한 이해 가능
단점	텍스트 생성은 불가능 (Decoder 없으니까)

🎯 결론

"Encoder만 사용한다"는 건
👉 Transformer 구조 중 입력 이해에 해당하는 부분만 활용해서
👉 문장, 문맥, 관계, 의미를 해석하는 데 초점을 맞추는 방식이야.

BERT와 RoBERTa는 겉으로 보면 거의 비슷하지만, 학습 방식에서 전략적으로 달라진 부분들이 존재해.
이 차이들은 실제 성능에도 꽤 큰 영향을 줘.
한 줄로 요약하면:

RoBERTa는 BERT 구조는 그대로 두고, 학습 방법을 정밀하게 최적화한 개선판이야.

🧠 구조 비교 요약표

항목BERT vs RoBERTa

구조 (Transformer)	100% 동일	동일
Next Sentence Prediction (NSP)	사용함	사용 안 함
학습 데이터 양	약 16GB (BookCorpus + Wikipedia)	약 160GB (더 방대하고 다양함)
Masking 방식	static (고정된 마스킹)	dynamic (매 학습 반복마다 새로 마스킹)
학습 에폭	40만 step (1M 에폭 미만)	50만 step 이상으로 장시간 학습
배치 사이즈	256	8천 이상으로 크게 확장
성능	우수	대부분의 GLUE/SQuAD에서 우위

✅ 주요 차이점 설명

1. ❌ NSP (Next Sentence Prediction) 제거

BERT는 두 문장이 이어지는지 예측하는 NSP task를 pretraining에 포함했어.
RoBERTa는 실험적으로 NSP가 큰 효과가 없다고 판단하고 제거함.
오히려 NSP 제거가 일부 task에서 더 좋은 성능을 냈음 (예: 자연어 추론, QA).

2. 📚 훨씬 더 방대한 학습 데이터

BERT: Wikipedia + BookCorpus → 약 16GB
RoBERTa:
- CC-News
- OpenWebText
- Stories
- Wikipedia + BookCorpus
  → 총 약 160GB 이상의 데이터 사용
이 덕분에 일반화 능력이 월등히 향상됨.

3. 🎯 Dynamic Masking (동적 마스킹)

BERT는 마스크할 토큰을 처음부터 고정(static)해서 학습함.
RoBERTa는 학습 중 반복마다 다른 토큰을 랜덤하게 마스킹함.
이 방식이 더 다양한 문맥을 학습하게 해주고, 과적합 방지 효과도 있음.

4. ⏱ 긴 학습 시간 & 큰 배치 사이즈

RoBERTa는 배치 사이즈와 학습 step 수를 크게 증가시켜서 훨씬 더 충분한 학습을 진행함.
결과적으로 안정적인 수렴과 성능 향상이 나타남.

📌 그림으로 한눈에

scss

복사편집

구조는 같지만, ┌──────────────────────┐ │ BERT (기본형) │ └──────────────────────┘ ▲ │ 구조는 동일 ▼ ┌──────────────────────┐ │

RoBERTa (개선형) │ └──────────────────────┘

- NSP 제거 - 더 많은 데이터 - 동적 마스킹 - 더 긴 학습 - 더 큰 배치 사이즈

✅ 결론

RoBERTa는 BERT의 구조는 건드리지 않고, 학습 세팅을 고도화한 결과물
이런 작은 전략 차이들이 현실 성능에서 꽤 큰 차이를 만들어냄
따라서 실전에서는 RoBERTa가 BERT보다 더 강력한 선택지가 되는 경우가 많아

NSP(Next Sentence Prediction)는 원래 BERT에서 두 문장이 논리적으로 이어지는지를 맞추는 이진 분류 과제로 pretraining에 포함됐지.
하지만 RoBERTa에서는 실험 결과 NSP가 큰 효과가 없거나 오히려 방해가 되는 경우도 있다는 걸 보여주면서 과감히 제거했어.

🔍 NSP를 제거한 이유

1. 실제 task와의 불일치 (Mismatch)

BERT의 NSP는 "A 문장 다음에 B 문장이 오니?"를 맞추는 구조야.
그런데 실제 downstream task들(NLI, QA 등)은 문장 간의 관계를 더 복잡하게 요구해.
단순한 NSP 방식은 그 관계를 충분히 일반화하거나 포착하지 못해.

2. 학습 리소스를 덜 의미 있는 task에 낭비

NSP는 전체 학습 중 일부 자원을 소모해.
하지만 실제로는 문맥 정보 학습에 크게 기여하지 않는다는 증거가 있었음.
RoBERTa는 이걸 제거하고 masked language modeling(MLM)에만 집중해서 성능을 더 끌어올렸어.

3. 실험 결과에서 성능 하락이 없거나, 오히려 상승

RoBERTa 논문에 따르면 NSP를 제거해도:
- QNLI, MNLI, SQuAD, RTE 같은 문장쌍 과제들에서 성능이 유지되거나 향상
- 특히 SQuAD 같은 QA task에서는 오히려 + 성능 향상

📊 실험 요약 (RoBERTa 논문 기반)

모델NSP 포함 여부QNLIMNLISQuAD

BERT (base)	✅ 포함	낮음	낮음	낮음
BERT (no NSP)	❌ 제거	↑	↑	↑
RoBERTa	❌ 완전 제거	최고	최고	최고

🧠 결론

NSP는 이론상으론 문장 관계 학습에 도움될 것처럼 보였지만,
실제로는 모호한 정의와 과도한 단순화로 인해 효과가 미미했고,
제거하는 것이 더 효율적인 pretraining 방식으로 판명되었어.

🔁 예시로 보는 한계

plaintext

[문장 A]: 그는 아침에 운동을 갔다.

[문장 B]: 햇빛이 따가웠다.

→ NSP는 이어지는 문장으로 볼 수도 있고 아닐 수도 있어. 모호함.

→ 이런 애매한 문장을 정답/오답으로 나누는 게 학습 효율이 떨어짐.

BERT의 입력 토큰 구성 방식은 그 자체로도 이 모델의 다재다능함을 설명해주는 포인트야.

✅ BERT 입력 구조 요약

BERT는 다음과 같은 세 가지 임베딩의 합을 입력으로 사용해:

Token Embedding: 각각의 단어(WordPiece)를 숫자로 변환
Segment Embedding: 문장 A / 문장 B를 구분하기 위한 구간 정보
Position Embedding: 순서를 표현하기 위한 위치 정보

🔠 예시: 문장쌍 입력 구조

plaintext

복사편집

[문장 A]: 오늘 날씨가 좋다

[문장 B]: 그래서 산책을 나갔다

→ BERT 입력: [CLS] 오늘 날씨 가 좋 다 [SEP] 그래서 산책 을 나 갔 다 [SEP]

그리고 각 단어는 WordPiece로 쪼개져서 token화됨.

🧩 특수 토큰의 역할

토큰위치역할 설명

[CLS]	문장 맨 앞	전체 입력을 대표하는 특수 토큰. → 분류 task에서 사용됨 (예: 감정 분석, 문장 관계 예측 등)
[SEP]	문장 끝	문장 A와 문장 B 사이를 구분하거나, 단일 문장의 끝을 명시함

📌 각 토큰의 실제 활용

▶️ [CLS] 토큰

항상 입력의 제일 앞에 위치
이 토큰의 최종 출력(hidden state)은 전체 시퀀스의 요약 벡터로 사용돼
예: 감정 분류, 문장 관계 판단, NSP 등에서
→ [CLS] 벡터를 분류기에 전달함

🧱 [SEP] 토큰

문장 간 경계 역할
단일 문장에서도 문장의 끝을 명확히 구분하기 위해 사용돼
QA(Task)에서는:
- [CLS] 질문 [SEP] 문서 내용 [SEP]
- 이렇게 해서 질문과 문서를 구분함

🎯 시각화 구조 예시 (문장쌍)

less

복사편집

Input Text:

[CLS] 그는 아침에 운동을 갔다 [SEP] 날씨가 좋아서 기분이 좋았다 [SEP]

Token Embedding: [CLS], 그는, 아침, ##에, ..., [SEP], 날씨, ##가, ..., [SEP]

Segment Embedding: A A A A ... A B B B ... B

Position Embedding: 0 1 2 3 ... n n+1 n+2 ...

🧠 정리하면

구성 요소목적

[CLS]	전체 문장을 대표하는 요약 벡터
[SEP]	문장 경계 구분
Token Embedding	단어 의미 표현
Segment Embedding	문장 A와 B 구분
Position Embedding	순서 정보 반영

✅ BERT의 전체 구조 요약

BERT는 크게 아래의 구조로 동작해:

1. 입력 처리 (Input Representation)

[CLS] + 문장 A + [SEP] + 문장 B + [SEP] 형태로 입력
각 토큰은 Token Embedding + Segment Embedding + Position Embedding이 더해져서 Transformer에 입력됨

2. Transformer Encoder Layer (12~24층)

BERT는 Transformer의 Encoder 부분만 사용
각 Encoder Layer는 다음을 포함:
- Multi-Head Self-Attention
- Feed-Forward Neural Network
- LayerNorm, Residual Connection 등

➡️ 입력된 토큰들 각각이 서로를 참조(Attention)하며 점점 더 깊이 있는 의미를 갖는 벡터로 변환됨

3. Output 활용 방식 (task별 차이)

🔹 분류(Classification)

[CLS] 토큰의 최종 벡터 → 분류기(Linear layer)로 전달

🔹 문장쌍 관계(NLI)

[CLS] 토큰 벡터 → 두 문장의 관계 분류

🔹 QA (질의응답)

질문 + 문서를 입력으로 넣고
각 토큰에 대해 시작 위치 / 끝 위치 확률을 계산함

🔹 NER 등 token-level task

각 토큰의 출력 벡터를 태깅기에 연결 (예: 개체명 인식)

📊 시각적 구조

직접 보기 좋게 BERT 구조의 이미지 다이어그램도 첨부했어 👇
(Transformer Encoder를 중심으로 전체 흐름을 보여줌)

![BERT 구조](sandbox:/mnt/data/A_flowchart_diagram_illustrates_the_BERT_(Bidirect.png)

📌 핵심 요약

단계구성 요소설명

1	입력 준비	[CLS] 문장 A [SEP] 문장 B [SEP] 형태로 Token, Segment, Position Embedding 결합
2	Transformer Encoder 반복	Self-Attention으로 문맥적 의미 강화 (12~24층 반복)
3	Task-specific Head	[CLS] 또는 각 토큰 벡터를 task별로 분류, 태깅 등 처리

Transformer Encoder Layer는 말이 어렵지, 실제로는 입력 문장에 있는 단어들(토큰)이 서로를 살펴보며 의미를 이해하는 층이야.

✅ 핵심 개념: “모든 단어가 서로를 바라본다” = Self-Attention

먼저 이 그림 하나 그려보자:

bash

복사편집

입력 문장: "그는 아침에 운동을 갔다"

각 단어: [그는] [아침] [##에] [운동] [##을] [갔다]

이 문장이 Transformer Encoder에 들어가면, 각 단어는 자기 자신뿐 아니라 다른 단어들도 함께 참고해서 "내가 어떤 의미인지" 판단해.

🔍 Self-Attention 동작 원리 요약

✨ “나는 어떤 단어에 더 주목해야 의미가 살아날까?”
모든 단어가 이런 질문을 던지고, 스스로 중요한 단어에 Attention을 주는 방식

예시로:

"운동"이라는 단어는 "갔다"나 "아침"을 주목해야 문장이 이해됨
반대로 "그는"은 "갔다"와 "운동" 둘 다 중요

→ 이걸 수학적으로 처리하는 게 Self-Attention이고, 그걸 여러 방향(Head)으로 반복하는 게 Multi-Head Self-Attention이야.

🧱 Transformer Encoder Layer 구성 그림

각 층은 이렇게 구성돼:

mathematica

복사편집

[입력 임베딩] ↓ Multi-Head Self-Attention ↓ Add & Layer Norm ↓ Feed Forward Neural Net ↓ Add & Layer Norm ↓ [출력 임베딩] ← 다음 층 입력

이걸 12번 반복하는 게 BERTBASE, 24번이면 BERTLARGE

🔄 Residual Connection과 LayerNorm

Residual Connection:
→ 각 층의 출력에 원래 입력을 더해줌 (정보 손실 방지)
LayerNorm:
→ 벡터 값을 정규화해서 학습을 안정화시킴

📌 최종적으로는?

각 단어는 주변 모든 단어를 보고 “문맥 기반 의미 벡터”를 얻게 돼
12층, 24층을 거치며 점점 더 복잡하고 깊은 의미로 진화함

예시: "은행에 갔다"라는 문장에서

"은행"은 앞 문맥에 따라 의미가 달라짐
→ "물가 근처의 은행" (riverbank)
→ "돈을 찾으러 은행에 갔다" (bank)

→ Self-Attention이 앞뒤 단어를 함께 보고, 적절한 의미를 잡아주는 것

요약하면

구성설명

Self-Attention	단어가 모든 다른 단어를 함께 바라보며 중요도 계산
Multi-Head	다양한 시각으로 의미를 해석함 (병렬 attention)
Feed Forward	각 토큰에 비선형 변환 적용, 더 복잡한 표현 가능
Residual & LayerNorm	학습 안정화, 정보 손실 방지
Stacked Layers	12~24층 반복하며 의미를 점점 더 풍부하게 확장

이제 Self-Attention을 수학적으로 어떻게 계산하는지를 예시와 함께 단계별로 설명해줄게.
복잡한 공식처럼 보일 수 있지만, 실제로는 **"입력 단어들 간의 중요도(유사도)를 계산해서 가중 평균을 내는 것"**이 전부야.

✅ Self-Attention 수학적 구조

Self-Attention의 핵심 공식은 아래와 같아:

Attention(Q,K,V)=softmax(QKTdk)V\text{Attention}(Q, K, V) = \text{softmax}\left( \frac{QK^T}{\sqrt{d_k}} \right) V

이게 의미하는 걸 단계별로 쪼개볼게.

💡 용어 정리

기호의미

Q (Query)	내가 지금 "관심 가지려는" 토큰의 벡터
K (Key)	모든 토큰의 "특징" 벡터 (자신 포함)
V (Value)	모든 토큰의 "정보" 벡터
dkd_k	Key의 차원 수 (정규화용)
Softmax	유사도 → 확률화

📌 Step-by-Step 예시

문장:

"나는 너를 좋아해"

토큰 임베딩을 단순하게 아래와 같이 가정해보자 (실제론 768차원 정도지만, 우리는 3차원으로 축소해서 설명):

plaintext

복사편집

"나" → [1, 0, 1]

"는" → [0, 1, 0]

"너" → [1, 1, 0]

"를" → [0, 0, 1]

"좋아해"→ [1, 0, 0]

Step 1: 임베딩 → Q, K, V로 변환

각 단어의 임베딩에 Wq, Wk, Wv 라는 학습 가능한 가중치 행렬을 곱해서 각각 Query, Key, Value로 만듦.

plaintext

복사편집

Q = X × Wq K = X × Wk V = X × Wv

예시로 "나"에 대한 Q는 [1, 0, 1] × Wq 가 되고,
전체 문장에 대한 K, V는 모든 단어에 대해 계산됨.

Step 2: 유사도 계산

"나"라는 Query 벡터와 모든 단어의 Key 벡터 간 내적 (dot product)을 수행해서 얼마나 관련 있는지를 수치로 계산함:

plaintext

복사편집

[Q나] · [K나] → 유사도 점수

[Q나] · [K는] → 유사도 점수 ... 등

→ 이 유사도 점수들이 softmax를 통해 확률로 바뀌어 가중치가 됨.

Step 3: Value 가중 평균

plaintext

복사편집

Attention 결과 = ∑ (softmax 가중치 × 각 V)

즉, 나에 대해 중요한 단어들에 더 많은 가중치를 주고,
그들의 정보를 합쳐서 새로운 벡터로 만드는 거야.

🔄 이걸 Head를 여러 개로 반복하면?

Multi-Head Self-Attention은 이 과정을 여러 번 평행하게 진행해서 다양한 관계를 학습함.

예를 들어:

Head 1은 "문법적 관계 (주어-동사)"
Head 2는 "감정적 강조 (좋아해-너)"
Head 3은 "위치적 거리 고려"

→ 각각 따로 Attention을 한 후, 다 합쳐서 최종 결과 벡터를 구성함.

📌 정리하면

단계설명

1. Q/K/V 생성	각 단어를 서로 다른 관점에서 변환
2. Q · K 계산	유사도 점수 계산
3. softmax	유사도를 확률로 변환
4. V와 곱합	중요한 단어일수록 더 많이 반영됨
5. Head 여러개	다양한 의미 관계 병렬 학습

🔁 실제 효과

예를 들어 "나는 너를 좋아해"에서 "좋아해"는 주어("나")와 목적어("너")를 모두 고려해야 의미가 분명해지지?

→ 이 구조가 바로 그 관계를 스스로 찾아내고 반영하는 방식이야.

우리가 아까 얘기했던 문장 "나는 너를 좋아해" 하나를 가지고 Self-Attention이 어떻게 작동하는지 처음부터 끝까지 수학적으로 계산해볼게.
이해를 쉽게 하려고 벡터 차원 수는 2로 단순화할게.

✅ Step 0: 입력 문장 임베딩

문장: "나는 너를 좋아해"
→ 토큰화: ["나", "는", "너", "를", "좋아해"]
각 토큰을 2차원 벡터로 임의 설정:

토큰임베딩

나	[1, 0]
는	[0, 1]
너	[1, 1]
를	[0, 0]
좋아해	[1, 2]

✅ Step 1: Q, K, V로 변환

가중치 행렬도 단순화해서 고정하자:

WQ=[1001]W_Q = \begin{bmatrix}1 & 0 \\ 0 & 1\end{bmatrix}
WK=[0110]W_K = \begin{bmatrix}0 & 1 \\ 1 & 0\end{bmatrix}
WV=[111−1]W_V = \begin{bmatrix}1 & 1 \\ 1 & -1\end{bmatrix}

예를 들어, “나”의 임베딩 [1, 0]에 Q를 곱하면:

Q"나"=[1,0]⋅WQ=[1,0]Q_{\text{"나"}} = [1, 0] \cdot W_Q = [1, 0] K"나"=[1,0]⋅WK=[0,1]K_{\text{"나"}} = [1, 0] \cdot W_K = [0, 1] V"나"=[1,0]⋅WV=[1,1]V_{\text{"나"}} = [1, 0] \cdot W_V = [1, 1]

모든 토큰에 대해 Q, K, V를 계산해보자:

토큰QKV

나	[1, 0]	[0, 1]	[1, 1]
는	[0, 1]	[1, 0]	[1, -1]
너	[1, 1]	[1, 1]	[2, 0]
를	[0, 0]	[0, 0]	[0, 0]
좋아해	[1, 2]	[2, 1]	[3, -1]

✅ Step 2: Attention 유사도 계산

우리는 지금 “나”라는 단어에 대해 Attention을 계산한다고 해보자.

Q"나"=[1,0]Q_{\text{"나"}} = [1, 0]
나머지 토큰들의 K와 dot product (내적) 계산:

Q⋅KT=[1,0]⋅Ki=Ki[0]Q \cdot K^T = [1, 0] \cdot K_i = K_i[0]

TokenKQ · K (score)

나	[0, 1]	1 × 0 + 0 × 1 = 0
는	[1, 0]	1 × 1 + 0 × 0 = 1
너	[1, 1]	1 × 1 + 0 × 1 = 1
를	[0, 0]	0
좋아해	[2, 1]	1 × 2 + 0 × 1 = 2

✅ Step 3: Softmax로 정규화

정규화를 위해 softmax 적용:

Softmax(si)=esi∑esj\text{Softmax}(s_i) = \frac{e^{s_i}}{\sum e^{s_j}}

계산:

e0=1,e1≈2.718,e2≈7.389e^0 = 1,\quad e^1 ≈ 2.718,\quad e^2 ≈ 7.389

합계:

1+2.718+2.718+1+7.389=14.8251 + 2.718 + 2.718 + 1 + 7.389 = 14.825

가중치:

TokenScoreSoftmax Weight

나	0	1 / 14.825 ≈ 0.067
는	1	2.718 / 14.825 ≈ 0.183
너	1	2.718 / 14.825 ≈ 0.183
를	0	1 / 14.825 ≈ 0.067
좋아해	2	7.389 / 14.825 ≈ 0.498

✅ Step 4: V와 곱해서 가중 평균

각 토큰의 V 벡터에 가중치를 곱해서 모두 더함:

Attention 결과=∑Softmaxi×Vi\text{Attention 결과} = \sum \text{Softmax}_i × V_i =0.067×[1,1]+0.183×[1,−1]+0.183×[2,0]+0.067×[0,0]+0.498×[3,−1]= 0.067×[1,1] + 0.183×[1, -1] + 0.183×[2, 0] + 0.067×[0,0] + 0.498×[3, -1]

하나씩 계산:

[1,1] × 0.067 → [0.067, 0.067]
[1, -1] × 0.183 → [0.183, -0.183]
[2, 0] × 0.183 → [0.366, 0]
[0, 0] × 0.067 → [0, 0]
[3, -1] × 0.498 → [1.494, -0.498]

다 합치면:

=[0.067+0.183+0.366+0+1.494,0.067−0.183+0−0−0.498]=[2.11,−0.614]= [0.067 + 0.183 + 0.366 + 0 + 1.494, 0.067 - 0.183 + 0 - 0 - 0.498] = [2.11, -0.614]

✅ 결과

**“나”**라는 토큰은 주변 단어들의 정보를 종합해서
**새로운 벡터 [2.11, -0.614]**로 업데이트됨.
이 벡터는 다음 Encoder Layer로 전달돼 더 깊은 의미를 학습해.

🧠 요약

개념설명

Q, K, V	Query로 관심 갖고, Key로 비교하고, Value로 정보 추출
Dot Product	유사도 계산
Softmax	유사도를 확률로 변환
V의 가중 평균	최종 결과 생성

1. 도입 (Introduction)

Transfer Learning & Pretraining의 흐름
BERT의 혁신과 한계
RoBERTa의 등장 배경

Point: “BERT는 강력했지만, 최적화가 충분하지 않았다.”

2. BERT vs RoBERTa: 핵심 차이점 요약

한 슬라이드로 요약해두면 이후 설명이 쉬워짐

항목BERTRoBERTa

NSP 사용	✅ Yes	❌ No
학습 데이터 크기	16GB	160GB
학습 Step 수	1M	500K ~ 1.5M
배치 크기	작음	큼
동적 마스킹	❌ No	✅ Yes

3. 실험 구성과 Ablation Study

No NSP → 더 나은 성능
더 큰 데이터 → 안정적인 향상
Dynamic Masking → overfitting 줄임
Batch size와 Learning rate 튜닝 → 성능 강화

Point: “모델 아키텍처 변경 없이도 최적화만으로 BERT를 능가할 수 있다”

4. GLUE, SQuAD, RACE 등에서의 성능 개선

다양한 다운스트림 태스크에서의 수치 비교
RoBERTa가 GPT보다도 높은 성능을 달성함

그래프로 시각화: 성능 차이 강조
Point: “정제된 학습법 하나로 SOTA를 달성”

5. RoBERTa가 보여주는 시사점

사전학습의 강력함과 중요성 재확인
"더 큰 데이터 + 더 오래 학습 + 튜닝 = 더 나은 모델"
모델 구조보단 학습 전략의 중요성

Point: “RoBERTa는 더 나은 ‘훈련 방법론’의 사례다”

6. 한계와 후속 연구 방향

학습 비용이 너무 큼 (대규모 연산 자원 필요)
이후 등장한 ELECTRA, DeBERTa, ALBERT 등과의 비교
Multi-lingual 확장성과 다양한 언어 적용의 필요성

Point: “RoBERTa는 BERT의 다음 단계지만, 아직 끝은 아니다”

7. 결론 및 Q&A

BERT를 넘어서는 사전학습 모델의 전략
실무적 적용과 일반화 가능성
여러분이 실무에 응용한다면?

🎯 발표 전략 팁

BERT를 먼저 간단히 설명하고 → 그걸 개선한 게 RoBERTa임을 강조
각 실험이 왜 중요한지 → 성능 향상과 논리로 연결
질문 유도 포인트: "NSP는 꼭 필요할까?", "모델 구조를 안 바꾸고 성능 향상 가능?"

🔢 BERT가 단어를 맞추는 과정 = "수학적으로 단어를 이해하고 비교하는 과정"

1. 단어는 숫자로 바뀌어요 (→ 임베딩 벡터로 변환)

BERT는 '고양이', '개', '사과' 같은 단어를 그대로 다루지 않고,
각 단어를 **숫자들의 모임(벡터)**으로 바꿔서 계산해.

예시)

"고양이" → [0.21, -0.33, 0.56, ..., 0.10] (768차원 벡터)
"사과" → [0.02, 0.65, -0.23, ..., 0.91]

이걸 Word Embedding이라고 해.
벡터끼리의 방향, 거리, 각도 등을 비교해서 뜻이 비슷한지도 알아낼 수 있어.

2. 벡터들끼리 서로 '참조(Attention)'해요

예를 들어 BERT가 아래 문장을 이해하려고 해:

"철수가 사과를 먹었다."

이 문장에서 "먹었다"를 보면, 누가 먹었는지(→ 철수),
**무엇을 먹었는지(→ 사과)**를 알아야 하잖아?

그래서 BERT는 모든 단어의 벡터를 서로 비교해
→ "이 단어가 다른 단어들과 얼마나 중요한 관계가 있는지" 계산해

이 수식을 Self-Attention이라고 해.

Attention(Q,K,V)=softmax(QKTdk)V\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V

여기서 Q, K, V는 각각 Query, Key, Value
각 단어의 벡터에서 Q, K, V를 뽑아서 서로 곱하고, softmax로 중요도 계산
중요한 애들한테 더 가중치를 줘서 정보 모으는 구조야

3. 이 과정을 여러 방향(Head)으로 반복해요

→ Multi-Head Attention

한 번의 Attention으로는 다양한 관계를 다 보기 힘들어
예를 들어:

누가 주어인지?
목적어는 뭔지?
문맥상 강조되는 단어는 뭔지?

그래서 여러 개의 'Head'로 나눠서 각기 다른 관점으로 Attention해
그리고 마지막엔 다시 모두 합쳐서 더 풍부한 의미를 가진 벡터를 만들어.

4. 마지막에는 [MASK] 자리를 예측

Self-Attention과 FeedForward를 거친 후,
마지막 벡터에서 [MASK] 자리에 들어갈 단어가 뭐일지 확률을 계산해.

예를 들어:

"나는 아침에 [MASK]를 먹었다."
→ BERT는 수많은 계산 끝에 "빵" 확률이 가장 높다고 판단하면
→ [MASK] = "빵"으로 예측해!

요약하자면,

단어 → 숫자(벡터) → 벡터 간 관계 계산(Self-Attention)
→ 여러 방향으로 관찰(Multi-Head) → 벡터로 의미 파악 → 단어 예측

이제는 자연어 처리(NLP) 모델들이 어떻게 발전해왔는지
큰 그림을 BERT, GPT 중심으로 정리해줄게.

🧭 언어 모델 발전 역사: GPT vs BERT 중심 흐름

📍1. RNN, LSTM, GRU 시대 (2014년 이전~2017년 초)

단어를 하나씩 순차적으로 처리 (Left → Right)
대표 모델: RNN, LSTM, GRU
문맥은 고려할 수 있었지만,
- 병렬처리가 불가능하고
- 긴 문장에서는 앞의 정보가 쉽게 사라짐 (장기 의존성 문제)

➡️ 그래서 복잡한 문장은 잘 못 이해하거나, 학습 속도가 매우 느렸음.

📍2. Attention 탄생 – Transformer (2017, Vaswani et al.)

“모든 단어가 모든 단어를 동시에 바라보게 하자”

핵심: Self-Attention
기존 순차적인 구조를 버리고 병렬 처리 가능하게 설계
구조는 2파트로 나뉨:
- Encoder: 입력 문장 이해 (BERT가 사용)
- Decoder: 문장 생성 (GPT가 사용)
논문 제목: “Attention is All You Need”

📍3. BERT의 등장 (2018, Google)

“문장을 양방향으로 이해하자”

✅ 핵심 특징

Transformer의 Encoder만 사용
한 단어 앞뒤 양쪽 문맥 모두 보는 양방향 구조
학습 방식:
- MLM (Masked Language Modeling): 문장 중간 일부를 [MASK]로 가리고 맞추기
- NSP (Next Sentence Prediction): 문장이 이어지는지 판단

🎯 효과

문장/문단 이해에 탁월 → QA, NER, 분류 등 이해 중심의 NLP 태스크에 강함

📍4. GPT 시리즈의 등장 (2018~, OpenAI)

“문장을 왼쪽에서 오른쪽으로 자연스럽게 이어 써보자”

✅ 핵심 특징

Transformer의 Decoder만 사용
문장을 왼쪽 → 오른쪽으로 순차적으로 생성 (Unidirectional)
학습 방식: 다음 단어 예측
예: “나는 아침에 빵을” → 다음 단어 “먹었다” 예측

🎯 효과

텍스트 생성 능력이 뛰어남 → ChatGPT, 소설/에세이/답변 생성 등 생성 중심의 NLP 태스크에 강함

📍5. RoBERTa, ALBERT, XLNet 등 BERT 후속들

모델차별점

RoBERTa	NSP 제거, 더 많은 데이터, 더 긴 학습시간 (성능 ↑)
ALBERT	파라미터 공유로 모델 경량화
XLNet	BERT의 [MASK] 방식 한계 보완 (Permutation LM)
ELECTRA	[MASK] 대신 ‘진짜 단어 vs 가짜 단어’ 구별 방식 사용

📍6. 최근 흐름 (T5, BART, GPT-4, Claude 등)

통합형 모델 (Encoder + Decoder 구조): 번역, 생성, 이해 모두 가능
- T5, BART: “모든 태스크를 텍스트→텍스트로 바꿔 처리”
초대형 모델 시대: GPT-3, GPT-4, Claude, Gemini 등
- 수천억~수조 파라미터
- Few-shot, Zero-shot, Prompt 학습 활용 가능

🧠 비유로 이해하자

모델비유

RNN	책을 처음부터 한 장씩 읽는 독자
BERT	책을 앞뒤로 왔다 갔다 하며 요점 정리하는 독자
GPT	책 스타일을 파악해 직접 이어 써보는 작가
T5/BART	읽고 쓰고 다 하는 국어 만능 전문가

📌 핵심 정리

Transformer = 혁명적인 구조
BERT = 이해를 위한 양방향 학습
GPT = 생성을 위한 왼쪽→오른쪽 학습
RoBERTa 등 = BERT를 더 정교하게 만든 모델

'개인 프로젝트 > [LLM] 논문리뷰' 카테고리의 다른 글

[논문리뷰] GPT-1 (0)	2025.04.07
[논문리뷰] RoBERT 언어모델 발표자료 (0)	2025.04.06
[논문리뷰] BERT-RoBERTa (0)	2025.04.01
[논문] BERT : Bidirectional Encoder Representations from Transformers (0)	2025.03.31
[논문] RNN_2014_Sequence to Sequence Learning with Neural Networks (0)	2025.03.24

내 블로그 - 관리자 홈 전환	`Q` `Q`
새 글 쓰기	`W` `W`

글 수정 (권한 있는 경우)	`E` `E`
댓글 영역으로 이동	`C` `C`

이 페이지의 URL 복사	`S` `S`
맨 위로 이동	`T` `T`
티스토리 홈 이동	`H` `H`
단축키 안내	`Shift` + `/` `⇧` + `/`