임베딩 모델 선택 가이드 - 개념부터 한국어 벤치마크까지

임베딩 모델은 텍스트를 의미를 담은 벡터로 변환하는 AI 모델로, RAG, 시맨틱 검색, 추천 시스템의 핵심 구성 요소입니다. 이 글에서는 임베딩의 개념부터 한국어 벤치마크, 모델 선택 전략까지 체계적으로 다룹니다.

1. 임베딩이란 무엇인가

정의와 동작 원리

임베딩(Embedding)은 텍스트를 고차원 벡터 공간의 수치 벡터로 변환하는 과정입니다. 의미적으로 유사한 텍스트는 벡터 공간에서 가까운 위치에 배치됩니다.

[임베딩 변환 과정]

"Apache Spark는 빅데이터 분석 프레임워크입니다"
     ↓ 임베딩 모델
[0.023, -0.156, 0.834, 0.012, ..., -0.067]  (1536차원)

"대규모 데이터 처리를 위한 분산 컴퓨팅 엔진"
     ↓ 임베딩 모델
[0.019, -0.148, 0.821, 0.015, ..., -0.059]  (1536차원)

→ 코사인 유사도: 0.94 (의미가 유사하므로 높은 유사도)

의미 공간 시각화

벡터 공간 (축소하여 2D로 표현)

  데이터 엔지니어링 ●      ● 분산 처리
                     ╲    ╱
                      ● Spark
                      
       Kafka ●          ● 이벤트 스트리밍
       
                   ● 메시지 큐
                   
  ● 기계 학습
              ● 딥러닝
                        ● 신경망
                        
→ 관련 개념은 가까이, 무관한 개념은 멀리 배치됨

임베딩 유형

임베딩 차원의 의미

2. 임베딩 모델 아키텍처

Bi-Encoder vs Cross-Encoder

[Bi-Encoder]
텍스트 A → Encoder → 벡터 A ─┐
                               ├→ cosine(A, B) = 0.87
텍스트 B → Encoder → 벡터 B ─┘

[Cross-Encoder]
(텍스트 A, 텍스트 B) → Encoder → 점수: 0.92

참고: RAG에서는 1차 검색(Bi-Encoder)으로 후보를 좁힌 뒤, 2차 리랭킹(Cross-Encoder)으로 정밀도를 높이는 2단계 전략이 일반적입니다.

학습 목표: Contrastive Learning

대부분의 현대 임베딩 모델은 **대조 학습(Contrastive Learning)**으로 훈련됩니다.

[대조 학습]

Anchor: "Spark 성능 최적화 방법"
Positive: "Spark 튜닝 가이드 및 모범 사례"     → 가까이
Negative: "Python 웹 프레임워크 Django 소개"    → 멀리

손실 함수: 
  Anchor-Positive 거리 최소화 + Anchor-Negative 거리 최대화

풀링 전략

Transformer 출력을 단일 벡터로 요약하는 방법:

3. 주요 임베딩 모델 비교

종합 비교표

모델별 특징 상세

OpenAI text-embedding-3 시리즈

• 장점: 높은 범용 성능, 간편한 API, Matryoshka 임베딩 지원 (차원 축소 가능)
• 단점: API 비용 발생, 데이터 외부 전송, 오프라인 사용 불가
• 적합: 빠른 구현, 비용 감당 가능한 프로젝트

BGE-M3 (BAAI)

• 장점: 오픈소스 최고 수준 성능, Dense + Sparse + ColBERT 멀티 검색, 다국어 강점
• 단점: 모델 크기 대비 추론 속도 약간 느림
• 적합: 오픈소스 + 다국어 + 고성능이 모두 필요한 경우

E5-Mistral-7B

• 장점: 긴 문서(32K 토큰) 지원, 최고 수준 정확도
• 단점: 7B 파라미터로 GPU 필수, 추론 느림
• 적합: 긴 문서 처리, 최고 정확도 요구

multilingual-e5-large

• 장점: 경량 (560M), 다국어 균형 성능, CPU에서도 실행 가능
• 단점: 짧은 최대 토큰 (512)
• 적합: 리소스 제한 환경, 다국어 범용

4. 한국어 성능

한국어 임베딩이 어려운 이유

한국어 검색 벤치마크 (참고용)

참고: 벤치마크 수치는 데이터셋과 평가 조건에 따라 달라집니다. 실제 도메인 데이터로 평가하는 것을 권장합니다.

한국어 RAG를 위한 실전 팁

