[딥러닝, 논문리뷰] Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks

 

 

 

https://arxiv.org/abs/1908.10084

Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks

 

SBERT란? 

• BERT기반으로 한 문장 임베딩 모델임(양방향 학습을 통해 문장에 대한 문맥 이해가 가장 빠른 모델) 
• 샴 쌍둥이(Siamese) 트리플렛 네트워크 구조를 사용하며, 의미적으로 유사한 문장들을 벡터 공간 안에서 가깝게 위치하도록 조정하는 임베딩을 생성하는 역할 

 

1. Abstract 

 

 

BERT(Devlin et al., 2018)와 RoBERTa(Liu et al., 2019)는 의미적 텍스트 유사성(STS, Semantic Textual Similarity)과 같은 문장 쌍 회귀(sentence-pair regression) 태스크에서 SOTA 성능을 달성했다.

 

그러나 두 문장을 네트워크에 함께 입력해야 하므로, 엄청난 계산량이 발생한다.

 

STS에서 다루는 문장 간 유사성의 유형

 

완전히 동일한 의미 (Similarity Score ≈ 5.0)

• “I love playing soccer.”
• “I enjoy playing football.”

→ 의미적으로 거의 동일한 문장

 

부분적으로 유사한 의미 (Similarity Score ≈ 3.0)

 

• “She bought a new car.”
• “She got a new vehicle as a gift.”

→ 일부 단어가 다르지만 의미는 유사

 

의미가 전혀 다른 문장 (Similarity Score ≈ 0.0)

• “The weather is nice today.”
• “I love eating pizza.”

→ 전혀 관련 없는 내용

 

STS 태스크에서는 이런 문장 쌍을 주고, 사람이 매긴 유사도 점수(보통 0~5점)를 예측하는 모델을 학습하는 것이 목표

 

그렇기에, 10,000개의 문장 중에서 가장 유사한 문장 쌍을 찾으려면 약 5천만 번의 추론(inference) 연산이 필요하며, BERT를 사용하면 약 65시간이 걸린다.

 

이러한 구조적 한계로 인해, BERT는 의미적 유사성 검색과 같은 작업이나, 군집화 같은 비지도 학습에는 적합하지 않은 상황이 발생하게 됨 

 

그런 상황에서 위 논문은 Sentence-BERT(SBERT)를 제안한다.

 

SBERT(Sentence-BERT)는 BERT의 구조를 수정하여, 의미적으로 유사한 문장을 더욱 효율적으로 비교할 수 있도록 만든 모델

 

특징 

• BERT 대신 Siamese & Triplet 네트워크 사용
• 각 문장을 독립적인 벡터(embedding)로 변환
• 문장 비교 시 사전 계산된 벡터 간의 코사인 유사도만 측정
• → 65시간 → 5초로 계산 시간 단축

Siamese & Triplet 네트워크란?

Siamese(샴 쌍둥이) 네트워크와 Triplet(트리플렛) 네트워크는 두 개 또는 세 개의 입력 데이터를 비교하여 유사도를 학습하는 딥러닝 아키텍처입니다.

 

이 방식은 이미지 유사도, 얼굴 인식, 문장 임베딩(STS, 검색 등)에 널리 사용됩니다.

 

샴 쌍둥이 네트워크

Siamese(샴쌍둥이) 네트워크

 

두 개의 입력 데이터(문장, 이미지 등)를 각각 같은 신경망에 통과시켜 벡터(임베딩)로 변환

 

• 변환된 두 벡터 간의 유사도를 측정하는 방식
• 💡 목표: 두 개의 입력이 얼마나 비슷한지를 학습

 

구조

 

1. 두 개의 입력을 동일한 네트워크(같은 가중치를 공유하는 모델)에 통과

 

• 두 개의 문장(또는 이미지)을 같은 신경망을 통과시켜 벡터를 생성
• SBERT에서는 BERT를 두 번 사용하여 각 문장을 독립적인 벡터로 변환

 

2. 출력된 벡터 간의 거리 측정 (Cosine Similarity, Euclidean Distance 등)

 

• 벡터가 가까울수록 두 입력이 유사함
• 벡터가 멀수록 두 입력이 다름

3. Loss(손실 함수) 계산 후 네트워크 학습

 

• 유사한 샘플은 가까운 벡터로,
• 다른 샘플은 멀리 떨어진 벡터로 변환하도록 학습

