BERT 설명: 아키텍처, 사전 훈련 및 미세 조정
2018년은 자연어 처리 역사에 전환점이 되는 해였습니다. 의 출판과 함께 BERT(변압기의 양방향 인코더 표현), Google AI 팀은 11개 NLP 벤치마크에서 동시에 최첨단 기술을 재정의한 모델을 도입했습니다. 에 대한 최초로 사전 훈련된 단일 모델을 매우 다양한 작업에 적용할 수 있었습니다. (분류, 질의 응답, NER) 모든 전문 시스템에 대해 우수한 결과 획득 전례.
하지만 BERT가 그토록 혁명적인 이유는 무엇입니까? 그 답은 세 가지 근본적인 혁신에 있습니다. 는 심오한 양방향성, il 대규모 사전 훈련 그리고 단순함 미세 조정 다운스트림 작업용. 이 기사에서 우리는 분석할 것입니다 내부 주의 메커니즘부터 구현까지 BERT 아키텍처의 모든 측면 HuggingFace를 사용하여 파생된 변형을 통과하면서 연습해 보세요.
이 시리즈의 두 번째 기사입니다. 최신 NLP: BERT에서 LLM까지. 기본 사항(토큰화, 임베딩 및 NLP 파이프라인)에 대한 첫 번째 기사를 아직 읽지 않았다면, 계속하기 전에 이 작업을 수행하는 것이 좋습니다. 여기서 다루는 많은 개념은 구성되어 있습니다. 그 기지에.
무엇을 배울 것인가
- BERT가 NLP의 혁명을 대표하는 이유와 이전 모델의 한계
- BERT의 기반이 되는 Transformer 인코더 전용 아키텍처
- 다중 헤드 셀프 어텐션 작동 방식 및 수학 공식
- 입력 표현: 토큰, 세그먼트 및 위치 임베딩
- 두 가지 사전 학습 전략: MLM(Masked Language Model) 및 NSP(다음 문장 예측)
- WordPiece 토큰화 및 특수 토큰 [CLS], [SEP], [MASK]
- 분류, NER, 질문 답변을 위한 미세 조정 방법
- HuggingFace Transformers를 사용한 완벽한 실습 구현
- BERT 변형: RoBERTa, ALBERT, DistilBERT, DeBERTa, ELECTRA
- 이탈리아어용 BERT: 사용 가능한 모델 및 비교
- BERT의 한계와 이후 모델이 이를 극복한 방법
시리즈 개요
| # | Articolo | 집중하다 |
|---|---|---|
| 1 | NLP 기초 | 토큰화, 임베딩, 파이프라인 |
| 2 | 현재 위치 - BERT 및 Transformer | Attention 아키텍처, 사전 학습 |
| 3 | 감성 분석 | BERT를 사용한 텍스트 분류 |
| 4 | 명명된 엔터티 인식 | 텍스트에서 엔터티 추출 |
| 5 | 허깅페이스 트랜스포머 | 사전 학습된 라이브러리 및 모델 |
| 6 | 모델 미세 조정 | 귀하의 도메인에 BERT를 적용하십시오 |
| 7 | 이탈리아어를 위한 NLP | 이탈리아어용 템플릿 및 리소스 |
| 8 | BERT에서 LLM까지 | GPT, LLaMA 및 텍스트 생성 |
1. BERT가 NLP에 혁명을 일으킨 이유
BERT의 영향을 이해하려면 2018년 이전 NLP 환경으로 돌아가서 이전 모델이 해결하지 못한 근본적인 문제는 무엇입니까?
1.1 Word2Vec과 GloVe의 한계
시리즈의 첫 번째 기사에서 보았듯이, Word2Old (2013) 전자 장갑 (2014)은 중요한 전환점이 되었다. 의미론적 관계가 연속된 공간에서 밀집된 벡터로 표현되었습니다. '왕-남자+여자=여왕'이 공간의 기하학에서 자연스럽게 등장한 것이다.
그러나 이러한 모델에는 근본적인 한계가 있습니다. 정적 표현. 각 단어에는 고유한 벡터가 있습니다. 그것이 나타나는 맥락에 관계없이. "벤치"라는 단어를 생각해 봅시다.
정적 표현의 문제
- "내가 돈을 넣었어. 벤치"(은행 기관)
- "그만큼 벤치 그 사람 학교 다닐 때 너무 어렸어요" (모바일)
- "에이 벤치 안개가 계곡을 덮었다" (안개 덩어리)
- "그만큼 벤치 물고기 떼는 엄청났다" (물고기 떼)
Word2Vec에서는 "bank"라는 단어에 고유한 퍼지 평균인 벡터 이 모든 의미 중. 모델에는 상황을 구별할 방법이 없습니다.
1.2 ELMo: 상황을 향한 첫 번째 단계
BERT 이전인 2018년에는 ELMo(언어 모델의 임베딩) 작성자: AllenAI 이미 상황의 문제를 해결하려고 시도했습니다. ELMo는 네트워크를 사용했습니다. biLSTM (양방향 장단기 기억) 작업에 대해 사전 훈련됨 상황에 맞는 임베딩을 생성하기 위한 언어 모델링.
ELMo의 문제는 두 가지였습니다. 첫째, 양방향이었습니다. 표면적인, 두 개의 LSTM(하나는 앞으로, 하나는 뒤로)이 연결되었지만 연결되지 않았다는 의미에서 처리하는 동안 상호작용했습니다. 둘째, LSTM은 다음과 같은 문제를 겪습니다. 정보 병목 현상: 장기적인 의존성은 점차적으로 "잊혀진다" 시퀀스가 길어질수록.
1.3 전환점: 깊은 양방향성
BERT는 다음 메커니즘 덕분에 두 가지 문제를 모두 해결합니다. 자기 관심 트랜스포머의. 시퀀스의 각 토큰은 다른 모든 토큰을 "감시"할 수 있습니다. 동시에 왼쪽과 오른쪽에 있는 것들도 마찬가지입니다. 이 양방향성은 그렇지 않습니다. ELMo에서와 같이 두 개의 개별 모델을 연결하지만 아키텍처의 모든 단일 레이어에서 발생합니다.
비교: 양방향성에 대한 접근 방식
| 모델 | 유형 | 문맥 | 한정 |
|---|---|---|---|
| Word2Vec/GloVe | 공전 | 맥락 없음 | 단어당 하나의 벡터 |
| GPT-1 | 단방향(왼쪽 -> 오른쪽) | 이전 컨텍스트만 | 그 사람은 미래를 보지 못해요 |
| 헬멧 | 표면적 양방향 | 연결된 컨텍스트 | 방향 간 상호 작용 없음 |
| 버트 | 깊은 양방향 | 모든 계층의 전체 컨텍스트 | 인코더만(생성 없음) |
이러한 심오한 양방향성이 바로 BERT가 에 대한 새로운 기록 11가지 NLP 벤치마크 출판 당시, GLUE, SQuAD 1.1, SQuAD 2.0 및 MultiNLI를 포함합니다.
2. BERT 아키텍처: 인코더 변환기
BERT는 모델입니다 인코더 전용즉, 인코더 부분만 사용합니다. "Attention Is All You Need"(2017) 논문에 설명된 원래 Transformer 아키텍처의 내용입니다. 각 구성요소를 자세히 살펴보겠습니다.
2.1 아키텍처 개요
BERT의 아키텍처는 일련의 Transformer 블록으로 시각화될 수 있습니다. 수직으로 쌓였습니다. 각 블록에는 다중 헤드 Self-Attention 레이어가 포함되어 있습니다. 그 다음에는 정규화 계층과 잔여 연결이 있는 피드포워드 네트워크가 옵니다.
Input: [CLS] Il gatto si siede sul tappeto [SEP]
| | | | | | |
+-----+-------+-----+----+-----+----+-------+-----+
| Token Embeddings |
| + Segment Embeddings |
| + Position Embeddings |
+-----+-------+-----+----+-----+----+-------+-----+
| | | | | | |
+---------------------------------------------------------+
| Transformer Encoder Block 1 |
| +---------------------------------------------------+ |
| | Multi-Head Self-Attention | |
| | Q = XWq K = XWk V = XWv | |
| | Attention(Q,K,V) = softmax(QK^T/sqrt(dk))V | |
| +---------------------------------------------------+ |
| | Add & Layer Norm | |
| +---------------------------------------------------+ |
| | Feed-Forward Network | |
| | FFN(x) = max(0, xW1 + b1)W2 + b2 | |
| +---------------------------------------------------+ |
| | Add & Layer Norm | |
+---------------------------------------------------------+
| | | | | | |
... ... ... ... ... ... ...
| | | | | | |
+---------------------------------------------------------+
| Transformer Encoder Block L (12 o 24) |
+---------------------------------------------------------+
| | | | | | |
[CLS]out T1 T2 T3 T4 T5 T6 [SEP]out
|
Pooling --> Classificazione / Output per task
2.2 BERT 기반 vs BERT 대규모
원본 논문에서는 두 가지 구성을 제안합니다.
BERT 구성
| 매개변수 | BERT 기본 | BERT-대형 |
|---|---|---|
| 변압기 레이어(L) | 12 | 24 |
| 숨겨진 크기(H) | 768 | 1024 |
| 어텐션 헤드(A) | 12 | 16 |
| 총 매개변수 | 1억 1천만 | 340M |
| 어둑한. 머리용 | 768/12 = 64 | 1024/16 = 64 |
| 피드포워드 치수 | 3072(4x768) | 4096(4x1024) |
| 최대 시퀀스 길이 | 512 | 512 |
| 어휘 크기 | 30,522 | 30,522 |
2.3 입력 표현: 세 가지 임베딩
BERT의 혁신 중 하나는 바로 당신의 것입니다 입력의 표현, 세 가지 개별 임베딩의 합으로 구성됩니다.
Input: [CLS] Il gatto dorme [SEP] Il cane corre [SEP]
| | | | | | | | |
Token Emb: E[CLS] E_il E_gatto E_dorme E[SEP] E_il E_cane E_corre E[SEP]
+ + + + + + + + +
Segment Emb: EA EA EA EA EA EB EB EB EB
+ + + + + + + + +
Position Emb: E0 E1 E2 E3 E4 E5 E6 E7 E8
= = = = = = = = =
Input finale: I0 I1 I2 I3 I4 I5 I6 I7 I8
토큰 임베딩: 시퀀스의 각 토큰은 밀집된 벡터에 매핑됩니다. 학습된 임베딩 행렬을 통해 크기 H(BERT 기반의 경우 768) 훈련. WordPiece 어휘에는 30,522개의 토큰이 포함되어 있습니다.
세그먼트 임베딩: BERT는 하나 또는 두 개의 별도 문장을 입력으로 받을 수 있습니다. 토큰 [SEP]. 세그먼트 임베딩은 각 토큰이 속한 문장을 나타냅니다. 모든 토큰 첫 번째 문장의 임베딩을 수신합니다. E_A, 두 번째 E_B. 이는 BERT가 추론해야 하는 자연어 추론과 같은 작업에 기본입니다. 두 문장의 관계에 대해
위치 임베딩: 함수를 사용하는 원래 Transformer와는 달리 정현파, BERT는 위치 임베딩을 사용합니다. 나는 배웠다. 모든 직위 (0 ~ 511)에는 훈련 중에 학습된 벡터가 있습니다. 이는 BERT가 처리할 수 있음을 의미합니다. 최대 512개의 토큰 시퀀스.
from transformers import BertTokenizer, BertModel
import torch
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertModel.from_pretrained('bert-base-uncased')
# Tokenizzare un input con due frasi
text_a = "Il gatto dorme"
text_b = "Il cane corre"
encoded = tokenizer(text_a, text_b, return_tensors='pt')
print("Token IDs:", encoded['input_ids'])
print("Token Type IDs (Segments):", encoded['token_type_ids'])
print("Attention Mask:", encoded['attention_mask'])
# Decodifica per vedere i token
tokens = tokenizer.convert_ids_to_tokens(encoded['input_ids'][0])
print("Tokens:", tokens)
# Output: ['[CLS]', 'il', 'gatto', 'dor', '##me', '[SEP]', 'il', 'cane', 'cor', '##re', '[SEP]']
# Accesso agli embedding layers
token_embeddings = model.embeddings.word_embeddings
position_embeddings = model.embeddings.position_embeddings
segment_embeddings = model.embeddings.token_type_embeddings
print(f"Token embedding matrix: {token_embeddings.weight.shape}")
# Output: Token embedding matrix: torch.Size([30522, 768])
print(f"Position embedding matrix: {position_embeddings.weight.shape}")
# Output: Position embedding matrix: torch.Size([512, 768])
print(f"Segment embedding matrix: {segment_embeddings.weight.shape}")
# Output: Segment embedding matrix: torch.Size([2, 768])2.4 다중 헤드 Self-Attention
BERT(및 모든 Transformer)의 핵심과 메커니즘 자기 관심. 직관적으로 셀프 어텐션을 통해 각 토큰은 다른 모든 토큰을 "감시"할 수 있습니다. 순서대로 그리고 각각이 귀하의 표현과 얼마나 관련이 있는지 결정하십시오.
스케일링된 내적 주의
각 토큰에 대해 Attention은 학습된 선형 투영을 통해 세 가지 벡터를 계산합니다.
- 쿼리(Q): "내가 뭘 찾고 있는 거지?"
- 키(K): "무엇을 제안하나요?"
- 가치(V): "어떤 정보를 가져오나요?"
주의 공식은 다음과 같습니다.
주의(Q, K, V) = 소프트맥스\left(\frac{QK^T}{\sqrt{d_k}}\right)V어디 d_k 키의 크기(BERT 기반의 경우 64). 요인 \frac{1}{\sqrt{d_k}} 안정시키는 역할을 한다. 그래디언트: 이 스케일링이 없으면 내적은 다음에 대해 매우 큰 값을 생성합니다. 높은 차원성을 가지며 소프트맥스는 "포화"되어 거의 원-핫 분포를 생성합니다.
다중 헤드 주의
단일 주의 함수를 계산하는 대신 BERT는 다음을 사용합니다. 멀티 헤드 주의: 계산이 복제됩니다. h 횟수(BERT 기반의 경우 12번, BERT 기반의 경우 16번) BERT-large), 각각 서로 다른 투영 행렬을 사용합니다. 이를 통해 모델은 다음을 수행할 수 있습니다. 다양한 유형의 관계를 동시에 포착합니다. 책임자는 전문화할 수 있습니다. 구문적 관계에서, 상호 참조에서 또 다른, 의미론적 종속에서 또 다른 것입니다.
멀티헤드(Q, K, V) = Concat(head_1, ..., head_h)W^O head_i = 주의(QW_i^Q, KW_i^K, VW_i^V)어디 W_i^Q \in \mathbb{R}^{d_{모델} \times d_k}, W_i^K \in \mathbb{R}^{d_{모델} \times d_k}, W_i^V \in \mathbb{R}^{d_{모델} \times d_v} e W^O \in \mathbb{R}^{hd_v \times d_{모델}}.
import torch
import torch.nn.functional as F
import math
def scaled_dot_product_attention(Q, K, V, mask=None):
"""Calcolo dell'attention scalata."""
d_k = Q.size(-1)
# Calcolo dei punteggi di attention
scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(d_k)
# Applicazione della maschera (opzionale)
if mask is not None:
scores = scores.masked_fill(mask == 0, float('-inf'))
# Softmax per ottenere i pesi
attention_weights = F.softmax(scores, dim=-1)
# Output pesato
output = torch.matmul(attention_weights, V)
return output, attention_weights
class MultiHeadAttention(torch.nn.Module):
"""Multi-Head Attention come in BERT."""
def __init__(self, d_model=768, num_heads=12):
super().__init__()
self.d_model = d_model
self.num_heads = num_heads
self.d_k = d_model // num_heads # 64 per BERT-base
self.W_q = torch.nn.Linear(d_model, d_model)
self.W_k = torch.nn.Linear(d_model, d_model)
self.W_v = torch.nn.Linear(d_model, d_model)
self.W_o = torch.nn.Linear(d_model, d_model)
def forward(self, x, mask=None):
batch_size, seq_len, _ = x.size()
# Proiezioni lineari
Q = self.W_q(x) # (batch, seq_len, d_model)
K = self.W_k(x)
V = self.W_v(x)
# Reshape per multi-head: (batch, heads, seq_len, d_k)
Q = Q.view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2)
K = K.view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2)
V = V.view(batch_size, seq_len, self.num_heads, self.d_k).transpose(1, 2)
# Attention per ogni head
attn_output, attn_weights = scaled_dot_product_attention(Q, K, V, mask)
# Concatenazione delle head
attn_output = attn_output.transpose(1, 2).contiguous()
attn_output = attn_output.view(batch_size, seq_len, self.d_model)
# Proiezione finale
output = self.W_o(attn_output)
return output, attn_weights
# Test
mha = MultiHeadAttention(d_model=768, num_heads=12)
x = torch.randn(1, 10, 768) # batch=1, seq_len=10, dim=768
output, weights = mha(x)
print(f"Output shape: {output.shape}") # torch.Size([1, 10, 768])
print(f"Weights shape: {weights.shape}") # torch.Size([1, 12, 10, 10])2.5 피드포워드 네트워크
각 주의 레이어 이후에 BERT는 위치별 피드포워드 네트워크를 적용합니다. 동일한 네트워크가 시퀀스의 각 위치에 독립적으로 적용됩니다.
FFN(x) = \text{GELU}(xW_1 + b_1)W_2 + b_2중간 크기는 일반적으로 4회 숨겨진 차원 (BERT 기반의 경우 3072, BERT 대형의 경우 4096) BERT는 활성화 기능을 사용합니다 겔루 (Gaussian Error Linear Unit)은 기존의 ReLU 대신에 실제로 더 부드러운 전환과 더 나은 성능을 제공합니다.
2.6 레이어 정규화와 잔여 연결
BERT의 각 하위 계층(주의 및 피드포워드)은 다음과 같이 래핑됩니다. 잔여 연결 이어서 레이어 정규화:
\text{출력} = \text{LayerNorm}(x + \text{하위 레이어}(x))잔여 연결을 사용하면 경사도가 네트워크를 통해 직접 흐를 수 있습니다. 역전파 동안 매우 네트워크에서 Vanishing Gradient 문제를 방지합니다. 깊은. 레이어 정규화는 활성화를 정규화하여 훈련을 안정화합니다. 기능 차원을 따라.
import torch
import torch.nn as nn
class TransformerEncoderBlock(nn.Module):
"""Un singolo blocco encoder come in BERT."""
def __init__(self, d_model=768, num_heads=12, d_ff=3072, dropout=0.1):
super().__init__()
# Multi-Head Attention
self.attention = nn.MultiheadAttention(
embed_dim=d_model,
num_heads=num_heads,
dropout=dropout,
batch_first=True
)
# Feed-Forward Network
self.ffn = nn.Sequential(
nn.Linear(d_model, d_ff),
nn.GELU(),
nn.Dropout(dropout),
nn.Linear(d_ff, d_model),
nn.Dropout(dropout)
)
# Layer Normalization
self.norm1 = nn.LayerNorm(d_model)
self.norm2 = nn.LayerNorm(d_model)
self.dropout = nn.Dropout(dropout)
def forward(self, x, mask=None):
# Sub-layer 1: Multi-Head Attention + Residual + LayerNorm
attn_output, _ = self.attention(x, x, x, key_padding_mask=mask)
x = self.norm1(x + self.dropout(attn_output))
# Sub-layer 2: FFN + Residual + LayerNorm
ffn_output = self.ffn(x)
x = self.norm2(x + ffn_output)
return x
class BERTEncoder(nn.Module):
"""Stack di encoder blocks come in BERT-base."""
def __init__(self, num_layers=12, d_model=768, num_heads=12, d_ff=3072):
super().__init__()
self.layers = nn.ModuleList([
TransformerEncoderBlock(d_model, num_heads, d_ff)
for _ in range(num_layers)
])
def forward(self, x, mask=None):
for layer in self.layers:
x = layer(x, mask)
return x
# Test: simula BERT-base
encoder = BERTEncoder(num_layers=12, d_model=768, num_heads=12, d_ff=3072)
x = torch.randn(2, 128, 768) # batch=2, seq_len=128
output = encoder(x)
print(f"Output: {output.shape}") # torch.Size([2, 128, 768])
# Conta parametri
total_params = sum(p.numel() for p in encoder.parameters())
print(f"Parametri encoder: {total_params:,}")
# ~85M (solo encoder, senza embeddings)3. 사전 훈련: BERT가 언어를 배우는 방법
BERT는 다음을 사용하여 라벨이 지정되지 않은 엄청난 양의 텍스트에 대해 사전 학습되었습니다. 두 가지 보완적인 훈련 목표: 마스크된 언어 모델(MLM) 그리고 다음 문장 예측(NSP). 기본적인 아이디어는 모델이 이러한 자기 지도 작업을 통해 풍부한 언어 표현을 배우게 됩니다. 이 지식은 미세 조정을 통해 특정 작업으로 이전될 수 있습니다.
사전 훈련 데이터
- 책코퍼스: ~8억 단어(미출판 도서 11,000권)
- 영어 위키피디아: ~2,500M 단어(텍스트만, 표/목록 없음)
- Totale: ~33억 단어
- 훈련: TPU Pod 4개(TPU 칩 64개), BERT 기반의 경우 4일
3.1 마스크된 언어 모델(MLM)
Masked Language Model은 BERT의 주요 혁신입니다. 언어의 문제 전통적인 모델링(다음 단어 예측)은 본질적으로 단방향: 모델은 왼쪽만 볼 수 있습니다. 만들다 양방향 모델인 BERT는 부분을 마스킹하는 우아한 트릭을 도입합니다. 무작위 입력 토큰을 선택하고 모델에 이를 예측하도록 요청합니다.
80/10/10 전략
각 입력 시퀀스에 대해 15% 예측을 위해 토큰이 선택되었습니다. 선택한 토큰 중:
- 80% 특수 토큰 [MASK]로 대체됩니다.
- 10% 사전의 무작위 토큰으로 대체됩니다.
- 10% 변함없이 남아있다
이 전략은 미묘한 문제를 해결합니다. 미세 조정 중에 [MASK] 토큰이 실패합니다. 입력에는 절대 나타나지 않습니다. 모델이 사전 훈련 중에 [MASK]만 본 경우 해당 항목이 있을 것입니다. 에 사전 훈련과 미세 조정 간의 불일치. 10%를 토큰으로 대체 무작위로 추출하고 10%를 변경하지 않은 채로 두면 모델은 좋은 표현을 생성하는 방법을 학습합니다. 에 대한 모든 사람 위장한 토큰만을 위한 것이 아닙니다.
import random
import torch
from transformers import BertTokenizer
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
def apply_mlm_masking(tokens, tokenizer, mask_prob=0.15):
"""Applica la strategia di masking 80/10/10 di BERT."""
masked_tokens = list(tokens)
labels = [-100] * len(tokens) # -100 = ignora nella loss
for i in range(len(tokens)):
# Non mascherare token speciali
if tokens[i] in [tokenizer.cls_token_id, tokenizer.sep_token_id,
tokenizer.pad_token_id]:
continue
if random.random() < mask_prob:
labels[i] = tokens[i] # Salva il token originale come label
rand = random.random()
if rand < 0.8:
# 80%: sostituisci con [MASK]
masked_tokens[i] = tokenizer.mask_token_id
elif rand < 0.9:
# 10%: sostituisci con token casuale
masked_tokens[i] = random.randint(0, tokenizer.vocab_size - 1)
# else: 10%: lascia invariato
return masked_tokens, labels
# Esempio
text = "Il gatto si siede sul tappeto rosso"
encoded = tokenizer.encode(text)
print("Originale:", tokenizer.decode(encoded))
masked, labels = apply_mlm_masking(encoded, tokenizer)
print("Mascherato:", tokenizer.decode(masked))
print("Labels (posizioni da predire):",
[(i, tokenizer.decode([labels[i]])) for i in range(len(labels)) if labels[i] != -100])3.2 다음 문장 예측(NSP)
두 번째 사전 훈련 목표는 다음 문장 예측. 모든 입력의 문장 쌍(A, B)인 경우 모델은 B가 뒤에 오는 문장인지 예측해야 합니다. 실제로 원문에서는 A(IsNext) 또는 임의의 문구인 경우 (다음 아님). 데이터 세트는 쌍의 50%가 양성이 되도록 구성되었습니다. 그리고 50%는 부정적이다.
Input = [CLS] Il gatto dorme [SEP] E' stanco dopo aver giocato [SEP]
Label = IsNext (frase B segue A nel testo originale)
Input = [CLS] Il gatto dorme [SEP] Roma e' la capitale d'Italia [SEP]
Label = NotNext (frase B e' casuale, non correlata ad A)NSP 목표는 BERT가 다음과 같은 작업에 유용한 문장 간의 관계를 캡처하는 데 도움이 됩니다. 질문 응답 및 자연어 추론. 그러나 후속 연구(특히 RoBERTa)는 NSP가 필요하지 않을 수도 있고 심지어 NSP가 필요하지 않을 수도 있음을 보여주었습니다. 손상 변형 섹션에서 볼 수 있듯이 성능이 향상됩니다.
3.3 합산 손실
사전 훈련 중 BERT의 총 손실은 두 손실의 합입니다.
\mathcal{L}_{합계} = \mathcal{L}_{MLM} + \mathcal{L}_{NSP}어디 \mathcal{L}_{MLM} 토큰의 교차 엔트로피 손실 가면을 쓰고 \mathcal{L}_{NSP} 교차 엔트로피 손실 IsNext/NotNext 분류의 바이너리입니다.
4. 워드피스 토큰화
BERT는 토큰화를 사용합니다. 워드피스, 토큰화 알고리즘 어휘 효율성과 언어적 적용 범위의 균형을 맞추는 하위 단어입니다. WordPiece 및 상태 원래 Google의 기계 번역 시스템용으로 개발되었습니다.
4.1 워드피스의 작동 원리
WordPiece의 아이디어는 간단하지만 강력합니다. 개인의 어휘에서 시작하는 것입니다. 문자를 최대화하는 토큰 쌍을 반복적으로 병합합니다. 진실성 훈련 코퍼스의. 이 과정은 어휘가 따라잡을 때까지 계속됩니다. 목표 크기(BERT의 경우 30,522)
결과는 다음을 포함하는 어휘입니다.
- 전체 공통 단어(예: "the", "of", "and")
- 일반적인 접두사 및 어근(예: "un", "re", "pre")
- 로 표시된 접미사와 어미
##(예: "##ing", "##tion", "##ed") - 알 수 없는 단어를 처리하는 단일 문자
4.2 특별 토큰
WordPiece 어휘 토큰 외에도 BERT는 몇 가지 특수 토큰을 사용합니다.
BERT 특별 토큰
| 토큰 | ID | 범위 |
|---|---|---|
| [인주] | 0 | 배치의 시퀀스 길이를 표준화하기 위한 패딩 |
| [UNK] | 100 | 알 수 없는 토큰(사전에는 없음) |
| [CLS] | 101 | 시퀀스 시작, 최종 표현이 분류에 사용됩니다. |
| [9월] | 102 | 두 입력 문장 사이의 구분 기호 |
| [마스크] | 103 | 사전 훈련 중 마스크된 언어 모델용 마스크 |
from transformers import BertTokenizer
# Carica il tokenizer
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
# Tokenizzazione di parole comuni e rare
examples = [
"The cat sat on the mat",
"Electroencephalography is fascinating",
"L'intelligenza artificiale rivoluzionera il mondo",
"Tokenizzazione subword con WordPiece"
]
for text in examples:
tokens = tokenizer.tokenize(text)
ids = tokenizer.encode(text)
print(f"Testo: {text}")
print(f" Tokens: {tokens}")
print(f" IDs: {ids}")
print(f" Num tokens: {len(tokens)}")
print()
# Output per "Electroencephalography is fascinating":
# Tokens: ['electro', '##ence', '##pha', '##log', '##raphy', 'is', 'fascinating']
# La parola lunga viene spezzata in subword, ma "is" e "fascinating" restano intere
# Decodifica
encoded = tokenizer("Hello world!", return_tensors="pt")
decoded = tokenizer.decode(encoded['input_ids'][0])
print(f"Encoded -> Decoded: {decoded}")
# Output: [CLS] hello world ! [SEP]
# Vocabolario
print(f"Dimensione vocabolario: {tokenizer.vocab_size}")
# Output: 305225. 다운스트림 작업을 위한 BERT 미세 조정
BERT가 도입한 패러다임은 "사전 훈련 후 미세 조정"입니다. 사전 훈련 단계 언어에 대한 깊은 이해를 바탕으로 모델을 생성합니다. 미세 조정 단계 출력 레이어를 추가하고 훈련하여 이 모델을 특정 작업에 맞게 조정 작업의 레이블이 지정된 데이터에 대한 전체 모델(또는 그 일부).
미세 조정의 장점은 다음과 같습니다. 레이블이 지정된 데이터가 거의 없음 e 약간의 훈련 시간 모델을 처음부터 훈련시키는 것과 비교됩니다. 일반적으로 학습률이 낮은(2e-5~5e-5) 2~4세대이면 충분합니다.
5.1 텍스트 분류
텍스트 분류(감정분석, 주제 분류, 스팸 감지)의 경우, 토큰 표현이 사용됩니다 [CLS] 분류기에 대한 입력으로 선형:
Input: [CLS] Questo film e' fantastico [SEP]
|
BERT: 12 layers di Transformer Encoder
|
[CLS] output (768-dim) --> Linear(768, num_classes) --> Softmax --> Predizione
|
"Positivo" (p=0.95)
from transformers import BertForSequenceClassification, BertTokenizer
from transformers import Trainer, TrainingArguments
from datasets import load_dataset
import torch
# 1. Carica modello pre-addestrato con classification head
model = BertForSequenceClassification.from_pretrained(
'bert-base-uncased',
num_labels=2 # positivo/negativo
)
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
# 2. Prepara il dataset (esempio: IMDB reviews)
dataset = load_dataset('imdb')
def tokenize_function(examples):
return tokenizer(
examples['text'],
padding='max_length',
truncation=True,
max_length=256
)
tokenized_datasets = dataset.map(tokenize_function, batched=True)
# 3. Configura il training
training_args = TrainingArguments(
output_dir='./results',
num_train_epochs=3,
per_device_train_batch_size=16,
per_device_eval_batch_size=64,
warmup_steps=500,
weight_decay=0.01,
learning_rate=2e-5,
logging_dir='./logs',
evaluation_strategy='epoch',
save_strategy='epoch',
load_best_model_at_end=True,
)
# 4. Crea il Trainer e avvia il fine-tuning
trainer = Trainer(
model=model,
args=training_args,
train_dataset=tokenized_datasets['train'],
eval_dataset=tokenized_datasets['test'],
)
trainer.train()
# 5. Valutazione
results = trainer.evaluate()
print(f"Accuracy: {results['eval_loss']:.4f}")5.2 명명된 엔터티 인식(NER)
NER의 경우 [CLS] 토큰을 사용하는 대신 출력이 사용됩니다. 각 토큰 각각을 개체 범주(사람, 장소, 조직 등)로 분류합니다.
Input: [CLS] Mario Rossi vive a Roma [SEP]
| | | | | | |
BERT: 12 layers di Transformer Encoder
| | | | | | |
Output: O B-PER I-PER O O B-LOC O
Ogni token --> Linear(768, num_entity_types) --> Softmax --> Tipo entità
from transformers import BertForTokenClassification, BertTokenizer
from transformers import pipeline
# Usa un modello già fine-tuned per NER
ner_pipeline = pipeline(
"ner",
model="dbmdz/bert-large-cased-finetuned-conll03-english",
aggregation_strategy="simple"
)
text = "Mario Rossi works at Google in Mountain View, California"
entities = ner_pipeline(text)
for entity in entities:
print(f" {entity['word']}: {entity['entity_group']} "
f"(score: {entity['score']:.3f})")
# Output:
# Mario Rossi: PER (score: 0.998)
# Google: ORG (score: 0.997)
# Mountain View: LOC (score: 0.995)
# California: LOC (score: 0.999)5.3 질문 답변
추출적 질문 답변의 경우 BERT는 질문과 컨텍스트를 입력으로 받습니다. [SEP]로 구분됩니다. 모델은 다음의 위치를 예측해야 합니다. 시작 e fine 컨텍스트 내의 응답:
Input: [CLS] Quando e' nato Einstein? [SEP] Albert Einstein e' nato il 14 marzo 1879 [SEP]
| | | | | | | | | | | | | |
BERT: 12 layers di Transformer Encoder
| | | | | | | | | | | | | |
Start: 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.02 0.8 0.02 0.01 0.01 0.01
End: 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.85 0.01
Risposta estratta: "14 marzo 1879"
from transformers import pipeline
# Pipeline di Question Answering
qa_pipeline = pipeline(
"question-answering",
model="deepset/bert-base-cased-squad2"
)
context = """
BERT (Bidirectional Encoder Representations from Transformers)
e' un modello di linguaggio sviluppato da Google AI nel 2018.
E' stato addestrato su Wikipedia e BookCorpus, per un totale
di circa 3.3 miliardi di parole. BERT-base ha 110 milioni di
parametri e 12 layer di Transformer encoder.
"""
questions = [
"Chi ha sviluppato BERT?",
"Quanti parametri ha BERT-base?",
"Su quali dati e' stato addestrato BERT?",
"In che anno e' stato pubblicato BERT?"
]
for question in questions:
result = qa_pipeline(question=question, context=context)
print(f"D: {question}")
print(f"R: {result['answer']} (score: {result['score']:.3f})")
print()5.4 문장 쌍 분류
NLI(자연어 추론) 또는 의역 감지와 같은 작업의 경우 BERT는 다음을 수신합니다. 두 문장으로 이루어져 있으며 이들의 관계를 분류해야 합니다(수반, 모순, 중립).
from transformers import pipeline
# Natural Language Inference
nli_pipeline = pipeline(
"text-classification",
model="cross-encoder/nli-deberta-v3-small"
)
pairs = [
("Il gatto dorme sul divano", "Un animale sta riposando"),
("Il gatto dorme sul divano", "Il cane corre nel parco"),
("Tutti gli studenti hanno superato l'esame", "Nessuno studente ha fallito"),
]
for premise, hypothesis in pairs:
result = nli_pipeline(f"{premise} [SEP] {hypothesis}")
print(f"Premessa: {premise}")
print(f"Ipotesi: {hypothesis}")
print(f"Risultato: {result[0]['label']} ({result[0]['score']:.3f})")
print()6. BERT에서 임베딩 추출
특정 작업에 대한 미세 조정 외에도 BERT는 다음과 같이 매우 유용합니다. 특징 추출기. 내부 레이어에서 생성된 표현 그들은 다양한 추상화 수준에서 언어 정보를 포착합니다.
from transformers import BertTokenizer, BertModel
import torch
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertModel.from_pretrained('bert-base-uncased', output_hidden_states=True)
model.eval()
text = "Il Natural Language Processing e' affascinante"
inputs = tokenizer(text, return_tensors='pt')
with torch.no_grad():
outputs = model(**inputs)
# outputs contiene:
# - last_hidden_state: output dell'ultimo layer (batch, seq_len, 768)
# - pooler_output: [CLS] passato attraverso un linear + tanh (batch, 768)
# - hidden_states: tuple di 13 tensori (embedding + 12 layers)
last_hidden = outputs.last_hidden_state
pooler = outputs.pooler_output
all_layers = outputs.hidden_states
print(f"Last hidden state: {last_hidden.shape}")
# torch.Size([1, N, 768])
print(f"Pooler output: {pooler.shape}")
# torch.Size([1, 768])
print(f"Numero di layer: {len(all_layers)}")
# 13 (embedding layer + 12 transformer layers)
# Strategie per ottenere sentence embeddings:
# 1. Usa il [CLS] token dell'ultimo layer
cls_embedding = last_hidden[:, 0, :]
print(f"[CLS] embedding: {cls_embedding.shape}")
# 2. Mean pooling sull'ultimo layer (spesso migliore)
attention_mask = inputs['attention_mask'].unsqueeze(-1)
mean_embedding = (last_hidden * attention_mask).sum(1) / attention_mask.sum(1)
print(f"Mean pooling: {mean_embedding.shape}")
# 3. Concatena gli ultimi 4 layer (cattura più informazione)
last_4_layers = torch.cat(
[all_layers[i] for i in [-1, -2, -3, -4]],
dim=-1
)
print(f"Last 4 layers concatenated: {last_4_layers.shape}")
# torch.Size([1, N, 3072])어떤 레이어를 사용할 것인가?
연구에 따르면 서로 다른 계층이 서로 다른 유형의 정보를 캡처하는 것으로 나타났습니다.
- 레이어 1~4(베이스): 기본적인 형태적, 구문적 정보
- 레이어 5-8(중간): 복잡한 구문 정보, 종속성
- 레이어 9-12(높음): 상위 수준의 의미 정보
- 마지막 레이어: 의미론적 작업(NLI, 유사성)에 가장 적합
- 중간층: 구문 작업(POS 태깅, 구문 분석)에 가장 적합합니다.
7. BERT의 변형: 가족의 진화
BERT가 발표된 이후 수많은 연구 그룹에서 BERT의 변형을 제안했습니다. 여러 측면을 개선합니다. 다음은 가장 중요한 사항에 대한 개요입니다.
BERT 변형 비교표
| 모델 | 년도 | 혁신을 선도하다 | 매개변수 |
|---|---|---|---|
| BERT 기본 | 2018 | MLM + NSP, 심층 양방향 | 1억 1천만 |
| 로베르타 | 2019 | NSP 없음, 동적 마스킹, 더 많은 데이터, 더 긴 훈련 | 125M |
| 알버트 | 2019 | 매개변수 공유, 인수분해 임베딩 | 12M-235M |
| 디스틸버트 | 2019 | 지식 증류, 60% 더 빨라짐 | 66M |
| 엘렉트라 | 2020 | 대체된 토큰 감지(MLM보다 효율적) | 1억 1천만 |
| 데버타 | 2020 | 풀린 관심(콘텐츠+위치 별도) | 134M-390M |
| XLNet | 2019 | 순열 언어 모델링 | 340M |
| 스팬버트 | 2019 | 연속 범위 마스킹 + SBO | 1억 1천만 |
| 어니 | 2019 | 지식이 강화된 엔터티 마스킹 | 1억 1천만 |
7.1 RoBERTa: BERT 훈련 최적화
RoBERTa(강력하게 최적화된 BERT 접근 방식), Facebook AI가 제공하는 (현재 Meta)는 BERT가 훈련이 덜 된. 변경 사항 주요 내용은 다음과 같습니다.
- NSP 제거: NSP 타겟은 도움이 되지 않으며 성능을 저하시킬 수도 있습니다.
- 동적 마스킹: 전처리 시 한번만 마스킹하는 것이 아닌, 마스킹 패턴은 각 시대마다 동적으로 생성됩니다.
- 더 많은 데이터: CC-News, OpenWebText, Stories를 포함한 텍스트 160GB(BERT 16GB 대비)
- 더 긴 훈련: 500K 단계(BERT의 100K 대비), 더 큰 배치 크기
- 더 긴 시퀀스: 여전히 512개 토큰(BERT는 128개로 시작)
7.2 ALBERT: 지능형 압축
ALBERT(A Lite BERT) Google은 성장 문제를 해결합니다. 두 가지 우아한 기술을 사용한 매개변수:
- 인수분해된 임베딩 매개변수화: 별도의 어휘 크기 숨겨진 차원에서. V x H 행렬 대신 V x E 및 E x H(E가 H보다 훨씬 작음)를 사용합니다.
- 레이어 간 매개변수 공유: 모든 Transformer 레이어가 공유 동일한 매개변수. 이렇게 하면 손실 없이 매개변수 수를 대폭 줄일 수 있습니다. 품질이 많이
ALBERT-xxlarge는 235M 매개변수만으로 BERT-large보다 더 높은 성능을 달성합니다. (vs 340M), 레이어 수가 남아있어 추론 시간은 줄어들지 않지만 변함없이.
7.3 DistillBERT: 지식의 증류
디스틸버트 Hugging Face는 다음을 사용합니다. 지식 증류 더 작고 빠른 모델을 만드는 것입니다. "학생" 모델(6개 레이어)이 훈련되었습니다. "교사" 모델(BERT 기반, 12개 레이어)의 출력을 모방합니다.
- 40% 더 작아짐: 66M 매개변수 대 110M
- 60% 더 빨라짐: 6개 레이어 대 12개 레이어
- 성능 97%: BERT 기반의 품질을 거의 모두 유지합니다.
7.4 ELECTRA: 완전히 다른 접근 방식
엘렉트라 Masked Language Model을 영감을 받은 접근 방식으로 대체합니다. GAN(Generative Adversarial Networks)에 적용됩니다. 토큰을 마스킹하고 예측하는 대신 ELECTRA는 다음을 수행합니다.
- 소형 생성기(소형 BERT)는 그럴듯한 대체 토큰을 생성합니다.
- 판별자(메인 모델)는 다음을 식별해야 합니다. 어느 토큰 교체되었습니다(교체된 토큰 감지).
주요 이점: 판별자는 다음으로부터 학습합니다. 모든 사람 토큰 BERT에서와 같이 마스크된 15%만이 아닙니다. 이것은 ELECTRA를 훨씬 더 좋게 만듭니다. 데이터 및 컴퓨팅 측면에서 효율적입니다.
7.5 DeBERTa: 분리된 주의
DeBERTa(해제된 Attention을 갖춘 디코딩 강화 BERT) 마이크로소프트 두 가지 혁신을 소개합니다.
- 얽매이지 않는 관심: 콘텐츠와 위치정보를 분리합니다. 모델이 "무엇"과 "어디"에 대해 추론할 수 있도록 두 개의 서로 다른 벡터로 분리 상관없이
- 향상된 마스크 디코더: 절대 위치 정보 추가 MLM 예측을 개선하기 위해 디코더에서
DeBERTa v3는 현재 많은 벤치마크에서 가장 성능이 좋은 인코더 모델 중 하나입니다. 종종 훨씬 더 큰 모델을 능가합니다.
8. 이탈리아어용 BERT
원래 BERT는 영어 텍스트로 학습되었습니다. 이탈리아어의 경우 몇 가지 옵션이 있습니다. 각각 장점과 단점이 있습니다.
이탈리아어용 BERT 모델
| 모델 | 기초적인 | 훈련 데이터 | 어휘 |
|---|---|---|---|
| 엠버트 | BERT 기본 | 104개 언어로 된 위키피디아 | 110K 다국어 토큰 |
| dbmdz/bert-base-italian-xxl-cased | BERT 기본 | OPUS, Wikipedia IT(~13GB) | 30K 이탈리아 토큰 |
| 알베르토 | BERT 기본 | 이탈리아어로 트윗하기 | 30K 이탈리아 토큰 |
| 움베르토 | 로베르타 | OSCAR 이탈리아어 코퍼스 | 32K SentencePiece 토큰 |
| XLM-RoBERTa | 로베르타 | 100개 언어로 제공되는 CC-100 | 250K 다국어 토큰 |
from transformers import pipeline, AutoTokenizer, AutoModelForMaskedLM
# 1. BERT Italiano (dbmdz)
fill_mask_it = pipeline(
"fill-mask",
model="dbmdz/bert-base-italian-xxl-cased"
)
results = fill_mask_it("Roma e' la [MASK] d'Italia.")
for r in results[:3]:
print(f" {r['token_str']}: {r['score']:.4f}")
# Output: capitale: 0.8234, citta: 0.0521, ...
# 2. UmBERTo (basato su RoBERTa)
fill_mask_umberto = pipeline(
"fill-mask",
model="Musixmatch/umberto-commoncrawl-cased-v1"
)
results = fill_mask_umberto("L'intelligenza artificiale <mask> il futuro.")
for r in results[:3]:
print(f" {r['token_str']}: {r['score']:.4f}")
# 3. Multilingual BERT
fill_mask_mbert = pipeline(
"fill-mask",
model="bert-base-multilingual-cased"
)
results = fill_mask_mbert("Roma e' la [MASK] d'Italia.")
for r in results[:3]:
print(f" {r['token_str']}: {r['score']:.4f}")
# mBERT funziona, ma il modello italiano dedicato e' molto più' preciso이탈리아어로 어떤 모델을 선택해야 합니까?
- 일반업무(NER, 분류, QA):
dbmdz/bert-base-italian-xxl-cased또는 UMBERTo - 소셜 미디어 분석: AlBERTo(트윗으로 훈련됨)
- 다국어 업무: XLM-RoBERTa(교차 언어 제로샷에 적합)
- 최고의 품질: 이탈리아 데이터에 대한 XLM-RoBERTa-large 미세 조정
9. BERT의 한계
혁명적인 영향에도 불구하고 BERT는 몇 가지 구조적 한계를 가지고 있습니다. 적용 가능성에 영향을 미칩니다.
9.1 512 토큰 한도
BERT는 최대 시퀀스를 처리할 수 있습니다. 토큰 512개. 긴 문서의 경우 (기사, 법적 계약, 과학 논문) 이는 심각한 제한입니다. 전략 완화에는 다음이 포함됩니다. 잘림, 그것 슬라이딩 윈도우 그리고 계층적 풀링, 그러나 최적의 것은 없습니다.
9.2 주의력의 2차 복잡성
Self Attention에는 계산상의 복잡성이 있습니다. 오(n^2) 존경 시퀀스 길이만큼 n. 길이가 두 배로 늘어난다는 뜻이다. 입력의 계산 비용과 메모리 소비가 4배로 늘어납니다. 다음과 같은 모델 롱포머, 빅버드 e 린포머 그들은 제안한다 이 문제를 해결하기 위한 희소 주의 메커니즘.
9.3 인코더만: 생성 기능 없음
BERT는 모델입니다 인코더 전용. 풍부한 표현을 생성할 수 있습니다. 문자 내용은 알지만 그는 그럴 수 없어 생성하다 새 텍스트. 세대를 위해서는 디코더가 필요합니다 (GPT에서와 같이) 또는 인코더-디코더 아키텍처(T5 또는 BART에서와 같이).
9.4 사전 훈련/미세 조정 불일치
[MASK] 토큰은 사전 훈련 중에는 나타나지만 미세 조정이나 추론 중에는 나타나지 않습니다. 80/10/10 전략이 문제를 부분적으로 완화하더라도 이러한 불일치는 여전히 남아 있습니다. 이론적 약점. ELECTRA는 [MASK]를 전혀 사용하지 않음으로써 문제를 완벽하게 해결합니다.
9.5 마스크된 토큰의 독립성
BERT가 여러 토큰을 마스킹하면 그에 따라 토큰을 예측합니다. 독립적인. 아니다 마스킹된 토큰 간의 종속성을 모델링합니다. 예를 들어 "New [MASK] [MASK]"라는 문구가 있다면 대답은 "New York City"입니다. BERT는 "York"와 "City"를 독립적으로 예측합니다. 서로의 예측에 영향을 미칩니다. XLNet은 다음을 통해 이 문제를 해결합니다. 순열 언어 모델링.
요약 제한 사항 및 솔루션
| 한계 | 영향 | 해결책 |
|---|---|---|
| 최대 512개의 토큰 | 긴 문서 없음 | 롱포머, 빅버드, 슬라이딩 윈도우 |
| 주의 O(n^2) | 높은 계산 비용 | 린포머, 퍼포머, 플래시 어텐션 |
| 인코더만 | 텍스트 생성 없음 | T5, 바트, GPT |
| [마스크] 불일치 | 훈련/추론 불일치 | 엘렉트라, XLNet |
| 독립적인 예측 | 마스킹된 토큰 사이에는 종속성이 없습니다. | XLNet, 자동회귀 모델 |
10. BERT에서 최신 모델까지
BERT는 NLP에서 "사전 훈련 후 미세 조정" 시대를 열었습니다. 근본적으로 모든 후속 아키텍처. 풍경이 어떻게 진화했는지 봅시다.
10.1 모델 가계도
Transformer (2017)
|
+------ Encoder-Only ------+------ Decoder-Only ------+--- Encoder-Decoder ---+
| | | |
BERT (2018) GPT-1 (2018) T5 (2019) BART (2019)
| | |
+-- RoBERTa (2019) GPT-2 (2019) mT5 (2020)
+-- ALBERT (2019) |
+-- DistilBERT (2019) GPT-3 (2020)
+-- XLNet (2019) |
+-- ELECTRA (2020) GPT-4 (2023)
+-- DeBERTa (2020) |
+-- DeBERTa v3 (2021) LLaMA (2023)
|
LLaMA 2 (2023)
|
Mistral (2023)
|
LLaMA 3 (2024)
10.2 BERT의 핵심 교훈
BERT의 가장 중요한 유산은 특정 아키텍처가 아니라 어형 변화표: 레이블이 지정되지 않은 엄청난 양의 텍스트에 대해 모델을 훈련합니다. 자기 감독 목표를 사용하고, 데이터가 거의 없는 특정 작업에 맞게 조정합니다. 라벨이 붙어 있습니다. 이 패러다임은 GPT에서 LLaMA까지 모든 현대 모델의 기초입니다.
10.3 BERT가 여전히 관련되는 곳
훨씬 더 큰 생성 모델의 출현에도 불구하고 BERT와 그 후손 인코더 전용은 다양한 시나리오에서 최선의 선택으로 남아 있습니다.
- 텍스트 분류: 감성, 주제, 스팸 감지
- 명명된 엔터티 인식: 구조화된 실체 추출
- 의미 검색: 의미 기반 검색(문장 변환기 사용)
- 정보 검색: 관련 문서의 순위
- 임베딩 생성: 텍스트의 조밀한 표현
BERT와 같은 인코더 모델은 더 많습니다. 효율적인, 더 빠른 e 덜 비싸다 대규모 생성 모델과 비교. 많은 작업의 경우 언어 이해력이 향상되어 미세 조정된 DeBERTa-v3는 모델보다 100배 더 뛰어난 성능을 발휘합니다. 매개변수.
11. 결론 및 BERT 사용 시기
이 기사에서는 인코더 전용 아키텍처부터 BERT를 심층적으로 분석했습니다. Transformer의 다중 헤드 self-attention 메커니즘, 사전 훈련 전략까지 (MLM 및 NSP), HuggingFace 및 그 변형을 사용한 실제 구현까지 그들은 파생물입니다.
의사결정 프레임워크: BERT를 사용해야 하는 경우
| 대본 | 추천 모델 | 동기 부여 |
|---|---|---|
| 텍스트 분류(제작) | DeBERTa-v3 또는 RoBERTa | 최대의 정확성, 합리적인 비용 |
| NER(이탈리아어) | dbmdz BERT IT 또는 UmBERTo | 네이티브 이탈리아어 어휘 |
| 제한된 리소스/에지 | DistilBERT 또는 TinyBERT | 빠르고 컴팩트하며 97% 품질 |
| 훈련 효율성 | 엘렉트라 | 단지 15%가 아닌 모든 토큰에서 배우세요 |
| 텍스트 생성 | GPT / T5 / LLaMA | BERT는 생성할 수 없습니다. |
| 긴 문서 | 롱포머 / 빅버드 | BERT는 512개의 토큰으로 제한됩니다. |
| 다국어/제로샷 | XLM-RoBERTa | 우수한 언어 간 전송 |
BERT는 현대 NLP의 주류로 남아 있습니다. 비록 대규모 언어 모델이지만 생성 모델이 헤드라인을 지배하고 BERT와 같은 인코더 모델이 백본입니다. 검색 엔진, 추천 시스템, 스팸 필터, 법률 보조, 감정 분석 등.
시리즈의 다음 기사에서는 다음을 구축하여 이 지식을 실제로 적용해 보겠습니다. 시스템 감성 분석 이탈리아어 텍스트 완료, from 모델 배포를 위한 데이터 세트를 준비합니다.
자세히 알아볼 수 있는 리소스
- 원본 논문: "BERT: 언어 이해를 위한 심층 양방향 변환기 사전 훈련"(Devlin et al., 2018)
- 논문 RoBERTa: "강력하게 최적화된 BERT 사전 훈련 접근 방식"(Liu 외, 2019)
- ELECTRA 논문: "ELECTRA: 생성자가 아닌 판별자로 사전 훈련된 텍스트 인코더"(Clark et al., 2020)
- 논문 DeBERTa: "DeBERTa: Disentangled Attention을 갖춘 디코딩 강화 BERT"(He et al., 2020)
- HuggingFace BERT 문서: Huggingface.co/docs/transformers/model_doc/bert
- 그림 BERT: jalammar.github.io/illustrated-bert/