• 모델 추천: BGE-M3 또는 multilingual-e5-large (오픈소스), text-embedding-3-small (API)
• 청킹 전략: 한국어는 문장 단위 분할이 효과적 (kss 라이브러리 활용)
• 쿼리 전처리: 조사 제거, 어근 추출로 검색 품질 향상
• 하이브리드 검색: 한국어는 벡터 + BM25 결합이 특히 효과적

# 한국어 문장 분리 (kss)
import kss
 
text = "Spark는 분산 처리 프레임워크입니다. 대용량 데이터를 병렬로 처리합니다."
sentences = kss.split_sentences(text)
# ['Spark는 분산 처리 프레임워크입니다.', '대용량 데이터를 병렬로 처리합니다.']

5. 임베딩 모델 사용법

OpenAI Embeddings

from openai import OpenAI
 
client = OpenAI()
 
# 단일 텍스트 임베딩
response = client.embeddings.create(
    model="text-embedding-3-small",
    input="Apache Spark는 분산 데이터 처리 프레임워크입니다"
)
embedding = response.data[0].embedding  # 1536차원 벡터
 
# 차원 축소 (Matryoshka)
response = client.embeddings.create(
    model="text-embedding-3-small",
    input="Apache Spark는 분산 데이터 처리 프레임워크입니다",
    dimensions=256  # 1536 → 256으로 축소
)
 
# 배치 처리
texts = ["텍스트 1", "텍스트 2", "텍스트 3", ...]
response = client.embeddings.create(
    model="text-embedding-3-small",
    input=texts  # 최대 2048개, 8191 토큰/건
)
embeddings = [d.embedding for d in response.data]

HuggingFace (sentence-transformers)

from sentence_transformers import SentenceTransformer
 
# BGE-M3 로드
model = SentenceTransformer("BAAI/bge-m3")
 
# 단일 텍스트 임베딩
embedding = model.encode("Apache Spark는 분산 데이터 처리 프레임워크입니다")
# 결과: (1024,) 차원 numpy 배열
 
# 배치 처리
texts = [
    "Spark 성능 최적화 방법",
    "Kafka 컨슈머 그룹 설정",
    "Airflow DAG 스케줄링"
]
embeddings = model.encode(texts, batch_size=32, show_progress_bar=True)
# 결과: (3, 1024) 차원 numpy 배열
 
# 정규화 (코사인 유사도 사용 시)
embeddings = model.encode(texts, normalize_embeddings=True)

Ollama Embeddings

import ollama
 
# Ollama로 임베딩 (로컬 실행)
response = ollama.embeddings(
    model="nomic-embed-text",
    prompt="Apache Spark는 분산 데이터 처리 프레임워크입니다"
)
embedding = response["embedding"]  # 768차원 벡터
 
# 배치 처리
texts = ["텍스트 1", "텍스트 2", "텍스트 3"]
embeddings = []
for text in texts:
    resp = ollama.embeddings(model="nomic-embed-text", prompt=text)
    embeddings.append(resp["embedding"])

유사도 계산

import numpy as np
 
def cosine_similarity(a, b):
    """코사인 유사도 계산"""
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
 
# 예시
emb1 = model.encode("Spark 성능 튜닝")
emb2 = model.encode("Apache Spark 최적화 방법")
emb3 = model.encode("Python 웹 개발 Django")
 
print(cosine_similarity(emb1, emb2))  # ~0.92 (높은 유사도)
print(cosine_similarity(emb1, emb3))  # ~0.35 (낮은 유사도)

6. 차원 축소

Matryoshka Embeddings

Matryoshka 임베딩은 벡터의 앞부분만 잘라도 유효한 임베딩이 되도록 학습된 모델입니다. 러시아 마트료시카 인형처럼, 큰 벡터 안에 작은 벡터가 내포되어 있습니다.

[Matryoshka 임베딩]

전체 벡터 (1536차원): [████████████████████████████████]
                       ↓ 앞 768개만 사용
축소 벡터 (768차원):  [████████████████]
                       ↓ 앞 256개만 사용
경량 벡터 (256차원):  [████]

→ 각 축소 단계에서도 유효한 임베딩 유지
→ 스토리지/검색 비용 절감 가능

지원 모델: OpenAI text-embedding-3, nomic-embed-text, jina-embeddings-v3

차원별 성능 트레이드오프

참고: 차원을 절반으로 줄이면 정확도는 1~2%만 감소하지만, 스토리지와 검색 비용은 절반으로 줄어듭니다. 대규모 시스템에서 비용 최적화에 매우 효과적입니다.

7. 임베딩 모델 미세 조정

미세 조정이 필요한 경우