수식 (Cosine Similarity 사용)

 

\(\text{similarity} = \frac{A \cdot B}{||A|| \times ||B||}\)

 

• \(A, B\) = 두 개의 입력 문장의 임베딩 벡터
• 두 벡터 간의 코사인 유사도(Cosine Similarity) 계산

Siamese 네트워크 예제 (문장 유사도 학습)

 

문장 A	문장 B	정답(유사도)
“I love coffee.”	“I love coffee.”	1 (유사)
“The sky is blue.”	“Grass is green.”	0 (다름)

 

• 두 문장을 같은 BERT 네트워크에 통과 → 각 문장의 벡터(임베딩) 생성
• 코사인 유사도를 계산하여 얼마나 유사한지 학습

 Triplet(트리플렛) 네트워크

 

개념

 

• Siamese 네트워크를 확장한 형태
• 한 번에 세 개의 입력을 사용하여 유사도 학습
  • 💡 목표:
    • 유사한 샘플(Positive)은 가까운 벡터로,
    • 다른 샘플(Negative)은 멀리 떨어진 벡터로 변환

구조

 

1. 세 개의 입력을 같은 신경망에 통과

 

• Anchor(기준), Positive(유사한 데이터), Negative(다른 데이터)

예:

 

Anchor: "The cat is on the mat."

Positive: "A cat is sitting on the rug." (유사한 문장)

Negative: "I love pizza." (완전히 다른 문장)

 

2. 세 개의 벡터를 생성 후 거리 측정

 

• Anchor-Positive 거리 → 가깝게
• Anchor-Negative 거리 → 멀게

3. Triplet Loss(트리플렛 손실 함수) 사용하여 학습

• Loss는 (Anchor - Positive) 거리보다 (Anchor - Negative) 거리가 일정 이상 더 커지도록 조정

수식 (Triplet Loss)

 

\(L = \max( || f(A) - f(P) ||^2 - || f(A) - f(N) ||^2 + \alpha, 0)\)

 

• \(A\) = Anchor(기준 문장)
• \(P\) = Positive(유사한 문장)
• \(N\) = Negative(다른 문장)
• \(\alpha\) = 최소 거리 마진(보통 1.0)
• 목표 : \(|| f(A) - f(P) ||\)를 작게 만들고, \(|| f(A) - f(N) ||\)를 크게 만듦

 

Triplet 네트워크 예제 (문장 유사도 학습)

Anchor(기준)	Positive(유사)	Negative(다름)
“I love coffee.”	“I enjoy drinking coffee.”	“The sky is blue.”
“The dog is playing.”	“A puppy is having fun.”	“I am reading a book.”

• Anchor-Positive는 가까운 벡터, Anchor-Negative는 먼 벡터로 학습

SBERT에서 Siamese & Triplet 네트워크 적용 방식

 

• Siamese 네트워크: 문장 쌍을 BERT에 통과 → 각 문장의 벡터를 생성 → 코사인 유사도를 계산하여 비교
• Triplet 네트워크: Anchor-Positive-Negative 세 문장을 동시에 학습 → 문장 임베딩이 의미적 유사도를 잘 반영하도록 최적화

 

다시 돌아온 S-BERT만의 특징 

 

Self-Attention을 문장 내부에서만 수행

• BERT는 문장 간 비교 시에도 Self-Attention을 수행하지만,
• SBERT는 문장 간 비교를 할 때는 벡터 연산만 수행
• → 비교할 문장이 많아질수록 성능 차이가 커짐

 문장 검색(Search) 및 군집화(Clustering) 가능

 

• SBERT의 문장 벡터는 미리 계산해서 저장할 수 있음
• 검색 시에는 벡터 간 유사도만 빠르게 계산
• BERT처럼 모든 문장 조합을 매번 입력하지 않아도 됨

 

---

2. Introduction

 

이 부분에서는 SBERT(Sentence-BERT)의 개념, 기존 BERT의 한계점, SBERT의 해결 방법 및 성능 평가에 대해 설명하고 있음 

 

SBERT는 기존 BERT를 수정하여 Siamese 및 Triplet 네트워크 구조를 적용한 모델

 

