BERT Açıklandı: Mimari, Ön Eğitim ve İnce Ayar
2018 yılı Doğal Dil İşleme tarihinde bir dönüm noktası oldu. Yayınlanmasıyla BERT (Transformatörlerden Çift Yönlü Kodlayıcı Gösterimleri), Google AI ekibinin 11 NLP kriterinde aynı anda en son teknolojiyi yeniden tanımlayan bir model tanıttı. için İlk defa, önceden eğitilmiş tek bir model çok farklı görevlere uyarlanabildi (sınıflandırma, soru cevaplama, NER) tüm özel sistemlere göre üstün sonuçlar elde edilmesi emsaller.
Peki BERT'i bu kadar devrimci yapan şey nedir? Cevap üç temel yenilikte yatıyor: the derin çift yönlülük, il büyük ölçekli ön eğitim ve basitliği ince ayar aşağı akış görevleri için. Bu yazıda analiz edeceğiz BERT mimarisinin her yönü, dahili dikkat mekanizmalarından uygulamaya kadar HuggingFace ile ondan türetilen varyasyonlardan geçerek pratik yapın.
Bu serinin ikinci makalesi Modern NLP: BERT'ten Yüksek Lisans'a. Temeller (tokenizasyon, yerleştirmeler ve NLP hatları) hakkındaki ilk makaleyi henüz okumadıysanız, Devam etmeden önce bunu yapmanızı tavsiye ederim: Burada ele alınan kavramların çoğu yapılandırılmıştır. bu temeller üzerinde.
Ne Öğreneceksiniz
- BERT neden NLP'de bir devrimi ve önceki modellerin sınırlamalarını temsil ediyordu?
- BERT'in temelini oluşturan Transformer yalnızca kodlayıcı mimarisi
- Çok kafalı öz dikkat nasıl çalışır ve matematiksel formüller
- Giriş gösterimi: jeton, segment ve konum yerleştirmeleri
- İki eğitim öncesi strateji: Maskeli Dil Modeli (MLM) ve Sonraki Cümle Tahmini (NSP)
- WordPiece tokenizasyonu ve özel tokenler [CLS], [SEP], [MASK]
- Sınıflandırma, NER, soru cevaplama için ince ayar nasıl yapılır?
- HuggingFace Transformers ile uygulamalı uygulamayı tamamlayın
- BERT çeşitleri: RoBERTa, ALBERT, DistilBERT, DeBERTa, ELECTRA
- İtalyanca dili için BERT: mevcut modeller ve karşılaştırma
- BERT'in sınırları ve daha sonraki modellerin bunları nasıl aştığı
Seriye Genel Bakış
| # | Öğe | Odak |
|---|---|---|
| 1 | NLP'nin Temelleri | Tokenleştirme, Yerleştirmeler, İşlem Hatları |
| 2 | Buradasınız - BERT ve Trafo | Dikkat Mimarlık, Ön Eğitim |
| 3 | Duygu Analizi | BERT ile metin sınıflandırması |
| 4 | Adlandırılmış Varlık Tanıma | Varlıkların metinden çıkarılması |
| 5 | SarılmaYüz Transformers | Önceden eğitilmiş kütüphane ve modeller |
| 6 | Modellerin İnce Ayarı | BERT'i etki alanınıza uyarlayın |
| 7 | İtalyanca için NLP | İtalyanca dili için şablonlar ve kaynaklar |
| 8 | BERT'den LLM'lere | GPT, LLaMA ve metin oluşturma |
1. BERT neden NLP'de devrim yarattı?
BERT'in etkisini anlamak için 2018 öncesi NLP ortamına dönüp anlamamız gerekiyor. Önceki modellerin çözemediği temel sorunlar.
1.1 Word2Vec ve GloVe'nin Sınırlamaları
Serinin ilk makalesinde gördüğümüz gibi, Word2Eski (2013) ve Eldiven (2014) önemli bir dönüm noktasıydı: ilk kez kelimeler anlamsal ilişkilerin olduğu sürekli bir uzayda yoğun vektörler olarak temsil edildi "kral - erkek + kadın = kraliçe" uzay geometrisinden doğal olarak ortaya çıkmıştır.
Ancak bu modellerin temel bir sınırlaması vardır: statik gösterimler. Her kelimenin benzersiz bir vektörü vardır, ortaya çıktığı bağlamdan bağımsız olarak. "Bench" sözcüğünü ele alalım:
Statik Temsiller Sorunu
- "Parayı yatırdım tezgah" (banka kurumu)
- "Il tezgah okulda çok küçüktü" (cep telefonu)
- "A tezgah Vadiyi sis kapladı" (sis kütlesi)
- "Il tezgah balık miktarı çok büyüktü" (balık grubu)
Word2Vec ile "banka" kelimesinin bir anlamı vardır. eşsiz bulanık ortalama olan vektör tüm bu anlamlardan. Modelin bağlamı ayırt etme yolu yoktur.
1.2 ELMo: Bağlama Doğru İlk Adım
2018'de BERT'ten önce, ELMo (Dil Modellerinden Yerleştirmeler) tarafından AllenAI zaten bağlam sorununu çözmeye çalışmıştı. ELMo bir ağ kullandı biLSTM (çift yönlü Uzun Kısa Süreli Bellek) bir görev üzerinde önceden eğitilmiştir Bağlamsal yerleştirmeler üretmek için dil modelleme.
ELMo'nun sorunu iki yönlüydü: Birincisi, iki yönlüydü yüzeysel, iki LSTM'nin (biri ileri, biri geri) birleştirilmesi anlamında, ancak işlem sırasında etkileşime girer. İkincisi, LSTM'ler bir sorundan muzdariptir bilgi darboğaz: uzun vadeli bağımlılıklar giderek "unutulur" dizi uzadıkça.
1.3 Dönüm Noktası: Derin Çift Yönlülük
BERT mekanizması sayesinde her iki sorunu da çözer kendine dikkat Transformatörün. Bir dizideki her jeton diğer tüm jetonları "izleyebilir" aynı anda hem soldakiler hem de sağdakiler. Bu çift yönlülük değil iki ayrı modelin birleştirilmesi (ELMo'da olduğu gibi), ancak derin bir etkileşim mimarinin her katmanında gerçekleşir.
Karşılaştırma: Çift Yönlülüğe Yaklaşımlar
| Modeli | Tip | Bağlam | Sınırlama |
|---|---|---|---|
| Word2Vec/Eldiven | Statik | Bağlam yok | Kelime başına bir vektör |
| GPT-1 | Tek yönlü (sol -> sağ) | Yalnızca önceki bağlam | Geleceği görmüyor |
| Kask | Yüzeysel çift yönlü | Bağlantılı bağlam | Yönler arasında etkileşim yok |
| BERT | Derin çift yönlü | Her katmanda tam bağlam | Yalnızca kodlayıcı (nesil yok) |
BERT'in bu derin çift yönlülük sayesinde kurulabilmesi yeni rekorlar 11 NLP kriteri yayınlandığı sırada, GLUE, SQuAD 1.1, SQuAD 2.0 ve MultiNLI dahil.
2. BERT Mimarisi: Kodlayıcı Transformatörü
BERT bir modeldir yalnızca kodlayıcıyani sadece kodlayıcı kısmını kullanır "İhtiyacınız Olan Tek Şey Dikkat" (2017) makalesinde açıklanan orijinal Transformer mimarisinin bir örneğidir. Her bileşeni ayrıntılı olarak görelim.
2.1 Mimariye Genel Bakış
BERT mimarisi bir dizi Transformatör bloğu olarak görselleştirilebilir dikey olarak istiflenir. Her blokta çok başlı bir öz-dikkat katmanı bulunur ardından normalizasyon katmanı ve artık bağlantılardan oluşan ileri beslemeli bir ağ gelir.
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 tabanı ve BERT-büyük karşılaştırması
Orijinal makale iki konfigürasyon önermektedir:
BERT Yapılandırmaları
| Parametre | BERT-temel | BERT-büyük |
|---|---|---|
| Transformatör Katmanları (L) | 12 | 24 |
| Gizli Boyut (H) | 768 | 1024 |
| Dikkat Başlıkları (A) | 12 | 16 |
| Toplam Parametreler | 110 milyon | 340M |
| Loş. Kafa için | 768/12 = 64 | 1024/16 = 64 |
| İleri Besleme Dim. | 3072 (4x768) | 4096 (4x1024) |
| Maksimum Sıra. Uzunluk | 512 | 512 |
| Kelime Boyutu | 30.522 | 30.522 |
2.3 Giriş Temsili: Üç Yerleştirme
BERT'in yeniliklerinden biri sizinki girişin temsili, üç farklı yerleştirmenin toplamından oluşur:
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
Jeton Yerleştirmeleri: Dizideki her jeton yoğun bir vektörle eşlenir sırasında öğrenilen bir gömme matrisi aracılığıyla H boyutunda (BERT tabanı için 768) eğitim. WordPiece sözlüğü 30.522 jeton içerir.
Segment Yerleştirmeleri: BERT girdi olarak bir veya iki ayrı cümle alabilir jeton [SEP]. Segment yerleştirmeleri her bir jetonun hangi cümleye ait olduğunu gösterir: tüm jetonlar ilk cümlenin yerleştirmesini alın E_A, ikincidekiler E_B. Bu, BERT'in akıl yürütmesi gereken Doğal Dil Çıkarımı gibi görevler için temeldir. iki cümle arasındaki ilişki hakkında
Pozisyon Gömmeleri: İşlevleri kullanan orijinal Transformer'ın aksine sinüzoidal, BERT konum yerleştirmelerini kullanır öğrendim. Her pozisyon (0 ila 511) eğitim sırasında öğrenilen bir vektöre sahiptir; bu, BERT'in işleyebileceği anlamına gelir maksimum 512 jetona kadar diziler.
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 Çok-Başlı Kişisel Dikkat
BERT'in (ve her Transformatörün) kalbi ve mekanizması kendine dikkat. Sezgisel olarak, öz-dikkat her jetonun diğer tüm jetonları "izlemesine" olanak tanır sırayla ve her birinin temsilinizle ne kadar alakalı olduğuna karar verin.
Ölçeklendirilmiş Nokta Ürün Dikkati
Dikkat, her bir simge için öğrenilen doğrusal projeksiyonlar aracılığıyla üç vektörü hesaplar:
- Sorgular (S): "Ne arıyorum?"
- Anahtar (K): "Ne öneriyorum?"
- Değer (V): "Hangi bilgileri getireceğim?"
Dikkat formülü:
Dikkat(Q, K, V) = softmax\left(\frac{QK^T}{\sqrt{d_k}}\right)VNerede d_k ve tuşların boyutu (BERT tabanı için 64). Faktör \frac{1}{\sqrt{d_k}} stabilize etmeye hizmet eder degradeler: bu ölçeklendirme olmadan, nokta çarpımı çok büyük değerler üretir. yüksek boyutluluk ve softmax neredeyse tek sıcak dağılımlar üreterek "doymuş" hale gelir.
Çok Kafalı Dikkat
BERT, tek bir dikkat fonksiyonunu hesaplamak yerine, çok kafalı dikkat: Hesaplama tekrarlanır h kez (BERT tabanı için 12, BERT-büyük), her biri farklı projeksiyon matrislerine sahiptir. Bu, modelin farklı türden ilişkileri aynı anda yakalayın: bir kafa uzmanlaşabilir sözdizimsel ilişkilerde, diğeri ortak referanslarda, diğeri anlamsal bağımlılıklarda.
ÇokluHead(Q, K, V) = Concat(head_1, ..., head_h)W^O head_i = Dikkat(QW_i^Q, KW_i^K, VW_i^V)Nerede W_i^Q \in \mathbb{R}^{d_{model} \times d_k}, W_i^K \in \mathbb{R}^{d_{model} \times d_k}, W_i^V \in \mathbb{R}^{d_{model} \times d_v} e W^O \in \mathbb{R}^{hd_v \times d_{model}}.
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 İleri Beslemeli Ağ
Her dikkat katmanından sonra BERT, konum bazında ileri beslemeli bir ağ uygular; aynı ağ, dizinin her konumuna bağımsız olarak uygulanır:
FFN(x) = \text{GELU}(xW_1 + b_1)W_2 + b_2Orta boyut genellikle 4 kez gizli boyut (BERT-tabanı için 3072, BERT-büyük için 4096). BERT aktivasyon fonksiyonunu kullanır GELÜ (Gauss Hata Doğrusal Birimi) geleneksel ReLU yerine pratikte daha yumuşak bir geçiş ve daha iyi performans sağlar.
2.6 Katman Normalleştirme ve Artık Bağlantılar
BERT'teki her alt katman (dikkat ve ileri besleme) bir kalan bağlantı ardından katman normalizasyonu:
\text{çıkış} = \text{KatmanNorm}(x + \text{Alt katman}(x))Artık bağlantılar, eğimlerin doğrudan ağ üzerinden akmasına olanak tanır geri yayılım sırasında birçok ağda yok olan gradyan sorununun önlenmesi derin. Katman normalleştirme, aktivasyonları normalleştirerek eğitimi stabilize eder özellik boyutu boyunca.
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. Ön Eğitim: BERT Dili Nasıl Öğrenir?
BERT, büyük miktarda etiketsiz metin üzerinde önceden eğitilmiştir. iki tamamlayıcı eğitim hedefi: Maskeli Dil Modeli (MLM) ve Sonraki Cümle Tahmini (NSP). Temel fikir, modelin Bu kendi kendini denetleyen görevlerden dilin zengin temsillerini öğrenirsiniz ve bu bu bilgi daha sonra ince ayar yoluyla belirli görevlere aktarılabilir.
Eğitim öncesi veriler
- KitaplarCorpus: ~800M kelime (11.000 yayınlanmamış kitap)
- İngilizce Vikipedi: ~2.500M kelime (yalnızca metin, tablo/liste yok)
- Toplam: ~3,3 milyar kelime
- Eğitim: 4 TPU Pod (64 TPU çipi), BERT tabanı için 4 gün
3.1 Maskeli Dil Modeli (MLM)
Maskeli Dil Modeli BERT'in ana yeniliğidir. Dil ile ilgili sorun geleneksel modelleme (bir sonraki kelimeyi tahmin etme) ve bu doğası gereği tek yönlü: Model yalnızca sola bakabilir. Yapmak Çift yönlü modelde BERT şık bir numara sunuyor: bir kısmı maskelemek rastgele giriş belirteçleri ve modelden bunları tahmin etmesini isteyin.
80/10/10 Stratejisi
Her giriş sırası için, %15 Tahmin için token sayısı seçilir. Bu seçilen tokenlardan:
- %80 özel belirteç [MASK] ile değiştirildi
- %10 sözlükten rastgele bir jetonla değiştirilir
- %10 değişmeden kaldı
Bu strateji ince bir sorunu çözüyor: ince ayar sırasında [MASK] belirteci başarısız oluyor girişte hiçbir zaman görünmez. Model yalnızca eğitim öncesi sırasında [MASK]'ı görseydi orada olurdu bir Eğitim öncesi ve ince ayar arasındaki uyumsuzluk. %10'unun jetonlarla değiştirilmesi Rastgele ve %10'u değiştirmeden bırakan model, iyi temsiller üretmeyi öğrenir. için herkes jetonlar, yalnızca gizlenmiş olanlar için değil.
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 Sonraki Cümle Tahmini (NSP)
İkinci eğitim öncesi hedef ise Sonraki Cümle Tahmini. Her biri için Girişteki cümle çifti (A, B), modelin B'nin aşağıdaki cümle olup olmadığını tahmin etmesi gerekir aslında orijinal metinde A (Sonraki) veya rastgele bir ifade ise (Sonraki Değil). Veri seti çiftlerin %50'si pozitif olacak şekilde oluşturulmuştur ve %50 olumsuz.
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 hedefi BERT'in cümleler arasındaki ilişkileri yakalamasına yardımcı olur ve aşağıdaki gibi görevler için faydalıdır: Soru Cevaplama ve Doğal Dil Çıkarımı. Ancak daha sonraki çalışmalar (özellikle RoBERTa) NSP'nin gerekli olmayabileceğini ve hatta zarar varyantlar bölümünde göreceğimiz gibi performans.
3.3 Birleşik Kayıp
Eğitim öncesi sırasındaki toplam BERT kaybı, iki kaybın toplamıdır:
\mathcal{L_{toplam} = \mathcal{L_{MLM} + \mathcal{L} _{NSP}Nerede \mathcal{L_{MLM} ve jetonlardaki çapraz entropi kaybı maskeli ve \mathcal{L_{NSP} ve çapraz entropi kaybı IsNext/NotNext sınıflandırmasında ikili.
4. WordPiece Tokenizasyonu
BERT tokenizasyon kullanıyor Kelime Parçası, bir tokenizasyon algoritması Kelime dağarcığı verimliliğini ve dil kapsamını dengeleyen alt kelime. Kelime Parçası ve durumu Başlangıçta Google'ın makine çeviri sistemi için geliştirildi.
4.1 WordPiece Nasıl Çalışır?
WordPiece'in arkasındaki fikir basit ama güçlü: bireylerin kelime dağarcığından başlamak karakterler ve maksimuma çıkaran simge çiftlerini yinelemeli olarak birleştirir. gerçeğe benzerlik eğitim külliyatı. Kelime bilgisi tamamlanıncaya kadar süreç devam eder. bir hedef boyutu (BERT için 30.522).
Sonuç olarak aşağıdakileri içeren bir kelime dağarcığı ortaya çıkar:
- Tüm yaygın kelimeler (örneğin, "the", "of", "ve")
- Yaygın önekler ve kökler (ör. "un", "re", "pre")
- ile işaretlenmiş son ekler ve sonlar
##(örneğin, "##ing", "##tion", "##ed") - Bilinmeyen herhangi bir kelimeyi işlemek için tek karakterler
4.2 Özel Jetonlar
BERT, WordPiece kelime belirteçlerine ek olarak birkaç özel belirteç kullanır:
BERT Özel Jetonları
| Jetonlar | ID | Kapsam |
|---|---|---|
| [PAD] | 0 | Bir toplu işteki dizilerin uzunluğunu standartlaştırmak için dolgu |
| [UNK] | 100 | Bilinmeyen belirteç (sözlükte yok) |
| [CLS] | 101 | Sıra başlangıcı, son temsili sınıflandırma için kullanılır |
| [EYLÜL] | 102 | İki giriş cümlesi arasındaki ayırıcı |
| [MASK] | 103 | Eğitim öncesi maskeli dil modeli için maske |
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. Aşağı Yöndeki Görevler için BERT'nin İnce Ayarı
BERT'in ortaya koyduğu paradigma "ön eğitim, ardından ince ayar"dır. Eğitim öncesi aşama Dilin derinlemesine anlaşılmasına sahip bir model üretir. İnce ayar aşaması Bir çıktı katmanı ve eğitim ekleyerek bu modeli belirli bir göreve uyarlayın modelin tamamını (veya bir kısmını) görevin etiketli verileri üzerine yerleştirin.
İnce ayarın güzelliği, bunu gerektirmesidir. birkaç etiketli veri e az eğitim süresi bir modeli sıfırdan eğitmeye kıyasla. Tipik olarak, düşük öğrenme oranına sahip 2-4 dönem (2e-5 ila 5e-5) yeterlidir.
5.1 Metin Sınıflandırması
Metin sınıflandırması için (duygu analizi, konu sınıflandırması, spam tespiti), belirteç temsili kullanılır [CLS] bir sınıflandırıcıya girdi olarak doğrusal:
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 Adlandırılmış Varlık Tanıma (NER)
NER için yalnızca [CLS] belirtecini kullanmak yerine çıktısı kullanılır her jeton her birini bir varlık kategorisine (kişi, yer, kuruluş vb.) göre sınıflandırmak için:
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 Soru Cevaplama
Çıkarıcı soru yanıtlama için BERT girdi olarak bir soru ve bağlam alır [SEP] ile ayrılmış. Modelin konumlarını tahmin etmesi gerekir. başlangıç e son bağlamdaki yanıtın:
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 Cümle Çifti Sınıflandırması
Doğal Dil Çıkarımı (NLI) veya açıklama tespiti gibi görevler için BERT, iki cümle ve ilişkilerini sınıflandırmalıdır (zorunluluk, çelişki, tarafsız):
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'ten Gömmeleri Çıkarın
Belirli görevler için ince ayar yapılmasına ek olarak BERT son derece kullanışlıdır. özellik çıkarıcı. İç katmanlar tarafından üretilen temsiller farklı soyutlama düzeylerinde dilsel bilgileri yakalarlar.
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])Hangi Katman Kullanılmalı?
Araştırmalar, farklı katmanların farklı türde bilgileri yakaladığını göstermiştir:
- Katmanlar 1-4 (bas): Temel morfolojik ve sözdizimsel bilgiler
- Katmanlar 5-8 (orta): Karmaşık sözdizimsel bilgiler, bağımlılıklar
- Katmanlar 9-12 (yüksek): Üst düzey anlamsal bilgi
- Son katman: Anlamsal görevler için en iyisi (NLI, benzerlik)
- Orta katmanlar: Sözdizimsel görevler için en iyisi (POS etiketleme, ayrıştırma)
7. BERT'in Çeşitleri: Ailenin Evrimi
BERT'in yayınlanmasından bu yana çok sayıda araştırma grubu bunun varyasyonlarını önerdi çeşitli yönleri geliştirin. İşte en önemlilerine genel bir bakış.
BERT Varyantlarının Karşılaştırma Tablosu
| Modeli | Yıl | Lider İnovasyon | Parametreler |
|---|---|---|---|
| BERT-temel | 2018 | MLM + NSP, derin çift yönlü | 110 milyon |
| Roberta | 2019 | NSP yok, dinamik maskeleme, daha fazla veri, daha uzun eğitim | 125 milyon |
| ALBERT | 2019 | Parametre paylaşımı, çarpanlara ayrılmış yerleştirme | 12M-235M |
| DistilBERT | 2019 | Bilginin damıtılması, %60 daha hızlı | 66M |
| ELEKTRA | 2020 | Değiştirilen jeton tespiti (MLM'den daha verimli) | 110 milyon |
| DeBERTa | 2020 | Çözülmüş dikkat (ayrı içerik + konum) | 134M-390M |
| XLNet | 2019 | Permütasyon dili modelleme | 340M |
| SpanBERT | 2019 | Bitişik açıklıkların maskelenmesi + SBO | 110 milyon |
| ERNIE | 2019 | Bilgiyle geliştirilmiş varlık maskeleme | 110 milyon |
7.1 RoBERTa: BERT Eğitiminin Optimize Edilmesi
RoBERTa (Sağlam şekilde optimize edilmiş BERT yaklaşımı), Facebook AI tarafından size sunuldu (şimdi Meta), BERT'in olduğunu kanıtladı az eğitimli. Değişiklikler başlıcaları şunlardır:
- NSP'nin kaldırılması: NSP hedefi yardımcı olmaz ve hatta performansı düşürebilir
- Dinamik maskeleme: Ön işleme sırasında yalnızca bir kez maskelemek yerine, maskeleme modelleri her dönemde dinamik olarak oluşturulur
- Daha fazla veri: CC-News, OpenWebText, Stories dahil 160 GB metin (16 GB BERT'e karşılık)
- Daha uzun eğitim: 500K adım (100K BERT'e kıyasla), daha büyük parti boyutu
- Daha uzun diziler: Hala 512 token (BERT 128 ile başladı)
7.2 ALBERT: Akıllı Sıkıştırma
ALBERT (Lite BERT) Google'ın büyümesi sorununu ele alıyor iki zarif teknikle parametreler:
- Faktorize edilmiş gömme parametrelendirmesi: Ayrı kelime boyutu gizli boyuttan. V x H matrisi yerine V x E ve E x H'yi kullanın (E, H'den çok daha küçüktür)
- Katmanlar arası parametre paylaşımı: Tüm Transformer katmanları paylaşır aynı parametreler. Bu, kayıp olmadan parametre sayısını büyük ölçüde azaltır. çok kaliteli
ALBERT-xxlarge, yalnızca 235M parametreyle BERT-large'den daha yüksek performansa ulaşır (340M'ye kıyasla), ancak katman sayısı kaldıkça çıkarım süresi azalmaz değişmedi.
7.3 DistilBERT: Bilginin Damıtılması
DistilBERT Hugging Face tarafından bilgi damıtma daha küçük, daha hızlı bir model oluşturmak için. Bir “öğrenci” modeli (6 katman) eğitilir bir "öğretmen" modelinin (BERT tabanlı, 12 katman) çıktılarını taklit etmek.
- %40 daha küçük: 66M parametreye karşılık 110M parametre
- %60 daha hızlı: 6 katmana karşı 12 katman
- Performansın %97'si: BERT tabanının neredeyse tüm kalitesini korur
7.4 ELECTRA: Bambaşka Bir Yaklaşım
ELEKTRA Maskeli Dil Modelini ilham verici bir yaklaşımla değiştiriyor GAN'lara (Üretici Rekabet Ağları). ELECTRA, jetonları maskelemek ve tahmin etmek yerine:
- Küçük bir oluşturucu (küçük bir BERT) makul yedek tokenlar üretir
- Ayırıcı (ana model) tanımlamalıdır Hangi jeton değiştirildi (belirteç tespiti değiştirildi)
Temel fayda: Ayrımcının bundan öğrenmesi herkes belirteçleri BERT'teki gibi sadece maskelenmiş %15 değil. Bu, ELECTRA'yı çok daha fazla hale getiriyor Veri ve bilgi işlem açısından verimli.
7.5 DeBERTa: Ayrılmış Dikkat
DeBERTa (Kod çözme özelliği geliştirilmiş BERT, çözülmüş Dikkat ile) Microsoft tarafından iki yenilik getiriyor:
- Çözülmüş dikkat: İçerik ve konum bilgilerini ayırır modelin "ne" ve "nerede" hakkında akıl yürütmesine olanak tanıyan iki farklı vektöre ayırma ne olursa olsun
- Geliştirilmiş maske kod çözücü: Mutlak konum bilgisi ekler MLM tahminlerini iyileştirmek için kod çözücüde
DeBERTa v3 şu anda birçok kıyaslamada en iyi performans gösteren kodlayıcı modellerinden biridir. çoğu zaman çok daha büyük modelleri geride bırakıyor.
8. İtalyanca dili için BERT
Orijinal BERT İngilizce metin üzerinde eğitildi. İtalyanca için birkaç seçeneğimiz var. her birinin avantajları ve dezavantajları vardır.
İtalyanca için BERT modelleri
| Modeli | Temel | Eğitim Verileri | Kelime bilgisi |
|---|---|---|---|
| mBERT | BERT-temel | 104 dilde Vikipedi | 110.000 çok dilli jeton |
| dbmdz/bert-base-italian-xxl-kasalı | BERT-temel | OPUS, Vikipedi BT (~13GB) | 30 bin İtalyan jetonu |
| Alberto | BERT-temel | İtalyanca Tweet | 30 bin İtalyan jetonu |
| UBERTo | Roberta | OSCAR İtalyan külliyatı | 32K Cümle Parçası jetonları |
| XLM-RoBERTa | Roberta | 100 dilde CC-100 | 250.000 çok dilli jeton |
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İtalyanca İçin Hangi Modeli Seçmelisiniz?
- Genel görevler (NER, sınıflandırma, QA):
dbmdz/bert-base-italian-xxl-casedveya UmBERTo - Sosyal medya analizi: AlBERTo (tweet eğitimi aldı)
- Çok dilli görevler: XLM-RoBERTa (diller arası sıfır atış için harika)
- Maksimum kalite: İtalyan verilerine göre XLM-RoBERTa-large'nin ince ayarı
9. BERT'in Sınırları
Devrim niteliğindeki etkisine rağmen BERT'in bazı yapısal sınırlamaları vardır. uygulanabilirliğini etkiler:
9.1 512 Token Limiti
BERT maksimum dizileri işleyebilir 512 jeton. Uzun belgeler için (makaleler, yasal sözleşmeler, bilimsel makaleler), bu ciddi bir sınırdır. Stratejiler Azaltma şunları içerir: kesme, BT sürgülü pencere ve hiyerarşik havuzlama, ancak hiçbiri optimal değil.
9.2 Dikkatin İkinci Dereceden Karmaşıklığı
Kişisel dikkatin hesaplama karmaşıklığı vardır Ç(n^2) saygı dizinin uzunluğuna n. Bu, uzunluğun iki katı anlamına gelir Girişin artması, hesaplama maliyetini ve bellek tüketimini dört katına çıkarır. Gibi modeller Uzun Biçimli, Büyük Kuş e Linformer teklif ediyorlar Bu sorunu aşmak için seyrek dikkat mekanizmaları.
9.3 Yalnızca Kodlayıcı: Üretim Yeteneği Yok
BERT bir modeldir yalnızca kodlayıcı. Zengin temsiller üretebilir metnin, ama yapamıyor oluşturmak yeni metin. Nesil için bir kod çözücüye ihtiyacınız var (GPT'de olduğu gibi) veya bir kodlayıcı-kod çözücü mimarisi (T5 veya BART'ta olduğu gibi).
9.4 Eğitim öncesi/İnce ayar uyumsuzluğu
[MASK] belirteci eğitim öncesi sırasında görünür ancak ince ayar veya çıkarım sırasında asla görünmez. 80/10/10 stratejisi sorunu kısmen hafifletse de bu uyumsuzluk devam ediyor Teorik bir zayıflık. ELECTRA, [MASK]'ı asla kullanmayarak sorunu tamamen çözer.
9.5 Maskelenmiş Tokenların Bağımsızlığı
BERT birden fazla tokenı maskelediğinde bunları buna göre tahmin eder bağımsız. Hayır maskelenmiş belirteçler arasındaki bağımlılıkları modeller. Örneğin, ifade "Yeni [MASK] [MASK]" ise ve cevap "New York Şehri" ise BERT, "York" ve "Şehir"i bağımsız olarak tahmin eder. birinin diğerini tahmin etmesini etkiler. XLNet bu sorunu şu şekilde çözer: permütasyon dili modellemesi.
Özet Sınırlamalar ve Çözümler
| Sınır | Darbe | Çözüm |
|---|---|---|
| Maksimum 512 jeton | Uzun belge yok | Longformer, BigBird, sürgülü pencere |
| Dikkat O(n^2) | Yüksek hesaplama maliyetleri | Linformer, Oyuncu, Flash Attention |
| Yalnızca kodlayıcılar | Metin oluşturma yok | T5, BART, GPT |
| [MASK] uyumsuzluğu | Eğitim/çıkarım tutarsızlığı | ELECTRA, XLNet |
| Bağımsız tahminler | Maskelenmiş belirteçler arasında bağımlılık yok | XLNet, otoregresif modeller |
10. BERT'ten Modern Modellere
BERT, NLP'de "önceden eğitim ver, sonra ince ayar yap" çağını başlattı. derinden sonraki tüm mimari. Manzaranın nasıl geliştiğini görelim.
10.1 Model Aile Ağacı
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'in Temel Dersi
BERT'in en önemli mirası belirli bir mimari değil, paradigma: Büyük miktarda etiketlenmemiş metin üzerinde bir model eğitin kendi kendini denetleyen hedefleri kullanma ve ardından bunu az veri içeren belirli görevlere uyarlama etiketli. Bu paradigma, GPT'den LLaMA'ya kadar tüm modern modellerin temelini oluşturur.
10.3 BERT'in Hala Geçerli Olduğu Yerler
Çok daha büyük üretken modellerin ortaya çıkmasına rağmen, BERT ve onun soyundan gelenler Yalnızca kodlayıcı birçok senaryo için en iyi seçenek olmaya devam ediyor:
- Metin sınıflandırması: Duygu, konu, spam tespiti
- Adlandırılmış Varlık Tanıma: Yapılandırılmış varlıkların çıkarılması
- Anlamsal arama: Anlam temelli arama (cümle dönüştürücülerle)
- Bilgi alma: İlgili belgelerin sıralaması
- Gömme oluşturma: Metin için yoğun gösterimler
BERT gibi kodlayıcı modelleri daha fazladır verimli, Daha hızlı e daha az pahalı büyük üretken modellerle karşılaştırıldığında. Birçok görev için Dil anlama konusunda ince ayarlı DeBERTa-v3, modellerden 100 kat daha fazla performans sergiliyor parametreler.
11. Sonuçlar ve BERT Ne Zaman Kullanılmalı?
Bu makalede BERT'i derinlemesine analiz ettik: yalnızca kodlayıcı mimarisinden Transformatörün, çok kafalı öz-dikkat mekanizmasının, ön eğitim stratejilerinin (MLM ve NSP), HuggingFace ve çeşitleriyle pratik uygulamalara kadar bunlar türevdir.
Karar Çerçevesi: BERT Ne Zaman Kullanılmalı?
| Senaryo | Önerilen model | Motivasyon |
|---|---|---|
| Metin sınıflandırması (üretim) | DeBERTa-v3 veya RoBERTa | Maksimum doğruluk, uygun maliyet |
| NER (İtalyanca) | dbmdz BERT IT veya UmBERTo | Yerli İtalyanca kelime hazinesi |
| Sınırlı kaynaklar / uç | DistilBERT veya TinyBERT | Hızlı, kompakt, %97 kalite |
| Eğitim verimliliği | ELEKTRA | Sadece %15'ten değil, tüm tokenlardan öğrenin |
| Metin oluşturma | GPT / T5 / LLaMA | BERT oluşturulamıyor |
| Uzun belgeler | Uzun Biçimli / BigBird | BERT 512 jetonla sınırlı |
| Çok dilli / sıfır atış | XLM-RoBERTa | Mükemmel diller arası aktarım |
BERT, modern NLP'nin dayanak noktası olmaya devam ediyor. Büyük Dil Modelleri olmasına rağmen Üretken modeller manşetlere hakim, BERT gibi kodlayıcı modeller omurgayı oluşturuyor üretimdeki sayısız uygulama: arama motorları, öneri sistemleri, spam filtreleri, hukuk asistanları, duygu analizi ve çok daha fazlası.
Serinin bir sonraki makalesinde, bu bilgiyi bir temel oluşturarak uygulamaya koyacağız. sistemi Duygu Analizi İtalyanca metin için tamamlandı Veri kümesinin model konuşlandırması için hazırlanması.
Daha fazla bilgi edinmek için kaynaklar
- Orijinal makale: "BERT: Dil Anlamak için Derin Çift Yönlü Transformatörlerin Ön Eğitimi" (Devlin ve diğerleri, 2018)
- Makale RoBERTa: "Sağlam Şekilde Optimize Edilmiş BERT Eğitim Öncesi Yaklaşımı" (Liu ve diğerleri, 2019)
- ELECTRA Makalesi: "ELECTRA: Metin Kodlayıcıları Oluşturucular Yerine Ayırıcı Olarak Ön Eğitmek" (Clark ve diğerleri, 2020)
- Makale DeBERTa: "DeBERTa: Çözülmüş Dikkat ile Kod Çözmeyle geliştirilmiş BERT" (He ve diğerleri, 2020)
- HuggingFace BERT belgeleri: huggingface.co/docs/transformers/model_doc/bert
- Resimli BERT: jalammar.github.io/illustated-bert/