• 범용 모델이 도메인 전문 용어를 잘 이해하지 못할 때
• 검색 정확도가 요구 수준에 미치지 못할 때
• 특정 언어/도메인의 유사도 판단이 부정확할 때

학습 데이터 형식

# Query-Positive-Negative 트리플 형식
training_data = [
    {
        "query": "Spark executor OOM 에러 해결",
        "positive": "Spark executor 메모리 부족 시 spark.executor.memory를 늘리고...",
        "negative": "Python Django에서 메모리 최적화를 위해..."
    },
    {
        "query": "Kafka 컨슈머 랙 증가 원인",
        "positive": "컨슈머 그룹의 처리 속도가 프로듀서 생산 속도를 따라가지 못하면...",
        "negative": "Redis 캐시 만료 정책을 TTL로 설정하면..."
    }
]

미세 조정 코드

from sentence_transformers import SentenceTransformer, InputExample, losses
from torch.utils.data import DataLoader
 
# 기반 모델 로드
model = SentenceTransformer("BAAI/bge-m3")
 
# 학습 데이터 구성
train_examples = [
    InputExample(texts=[
        "Spark executor OOM 에러 해결",
        "Spark executor 메모리 부족 시 spark.executor.memory를 늘리고..."
    ], label=1.0),
    InputExample(texts=[
        "Spark executor OOM 에러 해결",
        "Python Django에서 메모리 최적화를 위해..."
    ], label=0.0),
]
 
train_dataloader = DataLoader(train_examples, shuffle=True, batch_size=16)
 
# 손실 함수
train_loss = losses.CosineSimilarityLoss(model)
 
# 학습
model.fit(
    train_objectives=[(train_dataloader, train_loss)],
    epochs=3,
    warmup_steps=100,
    output_path="./fine_tuned_embedding"
)
 
# 평가
from sentence_transformers.evaluation import InformationRetrievalEvaluator
 
evaluator = InformationRetrievalEvaluator(
    queries=eval_queries,
    corpus=eval_corpus,
    relevant_docs=eval_relevant,
    name="domain-eval"
)
model.evaluate(evaluator)

8. RAG 연동 모범 사례

청킹과 임베딩 정렬

쿼리 vs 문서 임베딩

일부 모델은 쿼리와 문서에 다른 프리픽스를 사용합니다.

# BGE 모델: 쿼리에 프리픽스 추가
query_embedding = model.encode("Represent this sentence for searching: Spark 성능 최적화")
doc_embedding = model.encode("Spark 성능을 최적화하려면 파티션 수를 조정하고...")
 
# E5 모델: query/passage 프리픽스
query_embedding = model.encode("query: Spark 성능 최적화")
doc_embedding = model.encode("passage: Spark 성능을 최적화하려면...")

비용 최적화 전략

9. 선택 가이드

의사결정 플로차트

[API 비용을 감당할 수 있는가?]
├─ Yes, 간편함 우선 → OpenAI text-embedding-3-small
├─ Yes, 최고 성능 → OpenAI text-embedding-3-large
└─ No, 오픈소스
   ↓
[한국어/다국어가 중요한가?]
├─ Yes
│  ↓
│  [GPU가 있는가?]
│  ├─ Yes → BGE-M3 (최고 성능)
│  └─ No → multilingual-e5-large (CPU 가능)
└─ No (영어 중심)
   ↓
[긴 문서(8K+ 토큰)를 처리해야 하는가?]
├─ Yes → E5-Mistral-7B 또는 GTE-Qwen2
└─ No → nomic-embed-text (Ollama 지원)

시나리오별 추천

참고: "최고의 임베딩 모델"은 없습니다. 도메인, 언어, 인프라, 비용 제약에 따라 최적의 선택이 달라집니다. 프로토타입은 OpenAI API로 빠르게 검증하고, 프로덕션에서는 요구사항에 맞는 오픈소스 모델로 전환하는 전략을 추천합니다.

References

• Reimers, N. & Gurevych, I. (2019). "Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks." EMNLP
• Chen, J. et al. (2024). "BGE M3-Embedding: Multi-Lingual, Multi-Functionality, Multi-Granularity Text Embeddings." arXiv
• Wang, L. et al. (2024). "Multilingual E5 Text Embeddings: A Technical Report." arXiv
• Kusupati, A. et al. (2024). "Matryoshka Representation Learning." NeurIPS
• OpenAI. "Embeddings Guide" — https://platform.openai.com/docs/guides/embeddings
• Sentence-Transformers Documentation — https://www.sbert.net/
• MTEB Leaderboard — https://huggingface.co/spaces/mteb/leaderboard

— Data Dynamics 엔지니어링 팀