• 의미적으로 더 유의미한 문장 임베딩(Sentence Embedding)을 생성할 수 있음
• 이를 통해 기존 BERT가 어려웠던 대규모 의미적 유사도 비교(Semantic Similarity), 군집화(Clustering), 정보 검색(Semantic Search) 등의 새로운 작업을 수행할 수 있음

기존 BERT는 문장 간 관계를 직접 비교해야 하는 Cross-Encoder 구조라서 문장 임베딩을 독립적으로 생성하는 것이 불가능했음

하지만 SBERT는 Siamese 및 Triplet 네트워크를 활용해 문장을 고정된 크기의 벡터로 변환 가능

 

이를 활용하면 대규모 문장 비교 및 검색이 가능해지고, 계산 속도가 획기적으로 향상됨

 

기존 BERT의 문제점 

 

• BERT는 문장 분류(Classification) 및 문장 쌍 회귀(Sentence-Pair Regression) 태스크에서 최고 성능을 기록했지만, 계산량이 너무 많음 
• Cross-Encoder 구조 때문에 두 문장을 매번 같이 입력해야 함 → 문장이 많을수록 계산량이 기하급수적으로 증가

예제:

 

• 10,000개 문장에서 가장 유사한 문장을 찾으려면 50억 회 연산이 필요
• 최신 GPU(V100)에서도 65시간이 걸림 (지금은 구형인데... 그 때 당시에는 최신이었나보네요...)
• Quora에서 4천만 개 질문 중 가장 유사한 질문을 찾으려면 50시간 이상 소요됨

 

BERT의 Cross-Encoder 구조 문제점

 

• 기존 BERT는 두 문장을 [SEP] 토큰으로 구분해 입력 → BERT 내부에서 어텐션을 통해 관계를 학습
• 즉, 문장 비교를 하려면 모든 문장 쌍을 BERT에 넣어야 함 → 계산량이 O(n²)로 폭발적 증가
• 실제 예시 (문장이 10,000개인 경우)
• 비교해야 할 문장 쌍 수:
  • \(n \times (n - 1) / 2 = 10,000 \times 9,999 / 2 = 49,995,000\)
  • BERT 연산량: 50억 회 이상 → 실제 계산 시간: 65시간
• 대규모 검색(예: Quora 질문 검색)에서는 BERT 사용이 현실적으로 어려움

기존의 해결방법과 그에 대한 한계

• 일반적인 해결 방법: 문장을 벡터 공간(Vector Space)에 매핑하여 유사한 문장끼리 가깝게 배치하는 방식
• BERT 임베딩(Embedding) 방식 두 가지:
  1. BERT 출력 벡터를 평균(Average Pooling)
  2. BERT의 [CLS] 토큰을 문장 벡터로 사용
• 그러나 이 방법들은 오히려 GloVe(2014) 임베딩보다 성능이 낮음

기존 BERT를 활용해 문장을 벡터화하려 했지만, 문장 간 의미적 관계를 잘 반영하지 못함

특히 BERT의 [CLS] 토큰을 사용하면 성능이 더 낮음

 

 

그래서 나온 SBERT의 해결책

 

• SBERT는 Siamese 네트워크 구조를 활용해 문장을 고정된 크기의 벡터로 변환
• 코사인 유사도(Cosine Similarity), 맨해튼 거리(Manhattan Distance), 유클리드 거리(Euclidean Distance) 등을 활용해 문장 비교 가능
• 이 방식은 최신 하드웨어에서 매우 효율적으로 동작하며, 의미적 유사성 검색(Semantic Search) 및 군집화(Clustering) 작업을 가능하게 함

SBERT의 성능 평가

 

• SBERT는 STS 태스크에서 기존 방법보다 성능이 크게 향상됨
  • InferSent 대비 11.7점 향상
  • Universal Sentence Encoder 대비 5.5점 향상

---

3.  Related Work

BERT와 기존 문장 임베딩 방법 소개

 

BERT를 소개한 후, 최신 문장 임베딩(sentence embedding) 기법을 단계적으로 소개한다는 내용 

즉, BERT의 한계와 이를 해결하는 SBERT의 필요성을 설명하려는 구조

 

BERT는 사전 학습된 Transformer 모델

• 질문 응답(Question Answering), 문장 분류(Sentence Classification), 문장 쌍 회귀(Sentence-Pair Regression) 등에서 최고 성능을 기록
• BERT는 Transformer(Self-Attention 기반) 모델
• 사전 학습(Pre-training) 후, 다양한 NLP 태스크에 미세 조정(Fine-tuning)하여 사용 가능

