https://arxiv.org/abs/2402.09906
기존 모델들은 생성만 잘하거나, Embedding만 잘 진행하였습니다.
그리하여 둘 다 잘 하도록 두개 다 학습을 진행한 GRIT이 등장합니다.
생성과 Representation 모두 진행하여 학습하는 것을 볼 수 있다.
임베딩에서는 양방향 Attention을 사용하고, 생성에서는 단방향 Attention을 진행하는 것을 볼 수 있습니다.
진짜 단순한 아이디어였고, Loss도 어려운 수식이 아닙니다.
Closed Model인 OpenAI를 이기는 모습을 볼 수 있습니다.
Embedding 성능에서 높은 성과를 보이는 것을 볼 수 있습니다.
여기서 8X7B의 성능이 낮은 이유는 배치가 작아졌다는 이유라고 말합니다.
여기선 생성형 능력을 볼 수 있습니다.
생성형으로 Reranking을 진행할 수 있어 더 높은 성능을 기대할 수 있다고 합니다.
또 Few-Shot은 안통한다고 합니다.
데이터 셋에 Few-Shot이 거의 없다고 저자는 말합니다.
강화학습을 진행하면 MTEB 성능(Embedding)은 조금씩 떨어지지만 생성능력은 강화됩니다.
이미지에 보이듯 전통적인 RAG와 다르게 같은 모델을 사용한다는 장점으로 캐싱을 사용할 수 있었습니다.
캐싱으로 저장된 값은 뒤에 사용하여 컴퓨팅을 절약할 수 있습니다.
쿼리 캐싱은 양이 적기 때문에 적은 양만 캐싱하고, 연산에 사용하여 연산량을 조금 줄일 수 있습니다.
DOC 캐싱은 캐싱할 양도 많고, 추후에 연산량도 많이 줄이기에 저장공간이 많다면 사용할 수 있는 방법이지만, 문서의 양이 많기에 초기 인덱스 구축 시 계산 비용이 증가한다고 합니다.
두가지를 모두 캐싱하면 연산이 되지 않아 성능에 악화가 생길 수 있습니다.
용량은 엄청나게 잡아먹지만 성능, 시간이 좋아지는 것을 확인할 수 있습니다.
캐싱에 따라 CPU, GPU 잡아먹는 것도 엄청 다릅니다.
이렇게 하려고 하는 것이기에...
재미있는 연구가 될 것 같습니다.
| 문제 정의 | - 임베딩과 생성 작업을 위해 별도 모델 사용 시 비효율 발생 - 하나의 모델이 두 작업을 동시에 잘 수행하는 방법 필요 |
🔑 임베딩 + 생성 통합 모델 필요성 제기 |
| 제안 방법 (GRIT) | - GRITLM: 임베딩과 생성 작업을 하나의 모델로 통합 - 두 작업을 위한 손실 함수 통합: - 임베딩: 대조적 손실(contrastive loss) - 생성: 언어 모델링 손실(language modeling loss) |
✅ 단일 모델로 두 작업 수행 ✅ 성능과 효율성 동시 확보 |
| 훈련 설정 | - 모델: Mistral 7B, Mixtral 8x7B - 데이터: E5(+S2ORC) → 임베딩, Tülu 2 → 생성 - 배치 크기: - 임베딩: 최대 2048 - 생성: 256 - 총 1253 스텝 훈련 |
🔑 큰 배치로 임베딩 품질 향상 ✅ 생성-임베딩 동시 훈련 최적화 |
| 성능 평가 | - MTEB (임베딩): SOTA 달성 - HumanEvalSynthesize (생성): 기존 모델보다 우수 - RAG: No RAG 대비 성능 개선 |
🏆 임베딩 + 생성 모두에서 최첨단 성능 달성 |
| Reranking 실험 | - GRITLM으로 임베딩 + 재정렬(reranking) 수행 가능 - 대부분 데이터셋에서 재정렬 시 성능 개선 - 평균 성능: 57.4 → 57.9 (+0.5) |
✅ 단일 모델 재정렬 성능 우수 🔥 추론 비용 절감 |
| RAG 최적화 및 캐싱 방법 | - 쿼리 캐싱(Query Caching): - 쿼리 계산 제거 → 속도 ↑, 성능 약간 ↓ - 문서 캐싱(Doc Caching): - 문서 계산 제거 → 속도 ↑, 성능 ↑ - 쿼리-문서 캐싱(Query-Doc): - 최대 속도 ↑, 성능 ↓ |
🔑 캐싱으로 최대 63% 속도 향상 ✅ Doc Caching: 성능+속도 최고 |
| 지연 시간 분석 (Latency) | - 4000 토큰 기준: - Query Caching: CPU +54%, GPU +33% 속도 향상 - Doc Caching: CPU +63%, GPU +31% 속도 향상 - 긴 문서 → Doc Caching, 긴 쿼리 → Query Caching 추천 |
⚡ 캐싱 방식에 따라 큰 속도 향상 가능 |
| 저장 비용 (Storage) | - 전통 RAG: 문서 텍스트 + 임베딩 저장 필요 - Doc Caching: 텍스트 대신 key-value states 저장 - 저장 비용: - 2.68M 문서 기준 약 30TB - 문서당 약 12.5MB 필요 |
🗂️ 저장 공간 ↔ 속도 균형 필요 💾 디스크 저장으로 메모리 부담 완화 |
| 한계 및 해결 방안 | - 쿼리 캐싱 성능 저하 원인: 1. 어텐션 불일치 (임베딩 ↔ 생성) 2. 포맷 문제 (훈련 시 본 적 없는 입력 구조) - 해결책: 추가적인 RAG 파인튜닝 필요 |
⚠️ 성능 저하 원인 해결 시 추가 개선 기대 |
| 결론 및 향후 연구 | - GRITLM: 임베딩과 생성 모두에서 우수한 단일 모델 - 캐싱: 큰 속도 향상과 효율성 제공 - 향후 과제: - RAG 파인튜닝으로 성능 저하 해소 - 멀티모달 확장 및 경량화 연구 가능 |
✅ 빠른 추론 + 높은 성능 🚀 실전 적용에 적합한 모델 제안 |
문제 정의 및 목표
기존의 자연어 처리 모델들은 주로 생성 작업(generative tasks)과 임베딩 작업(embedding tasks)을 별도로 다루고 있었습니다. 그러나 이러한 모델들은 일반적으로 생성 작업에서 뛰어나지만 임베딩 작업에서 성능이 부족하거나 그 반대의 경우도 있었습니다. 이 연구에서는 이러한 두 작업을 통합하여, 동일한 모델이 두 작업을 모두 잘 처리할 수 있도록 하는 방법인 "Generative Representational Instruction Tuning (GRIT)"을 제시합니다.
GRIT의 목표는 임베딩과 생성 작업을 통합하여, 하나의 모델이 두 작업을 동시에 잘 수행할 수 있도록 훈련하는 것입니다. 이 방법을 통해, 모델의 성능을 향상시키고, 효율적인 추론을 가능하게 합니다.
방법
GRIT은 다음의 두 가지 주요 훈련 방식을 통합합니다:
- Generative Instruction Tuning (생성 작업 훈련): 모델이 주어진 지침에 맞춰 텍스트를 생성하는 훈련.
- Representational Instruction Tuning (임베딩 작업 훈련): 모델이 입력을 임베딩 벡터로 변환하도록 훈련.
이 두 가지 작업을 처리할 수 있도록 별도의 손실 함수를 사용하여 모델을 훈련하며, 각 작업에 대해 적합한 손실 함수(Loss Function)를 사용합니다. 임베딩 작업은 대조적 손실(contrastive loss)을 사용하고, 생성 작업은 언어 모델링 손실(language modeling loss)을 사용합니다. GRIT은 이 두 가지 훈련을 동시에 수행하여, 모델이 두 가지 작업을 구별하여 학습할 수 있도록 합니다.
주요 성과
GRIT은 여러 가지 실험에서 우수한 성능을 보였습니다:
- 성능 향상: GRIT 모델은 기존의 임베딩 전용 모델과 생성 전용 모델을 능가하는 성능을 보였습니다. 예를 들어, GRITLM 7B는 Massive Text Embedding Benchmark (MTEB)에서 새로운 최첨단 성능을 달성하였고, 생성 작업에서도 기존의 생성 모델을 능가했습니다.
- 효율성 향상: GRIT을 사용하여 Retrieval-Augmented Generation (RAG) 작업에서 약 60% 이상의 성능 향상을 보였으며, 문서 길이에 관계없이 더 빠른 추론을 가능하게 했습니다. 이는 별도의 검색 모델과 생성 모델을 결합하는 대신, GRIT 모델 하나로 모든 작업을 처리할 수 있기 때문입니다.
- 단순화된 인프라: 두 작업을 하나의 모델로 처리할 수 있기 때문에 서버와 저장소의 복잡성을 줄이고, 모델 배치 및 서비스 인프라를 단순화할 수 있습니다.
실험
GRIT 모델은 다양한 데이터셋과 작업에서 테스트되었습니다:
- MTEB (Massive Text Embedding Benchmark)에서 GRIT은 임베딩 성능에서 기존의 모델들보다 우수한 성능을 보였습니다.
- 생성 작업에서는 HumanEval과 AlpacaEval을 포함한 여러 작업에서 우수한 성과를 기록했습니다.
결론
GRIT은 임베딩과 생성 작업을 통합하여, 하나의 모델이 두 가지 작업을 동시에 잘 수행하도록 하는 혁신적인 접근법입니다. 이를 통해 모델 성능을 크게 향상시키고, 추론 효율성을 높이며, 인프라 복잡성을 줄이는 데 기여할 수 있음을 증명했습니다.
GRIT의 핵심적인 장점은 두 가지 주요 작업을 하나의 모델로 통합함으로써 기존의 별도 훈련 방식에서 발생하는 문제들을 해결할 수 있다는 점입니다. 이러한 방식은 모델을 더욱 효율적이고 강력하게 만들며, 다양한 자연어 처리 작업에서 성능을 극대화하는 데 중요한 역할을 합니다.
Generative Representational Instruction Tuning (GRIT) 논문에서 모델이 학습에 사용한 방법에 대해 자세히 설명하겠습니다. GRIT의 주요 목표는 임베딩 작업과 생성 작업을 하나의 모델로 통합하는 것입니다. 이를 위해 모델은 두 가지 주요 작업을 다른 손실 함수를 통해 학습하게 됩니다. 이 과정은 명시적인 지침을 통해 수행됩니다.
1. GRIT의 학습 과정
GRIT 모델은 두 가지 주요 학습 방법인 Generative Instruction Tuning과 Representational Instruction Tuning을 결합한 방식으로 훈련됩니다. 이 두 가지 방식은 각기 다른 손실 함수와 데이터를 사용하여 모델을 훈련시킵니다.
1.1 Generative Instruction Tuning (생성 작업 훈련)
- 목표: 주어진 텍스트 지침에 따라 자연어를 생성하는 작업입니다. 예를 들어, "Bitcoin의 역사에 대해 블로그 포스트를 작성하라"는 지침이 주어지면, 모델은 이 지침에 맞는 텍스트를 생성합니다.
- 훈련 방식:
- 모델은 언어 모델링 언어 모델링 손실(Language Modeling Loss)을 사용하여 다음 단어 예측 작업을 학습합니다.
- 예를 들어, "Bitcoin: A Peer-to-Peer Electronic Cash System"라는 텍스트의 일부가 주어지면, 모델은 그 다음에 올 단어를 예측하는 방식으로 훈련됩니다. 이를 통해 모델은 언어의 흐름과 문법을 학습합니다.
예시:
- 지침: "내가 최근에 한 하이킹에 대해 블로그 포스트를 써라"
- 모델의 응답: "최근에 나는 후지산을 새벽에 오르며 하이킹을 했다. 그 날의 경험은 정말 특별했는데..."
손실 함수:
- Generative Loss는 모델이 생성한 텍스트가 얼마나 정확히 주어진 지침에 맞는지 평가합니다.
- 예를 들어, 모델이 "후지산 하이킹"에 대한 포스트를 생성했다면, 손실 함수는 생성된 텍스트의 품질을 평가하고 개선을 위한 피드백을 제공합니다.
1.2 Representational Instruction Tuning (임베딩 작업 훈련)
- 목표: 주어진 텍스트를 고정된 벡터로 변환하는 작업입니다. 이 벡터는 텍스트의 의미나 구조적 특성을 잘 포착해야 합니다. 예를 들어, "Bitcoin"이라는 텍스트를 입력받으면, 모델은 이를 고차원 벡터 공간에 있는 포인트로 변환해야 합니다.
- 훈련 방식:
- 모델은 대조적 손실(contrastive loss)을 사용하여 주어진 쿼리와 문서가 얼마나 비슷한지, 또는 얼마나 다른지 판단하는 방식으로 훈련됩니다.
- 예를 들어, "Bitcoin의 역사"라는 쿼리가 주어지면, 모델은 관련된 문서를 검색하여 이를 비교하고, 올바른 쿼리-문서 쌍을 더 높은 점수로 평가합니다.
예시:
- 쿼리: "Bitcoin의 역사"
- 관련 문서: "Bitcoin: A Peer-to-Peer Electronic Cash System" (비트코인의 역사와 기술적 특성에 대한 설명)
- 비관련 문서: "디지털 카메라의 역사"
손실 함수:
- Representation Loss는 쿼리와 문서 간의 유사성을 계산하고, 쿼리와 관련된 문서를 높은 유사도로, 비관련 문서는 낮은 유사도로 평가하여 임베딩 벡터를 훈련시킵니다.
- 유사성 측정: 주로 코사인 유사도(cosine similarity)를 사용하여 두 벡터가 얼마나 유사한지 비교합니다. 코사인 유사도는 벡터 간의 각도를 측정하여 두 벡터가 얼마나 비슷한지를 파악합니다.
2. GRIT의 통합
GRIT 모델은 두 가지 학습 작업을 동시에 수행하여, 하나의 모델이 두 가지 작업을 동시에 잘 수행할 수 있도록 만듭니다. 이를 위해 두 가지 손실 함수(Generative Loss와 Representation Loss)를 결합하여 하나의 최종 손실 함수로 만듭니다.
2.1 손실 함수 결합
- 최종 손실 함수: GRIT은 다음과 같은 손실 함수를 사용하여 두 작업을 결합합니다:
2.2 지침에 따른 모델 분류
- 명시적인 지침을 사용하여 모델이 임베딩 작업과 생성 작업을 구별하여 수행할 수 있도록 합니다. 예를 들어, "이 문장을 임베딩하라"라는 지침이 주어지면, 모델은 이를 벡터로 변환하는 임베딩 작업을 수행합니다. 반면 "이 문장에 대한 블로그 포스트를 작성하라"는 지침이 주어지면 생성 작업을 수행합니다.
예시:
- 임베딩 작업: "Bitcoin의 기술적 특성"을 벡터로 변환하여 검색하거나 유사도 계산을 할 수 있습니다.
- 생성 작업: "Bitcoin의 역사"라는 주제에 대해 텍스트 생성 작업을 할 수 있습니다.
3. 효율성과 성능 향상
GRIT의 주요 장점 중 하나는 효율성입니다. 모델이 단일 파라미터로 두 가지 작업을 처리할 수 있기 때문에, 성능이 향상되고, 추론 속도가 빨라지며, 서버 및 인프라의 복잡성이 줄어듭니다.
4. 결론
GRIT의 핵심은 두 가지 작업을 하나의 모델로 통합하여, 학습과 추론 효율성을 크게 향상시키는 것입니다. 이 방식은 성능을 높이면서도 효율성을 유지할 수 있는 방법으로, 특히 RAG(Retrieval-Augmented Generation)와 같은 작업에서 매우 유용하게 사용될 수 있습니다.
GRIT 모델은 언어 모델링과 임베딩을 동시에 잘 수행할 수 있는 강력한 모델을 만들어내며, 모델의 확장성과 성능을 모두 개선하는 중요한 기여를 합니다.
이 부분은 GRIT 모델이 임베딩 작업과 생성 작업을 어떻게 동시에 학습하는지에 대한 설명입니다. 특히, 두 작업에 사용된 손실 함수(loss functions)와 그 훈련 과정을 중점적으로 다루고 있습니다. NLP 연구자 관점에서 수식과 함께 개념을 단계적으로 풀어 설명하겠습니다.
🔍 핵심 개요
GRIT은 두 가지 다른 작업을 하나의 모델에 통합합니다:
- Representational Instruction Tuning (임베딩 작업): 텍스트를 의미 공간에 임베딩하여 문서 검색이나 유사도 계산에 사용합니다.
- Generative Instruction Tuning (생성 작업): 주어진 지시문에 맞춰 텍스트를 생성합니다.
두 작업 모두 같은 모델(GRITLM)로 수행하며, 이를 위해 각 작업에 맞는 손실 함수를 정의하고 모델을 동시에 훈련합니다.
🧩 1. 임베딩 작업 학습 과정 (Representational Instruction Tuning)
📝 목표
쿼리(query)와 관련 문서(document)를 비슷한 벡터 공간에 위치시키고, 관련 없는 문서는 멀리 떨어뜨리기.
📐 사용된 손실 함수: 대조적 손실 (Contrastive Loss)
수식:
🧠 직관적 설명
- 목표: 올바른 쿼리-문서 쌍의 코사인 유사도는 최대화(높여야 함), 잘못된 쌍은 최소화(낮춰야 함)
- 방법: 모델이 올바른 쌍일수록 큰 확률값을 출력하도록 훈련
- 온도(τ): 너무 확신하지 않게 모델 출력을 부드럽게 조정
🌟 예시
- 쿼리: "비트코인의 역사"
- 정답 문서: "비트코인은 2009년에 시작된 디지털 화폐입니다."
- 오답 문서: "아마존 창업자 제프 베조스의 이야기"
✅ 훈련 목표:
- 쿼리와 정답 문서 유사도 ↑
- 쿼리와 오답 문서 유사도 ↓
🧬 임베딩 계산 과정
- 모델은 양방향 어텐션(bidirectional attention)을 사용해 입력 시퀀스를 인코딩합니다.
- 각 토큰의 숨겨진 상태(hidden states)를 평균(mean pooling)하여 최종 임베딩 벡터를 얻습니다.
- 중요 포인트: 지시문과 형식 토큰은 평균 계산에 포함되지 않지만, 자기어텐션(self-attention)을 통해 간접적인 영향을 줍니다.
📝 2. 생성 작업 학습 과정 (Generative Instruction Tuning)
🎯 목표
주어진 지시문과 입력에 맞춰 적절한 텍스트 생성하기. 예를 들어, "비트코인에 대해 블로그 포스트 작성" 지시 시 해당 텍스트 생성.
📐 사용된 손실 함수: 언어 모델링 손실 (Language Modeling Loss)
수식:
🧠 직관적 설명
- 다음 단어 예측 훈련: 현재 단어까지 보고 다음 단어를 최대 확률로 예측
- 예를 들어, 입력: "비트코인은 디지털" → 다음 단어: "화폐" 예측
🧮 손실 집계 방법 (중요 포인트)
- 샘플 레벨 집계 (Sample-level aggregation)
- 배치 내 각 샘플에 동일한 가중치 부여
- 장점: 분류와 같은 작업에 유리
- 단점: 짧은 문장 생성 편향 발생
- 토큰 레벨 집계 (Token-level aggregation)
- 모든 토큰에 동일한 가중치 부여
- 장점: 긴 문장 생성에 유리 (생성 평가에서 중요)
- 예시: AlpacaEval 평가에서는 긴 생성문을 선호
🧬 왜 두 집계 방법을 혼합할까?
- 샘플 레벨 → 짧고 정확한 생성에 도움
- 토큰 레벨 → 길고 풍부한 생성 유도
✔️ 혼합 방법:
- 일부 배치에서는 토큰 레벨 손실 사용
- 다른 배치에서는 샘플 레벨 손실 사용
🔗 3. 두 손실 함수 통합
최종 손실 함수:
⚙️ 4. 배치 크기와 계산 효율성
- 임베딩 작업에서는 큰 배치 크기(M) → 더 나은 임베딩 품질
- 생성 작업에서는 배치 크기(N) 고정 → 계산 부담 최소화
✔️ 문제점:
- 임베딩 배치 크기 증가 → 계산량 증가
- 생성 작업은 상대적으로 가벼움
🧪 5. 실제 적용 예시
💻 임베딩 작업 예시
쿼리: "비트코인의 역사" → 모델 임베딩: [0.42, 1.52, -0.01, …]
문서 A: [0.43, 1.50, -0.02, …] → 유사도 높음 (정답)
문서 B: [-0.23, 0.12, 0.95, …] → 유사도 낮음 (오답)
📝 생성 작업 예시
지시문: "비트코인에 대한 블로그 포스트 작성"
모델 생성:
"비트코인은 2009년에 등장한 최초의 디지털 화폐로, 탈중앙화 시스템을 기반으로 운영됩니다..."
🎯 최종 요약
✅ GRIT은 임베딩과 생성을 하나의 모델에서 처리
✅ 각 작업에 특화된 손실 함수를 사용
✅ 샘플/토큰 손실 집계 방식 선택 및 혼합
✅ 임베딩은 큰 배치 크기 사용, 생성은 소규모 배치 유지
이 방식으로 하나의 모델이 두 작업에서 모두 뛰어난 성능을 낼 수 있게 됩니다! 😊
그럼 진짜 Embedding 학습과, NTP를 합친 것 밖에 없네?
다른 추가적인 학습 방법을 더한 것이 아니라?
맞아요! GRIT 모델의 핵심은 임베딩 학습(Embedding Learning)과 다음 토큰 예측(Next Token Prediction, NTP)을 동시에 학습하는 것입니다.
기존에는 두 작업을 별도의 모델이나 별도의 훈련 단계로 처리했는데, GRIT은 하나의 모델에서 하나의 학습 과정으로 통합한 것이 주요 아이디어입니다.
🧠 GRIT의 핵심 아이디어: 단순하지만 강력한 통합
- 임베딩 학습 (Representation Loss)
- 대조적 손실(Contrastive Loss)을 사용해 입력 쌍의 의미적 유사도를 학습합니다.
- 기존 임베딩 모델(E5, SGPT 등)과 같은 방식.
- 생성 학습 (Generative Loss)
- 다음 토큰 예측 손실(Language Modeling Loss)을 사용합니다.
- 기존 언어모델(NTP 기반 LLMs)과 동일한 방식.
- 두 손실을 동시에 학습 (GRIT Loss)
🧐 그럼 추가적인 기법은 전혀 없을까?
GRIT은 핵심적으로 두 손실의 단순 통합이지만, 몇 가지 훈련 설계 선택과 최적화 기법으로 성능을 끌어올렸습니다.
1️⃣ 양방향 vs. 단방향 어텐션 사용
- 임베딩 작업에는 양방향 어텐션(bidirectional attention) 사용.
- 생성 작업에는 단방향 어텐션(causal attention) 사용.
✅ 이중 어텐션 설계 덕분에 두 작업에서 성능 저하 없이 통합이 가능했습니다.
2️⃣ 샘플-레벨 vs. 토큰-레벨 손실 집계 방법 도입
- 샘플 레벨 집계: 짧은 생성문에 유리.
- 토큰 레벨 집계: 긴 생성문 생성에 유리.
✅ GRIT은 두 집계 방식을 혼합해 짧은 답변과 긴 답변 생성 모두에 강한 모델을 만듭니다.
3️⃣ 큰 배치 크기 활용 (특히 임베딩 학습에 중요)
- 임베딩 작업 시 대규모 배치 사용으로 더 많은 인배치 음수 샘플(in-batch negatives) 확보.
- 생성 작업은 작은 배치로 계산량 최소화.
✅ 임베딩 성능과 계산 효율성을 동시에 잡았습니다.
4️⃣ RAG 작업에서의 최적화 (캐싱 기법 적용)
- GRIT은 검색(Retrieval)과 생성(Generation)을 하나의 모델로 처리.
- 쿼리 및 문서 캐싱 기법을 도입해 추론 속도 60% 이상 개선.
✅ 실전 사용 시 빠른 검색-생성 파이프라인 구현 가능.
🧪 결론: "단순 통합" + "최적화 설계" = 높은 성능
✔️ 핵심 기법:
✅ Embedding 학습 (Contrastive Loss)
✅ NTP 기반 생성 학습 (Language Modeling Loss)
✔️ 추가 최적화 요소:
🔸 양방향/단방향 어텐션 혼합
🔸 손실 집계 방식(샘플 vs. 토큰) 최적화
🔸 대규모 배치 & 캐싱 전략 적용
🔑 요약:
✅ 본질적으론 Embedding + NTP 통합.
✅ 하지만, 훈련 설계 선택과 최적화 기법 덕분에 단순한 손실 함수 합치기 이상의 성능 개선을 달성했습니다.
💡 즉, 단순하지만 잘 다듬은 통합 방식이라고 할 수 있죠! 😊
📄 GRIT 논문: 결과
🏆 1. 주요 실험 결과
GRIT은 임베딩 작업과 생성 작업을 하나의 모델에서 동시에 수행하면서도 각각의 전용 모델만큼 또는 그 이상의 성능을 달성했습니다.
🧪 임베딩 성능 (MTEB: Massive Text Embedding Benchmark)
- GRITLM 7B 모델은 MTEB 벤치마크에서 새로운 SOTA(State-of-the-Art)를 달성.
- 기존의 전용 임베딩 모델(E5, BGE 등)을 능가하며, 다양한 임베딩 작업(분류, 클러스터링, 검색 등)에서 뛰어난 성과를 보였습니다.
📝 생성 성능 (Generative Tasks)
- GRITLM 7B는 생성 작업에서도 LLM(예: LLaMA 2 70B)보다 더 나은 성능을 달성했습니다.
- 특히 HumanEval과 AlpacaEval에서 긴 텍스트 생성 및 복잡한 지시문 처리에 강점을 보였습니다.
🔄 RAG(Retrieval-Augmented Generation) 효율성 개선
- GRIT 모델을 사용하면 검색 + 생성 단계를 하나의 모델로 처리할 수 있어 60% 이상의 추론 속도 향상을 달성.
- 쿼리 및 문서 캐싱 기법을 적용하여 긴 문서 처리 시 더 큰 속도 개선을 확인했습니다.
🧠 2. 결론
🚀 GRIT의 핵심 기여
- 임베딩과 생성 작업을 하나의 모델에 통합
- 기존에는 별도 모델을 사용해야 했던 두 작업을 손실 함수 통합만으로 해결.
- 성능 저하 없이 통합을 달성하여 모델 관리와 배포의 복잡성 감소.
- 성능과 효율성의 균형 달성
- 임베딩 전용 모델 성능 유지 + 생성 전용 모델 성능 유지
- RAG 파이프라인 단순화: 더 빠르고 효율적인 시스템 구현 가능.
- 단순하지만 강력한 방법론
- 복잡한 추가 모듈 없이 손실 함수 설계와 학습 전략 변경만으로 성능 개선.
- 임베딩과 생성 모두에서 최첨단 성능을 달성하면서도 추론 비용 절감.
💡 3. 마무리 및 향후 연구 방향
📈 장점 및 기대 효과
- 모델 단순화: 임베딩과 생성을 위해 별도 모델을 유지할 필요 없음.
- 추론 효율성: RAG 및 멀티태스킹 환경에서 빠른 응답 시간 확보.
- 실전 적용 용이: 검색 기반 챗봇, 문서 요약, 질문 응답 시스템에 즉각적 적용 가능.
🔮 향후 연구 제안
- 멀티모달 확장
- 텍스트 외에도 이미지, 오디오 임베딩/생성으로 확장 가능성 탐색.
- 다국어 지원 및 성능 향상
- 현재 영어 중심의 데이터 → 다국어 데이터로 확장하여 글로벌 적용성 확보.
- 손실 함수와 집계 방식 최적화
- 샘플/토큰 집계 방식을 더 세분화해 특정 작업에 최적화된 학습법 개발 가능.
- 모델 경량화 및 에너지 효율성
- 더 작은 모델 버전 개발로 모바일 및 엣지 디바이스 지원 연구 가능.
🏁 최종 요약
✅ 임베딩과 생성 작업을 하나의 모델로 통합
✅ 성능 손실 없이 두 작업 모두 최첨단 수준 달성
✅ 추론 속도 60% 이상 개선 (특히 RAG에서)
✅ 실전 서비스에 바로 적용 가능한 실용적 연구
🔑 GRIT의 강점:
✔️ 단순함 + 강력함 + 높은 실용성
🔎 향후 과제: 멀티모달 확장, 다국어 지원, 더 작은 모델 개발
🚀 결론: GRIT은 미래의 다목적 NLP 시스템을 위한 새로운 표준을 제시합니다! 🌟
🧪 GRIT 논문의 실험
이 부분은 GRIT 모델의 실험 설정, 평가 방법, 그리고 모델 훈련 방식에 대해 설명합니다. 실험의 목적은 임베딩과 생성 작업에서 GRIT의 성능을 검증하는 것이며, 다양한 데이터셋과 모델 아키텍처를 활용합니다. 이해를 돕기 위해 각 문장을 단계별로 쉽게 풀어드리겠습니다.
🧰 3.1 실험 설정 (Setup)
🏗️ 사용된 모델 아키텍처
- GRITLM 7B:
- Mistral 7B 모델을 기반으로 파인튜닝.
- GRITLM 8X7B:
- Mixtral 8x7B 모델을 기반으로 파인튜닝.
- 8개의 7B 전문가(Experts)로 구성된 Mixture of Experts(MoE) 모델.
🔎 이유:
- Mistral 7B는 경량화 및 빠른 추론에 적합.
- Mixtral 8x7B는 모델 크기 대비 높은 성능을 제공합니다.
📦 학습 데이터
- 임베딩 학습 데이터:
- E5 데이터셋 기반 (텍스트 임베딩 전용 데이터셋).
- E5S: E5에 S2ORC(과학 논문 데이터)를 추가해 과학적 지식 커버리지 강화.
- 생성 학습 데이터:
- Tülu 2 데이터셋 사용 (지시문-응답 쌍 포함).
- 모델의 편향을 방지하기 위해 모델 기원 관련 커스텀 프롬프트 제거.
🔑 이유:
- E5 데이터는 임베딩 모델 학습에 최적화되어 있음.
- S2ORC 추가로 과학 분야에서의 임베딩 성능을 높임.
- Tülu 2는 다양한 지시문을 포함하여 생성 모델 학습에 적합.
🏋️ 훈련 설정과 하이퍼파라미터
📐 배치 크기 설정
| 모델 | 임베딩 배치 크기 | 생성 배치 크기 |
| GRITLM 7B | 2048 | 256 |
| GRITLM 8X7B | 256 | 256 |
💡 배치 크기 차이 이유:
- 임베딩 학습 시 큰 배치 크기(2048) 사용 → 더 많은 in-batch negatives 확보로 임베딩 성능 개선.
- 생성 학습은 작은 배치 크기(256) 사용 → 계산량 및 메모리 절약.
- GRITLM 8X7B는 메모리 한계로 인해 임베딩 배치를 256으로 제한.
🕰️ 훈련 스텝 및 에폭
- 총 1253 스텝 훈련.
- 생성 데이터: 1 에폭.
- 임베딩 데이터: 1.36 에폭.
🔑 이유:
- 생성 데이터는 상대적으로 적어 한 번만 반복.
- 임베딩 데이터는 크기가 커서 1.36 에폭만으로도 충분한 학습 효과 달성.
🧮 메모리 최적화 전략
메모리 요구량을 줄이기 위해 다음과 같은 전략을 사용합니다:
- 삼중 쌍 분할 학습(Triplet Splitting):
- 임베딩 학습 시 쿼리(query), 양성 문서(positive), 음성 문서(negative)가 필요합니다.
- 메모리 절약을 위해, 삼중 쌍을 나누어 순차적으로 처리:
- 1단계: 쿼리-양성 쌍만 처리 → 역전파
- 2단계: 쿼리-음성 쌍만 처리 → 역전파
- 🔥 효과: 메모리 요구량 감소 + 큰 배치 크기 유지 가능.
- FSDP와 Mixed Precision 사용:
- PyTorch의 Fully Sharded Data Parallel(FSDP)로 모델 파라미터 분산 처리.
- BF16 혼합 정밀도 사용 → 계산 속도 향상 및 메모리 절약.
🧪 3.2 성능 평가 (Performance Evaluation)
모델의 성능은 임베딩 작업과 생성 작업에서 모두 평가됩니다.
🧷 임베딩 성능 평가 (MTEB 벤치마크)
- MTEB (Massive Text Embedding Benchmark)의 56개 주요 데이터셋 사용.
- 다양한 임베딩 작업 평가:
- 분류(Classification), 클러스터링(Clustering), 검색(Retrieval), 문서 재정렬(Reranking) 등.
- 💡 목표: 쿼리와 문서 간 임베딩 유사도 정확성 측정.
✅ 평가 지표:
- nDCG: 검색 정확도 평가.
- F1 Score: 분류 작업 성능.
- Spearman Correlation: 유사도 순위 일치도.
📝 생성 성능 평가
- Ivison et al.의 평가 방식을 주로 따름.
- 하지만, HumanEvalSynthesize 변형 사용 → 지시문 따르기 능력을 더 잘 평가.
✅ 평가 작업:
- HumanEvalSynthesize: 코드 생성 능력 평가.
- AlpacaEval: 일반 지시문 응답 생성 성능 측정.
- TyDi QA: 다국어 질의응답 성능 평가.
✅ 평가 방식:
- 생성된 답변의 정확성, 유창성, 길이 등을 측정.
- 사람 기반 평가와 자동 평가 지표 혼합 사용.
🔍 3.3 모델 구성 요소별 영향 분석 (Ablation Studies)
모델 구성 요소가 성능에 미치는 영향을 파악하기 위해 제어된 실험을 수행합니다.
🔑 분석된 요소들:
- 훈련 데이터 종류 (E5 vs. E5S vs. Tülu 2)
- 정밀도(Precision) 설정 (BF16 vs. FP32)
- 풀링 방법 (Mean Pooling vs. Last Token Pooling)
- 시퀀스 길이 변화 (512 vs. 2048 토큰)
- 손실 가중치 (λ_{Rep}, λ_{Gen}) 조정
✅ 목적:
- 최종 모델에서 각 요소가 임베딩과 생성 성능에 미치는 영향을 이해.
- 최적의 하이퍼파라미터 설정 도출.
🚀 총정리
✅ 핵심 실험 설정 요약
- 모델: Mistral 7B, Mixtral 8x7B
- 데이터셋: E5(+S2ORC) → 임베딩 | Tülu 2 → 생성
- 배치 크기: 임베딩 최대 2048, 생성 256
- 훈련 단계: 총 1253 스텝, 생성 1 에폭, 임베딩 1.36 에폭
- 평가: MTEB(임베딩), HumanEvalSynthesize & AlpacaEval(생성)
🌟 중요 포인트
✅ 임베딩-생성 통합 모델임에도 각 작업에서 전용 모델만큼 우수한 성능
✅ 삼중 쌍 분할과 메모리 최적화로 대규모 배치 유지
✅ HumanEvalSynthesize 사용으로 생성 평가의 현실성 증가
💬 결론:
GRIT은 단순한 손실 함수 통합 이상의 결과를 달성했습니다. 메모리 최적화와 훈련 데이터 선택 덕분에, 임베딩과 생성 모두에서 SOTA 성능을 보여주었습니다.
🚀 실전 서비스에 빠른 추론 + 높은 정확도를 원하는 상황에 이상적인 접근법입니다! ✅
📝 GRITLM의 재정렬(Reranking) 실험
🧩 배경 및 개요
정보 검색(IR) 작업에서 일반적으로 두 단계가 사용됩니다:
- 1단계 - 초기 검색(Initial Retrieval):
- 임베딩 기반 검색(Bi-Encoder) 사용
- 쿼리와 문서의 임베딩 벡터를 비교하여 상위 k개의 문서를 빠르게 추출
- 장점: 계산 비용이 낮고 빠름
- 단점: 세밀한 문맥 정보 반영이 부족할 수 있음
- 2단계 - 재정렬(Reranking):
- 초기 검색으로 추출된 상위 k개의 문서를 더 정밀한 방식으로 다시 정렬
- Cross-Encoder 방식: 쿼리와 문서를 함께 입력해 모델이 직접 관련도를 계산
- 장점: 정확도가 높음
- 단점: 쿼리-문서 쌍마다 모델에 입력 → 계산 비용이 문서 수에 따라 급증 (O(k·n))
🚀 GRITLM의 접근법
기존 연구들은 임베딩 모델과 재정렬 모델을 별도로 사용했습니다.
👉 하지만 GRITLM은 하나의 모델로 두 작업을 모두 수행할 수 있습니다!
GRITLM의 재정렬 방식:
- 1단계 (Bi-Encoder): 빠른 임베딩 기반 검색으로 상위 10개 문서 추출
- 2단계 (Reranking):
- GRITLM의 생성 기능을 활용해 쿼리-문서 쌍의 관련성을 평가
- Permutation Generation 방식 사용 (Sun et al. [145])
- 문서의 순서를 예측하며 쿼리와의 관련성을 정밀히 계산
✅ 결과:
- 거의 모든 데이터셋에서 초기 임베딩 결과보다 재정렬 후 성능 향상
- 상위 k 값을 10보다 높이면 성능은 더 좋아질 수 있지만 계산 비용이 증가
📊 Table 3 해석
| 데이터 셋(MTEB DS) | NO Rerank | Rerank top 10 | 변화량 |
| ArguAna | 63.24 | 64.39 | +1.15 |
| ClimateFEVER | 30.91 | 31.85 | +0.94 |
| CQADupstack | 49.42 | 50.05 | +0.63 |
| DBPedia | 46.60 | 47.82 | +1.22 |
| FiQA2018 | 59.95 | 60.39 | +0.44 |
| FEVER | 79.00 | 79.48 | +0.48 |
| HotpotQA | 79.40 | 80.40 | +1.00 |
| NFCorpus | 40.89 | 41.23 | +0.34 |
| NQ | 70.30 | 71.49 | +1.19 |
| MSMARCO | 41.96 | 42.47 | +0.51 |
| QuoraRetrieval | 89.47 | 88.67 | -0.80 (예외) |
| SCIDOCS | 39.41 | 39.92 | +0.51 |
| SciFact | 79.17 | 79.28 | +0.11 |
| TRECCOVID | 74.08 | 75.14 | +1.06 |
| Touche2020 | 27.93 | 28.41 | +0.48 |
| 평균 (Average) | 57.4 | 57.9 | +0.5 |
✅ 주요 관찰점
- 대부분의 데이터셋에서 재정렬 후 성능이 향상됨.
- 예외: QuoraRetrieval에서 약간의 성능 감소(-0.80) 발생
- 평균 성능 개선: +0.5 포인트 (57.4 → 57.9)
🔑 핵심 이해 포인트
- 왜 재정렬이 필요한가?
- 임베딩 기반 검색은 빠르지만 세밀한 쿼리-문서 관계 파악에 한계
- 재정렬은 상위 문서들의 순위를 더 정확하게 조정해 관련도 개선
- GRITLM만의 장점:
- 하나의 모델로 임베딩과 재정렬 모두 처리 → 인프라 단순화
- 임베딩 단계의 빠른 검색 + 생성 단계의 정밀한 재정렬 결합
- Cross-Encoder 수준의 정확도 달성하면서도 계산 효율성 확보
- 왜 top 10으로 제한했을까?
- 더 많은 문서(k>10) 사용 시 성능은 더 개선되지만 계산 비용 급증
- top 10은 성능과 비용 간 균형점을 찾기 위한 선택
💡 실제 예시 시나리오
쿼리: "코로나 백신의 부작용에 대한 연구 결과"
📝 1단계 (임베딩 기반 검색)
- 상위 10개 문서 추출
- 예시 결과 (임베딩 점수 순):
- 문서 A: 0.88
- 문서 B: 0.85
- 문서 C: 0.84
- ...
- 문서 J: 0.76
🔄 2단계 (GRITLM 재정렬)
- 쿼리와 각 문서를 GRITLM에 입력
- 생성 기능을 사용하여 문서 순위 예측
- 최종 정렬 (관련도 기반):
- 문서 B: 0.91 (더 관련도가 높은 것으로 평가)
- 문서 A: 0.89
- 문서 D: 0.87
- ...
✅ 결과: 사용자에게 더 정확한 결과 제공
🏁 결론
✅ GRITLM은 임베딩과 재정렬 모두를 하나의 모델로 처리하여 편의성과 성능을 동시에 확보합니다.
✅ 재정렬(top 10) 단계에서 거의 모든 데이터셋에서 성능 향상을 보여줍니다.
✅ Cross-Encoder 대비 효율적이면서도 높은 정확도 달성이 가능.
✅ 실전 검색 시스템에 이상적: 빠른 초기 검색 + 정밀한 재정렬을 하나의 모델로 구현할 수 있습니다!
🔎 요약:
GRITLM은 빠른 임베딩 기반 검색과 정확한 재정렬을 동시에 처리하며, 검색 시스템의 정확성과 효율성을 모두 향상시킵니다! 🚀
📝 GRIT 논문의 RAG
GRIT 논문에서는 RAG(Retrieval-Augmented Generation) 작업에서 GRITLM을 사용하여 효율성과 성능을 동시에 개선하는 방법을 제시합니다. 핵심은 임베딩과 생성 작업을 하나의 모델로 통합하고, 캐싱(caching)을 통해 추론 시 계산 비용을 줄이는 것입니다.
🧠 RAG 기본 개념과 문제점
🔍 전통적인 RAG 파이프라인
- 쿼리 임베딩(Query Embedding): 쿼리를 임베딩 모델에 입력하여 벡터 생성
- 문서 검색(Document Retrieval): 쿼리 벡터와 유사한 문서 벡터를 검색
- 생성 단계(Generation): 쿼리와 검색된 문서를 생성 모델에 입력해 답변 생성
🚫 문제점
- 쿼리와 문서 모두 임베딩 모델과 생성 모델에 각각 입력되어 중복 계산 발생
- 계산 비용 증가 및 추론 시간 지연
🚀 GRITLM을 활용한 RAG 최적화
GRITLM은 임베딩과 생성을 같은 모델로 처리하므로, 중복 계산을 캐싱으로 줄일 수 있습니다.
캐싱의 개념:
- 캐싱(Caching): 모델이 처리한 중간 결과(키-값 상태, key-value states)를 저장하고 재사용
- 효과: 반복 계산 제거 → 추론 시간 단축 + 연산 비용 절감
🗂️ GRITLM 캐싱 방법 세 가지
🅰️ (a) 쿼리 캐싱 (Query Caching)
💡 방법
- 쿼리 임베딩 시 생성 모델의 중간 상태(key-value states)를 저장
- 생성 단계에서 저장된 상태를 재사용해 쿼리의 재계산을 생략
🔑 GRITLM만의 장점
- 임베딩과 생성 모델이 동일하므로 중간 상태 재사용이 자연스럽게 가능
- 1회의 쿼리 포워드 패스 계산 비용 절감
🔄 동작 과정
- 쿼리 → 임베딩 계산 + key-value states 저장
- 생성 시 → 저장된 쿼리 상태 재사용
📈 장점
✅ 쿼리 처리 비용 절약
✅ 빠른 추론 속도 확보
🅱️ (b) 문서 캐싱 (Doc Caching)
💡 방법
- 문서 임베딩 시 생성 모델의 key-value states도 함께 저장
- 문서 검색 시 문서의 key-value states를 바로 반환
🔄 동작 과정
- 인덱스 구축 시:
- 문서 → 임베딩 생성 + key-value states 저장
- 추론 시:
- 쿼리 → 문서 검색
- 문서의 key-value states 반환 및 재사용
📈 장점
✅ 문서 관련 재계산 제거 → 다수 문서 처리 시 큰 비용 절감
✅ RAG 외 다른 모델에도 적용 가능
⚠️ 단점
- 더 많은 저장 공간 필요 (key-value states 저장)
- 초기 인덱스 구축 시 계산 비용 증가
🆎 (c) 쿼리-문서 캐싱 (Query-Doc Caching / Doc-Query Caching)
💡 방법
- 쿼리 캐싱 + 문서 캐싱을 함께 사용 → 최대 연산 절감
- 두 가지 순서로 적용 가능:
- Query-Doc Caching: 쿼리 먼저, 문서 다음
- Doc-Query Caching: 문서 먼저, 쿼리 다음
📉 장단점 비교
| 방법 | 장점 | 단점 |
| Query-Doc Caching | 최대 계산 절약 | 쿼리-문서 상호작용 반영 어려움 |
| Doc-Query Caching | 문서 재사용 효율적 | 문맥 정보 손실 가능 |
⚠️ 주의사항
- 자기어텐션(self-attention)을 통한 쿼리-문서 간 상호작용이 약화될 수 있음
- 기존 RAG보다 약간의 정확도 손실 가능성 있음
📊 비교 및 효과 요약
| 캐싱 방법 | 절약 대상 | 장점 | 단점 |
| Query Caching | 쿼리 계산 | 빠른 쿼리 처리 | 문서 계산 필요 |
| Doc Caching | 문서 계산 | 다수 문서 재사용 | 저장 공간 증가 |
| Query-Doc Caching | 쿼리 + 문서 계산 | 최대 비용 절감 | 상호작용 정보 손실 가능 |
🧪 실제 예시 시나리오
🎯 쿼리: "코로나 백신 부작용 연구"
📄 문서 인덱스: 10만 개 문서
📝 전통적 RAG:
- 쿼리 임베딩 → 1 포워드 패스
- 상위 10개 문서 생성 입력 → 10 포워드 패스
- 총 11 포워드 패스 필요
🚀 GRITLM + Query Caching:
- 쿼리 임베딩 시 key-value states 저장
- 생성 시 쿼리 재계산 생략
- 총 10 포워드 패스 → 9% 비용 절감
🚀 GRITLM + Doc Caching:
- 문서 인덱스에 key-value states 저장
- 쿼리 검색 시 문서 상태 바로 반환
- 총 11 → 2 포워드 패스 → 80% 절감
🚀 GRITLM + Query-Doc Caching:
- 쿼리 + 문서 모두 캐싱
- 총 1 포워드 패스 → 최대 90% 절감
- 다만, 쿼리-문서 상호작용 약화 가능
🏁 결론 및 요약
✅ GRITLM의 통합 모델 구조 덕분에 RAG에서 중복 계산 제거 가능
✅ 쿼리 캐싱: 빠른 쿼리 처리
✅ 문서 캐싱: 다수 문서 처리 비용 절감
✅ 쿼리-문서 캐싱: 최대 비용 절감, 다만 약간의 성능 손실 가능
💡 실전 적용 시:
- 빠른 검색 + 정밀 생성 시스템 구축에 탁월한 선택
- 특히 대규모 검색 시스템에서 최대 90% 추론 비용 절감 가능 🚀
📝 GRIT 논문의 RAG 실험
이 섹션은 GRITLM을 활용한 RAG(Retrieval-Augmented Generation) 실험의 설정, 성능, 지연 시간(latency), 저장 비용(storage) 등에 대해 설명합니다. GRIT의 주요 목표는 임베딩-생성 통합 모델을 활용하여 RAG의 효율성과 성능을 동시에 향상시키는 것입니다.
🧪 1. 실험 설정 (Setup)
🗂️ 데이터셋과 인덱스
- 데이터셋: Natural Questions (NQ)
- 문서 수: 약 2,681,468개 (BEIR NQ 코퍼스 기반)
- 인덱스 크기: 기존 연구보다 작은 인덱스 사용
🔑 목적:
- 작은 인덱스에서도 RAG의 효과와 캐싱 방식의 효율성 검증
📝 모델 평가 방식
- 평가지표:
- Match Score:
- 정답 내용이 생성된 응답 내에 포함되는지 여부를 평가
- 보다 유연한 평가: 답변이 정답을 포함하지만 문장이 길거나 다를 때도 인정
- Exact Match (기존 방식):
- 생성된 답변이 정답과 정확히 일치할 때만 인정
- GRITLM처럼 더 길고 설명적인 답변 생성 시 불리
- Match Score:
💡 왜 Match Score 사용?
- 더 정확한 평가 가능:
- 예시: "Apple의 CEO는 Tim Cook입니다."
- Exact Match는 실패하지만, Match Score는 정답 부분("Tim Cook") 포함 시 인정
📊 2. 성능 분석 (Performance)
🚀 RAG vs No RAG 성능
- RAG 사용 시: No RAG 대비 더 나은 성능 달성
- 작은 인덱스에도 불구하고 유효성 검증 성공
🔄 캐싱별 성능 비교
캐싱 방법 성능 결과 특징
| 캐싱 방법 | 성능 | 결과 특징 |
| No RAG | 낮음 | 문서 없이 생성 → 정보 부족 |
| RAG (기준) | 최고 | 쿼리 + 문서 입력 |
| Query Caching | 다소 감소 | 쿼리 상태 재사용, 하지만 약간의 성능 저하 발생 |
| Doc Caching | 가장 우수 | 문서 상태 재사용 → 성능 향상 |
| Query-Doc/Doc-Query Caching | No RAG와 유사 | 상호작용 부족으로 성능 저하 |
❓ Query Caching 성능 저하 이유
- 어텐션 문제:
- 임베딩 시 양방향 어텐션(bidirectional attention) 사용
- 생성 시 단방향 어텐션(causal attention) 필요
- 쿼리 상태 캐싱 시 이 어텐션 불일치 발생 → 성능 저하
- 포맷 문제:
- 임베딩 포맷 사용 시, 모델이 생성 작업과 결합된 포맷을 훈련 중 본 적 없음
- → 추론 시 혼란 발생 → 성능 하락
🔑 결론:
- Query Caching 성능 저하 주원인: 어텐션 불일치
- 해결책: GRITLM에 추가적인 RAG 파인튜닝 필요
✅ Doc Caching 성능 개선 이유
- 문서는 완벽한 이해보다 대략적 스캐닝(skimming)으로도 충분
- 문서 캐싱 시 약간 손상된 key-value states도 큰 영향 없음
- 결과: Doc Caching은 오히려 성능 소폭 향상
⚠️ Query-Doc/Doc-Query Caching 성능 저하 이유
- 쿼리와 문서가 서로의 정보를 참조하지 못함 → 상호작용 약화
- → No RAG와 유사한 성능
🕒 3. 지연 시간(Latency) 분석
🖥️ 캐싱으로 인한 속도 향상
| 캐싱 방법 | CPU속도 향상 | GPU 속도 향상 | 설명 |
| Query Caching | +54% | +33% | 쿼리 계산 제거 효과 |
| Doc Caching | +63% | +31% | 문서 재계산 제거, 더 긴 문서에서 효과적 |
| Query-Doc/Doc-Query | 최대 속도 향상 | 최대 속도 향상 | 둘 다 캐싱 시 가장 빠름 |
📈 속도 향상 이유
- 쿼리 캐싱: 쿼리 포워드 패스 제거 → 빠른 쿼리 처리
- 문서 캐싱: 문서 재계산 제거 → 특히 긴 문서에서 큰 효과
- Query-Doc/Doc-Query Caching: 양쪽 캐싱 → 최대 속도 향상
🔑 CPU vs GPU 차이:
- CPU: 시퀀스 순차 처리 → 캐싱 효과 더 큼
- GPU: 시퀀스 병렬 처리 → 캐싱 효과 상대적으로 낮음
📝 토큰 수에 따른 속도 차이
| 토큰 수 | 캐싱 효과 | 이유 |
| 250 tokens | 미미 | 짧은 시퀀스 → 캐싱 효과 제한적 |
| 4000 tokens | 큰 향상 | 긴 시퀀스 → 캐싱 효과 극대화 |
💡 생산 환경 제안:
- 쿼리가 긴 경우 → Query Caching 추천
- 문서가 긴 경우 → Doc Caching 추천
- 쿼리/문서 길이 확인 후 자동 전환 로직 구현 가능
💾 4. 저장 비용(Storage) 분석
📦 전통적 RAG 저장 방식
- 저장 대상:
- 문서 텍스트
- 문서 임베딩
- 문제: 문서 내용 전체 저장 필요
🗃️ GRITLM + Doc Caching 저장 방식
- 저장 대상:
- 문서 임베딩
- 문서 key-value states (대신 텍스트 저장 불필요)
✅ 장점:
- 문서 텍스트 저장 필요 없음 → 저장 공간 절감 가능
❌ 단점:
- key-value states가 매우 큼
- 예시:
- 문서 수: 2,681,468개
- 모델: GRITLM-7B
- 총 약 30TB 저장 필요
- 한 문서 로드 시 약 12.5MB 메모리 필요
💡 저장 공간 절약 방법
- 디스크 저장 후 필요 시 로드 → 메모리 부담 완화
- 저장 공간-추론 속도 균형 필요
🏁 최종 요약
✅ 캐싱 방법 비교
| 캐싱 방식 | 성능 | 속도 | 저장 비용 | 추천 상황 |
| Query Caching | 다소 감소 | 빠름 | 낮음 | 긴 쿼리 처리 시 |
| Doc Caching | 개선 | 매우 빠름 | 높음(30TB) | 긴 문서 처리 시 |
| Query-Doc/Doc-Query | 저하 | 최대 | 높음 | 속도 최우선 시 |
🎯 핵심 결론
✅ Doc Caching → 최고 성능 + 빠른 속도
✅ Query Caching → 성능 약간 손실 있으나 빠른 쿼리 처리에 유리
✅ Query-Doc/Doc-Query → 속도는 빠르나 성능 저하
💡 권장 사용법:
- 문서가 길면 Doc Caching
- 쿼리가 길면 Query Caching
- 속도 최우선이면 Query-Doc Caching 고려
🚀 GRITLM의 장점:
✅ RAG보다 빠른 속도와 우수한 성능
✅ 캐싱으로 최대 63% 속도 향상
✅ 생산 환경에서 실용적 적용 가능성 높음
🌟 향후 과제: RAG 파인튜닝으로 캐싱 시 성능 저하 해결 기대! ✅