BERT는 문장 쌍(Sentence Pair)을 입력으로 받아, [SEP] 토큰으로 구분하여 처리

• 12층(BERT-base) 또는 24층(BERT-large) Transformer 레이어를 거친 후, 마지막에 회귀 함수(Regression Function)를 사용하여 결과를 예측
• BERT는 Cross-Encoder 구조를 사용하여 두 문장의 관계를 학습
• 하지만, 이 방식은 독립적인 문장 임베딩을 생성할 수 없다는 문제가 있음

BERT를 대체하여 문장간의 유사도를 효율적이게 계산하기 위한 노력

• RoBERTa:
  • BERT보다 더 많은 데이터를 활용하고, 동적 마스킹(Dynamic Masking) 등 사전 학습 방식에 최적화를 적용
  • 결과적으로 BERT보다 더 높은 성능을 보임

• XLNet:
  • Auto-Regressive(AR) 방식을 사용하여 문맥을 학습 (BERT는 Masked Language Model(MLM) 방식 사용)
  • Permutation-based Training(순열 학습) 방식을 적용하여 더 다양한 문맥을 학습 가능
  • BERT보다 성능이 낮았음
  • 결과적으로 STS(문장 유사도) 및 검색 관련 작업에서 BERT보다 성능이 낮았음

BERT의 문장 임베딩 한계

 

• BERT는 독립적인 문장 임베딩을 생성할 수 없음 → 문장 비교가 필요할 때 모든 문장 쌍을 매번 BERT에 넣어야 함 → 계산량이 너무 많음
• BERT는 Cross-Encoder 방식이라 문장 자체를 벡터로 변환하지 않고, 두 문장을 직접 비교해야 함 → 이로 인해 문장 간 의미적 유사성을 빠르게 비교하는 작업에 적합하지 않음

기존 BERT 기반 문장 임베딩 방법과 한계

 

• 연구자들은 BERT의 한계를 해결하기 위해 두 가지 방법을 사용

1. BERT의 출력 벡터를 평균(Average Pooling)하여 문장 임베딩으로 사용

2. BERT의 [CLS] 토큰 출력을 문장 임베딩으로 사용

 

하지만 이 방법들은 문장 의미를 제대로 반영하지 못함, 특히 CLS 토큰만 사용하는 방식은 성능이 낮음

 

SBERT의 개선점

 

• SBERT는 Siamese & Triplet 네트워크 구조를 활용하여 문장을 독립적인 벡터로 변환
• 즉, Cross-Encoder 방식이 아닌 Sentence-Pair를 따로 벡터화하여 비교 가능
• 결과적으로 문장 검색, STS(문장 유사도), 문장 군집화 등에 활용 가능

 

SBERT 내부 표현하는 Figure1, Figure2

 

Figure.1

SBERT는 학습 시 샴쌍둥이 네트워크(Siamese Network) 구조를 사용

• 두 개의 BERT 네트워크가 동일한 가중치를 공유(tied weights)
• SNLI(Sentence NLI) 데이터셋과 같은 분류(Classification) 태스크에서 미세 조정(Fine-tuning) 가능

Siamese Network 구조를 사용:

 

동일한 BERT 모델을 두 개 사용하여, 두 문장을 각각 임베딩

 

이 두 네트워크는 가중치를 공유(Tied Weights) → 즉, 같은 BERT 모델을 두 번 사용하는 것과 같음

이를 통해 두 문장이 유사한지, 관련성이 있는지를 학습

 

• SNLI 데이터셋에서 미세 조정
  • SNLI(Sentence Natural Language Inference) 데이터셋은 문장 간 관계를 예측하는 태스크

예: (A, B) 문장 쌍이 주어졌을 때 → Entailment(함축), Contradiction(모순), Neutral(중립) 예측

이 과정에서 SBERT는 문장 임베딩을 더 유의미한 벡터로 학습

 

Figure.2 

• 추론(Inference) 시에는 문장을 독립적인 벡터로 변환한 후, 유사도를 계산
• 코사인 유사도(Cosine Similarity) 또는 회귀(Regression) 함수 사용 가능

 

학습이 끝난 후 추론 단계에서는 BERT를 한 번만 실행하여 문장을 독립적인 벡터로 변환

• 이전 BERT의 Cross-Encoder 방식과 달리, SBERT는 미리 계산된 벡터 간의 비교만 수행 가능
• 유사도 계산 방식:
  • 코사인 유사도 (Cosine Similarity) → 두 문장이 얼마나 비슷한지 측정
  • 유클리드 거리 (Euclidean Distance), 맨해튼 거리 (Manhattan Distance) → 거리 기반 비교 가능
  • 회귀 모델(Regression Function) → 문장 간 유사도를 연속적인 값으로 예측 가능

---

4. Model

 

이 부분에서는 SBERT의 문장 임베딩 방식, 학습 방식(시암쌍둥이 네트워크, 트리플렛 네트워크), 그리고 최적화 목표(손실 함수)에 대해 설명하고 있음 

 

1. SBERT의 문장 임베딩 방식

 

• SBERT는 BERT/RoBERTa의 출력을 고정 크기의 문장 임베딩으로 변환하기 위해 “Pooling 연산”을 추가함
• BERT 자체는 문장 전체를 고려한 고정 크기 벡터를 제공하지 않으므로, SBERT에서 추가적인 연산이 필요
• 기존 BERT는 [CLS] 토큰을 활용하거나, 단어 단위 벡터를 개별적으로 제공
• 하지만 SBERT는 “문장 단위의 벡터(Sentence Embedding)” 가 필요하기 때문에, 추가적인 Pooling 기법을 적용

SBERT에서는 문장 임베딩을 생성할 때, 3가지 Pooling 전략을 실험함

 

1. CLS 전략: [CLS] 토큰의 출력값을 사용

2. MEAN 전략: 모든 출력 벡터의 평균값을 사용 (기본 설정)

3. MAX 전략: 모든 출력 벡터에서 최대값을 선택

 

CLS 토큰 사용 (CLS-strategy)

• Transformer의 [CLS] 토큰은 문장 전체를 대표하는 특수 토큰
• 하지만, 실험 결과 문장 의미를 제대로 반영하지 못하는 경우가 많음

출력 벡터 평균 (MEAN-strategy, 기본값)

• 모든 단어의 출력 벡터를 평균 내어 문장 임베딩 생성
• 문장 전체 의미를 고르게 반영할 수 있어 기본 설정으로 사용됨

출력 벡터 최대값 (MAX-strategy)

• 각 차원에서 최댓값을 선택하여 문장 벡터 생성
• 중요한 단어의 특징을 더 강조할 수 있음

 2. SBERT 학습 방식 (Siamese & Triplet Network)

 

• SBERT는 BERT/RoBERTa를 “Siamese & Triplet 네트워크” 방식으로 미세 조정(Fine-tuning)
• 이 과정을 통해 문장 임베딩이 의미적으로 유의미한 벡터로 학습됨
• 최종적으로 코사인 유사도(Cosine Similarity) 등의 거리 측정 방법을 통해 비교 가능

Siamese 네트워크

• 동일한 가중치를 공유하는 두 개의 BERT 네트워크를 사용하여 두 문장의 임베딩을 비교
• 문장 간 유사도를 코사인 유사도로 측정

 

Triplet 네트워크

• 한 개의 기준 문장(Anchor), 유사한 문장(Positive), 다른 문장(Negative) 세 개를 한 번에 학습
• 네트워크가 유사한 문장은 가깝게, 다른 문장은 멀리 떨어지도록 조정

3. SBERT의 손실 함수 (Objective Functions)

 

1) 분류(Classification) 손실 함수

 

\(o = softmax(W_t (u, v, |u - v|))\)

 

• \(u, v\) = 문장 임베딩 벡터
• \(W_t\) = 학습 가능한 가중치 행렬
• \(|u - v|\) = 두 벡터 간의 절댓값 차이
• 목표: 두 문장이 주어졌을 때 분류(Labeling) 문제로 변환하여 예측
• 손실 함수: Cross-Entropy Loss

 

 2) 회귀(Regression) 손실 함수

 

\(\text{similarity} = \frac{u \cdot v}{||u|| \times ||v||}\)

 

• 문장 임베딩 간 코사인 유사도를 계산하여 유사성 점수를 예측
• 손실 함수: Mean Squared Error (MSE) Loss
• 활용 사례: STS(Semantic Textual Similarity) 태스크

3) 트리플렛(Triplet) 손실 함수

 

\(L = \max(||s_a - s_p|| - ||s_a - s_n|| + \epsilon, 0)\)

 

• \(s_a\) = 기준 문장(Anchor) 임베딩
• \(s_p\) = 유사한 문장(Positive) 임베딩
• \(s_n\) = 다른 문장(Negative) 임베딩
• \(|| \cdot ||\) = 거리 함수 (유클리드 거리)
• \(\epsilon\) = 마진 값 (실험에서는 \(\epsilon = 1\) 사용)

목표:

• 유사한 문장은 더 가깝게, 다른 문장은 멀어지도록 조정
• 예를 들어, "I love coffee." 와 "I enjoy drinking coffee." 가 "I like football." 보다 가까운 벡터가 되도록 학습

✅ 손실 함수: Triplet Loss

 

• \(||s_a - s_p||\) (Anchor와 Positive의 거리)를 줄이고,
• \(||s_a - s_n||\) (Anchor와 Negative의 거리)를 크게 만듦

 

---

 

 

4.1 Training Details

 

📌 SBERT의 학습 과정:

 

데이터셋:

• SNLI(Sentence Natural Language Inference, 57만 개 문장 쌍)
• MultiNLI(Multi-Genre NLI, 43만 개 문장 쌍, 다양한 장르 포함)

학습 목표:

• 3-way Softmax 분류(Classification) 방식 사용
• 문장 간 관계를 “Contradiction(모순), Entailment(함축), Neutral(중립)“로 분류

하이퍼파라미터 설정:

• 배치 크기(Batch size): 16
• 최적화 함수(Optimizer): Adam
• 학습률(Learning rate): 2 \times 10^{-5}
• 학습률 스케줄링: 전체 데이터의 10% 동안 선형 워밍업(Linear Warm-up)

Pooling 방식: MEAN(출력 벡터 평균) 사용 (기본값)

 

 

---

5. Evaluation - Semantic Textual Similarity

 

🔹 SBERT의 STS 평가 요약

 

✅ 기존 STS 모델의 문제점

• 기존 방식(BERT 등)은 문장 임베딩 없이 문장 쌍을 직접 비교해야 하므로 계산량이 많음 (O(n²))
• BERT의 CLS 토큰(29.19) 및 평균 풀링(54.81)의 STS 성능이 낮음 → 문장 임베딩 품질이 좋지 않음

✅ SBERT의 개선점

• 코사인 유사도(Cosine Similarity) 기반 비교를 활용하여 연산량 감소
• BERT + NLI 데이터셋으로 학습된 Siamese Network 구조를 적용하여 문장 임베딩 품질 개선

✅ 실험 결과

• SBERT는 InferSent 및 Universal Sentence Encoder보다 높은 성능을 기록
• 다만, SICK-R 데이터셋에서는 Universal Sentence Encoder가 더 좋은 성능을 보임
• SBERT와 SRoBERTa의 문장 임베딩 성능 차이는 거의 없음

SBERT의 STS 성능 평가 표

 

4.3 Argument Facet Similarity (주장 측면 유사도 평가)

 

✅ 실험 목적:

SBERT가 서로 다른 주장(Arguments)에서 특정 측면(Facet)이 얼마나 유사한지 평가하는 AFS 태스크에서 얼마나 효과적인지 테스트

 

✅ 결과:

SBERT는 InferSent 및 Universal Sentence Encoder보다 높은 성능 기록

SRoBERTa와의 성능 차이는 크지 않음

 

4.4 Wikipedia Sections Distinction (위키피디아 섹션 구별 태스크)

 

✅ 실험 목적:

같은 위키피디아 문서의 다른 섹션에서 나온 문장을 구별할 수 있는지 평가

 

✅ 결과:

SBERT는 기존 문장 임베딩 모델보다 우수한 성능 기록

Triplet Loss 기반 학습이 효과적이었음

 

✅ 결론:

SBERT는 문서 내 섹션 구별, 문서 구조 분석, 뉴스 기사 구조 분석 등에 활용 가능

 

 

4.5 SentEval (문장 임베딩 일반화 성능 평가)

 

SBERT가 다양한 NLP 태스크에서 얼마나 범용적인 문장 임베딩 모델인지 평가

 

✅ 결과:

SBERT는 InferSent 및 Universal Sentence Encoder보다 높은 성능을 기록

Siamese 네트워크와 MEAN Pooling이 가장 효과적

 

Ablation Study (설계 요소별 성능 분석)

 

✅ 실험 목적:

SBERT의 각 구성 요소(예: Pooling 방법, 네트워크 구조 등)가 성능에 미치는 영향을 분석

 

✅ 결과:

MEAN Pooling 전략이 가장 높은 성능을 기록 (기본 설정)

Triplet Loss를 추가하면 STS 성능이 향상됨

BERT와 RoBERTa 기반 모델 간의 차이는 크지 않음

 

 

Computational Efficiency (계산 효율성 비교)

 

✅ 실험 목적:

SBERT가 기존 BERT보다 얼마나 빠르게 문장 비교 및 검색을 수행할 수 있는지 평가

 

✅ 결과:

BERT는 문장 비교 시 O(n²) 계산량 필요 → 10,000개 문장 비교에 65시간 소요

SBERT는 O(n)만 필요 → 10,000개 문장 비교에 5초 소요

 

SBERT가 STS Benchmark(STSb)에서 기존 BERT 및 다른 모델들과 비교하여 얼마나 좋은 성능을 보이는지 평가

 

나머지 실험들은 대동소이 해서 결론이랑 중요하다고 판단되는 요소들만 정리하겠습니다.

 

 

Computational Efficiency

Computational Efficiency (계산 효율성 비교)

 

SBERT와 기존 BERT의 문장 비교 속도를 비교하여, SBERT가 얼마나 효율적인지 평가

 

 

BERT (Cross-Encoder 방식)

• 문장 비교 시 O(n²) 계산량 필요
• 10,000개 문장 비교 → 65시간 소요

SBERT (Siamese Network 방식)

• 문장 임베딩을 미리 저장 → O(n) 계산량만 필요
• 10,000개 문장 비교 → 5초 소요

모델에 따른 장당 처리 속도(문장/초)

 

Conclusion

 

✅ SBERT의 핵심 기여:

 

• 기존 BERT의 Cross-Encoder 구조 문제(BERT는 문장 쌍을 직접 비교해야 해서 비효율적)를 해결
• Siamese & Triplet 네트워크를 활용해 독립적인 문장 임베딩 생성 가능
• 코사인 유사도를 활용하여 빠르고 효율적인 문장 비교 가능

✅ 실험 결과 요약:

• STS 및 다양한 NLP 태스크에서 SBERT가 InferSent, Universal Sentence Encoder보다 높은 성능 기록
• SBERT는 기존 BERT보다 46,800배 빠르게 문장 비교 가능 (O(n²) → O(n))
• SBERT-NLI는 NLI 데이터로 사전 학습하면 더욱 강력한 성능을 보임
• SRoBERTa와 SBERT의 성능 차이는 크지 않음

 

최종 결론 

# SBERT 실행 아키텍처 다이어그램

            ┌────────────────────────┐
            │  입력 문장 (Sentence)    │
            └──────────┬─────────────┘
                       │
                       ▼
            ┌────────────────────────┐
            │   BERT 토크나이징         │
            │ (Tokenization & Embedding) │
            └──────────┬─────────────┘
                       │
                       ▼
            ┌────────────────────────┐
            │   Transformer 인코딩     │
            │  (Self-Attention 연산)  │
            └──────────┬─────────────┘
                       │
                       ▼
          ┌────────────────────────┐
          │  Pooling (MEAN/CLS/MAX)│
          └──────────┬─────────────┘
                     │
                     ▼
         ┌────────────────────────┐
         │  문장 임베딩 (Embedding)  │
         └──────────┬─────────────┘
                     │
                     ▼
        ┌───────────────────────────┐
        │  코사인 유사도 계산           │
        │ (Cosine Similarity)       │
        └──────────┬───────────────┘
                     │
                     ▼
     ┌────────────────────────────────┐
     │    결과 출력 (유사도 점수)          │
     └────────────────────────────────┘

 

✅ 설명:

1. 입력 문장 → BERT 토크나이징(Tokenization)
2. Transformer(Self-Attention) 연산 수행
3. Pooling 전략 적용 (MEAN, CLS, MAX 중 선택)
4. 문장 벡터(Embedding) 생성
5. 코사인 유사도(Cosine Similarity) 계산
6. 최종 유사도 점수 출력